SpringBoot HandlerInterceptorAdapter

在SpringBoot中我们可以使用HandlerInterceptorAdapter这个适配器来实现自己的拦截器。这样就可以拦截所有的请求并做相应的处理。

应用场景

• 日志记录，可以记录请求信息的日志，以便进行信息监控、信息统计等。
• 权限检查：如登陆检测，进入处理器检测是否登陆，如果没有直接返回到登陆页面。
• 性能监控：典型的是慢日志。

在HandlerInterceptorAdapter中主要提供了以下的方法：
preHandle：在方法被调用前执行。在该方法中可以做类似校验的功能。如果返回true，则继续调用下一个拦截器。如果返回false，则中断执行，也就是说我们想调用的方法 不会被执行，但是你可以修改response为你想要的响应。
postHandle：在方法执行后调用。
afterCompletion：在整个请求处理完毕后进行回调，也就是说视图渲染完毕或者调用方已经拿到响应。

在HandlerInterceptorAdapter中主要提供了以下的方法：

• preHandle：在方法被调用前执行。在该方法中可以做类似校验的功能。如果返回true，则继续调用下一个拦截器。如果返回false，则中断执行，也就是说我们想调用的方法 不会被执行，但是你可以修改response为你想要的响应。
• postHandle：在方法执行后调用。
• afterCompletion：在整个请求处理完毕后进行回调，也就是说视图渲染完毕或者调用方已经拿到响应。

HandlerInterceptor

 拦截器适配器HandlerInterceptorAdapter

package org.springframework.web.servlet.handler;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.lang.Nullable;
import org.springframework.web.servlet.AsyncHandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public abstract class HandlerInterceptorAdapter implements AsyncHandlerInterceptor {
    public HandlerInterceptorAdapter() {
    }

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }

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

    public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    }
}

 

运行流程总结如下：

1. 拦截器执行顺序是按照Spring配置文件中定义的顺序而定的。
2. 会先按照顺序执行所有拦截器的preHandle方法，一直遇到return false为止，比如第二个preHandle方法是return false，则第三个以及以后所有拦截器都不会执行。若都是return true，则按顺序加载完preHandle方法。
3. 然后执行主方法（自己的controller接口），若中间抛出异常，则跟return false效果一致，不会继续执行postHandle，只会倒序执行afterCompletion方法。
4. 在主方法执行完业务逻辑（页面还未渲染数据）时，按倒序执行postHandle方法。若第三个拦截器的preHandle方法return false，则会执行第二个和第一个的postHandle方法和afterCompletion（postHandle都执行完才会执行这个，也就是页面渲染完数据后，执行after进行清理工作）方法。（postHandle和afterCompletion都是倒序执行）

接下来是项目中的实际应用：

@Component
public class CustomInterceptor extends HandlerInterceptorAdapter {

    private final static Logger logger = LoggerFactory.getLogger(CustomInterceptor.class);
    private final static ThreadLocal<Map<String, Object>> threadLocal = new ThreadLocal<Map<String, Object>>();
    
    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response, Object handler) throws Exception {

        Thread thread = Thread.currentThread();
        Map<String, Object> map = new HashMap<>();
        map.put("threadName", thread.getName());
        map.put("startTime", System.currentTimeMillis());
        threadLocal.set(map);
        String url = request.getRequestURL().toString();
        String method = request.getMethod();
        String uri = request.getRequestURI();
        String queryString = request.getQueryString();
        String remortIP = getRemortIP(request);
        logger.info(String.format("请求参数, url: %s, method: %s, uri: %s, params: %s, remortIP: %s", url, method, uri, queryString, remortIP));

        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        Method methods = ((HandlerMethod) handler).getMethod();
        ActionAnnotation annotation = methods.getAnnotation(ActionAnnotation.class);
        if (annotation == null) {
            return true;
        }

        String[] paramKey = annotation.params();
        Map<String, String> params = new HashMap<String, String>();
        for (int i = 0; i < paramKey.length; i++) {
            String param = request.getParameter(paramKey[i]);
            if (!"sign".equals(paramKey[i])) {
                params.put(paramKey[i], param);
            }
            logger.info("param: {} >>> {}", paramKey[i], param);
        }
        // 登录校验
        String token = request.getHeader("accessToken");
        if (annotation.check() == ActionAnnotation.Type.LOGIN || annotation.check() == ActionAnnotation.Type.LOGIN_GROUP) {
            if (StringUtils.isEmpty(token)) {
                throw new ServiceException(SysCode.NOT_LOGIN);
            }

            Serializable userId = (Serializable) redisTemplate.opsForValue().get("user:token:" + token);
            if (userId == null) {
                throw new ServiceException(SysCode.NOT_LOGIN);
            }
        }
        //接口限流
        if (StringUtils.isNotEmpty(token)) {
            boolean lock = RedisLock.lock1("lock:user:" + token + uri, redisTemplate);
            if (!lock) {
                throw new ServiceException(SysCode.REQUEST_OFTEN);
            }
        }
        request.setAttribute("params", params);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response, Object handler,
                           ModelAndView modelAndView) throws Exception {
        super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        if (!(handler instanceof HandlerMethod)) {
            return;
        }
        Map params = threadLocal.get();
        String uri = request.getRequestURI();
        long startTime = (long) params.get("startTime");
        long endTime = System.currentTimeMillis();
        long time = endTime - startTime;
        if (time < 1000) {
            logger.info("请求耗时: {}, {}ms", uri, time);
        } else {
            logger.warn("请求耗时过长: {}, {}ms", uri, time);
        }
        String token = request.getHeader("token");
        if (StringUtils.isNotEmpty(token)) {
            redisTemplate.delete("lock:user:" + token + uri);
        }
        super.afterCompletion(request, response, handler, ex);
    }

    public String getRemortIP(HttpServletRequest request) {
        if (request.getHeader("x-forwarded-for") == null) {
            return request.getRemoteAddr();
        }
        return request.getHeader("x-forwarded-for");
    }
}