springboot--拦截器和接口-ResponseBodyAdvice--WebMvcConfigurer-filter

org.springframework.web.servlet.config.annotation.WebMvcConfigurer的实现类和javax.servlet.Filter的实现类在springboot项目中那个先执行呢

在 Spring Boot 项目中，javax.servlet.Filter 的实现类会先于 WebMvcConfigurer 配置的拦截器（Interceptor）执行。以下是详细说明：

---

执行顺序

1. Filter（过滤器）

   • 属于 Servlet 规范 的组件，作用于 Servlet 容器层。
   • 执行时机：在请求进入 DispatcherServlet 之前，以及响应返回给客户端之前。
   • 顺序控制：通过 @Order 注解或 FilterRegistrationBean 设置优先级。

2. WebMvcConfigurer 配置的拦截器（Interceptor）

   • 属于 Spring MVC 框架 的组件，作用于 Spring MVC 层。
   • 执行时机：在 DispatcherServlet 处理请求的过程中（Controller 方法调用前后）。
   • 顺序控制：通过 @Order 注解或 addInterceptor 方法的调用顺序。

---

请求处理流程

客户端请求 → 
  Servlet 容器层（Filter 链） → 
    DispatcherServlet → 
      Spring MVC 拦截器链（preHandle → Controller → postHandle → afterCompletion） → 
        响应返回客户端（再次经过 Filter 链）

---

关键区别

组件	层级	执行阶段	配置方式
Filter	Servlet 容器层	全局请求处理（请求到达 DispatcherServlet 前/后）	@Component + @Order 或 FilterRegistrationBean
Interceptor	Spring MVC 框架层	针对 Spring MVC 请求（Controller 方法前后）	WebMvcConfigurer.addInterceptors() + @Order

---

代码示例

1. Filter 实现类

@Component
@Order(1) // 控制 Filter 执行顺序（数字越小优先级越高）
public class CustomFilter implements Filter {
    @Override
    public void doFilter(
        ServletRequest request, 
        ServletResponse response, 
        FilterChain chain
    ) throws IOException, ServletException {
        System.out.println("Filter 执行前");
        chain.doFilter(request, response);
        System.out.println("Filter 执行后");
    }
}

2. WebMvcConfigurer 配置的拦截器

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new CustomInterceptor())
                .addPathPatterns("/**")
                .order(2); // 控制拦截器执行顺序
    }
}

// 拦截器类
public class CustomInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        System.out.println("Interceptor preHandle");
        return true;
    }

    @Override
    public void postHandle(...) {
        System.out.println("Interceptor postHandle");
    }

    @Override
    public void afterCompletion(...) {
        System.out.println("Interceptor afterCompletion");
    }
}

---

输出结果

Filter 执行前    → Filter 先执行
Interceptor preHandle → 拦截器在 Filter 之后执行
Controller 方法处理...
Interceptor postHandle
Interceptor afterCompletion
Filter 执行后    → Filter 在响应返回前再次执行

---

总结

• Filter 先于 Interceptor 执行：因 Filter 属于 Servlet 容器层，处理请求更早。
• 执行范围不同：
  • Filter 可处理所有请求（包括静态资源）。
  • Interceptor 仅处理 Spring MVC 路由的请求。
• 用途差异：
  • Filter 适合全局性操作（如日志、跨域、权限）。
  • Interceptor 适合与业务逻辑相关的操作（如认证、参数校验）。

包装HttpServletRequest

添加链接描述

问题

目标

1 你可以在自己的日志中看到自己接口的出参和入参，同时你不用在每个接口中写打印的逻辑，直接交给拦截器完成。
2 你可以任意包装你的出参，比如加上消耗的时间，添加一个唯一的uuid等等，同时这些东西都是由拦截器提供的功能。这些功能也可以做成配置化，比如你那些接口不需要这样的包装，在yml中配置一下，就可以了。

core class for this function

import org.springframework.web.servlet.HandlerInterceptor
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

接口模样:

@RestController
public class TestController{
@RequestMapping(value = "/test")
public Object test(){
return "hello word";
}
}

每次接口请求都会输出param，路径 消耗的时间

接口正常输出就是hello word，可是包装后

copy thoese code for use

package wl.log.intercept.interceptor;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Objects;

/**
 * @program: log-intercepter
 * @description: 日志拦截器
 * @create: 2020-05-02 20:52
 * 描述：
 */
