SpringBoot入参校验

时间:2022-06-02 呆呆灿人气:8

前言：

问题源头：

在日常的开发中，在Service层经常会用到对某一些必填参数进行是否存在的校验。比如我在写一个项目管理系统：

这种必填参数少一些还好，如果多一些的话光是if语句就要写一堆。像我这种有代码洁癖的人看着这一堆无用代码更是难受。

如何解决：

在Spring里面有一个非常好用的东西可以对方法进行增强，那就是AOP。AOP可以对方法进行增强，比如：我要校验参数是否存在，可以在执行这个方法之前对请求里面的参数进行校验判断是否存在，如果不存在就直接的抛出异常。

因为不是所有的方法都需要进行必填参数的校验，所以我还需要一个标识用来标记需要校验参数的方法，这个标记只能标记在方法上。这一部分的功能可以使用Java中的注解来实现。然后配合AOP来实现必填参数的校验。

代码实现：

注解标记

这个是标记注解的代码：

package com.gcs.demo.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckRequireParam {
    String[] requireParam() default "";

}

@Target({ElementType.METHOD})：作用是该注解只能用到方法上

@Retention(RetentionPolicy.RUNTIME)：注解不仅被保留到 class 文件中，JVM 加载 class 文件之后，会仍然存在

这个里面还有一个requireParam参数，用来存放必填参数的Key

通过AOP对方法进行增强

需要依赖的Jar:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>版本号</version>
</dependency>
 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>fastjson</artifactId>
     <version>版本号</version>
 </dependency>

因为这里是要在执行一个方法之前对传入的参数进行校验，所以这里使用到了AOP的环绕通知

AOP里面的通知方式：

Before:前置通知
After:后置通知
Around：环绕通知

这里我选用的是环绕通知，环绕通知是这几个通知中最强大的一个功能。我选择环绕通知的一个原因是，环绕通知可以通过代码来控制被代理方法是否执行。

现在需要创建一个切面类，并且该类需要被@Aspect和@Component标记：

@Aspect:表明当前类是一个切面类
@Component:将其放到IOC里面管理

@Component
@Aspect
public class CheckRequireParamAop {
    //.....do something
}

这个类里面加了一个方法有来设置切点，通过@Pointcut注解

@Pointcut:这个参数是一个表达式，其作用是用来指定哪些方法需要被"增强"

@Pointcut("@annotation(com.gcs.demo.annotation.CheckRequireParam)")
public void insertPoint(){
}

接下来就是要写一个增强的方法，因为我是选用的环绕通知，所以该方法需要被@Around标记

@Around("insertPoint()")
public Object checkParam(ProceedingJoinPoint proceedingJoinPoint){
	//.....do something
}

然后就要具体的来聊一下这个checkParam方法里面要做什么事情了。

首先，这个的功能是校验参数，那么首先要做的是将请求的参数获取到。这里获取参数的方式就要区分成GET和POST请求。GET请求还好可以通过HttpServletRequest对象里面的getParameterMap方法可以直接获取到,然而POST通过这个方法就不可以了。

public Map<String,String> getRequestParams(HttpServletRequest request) throws IOException {
    Map<String,String> resultParam = null;
    if(request.getMethod().equalsIgnoreCase("POST")){
        StringBuffer data = new StringBuffer();
        String line = null;
        BufferedReader reader = request.getReader();
        while (null != (line = reader.readLine()))
            data.append(line);
        if(data.length() != 0) {
             resultParam = JSONObject.parseObject(data.toString(), new TypeReference<Map<String,String>>(){});
        }
    }else if(request.getMethod().equalsIgnoreCase("GET")){
        resultParam = request.getParameterMap().entrySet().stream().collect(Collectors.toMap(i -> i.getKey(), e -> Arrays.stream(e.getValue()).collect(Collectors.joining(","))));
    }
    return resultParam != null ? resultParam : new HashMap();
}

这里通过if分成了两块：

POST

POST无法通过getParameter获取到参数，请求体只能通过getInputStream或者是getReader来获取到。通过流的方式获取到后，通过FastJson里面的方法将其转成Map返回就好了

GET

GET方法就简单了，直接通过getParameterMap方法返回一个Map即可，这里也对直接获取到的Map做了下处理，通过这个方法获取到的Map它的泛形是<String,String[]>，我将这个数组里面的元素通过逗号给拼接了起来形成一个字符串，这样的话的判断是否是空的时候就比较容易了。

获取到参数后就可以对参数进行校验是否存在了：

