Spring Boot中拦截器的编写

步骤：
1.实现HandlerInterceptor接口；或继承HandlerInterceptorAdapter类；
2.实现WebMvcConfigurer接口，在addInterceptors方法中注册拦截器

说明：
1.HandlerInterceptorAdapter类实现了AsyncHandlerInterceptor接口，该接口继承自HandlerInterceptor接口，比HandlerInterceptor多了一个afterConcurrentHandlingStarted方法
2.方法执行顺序：
    2.1.preHandle在执行controller方法前执行，当preHandle返回为true时，继续往下执行，否则返回
    2.2.postHandle在执行controller方法后，返回结果前执行；具体是在渲染视图前，参数有一个ModelAndView对象，可以对试图进行处理
    2.3.afterCompletion在整个请求流程处理完成后执行，可以用于记录接口耗时等
    2.4.如果controller方法的返回值是java.util.concurrent.Callable类型，执行顺序是：preHandle -> controller方法 -> afterConcurrentHandlingStarted, 用一个新的线程执行 preHandle -> postHandle -> afterCompletion
3.如果有多个拦截器，执行顺序由注册顺序决定（除了preHandle方法，其它方法正好跟注册顺序相反）
    如：有拦截器A和B，注册顺序为A -> B
    拦截器方法的执行顺序为：

A.preHandle -> B.preHandle -> controller方法 -> B.postHandle -> A.postHandle -> B.afterCompletion -> A.afterCompletion

    或（继承了HandlerInterceptorAdapter类，且返回值为java.util.concurrent.Callable类型）：

A.preHandle -> B.preHandle -> controller方法 -> B.afterConcurrentHandlingStarted -> A.afterConcurrentHandlingStarted --启用另一个线程--> A.preHandle -> B.preHandle -> B.postHandle -> A.postHandle -> B.afterCompletion -> A.afterCompletion

另，如果需要在preHandle中打印请求参数，当需要从post的输入流中获取请求体时，由于输入流只能获取一次，会导致controller获取请求体时抛出异常（Required request body is missing），解决办法是继承HttpServletRequestWrapper类，重写getInputStream和getReader方法，并用Filter过滤器在Interceptor拦截器之前，将默认的ServletRequest对象替换为自定义的ServletRequest对象（HttpServletRequestWrapper实现了HttpServletRequest接口，该接口继承自ServletRequest接口）

代码：

编写拦截器：

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.lang.Nullable;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.Charset;

@Slf4j
@Configuration
public class GlobalInterceptor extends HandlerInterceptorAdapter {

    ThreadLocal<Long> threadLocal = new ThreadLocal<>();
    private static final String POST = "POST";
    private static final String GET = "GET";

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String uri = request.getRequestURI();
        String method = request.getMethod();
        String param;
        switch (method) {
            case GET:
                // 或者使用request.getQueryString()方法
                param = JSON.toJSONString(request.getParameterMap());
                break;
            case POST:
                param = getRequestBody(request);
                break;
            default:
                param = "";
        }
        threadLocal.set(System.currentTimeMillis());
        log.info(method + "接口:" + uri + " 请求参数：" + param);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        // 执行controller方法后，返回结果前执行
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
        log.info(request.getMethod() + "接口:" + request.getRequestURI() + "耗时:" + (System.currentTimeMillis() - threadLocal.get()) + "ms");
        // 此处必须手动remove，否则会导致内存泄漏
        threadLocal.remove();
    }

    @Override
    public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 执行返回值为java.util.concurrent.Callable类型的controller方法后，执行该方法
    }

    /**
     * 将输入流转换为字符串
     *
     * @param request 请求
     * @return 输入流转换后的字符串
     * @throws IOException 读取输入流异常
     */
    private String getRequestBody(HttpServletRequest request) throws IOException {
        ServletInputStream inputStream = request.getInputStream();
        byte[] bytes = new byte[1024];
        StringBuilder sb = new StringBuilder();
        int length = inputStream.read(bytes);
        while (length > 0) {
            sb.append(new String(bytes, 0, length, Charset.defaultCharset()));
            length = inputStream.read(bytes);
        }
        return sb.toString();
    }
}

注册拦截器：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class GlobalWebMvcConfigure implements WebMvcConfigurer {
    @Autowired
    private GlobalInterceptor globalInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(globalInterceptor).addPathPatterns("/**").excludePathPatterns("/test/exclude");
    }
}

继承HttpServletRequestWrapper并重写相关方法：

import org.springframework.util.StreamUtils;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class RepeatReadInputStreamHttpServletRequest extends HttpServletRequestWrapper {
    private byte[] bytes;

    public RepeatReadInputStreamHttpServletRequest(HttpServletRequest request) throws IOException {
        super(request);
        bytes = StreamUtils.copyToByteArray(request.getInputStream());
    }

    @Override
    public BufferedReader getReader() {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    @Override
    public ServletInputStream getInputStream() {
        final ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
        return new ServletInputStream() {
            @Override
            public int read() {
                return inputStream.read();
            }

            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {
            }
        };
    }
}

实现Filter接口，并注册拦截器：

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Configuration
public class RequestFilter implements Filter {
    @Autowired
    private RequestFilter requestFilter;
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        ServletRequest requestWrapper = null;
        if (servletRequest instanceof HttpServletRequest) {
            requestWrapper = new RepeatReadInputStreamHttpServletRequest((HttpServletRequest) servletRequest);
        }
        if (requestWrapper == null) {
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            filterChain.doFilter(requestWrapper, servletResponse);
        }
    }
}

 

 

参考文章：

1.https://www.jianshu.com/p/1e8d088c2be9

2.https://www.jianshu.com/p/34b3b5f28de3

3.https://blog.csdn.net/weixin_30613343/article/details/97074846?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param