@Slf4j
public class LogIntercepter implements HandlerInterceptor {
// 妈的，每次写接口都要你添加日志，监控你的 出入，累不累，直接用拦截器，他不香吗？
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod h = (HandlerMethod) handler;
            log.info("method is {}, param is{} ,path is {}",h.getMethod().getName(), JSON.toJSON(request.getParameterMap()),request.getRequestURI());
            request.setAttribute("startTime",System.currentTimeMillis());
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        Long startTime = (Long)request.getAttribute("startTime");
        //在info级别才打印
        if (Objects.nonNull(startTime)&&log.isInfoEnabled()) {
         log.info("the url use time is {}",System.currentTimeMillis()-startTime);
        }

    }

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

    }
}

WebMvcConfigurer code

package wl.log.intercept.interceptor;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.handler.MappedInterceptor;

/**
 * @program: log-intercepter
 * @create: 2020-05-02 21:12
 * 描述：
 */
@SpringBootConfiguration
public class CustomerWebMVCConfig implements WebMvcConfigurer {
    /**
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LogIntercepter()).addPathPatterns("/**");
    }
}

web 响应拦截器

package wl.log.intercept.interceptor;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
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.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
import wl.log.intercept.entity.global.ResponseResult;

import java.util.Objects;

/**
 * @program: log-intercepter
 * @description:
 * @create: 2020-05-02 22:30
 */
@ControllerAdvice
public class ApiResultIntercepter implements ResponseBodyAdvice<Object> {
    /**
     *  判断哪些需要拦截
     */
    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object body,
     MethodParameter returnType,
      MediaType selectedContentType, 
      Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request,
       ServerHttpResponse response) {
        //
        ResponseResult finalResult = null;
        Class bodyClass = body != null ? body.getClass() : null;
        // handle body  many conditions
        if(Objects.isNull(body)) {
            finalResult = ResponseResult.data(null).setCode(200);
        }else {
            finalResult = ResponseResult.data(body).setCode(200);
        }
         return String.class == bodyClass ? JSON.toJSONString(finalResult, SerializerFeature.WriteNullStringAsEmpty) : finalResult;
    }
}

demo已经写好，请拿去使用吧

https://download.youkuaiyun.com/download/wlwork66/12390425

WebMvcConfigurer

WebMvcConfigurerAdapter已经过时，在新版本2.x中被废弃，原因是springboot2.0以后，引用的是spring5.0，而spring5.0取消了WebMvcConfigurerAdapter ,现在都是直接实现WebMvcConfigure

/** 解决跨域问题 **/
public void addCorsMappings(CorsRegistry registry) ;
/** 添加拦截器 **/
void addInterceptors(InterceptorRegistry registry);
/** 这里配置视图解析器 **/
void configureViewResolvers(ViewResolverRegistry registry);
/** 配置内容裁决的一些选项 **/
void configureContentNegotiation(ContentNegotiationConfigurer configurer);
/** 视图跳转控制器 **/
void addViewControllers(ViewControllerRegistry registry);
/** 静态资源处理 **/
void addResourceHandlers(ResourceHandlerRegistry registry);
/** 默认静态资源处理器 **/
void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer);

HandlerInterceptor

SpringWebMVC的处理器拦截器，类似于Servlet开发中的过滤器Filter，用于处理器进行预处理和后处理。

使用的场景

　 1、日志记录，可以记录请求信息的日志，
　 以便进行信息监控、信息统计、计算PV（Page View）等等。
　　2、权限检查：如登陆检测，进入处理器检测是否登陆，
　　如果没有直接返回到登陆页面。
　　3、性能监控：有时候系统在某段时间莫名其妙的慢，
　　可以通过拦截器在进入处理器之前记录开始时间，在处理完后记录结束时间，从而得到该请求的处理时间（如果有反向代理，如apache可以自动记录）；

　　4、通用行为：读取cookie得到用户信息并将用户对象放入请求，
　　从而方便后续流程使用，还有如提取Locale、Theme信息等，
　　只要是多个处理器都需要的即可使用拦截器实现。
　　5:原理
　　本质也是AOP（面向切面编程），也就是说符合横切关注点的所有功能都可以放入拦截器实现。
 

public interface HandlerInterceptor {