@Around("insertPoint()")
public Object checkParam(ProceedingJoinPoint proceedingJoinPoint){
    //获取到HttpServletRequest对象
    HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    MethodSignature signature = (MethodSignature)proceedingJoinPoint.getSignature();
    //获取到CheckRequireParam注解
    CheckRequireParam annotation = signature.getMethod().getAnnotation(CheckRequireParam.class);
    //获取到CheckRequireParam注解中的requireParam属性
    String[] checkParams = annotation.requireParam();
    try {
        //通过封装的方法获取到请求的参数
        Map<String,String> parameterMap = getRequestParams(request);
        //当规定了必传参数，获取到的参数里面是空的，这里就直接抛出异常
        if(checkParams.length > 0 && (parameterMap == null || parameterMap.size() == 0)){
            throw new ParamNotRequire("当前获取到的参数为空");
        }
        //通过循环判断requireParam中的属性名是否在请求参数的中是否存在
        Arrays.stream(checkParams).forEach(item ->{
            if(!parameterMap.containsKey(item)){
                throw new ParamNotRequire("参数[" + item + "]不存在");
            }
            if(!StringUtils.hasLength(parameterMap.get(item))){
                throw new ParamNotRequire("参数[" + item + "]不能为空");
            }
        });
        //这个proceed方法一定要进行调用，否则走不到代理的方法
        Object proceed = proceedingJoinPoint.proceed();
        return proceed;
    } catch (Throwable throwable) {
        //如果参数不存在会抛出ParamNotRequire异常会被这里捕获到，在这里重新将其抛出，让全局异常处理器进行处理
        if(throwable instanceof ParamNotRequire){
            throw (ParamNotRequire)throwable;
        }
        throwable.printStackTrace();
    }
    return null;
}

上面的代码总结下大概有以下几步：

0x01:因为所有的参数都是在HttpServletRequest对象中获取到的，所要先获取到HttpServletRequest对象
0x02:其次，还要和CheckRequireParam注解里面requireParam属性写的参数名进行对比，所以这里要获取到这个注解的requireParam属性
0x03:通过代码中提供的getRequestParams方法来获取到请求的参数
0x04:将requireParam属性中的值与参数Map里面的值进行对比，如果requireParam中有一个值不存在于parameterMap就会抛出异常
0x05:如果参数判断通过，必须要调用proceed方法，否则会调用不到被代理的方法

代码写到这里，你创建一个Controller,然后写一个Get方法，程序应该是正常运行的，并且可以判断出哪一个参数没有传值。

测试Get请求

创建Controller是很简单的，这里我只贴出测试要用的代码：

@GetMapping("/test")
@CheckRequireParam(requireParam = {"username","age"})
public String testRequireParam(UserInfo info){
    return info.getUsername();
}

把参数按照CheckRequireParam注解的规定传入是可以正常返回没有抛出异常：

将age参数删除掉，就抛出了参数不存在的异常：

Get请求测试完美，撒花！！！！！

测试POST请求

写一个测试的方法：

@PostMapping("/postTest")
@CheckRequireParam(requireParam = {"password"})
public UserInfo postTest(@RequestBody UserInfo userInfo){
    return userInfo;
}

访问后并没有给出对应的错误信息，不过看后台是出现了非法状态异常：

这个问题的原因是，在使用@RequestBody的时候，它会通过流的方式将数据读出来(getReader或getInputStream)，而这种方式读取数据只能读取一次，不能读取第二次。

这里我解决这一问题的方法是先将RequestBody保存为一个byte数组，然后继承HttpServletRequestWrapper类覆盖getReader()和getInputStream()方法，使流从保存的byte数组读取。

解决方法代码

继承HttpServletRequestWrapper类重写getInputStream和getReader方法，每次读的时候读取保存在requestBody中的数据

public class CustomRequestWrapper extends HttpServletRequestWrapper {
    private byte[] requestBody;
    private HttpServletRequest request;
    public RequestWrapper(HttpServletRequest request) {
        super(request);
        this.request = request;
    }
    @Override
    public ServletInputStream getInputStream() throws IOException {
        if(this.requestBody == null){
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            IOUtils.copy(request.getInputStream(),bos);
            this.requestBody = bos.toByteArray();
        }
        ByteArrayInputStream bis = new ByteArrayInputStream(requestBody);
        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }
            @Override
            public boolean isReady() {
                return false;
            }
            @Override
            public void setReadListener(ReadListener readListener) {

            }
            @Override
            public int read() throws IOException {
                return bis.read();
            }
        };
    }
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.getInputStream()));
    }
}

增加一个过滤器,把Filter中的ServletRequest替换为ServletRequestWrapper

@Component
@WebFilter(filterName = "channelFilter",urlPatterns = {"/*"})
public class CustomFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        ServletRequest requestWrapper = null;
        if(request instanceof HttpServletRequest){
            requestWrapper = new CustomRequestWrapper((HttpServletRequest) request);
        }
        if(requestWrapper == null){
            filterChain.doFilter(request,servletResponse);
        }else{
            filterChain.doFilter(requestWrapper,servletResponse);
        }
    }
}

再次测试POST请求

按照CheckRequireParam规则传入参数：

不传入参数获者传入一个空的参数：

加载全部内容