SpringBoot通过AOP与注解实现入参校验详情（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:

org.springframework.boot

spring-boot-starter-aop

版本号

com.alibaba

fastjson

版本号

因为这里是要在执行一个方法之前对传入的参数进行校验，所以这里使用到了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 getRequestParams(HttpServletRequest request) throws IOException {

Map 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

}

}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它的泛形是，我将这个数组里面的元素通过逗号给拼接了起来形成一个字符串，这样的话的判断是否是空的时候就比较容易了。

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

@Around("http://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 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方法一定要进行调用，否则走不到代理的方法

TVyhlaMl 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规则传入参数：

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

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。