   /**
     * 预处理回调方法，实现处理器的预处理（如检查登陆），
     * 第三个参数为响应的处理器，自定义Controller
     * 返回值：true表示继续流程（如调用下一个拦截器或处理器）；
     * 　　　*       false表示流程中断（如登录检查失败），
     * 不会继续调用其他的拦截器或处理器，
     * 此时我们需要通过response来产生响应；
   */
    boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception;
   /**
     * 后处理回调方法，实现处理器的后处理（但在渲染视图之前），
     * 此时我们可以通过modelAndView（模型和视图对象）
     * 对模型数据进行处理或对视图进行处理，
     * modelAndView也可能为null。
   */
    void postHandle(
            HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
            throws Exception;
   /**
    * 整个请求处理完毕回调方法，即在视图渲染完毕时回调，
    * 如性能监控中我们可以在此记录结束时间并输出消耗时间，
    * 还可以进行一些资源清理，类似于try-catch-finally中的finall
　　 * 但仅调用处理器执行链中preHandle返回true的拦截器的afterCompletion。
   */
    void afterCompletion(
            HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception;
}

click

how

ResponseBodyAdvice接口是在Controller执行return之后，在response返回给浏览器或者APP客户端之前，执行的对response的一些处理。可以实现对response数据的一些统一封装或者加密等操作。

@Override
    //判断是否要执行beforeBodyWrite方法，true为执行，false不执行
    //有些情况是不需要进行封装的,所以这个方法非常nice
    public boolean supports(MethodParameter returnType, Class converterType) {
        return false;
    }

    @Override
    //对response处理的执行方法
    public Object beforeBodyWrite(Object body, MethodParameter returnType,
            MediaType selectedContentType, Class selectedConverterType,
            ServerHttpRequest request, ServerHttpResponse response) {
        return null;
    }

eg ------ Controller类，返回参数为OutputObject（一个自定义的javaBean），我们要通过ResponseBodyAdvice，对该类的所有方法返回的OutputObject中的部分数据进行统一加密处理。

package com.cmos.edcreg.web.intercepter;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
import com.alibaba.fastjson.JSON;
import com.cmos.edcreg.beans.common.OutputObject;
import com.cmos.edcreg.utils.StringUtil;
import com.cmos.edcreg.utils.des.DesSpecial;
import com.cmos.edcreg.utils.enums.ReturnInfoEnums;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 对响应报文统一处理，对bean内容进行加密
 * @author qiaozhong
 */
@Component
//声明该类要处理的包路径
@ControllerAdvice("com.cmos.edcreg.web.controller")
public class ResponseAdvice implements ResponseBodyAdvice {
    
    private final Logger logger = LoggerFactory.getLogger(ResponseAdvice.class);
    
    /* 
     * 对response处理的具体方法
     * arg0为返回的报文体，arg0为org.json.jsonObject，使用alibaba.json方法转换时候报错了
     */
    @Override
    public Object beforeBodyWrite(Object arg0, MethodParameter arg1,
            MediaType arg2, Class arg3, ServerHttpRequest arg4,
            ServerHttpResponse arg5) {
        OutputObject out = new OutputObject();
        try {
            //arg0转换为OutputObject类型
            ObjectMapper objectMapper=new ObjectMapper();
            out = objectMapper.readValue(org.json.JSONObject.valueToString(arg0), OutputObject.class);
            //获取加密密钥
            String oldEncryptKey = out.getBean().get("oldEncryptKey");
            //获取加密字符串
            DesSpecial des = new DesSpecial();
            String encryptData = des.strEnc(JSON.toJSONString(out.getBean()), oldEncryptKey, null, null);
            //封装数据（清除原来数据，放入加密数据）
            out.getBean().clear();
            out.getBean().put("data", encryptData);
            return out;
        } catch (Exception e) {
            logger.error("返回报文处理出错", e);
            out.setReturnCode(ReturnInfoEnums.PROCESS_ERROR.getCode());
            out.setReturnMessage(ReturnInfoEnums.PROCESS_ERROR.getMessage());
            return out;
        }
    }

    /* 
     * 选择哪些类，或哪些方法需要走beforeBodyWrite
     * 从arg0中可以获取方法名和类名
     * arg0.getMethod().getDeclaringClass().getName()为获取方法名
     */
    @Override
    public boolean supports(MethodParameter arg0, Class arg1) {
        if("com.cmos.edcreg.web.controller.GdH5AppointmentActiveVideoNewController".equals(arg0.getMethod().getDeclaringClass().getName())){
            return true;
        }else{
            return false;
        }
    }
}