springboot實現(xiàn)攔截器的3種方式及異步執(zhí)行的思考

更新時間：2021年07月09日 09:24:24 作者：老馬嘯西風

實際項目中，我們經(jīng)常需要輸出請求參數(shù)，響應結(jié)果，方法耗時，統(tǒng)一的權(quán)限校驗等。本文首先為大家介紹 HTTP 請求中三種常見的攔截實現(xiàn)，并且比較一下其中的差異。感興趣的可以了解一下

springboot 攔截器

實際項目中，我們經(jīng)常需要輸出請求參數(shù)，響應結(jié)果，方法耗時，統(tǒng)一的權(quán)限校驗等。

本文首先為大家介紹 HTTP 請求中三種常見的攔截實現(xiàn)，并且比較一下其中的差異。
（1）基于 Aspect 的攔截器
（2）基于 HandlerInterceptor 的攔截器
（3）基于 ResponseBodyAdvice 的攔截器

springboot 入門案例

為了便于大家學習，我們首先從最基本的 springboot 例子講起。

maven 引入

引入必須的 jar 包。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.8.10</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.10</version>
    </dependency>
</dependencies>
<!-- Package as an executable jar -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

啟動類

實現(xiàn)最簡單的啟動類。

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

定義 Controller

為了演示方便，我們首先實現(xiàn)一個簡單的 controller。

@RestController
public class IndexController {

    @RequestMapping("/index")
    public AsyncResp index() {
        AsyncResp asyncResp = new AsyncResp();
        asyncResp.setResult("ok");
        asyncResp.setRespCode("00");
        asyncResp.setRespDesc("成功");

        System.out.println("IndexController#index：" + asyncResp);
        return asyncResp;
    }

}

其中 AsyncResp 的定義如下：

public class AsyncResp {

    private String respCode;

    private String respDesc;

    private String result;


    // getter & setter & toString()
}

攔截器定義

基于 Aspect

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 *
 * @author binbin.hou
 * @since 1.0.0
 */
@Aspect
@Component
@EnableAspectJAutoProxy
public class AspectLogInterceptor {

    /**
     * 日志實例
     * @since 1.0.0
     */
    private static final Logger LOG = LoggerFactory.getLogger(AspectLogInterceptor.class);

    /**
     * 攔截 controller 下所有的 public方法
     */
    @Pointcut("execution(public * com.github.houbb.springboot.learn.aspect.controller..*(..))")
    public void pointCut() {
        //
    }

    /**
     * 攔截處理
     *
     * @param point point 信息
     * @return result
     * @throws Throwable if any
     */
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        try {
            //1. 設置 MDC

            // 獲取當前攔截的方法簽名
            String signatureShortStr = point.getSignature().toShortString();
            //2. 打印入?yún)⑿畔?
            Object[] args = point.getArgs();
            LOG.info("{} 參數(shù): {}", signatureShortStr, Arrays.toString(args));

            //3. 打印結(jié)果
            Object result = point.proceed();
            LOG.info("{} 結(jié)果: {}", signatureShortStr, result);
            return result;
        } finally {
            // 移除 mdc
        }
    }
}

這種實現(xiàn)的優(yōu)點是比較通用，可以結(jié)合注解實現(xiàn)更加靈活強大的功能。

是個人非常喜歡的一種方式。
主要用途：
（1）日志的出參/入?yún)?br /> （2）統(tǒng)一設置 TraceId
（3）方法的調(diào)用耗時統(tǒng)計

基于 HandlerInterceptor

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.DispatcherType;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author binbin.hou
 * @since 1.0.0
 */
@Component
public class LogHandlerInterceptor implements HandlerInterceptor {

