亚洲综合色成在线观看,欲妇荡岳丰满少妇岳,亚洲综合色无码

SpringBoot通過AOP與注解實現(xiàn)入?yún)⑿ｒ炘斍?/h1>

更新時間：2022年05月17日 11:57:40 作者：??呆呆燦????

這篇文章主要介紹了SpringBoot通過AOP與注解實現(xiàn)入?yún)⑿ｒ炘斍?，文章從相關(guān)問題展開全文內(nèi)容詳情，具有一定的參考價值，需要的小伙伴可以參考一下

前言：

問題源頭：

在日常的開發(fā)中，在Service層經(jīng)常會用到對某一些必填參數(shù)進(jìn)行是否存在的校驗。比如我在寫一個項目管理系統(tǒng)：

這種必填參數(shù)少一些還好，如果多一些的話光是if語句就要寫一堆。像我這種有代碼潔癖的人看著這一堆無用代碼更是難受。

如何解決：

在Spring里面有一個非常好用的東西可以對方法進(jìn)行增強(qiáng)，那就是AOP。AOP可以對方法進(jìn)行增強(qiáng)，比如：我要校驗參數(shù)是否存在，可以在執(zhí)行這個方法之前對請求里面的參數(shù)進(jìn)行校驗判斷是否存在，如果不存在就直接的拋出異常。

因為不是所有的方法都需要進(jìn)行必填參數(shù)的校驗，所以我還需要一個標(biāo)識用來標(biāo)記需要校驗參數(shù)的方法，這個標(biāo)記只能標(biāo)記在方法上。這一部分的功能可以使用Java中的注解來實現(xiàn)。然后配合AOP來實現(xiàn)必填參數(shù)的校驗。

代碼實現(xiàn)：

注解標(biāo)記

這個是標(biāo)記注解的代碼：

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參數(shù)，用來存放必填參數(shù)的Key

通過AOP對方法進(jìn)行增強(qiáng)

需要依賴的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>

因為這里是要在執(zhí)行一個方法之前對傳入的參數(shù)進(jìn)行校驗，所以這里使用到了AOP的環(huán)繞通知

AOP里面的通知方式：

Before:前置通知
After:后置通知
Around：環(huán)繞通知

這里我選用的是環(huán)繞通知，環(huán)繞通知是這幾個通知中最強(qiáng)大的一個功能。我選擇環(huán)繞通知的一個原因是，環(huán)繞通知可以通過代碼來控制被代理方法是否執(zhí)行。

現(xiàn)在需要創(chuàng)建一個切面類，并且該類需要被@Aspect和@Component標(biāo)記：

@Aspect:表明當(dāng)前類是一個切面類
@Component:將其放到IOC里面管理

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

這個類里面加了一個方法有來設(shè)置切點(diǎn)，通過@Pointcut注解

@Pointcut:這個參數(shù)是一個表達(dá)式，其作用是用來指定哪些方法需要被"增強(qiáng)"

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

接下來就是要寫一個增強(qiáng)的方法，因為我是選用的環(huán)繞通知，所以該方法需要被@Around標(biāo)記

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

然后就要具體的來聊一下這個checkParam方法里面要做什么事情了。

首先，這個的功能是校驗參數(shù)，那么首先要做的是將請求的參數(shù)獲取到。這里獲取參數(shù)的方式就要區(qū)分成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獲取到參數(shù)，請求體只能通過getInputStream或者是getReader來獲取到。通過流的方式獲取到后，通過FastJson里面的方法將其轉(zhuǎn)成Map返回就好了

GET

GET方法就簡單了，直接通過getParameterMap方法返回一個Map即可，這里也對直接獲取到的Map做了下處理，通過這個方法獲取到的Map它的泛形是<String,String[]>，我將這個數(shù)組里面的元素通過逗號給拼接了起來形成一個字符串，這樣的話的判斷是否是空的時候就比較容易了。

獲取到參數(shù)后就可以對參數(shù)進(jìn)行校驗是否存在了：

@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 {
        //通過封裝的方法獲取到請求的參數(shù)
        Map<String,String> parameterMap = getRequestParams(request);
        //當(dāng)規(guī)定了必傳參數(shù)，獲取到的參數(shù)里面是空的，這里就直接拋出異常
        if(checkParams.length > 0 && (parameterMap == null || parameterMap.size() == 0)){
            throw new ParamNotRequire("當(dāng)前獲取到的參數(shù)為空");
        }
        //通過循環(huán)判斷requireParam中的屬性名是否在請求參數(shù)的中是否存在
        Arrays.stream(checkParams).forEach(item ->{
            if(!parameterMap.containsKey(item)){
                throw new ParamNotRequire("參數(shù)[" + item + "]不存在");
            }
            if(!StringUtils.hasLength(parameterMap.get(item))){
                throw new ParamNotRequire("參數(shù)[" + item + "]不能為空");
            }
        });
        //這個proceed方法一定要進(jìn)行調(diào)用，否則走不到代理的方法
        Object proceed = proceedingJoinPoint.proceed();
        return proceed;
    } catch (Throwable throwable) {
        //如果參數(shù)不存在會拋出ParamNotRequire異常會被這里捕獲到，在這里重新將其拋出，讓全局異常處理器進(jìn)行處理
        if(throwable instanceof ParamNotRequire){
            throw (ParamNotRequire)throwable;
        }
        throwable.printStackTrace();
    }
    return null;
}

上面的代碼總結(jié)下大概有以下幾步：

0x01:因為所有的參數(shù)都是在HttpServletRequest對象中獲取到的，所要先獲取到HttpServletRequest對象
0x02:其次，還要和CheckRequireParam注解里面requireParam屬性寫的參數(shù)名進(jìn)行對比，所以這里要獲取到這個注解的requireParam屬性
0x03:通過代碼中提供的getRequestParams方法來獲取到請求的參數(shù)
0x04:將requireParam屬性中的值與參數(shù)Map里面的值進(jìn)行對比，如果requireParam中有一個值不存在于parameterMap就會拋出異常
0x05:如果參數(shù)判斷通過，必須要調(diào)用proceed方法，否則會調(diào)用不到被代理的方法

代碼寫到這里，你創(chuàng)建一個Controller,然后寫一個Get方法，程序應(yīng)該是正常運(yùn)行的，并且可以判斷出哪一個參數(shù)沒有傳值。

測試Get請求

創(chuàng)建Controller是很簡單的，這里我只貼出測試要用的代碼：

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

把參數(shù)按照CheckRequireParam注解的規(guī)定傳入是可以正常返回沒有拋出異常：

將age參數(shù)刪除掉，就拋出了參數(shù)不存在的異常：

Get請求測試完美，撒花?。。。?！

測試POST請求

寫一個測試的方法：

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

訪問后并沒有給出對應(yīng)的錯誤信息，不過看后臺是出現(xiàn)了非法狀態(tài)異常：

這個問題的原因是，在使用@RequestBody的時候，它會通過流的方式將數(shù)據(jù)讀出來(getReader或getInputStream)，而這種方式讀取數(shù)據(jù)只能讀取一次，不能讀取第二次。

這里我解決這一問題的方法是先將RequestBody保存為一個byte數(shù)組，然后繼承HttpServletRequestWrapper類覆蓋getReader()和getInputStream()方法，使流從保存的byte數(shù)組讀取。

解決方法代碼

繼承HttpServletRequestWrapper類重寫getInputStream和getReader方法，每次讀的時候讀取保存在requestBody中的數(shù)據(jù)

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