亲宝软件园·资讯

展开

SpringBoot入参校验

​ 呆呆灿   ​ 人气: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里面的通知方式:

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

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

@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方法里面要做什么事情了。

首先,这个的功能是校验参数,那么首先要做的是将请求的参数获取到。这里获取参数的方式就要区分成GETPOST请求。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

GET

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

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

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

代码写到这里,你创建一个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规则传入参数:

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

加载全部内容

相关教程
猜你喜欢
用户评论