    private Logger logger = LoggerFactory.getLogger(LogHandlerInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 統(tǒng)一的權(quán)限校驗、路由等
        logger.info("LogHandlerInterceptor#preHandle 請求地址：{}", request.getRequestURI());

        if (request.getDispatcherType().equals(DispatcherType.ASYNC)) {
            return true;
        }

        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        logger.info("LogHandlerInterceptor#postHandle 調(diào)用");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

然后需要指定對應的 url 和攔截器之間的關(guān)系才會生效：

import com.github.houbb.springboot.learn.aspect.aspect.LogHandlerInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/**
 * spring mvc 配置
 * @since 1.0.0
 */
@Configuration
public class SpringMvcConfig extends WebMvcConfigurerAdapter {

    @Autowired
    private LogHandlerInterceptor logHandlerInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(logHandlerInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/version");
        super.addInterceptors(registry);
    }
}

這種方式的優(yōu)點就是可以根據(jù) url 靈活指定不同的攔截器。
缺點是主要用于 Controller 層。

基于 ResponseBodyAdvice

此接口有beforeBodyWrite方法，參數(shù)body是響應對象response中的響應體，那么我們就可以用此方法來對響應體做一些統(tǒng)一的操作。

比如加密，簽名等。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

import javax.servlet.http.HttpServletRequest;

/**
 * @author binbin.hou
 * @since 1.0.0
 */
@ControllerAdvice
public class MyResponseBodyAdvice implements ResponseBodyAdvice<Object> {

    /**
     * 日志實例
     * @since 1.0.0
     */
    private static final Logger LOG = LoggerFactory.getLogger(MyResponseBodyAdvice.class);

    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        //這個地方如果返回false, 不會執(zhí)行 beforeBodyWrite 方法
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object resp, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        String uri = serverHttpRequest.getURI().getPath();
        LOG.info("MyResponseBodyAdvice#beforeBodyWrite 請求地址：{}", uri);

        ServletServerHttpRequest servletServerHttpRequest = (ServletServerHttpRequest) serverHttpRequest;
        HttpServletRequest servletRequest = servletServerHttpRequest.getServletRequest();

        // 可以做統(tǒng)一的攔截器處理

        // 可以對結(jié)果做動態(tài)修改等
        LOG.info("MyResponseBodyAdvice#beforeBodyWrite 響應結(jié)果：{}", resp);
        return resp;
    }
}

測試

我們啟動應用，頁面訪問：
http://localhost:18080/index
頁面響應：
{"respCode":"00","respDesc":"成功","result":"ok"}

后端日志：

c.g.h.s.l.a.a.LogHandlerInterceptor : LogHandlerInterceptor#preHandle 請求地址：/index
c.g.h.s.l.a.aspect.AspectLogInterceptor : IndexController.index() 參數(shù): []
IndexController#index：AsyncResp{respCode='00', respDesc='成功', result='ok'}
c.g.h.s.l.a.aspect.AspectLogInterceptor : IndexController.index() 結(jié)果: AsyncResp{respCode='00', respDesc='成功', result='ok'}
c.g.h.s.l.a.aspect.MyResponseBodyAdvice : MyResponseBodyAdvice#beforeBodyWrite 請求地址：/index
c.g.h.s.l.a.aspect.MyResponseBodyAdvice : MyResponseBodyAdvice#beforeBodyWrite 響應結(jié)果：AsyncResp{respCode='00', respDesc='成功', result='ok'}
c.g.h.s.l.a.a.LogHandlerInterceptor : LogHandlerInterceptor#postHandle 調(diào)用

這里執(zhí)行的先后順序也比較明確，此處不再贅述。

異步執(zhí)行

當然，如果只是上面這些內(nèi)容，并不是本篇文章的重點。
接下來，我們一起來看下，如果引入了異步執(zhí)行會怎么樣。

定義異步線程池

springboot 中定義異步線程池，非常簡單。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

/**
 * 請求異步處理配置
 *
 * @author binbin.hou
 */
@Configuration
@EnableAsync
public class SpringAsyncConfig {

    @Bean(name = "asyncPoolTaskExecutor")
    public AsyncTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(10);
        executor.setCorePoolSize(10);
        executor.setWaitForTasksToCompleteOnShutdown(true);
        return executor;
    }

}

異步執(zhí)行的 Controller

@RestController
public class MyAsyncController extends BaseAsyncController<String> {

    @Override
    protected String process(HttpServletRequest request) {
        return "ok";
    }

