SpringBoot通过AOP与注解实现入参校验详情

目录

• 前言：
• 注解标记
• 通过AOP对方法进行增强
• 测试Get请求
• 测试POST请求
• 解决方法代码
• 再次测试POST请求

前言：

问题源头：

在日常的开发中，在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规则传入参数：

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

到此这篇关于SpringBoot通过AOP与注解实现入参校验详情的文章就介绍到这了,更多相关SpringBoot入参校验内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！