本文介绍了一种日志拦截器的实现方法，能够自动记录API的出入参及执行时间，减轻程序员负担。同时，展示了如何使用ResponseBodyAdvice对响应结果进行统一处理，包括数据包装和性能监控。
org.springframework.web.servlet.config.annotation.WebMvcConfigurer的实现类和javax.servlet.Filter的实现类在springboot项目中那个先执行呢
在 Spring Boot 项目中，javax.servlet.Filter 的实现类会先于 WebMvcConfigurer 配置的拦截器（Interceptor）执行。以下是详细说明：
执行顺序
-
Filter（过滤器）- 属于 Servlet 规范 的组件，作用于 Servlet 容器层。
- 执行时机：在请求进入
DispatcherServlet之前，以及响应返回给客户端之前。 - 顺序控制：通过
@Order注解或FilterRegistrationBean设置优先级。
-
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适合与业务逻辑相关的操作（如认证、参数校验）。
问题
目标
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;
}
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;
}
}
}
扫一扫
955
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