    @RequestMapping("/async")
    public AsyncResp hello(HttpServletRequest request) {
        AsyncResp resp = super.execute(request);

        System.out.println("Controller#async 結(jié)果：" + resp);
        return resp;
    }
}

其中 BaseAsyncController 的實現(xiàn)如下：

@RestController
public abstract class BaseAsyncController<T> {

    protected abstract T process(HttpServletRequest request);

    @Autowired
    private AsyncTaskExecutor taskExecutor;

    protected AsyncResp execute(HttpServletRequest request) {
        // 異步響應結(jié)果
        AsyncResp resp = new AsyncResp();
        try {
            taskExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        T result = process(request);

                        resp.setRespCode("00");
                        resp.setRespDesc("成功");
                        resp.setResult(result.toString());

                    } catch (Exception exception) {
                        resp.setRespCode("98");
                        resp.setRespDesc("任務異常");
                    }
                }
            });
        } catch (TaskRejectedException e) {
            resp.setRespCode("99");
            resp.setRespDesc("任務拒絕");
        }

        return resp;
    }
}

execute 的實現(xiàn)也比較簡單：
（1）主線程創(chuàng)建一個 AsyncResp，用于返回。
（2）線程池異步執(zhí)行具體的子類方法，并且設置對應的值。

思考

接下來，問大家一個問題。
如果我們請求 http://localhost:18080/async，那么：
（1）頁面得到的返回值是什么？
（2）Aspect 日志輸出的返回值是？
（3）ResponseBodyAdvice 日志輸出的返回值是什么？
你可以在這里稍微停一下，記錄下你的答案。

測試

我們頁面請求 http://localhost:18080/async。

頁面響應如下：

{"respCode":"00","respDesc":"成功","result":"ok"}

后端的日志：

c.g.h.s.l.a.a.LogHandlerInterceptor : LogHandlerInterceptor#preHandle 請求地址：/async
c.g.h.s.l.a.aspect.AspectLogInterceptor : MyAsyncController.hello(..) 參數(shù): [org.apache.catalina.connector.RequestFacade@7e931750]
Controller#async 結(jié)果：AsyncResp{respCode='null', respDesc='null', result='null'}
c.g.h.s.l.a.aspect.AspectLogInterceptor : MyAsyncController.hello(..) 結(jié)果: AsyncResp{respCode='null', respDesc='null', result='null'}
c.g.h.s.l.a.aspect.MyResponseBodyAdvice : MyResponseBodyAdvice#beforeBodyWrite 請求地址：/async
c.g.h.s.l.a.aspect.MyResponseBodyAdvice : MyResponseBodyAdvice#beforeBodyWrite 響應結(jié)果：AsyncResp{respCode='00', respDesc='成功', result='ok'}
c.g.h.s.l.a.a.LogHandlerInterceptor : LogHandlerInterceptor#postHandle 調(diào)用

對比一下，可以發(fā)現(xiàn)我們上面問題的答案：
（1）頁面得到的返回值是什么？

{"respCode":"00","respDesc":"成功","result":"ok"}

可以獲取到異步執(zhí)行完成的結(jié)果。
（2）Aspect 日志輸出的返回值是？

AsyncResp{respCode='null', respDesc='null', result='null'}

無法獲取異步結(jié)果。
（3）ResponseBodyAdvice 日志輸出的返回值是什么？

AsyncResp{respCode='00', respDesc='成功', result='ok'}

可以獲取到異步執(zhí)行完成的結(jié)果。

反思

可以發(fā)現(xiàn)，spring 對于頁面的響應也許和我們想的有些不一樣，并不是直接獲取同步結(jié)果。
寫到這里，發(fā)現(xiàn)自己對于 mvc 的理解一直只是停留在表面，沒有真正理解整個流程。
Aspect 的形式在很多框架中都會使用，不過這里會發(fā)現(xiàn)無法獲取異步的執(zhí)行結(jié)果，存在一定問題。

到此這篇關(guān)于springboot實現(xiàn)攔截器的3種方式及異步執(zhí)行的思考的文章就介紹到這了,更多相關(guān)springboot 攔截器內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: