SpringBoot通過AOP與註解實現入參校驗詳情

Posted on by

前言：

問題源頭：

在日常的開發中，在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入參校驗內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：