SpringBoot通过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 "";

}

<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>

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

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

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

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();
}

@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;
}

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

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

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()));
    }
}

@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);
        }
    }
}