1.前言

本章主要讲解一些在开发中常用的技术：过滤器、拦截器、消息转换器和 ResponseBodyAdvice，这几个部分都能修改返回值，我觉得有相同的地方。

（1）关于过滤器和拦截器的区别，spring boot 过滤器、拦截器的区别与使用 这篇文章写的很清楚了。主要有以下几个不同：

• 使用范围不同
• 规范不同
• 使用的资源不同
• 深度不同

（2）实现了 ResponseBodyAdvice 这个接口的类，处理返回的json值在传递给HttpMessageConverter之前

2.拦截器

(1) 编写拦截器

(2) 注入拦截器，在SpringMVC中的 Interceptor拦截器才用实现 HandlerInterceptor的方式，实现其中的三个方法。

• preHandle():
  该方法在请求处理之前执行，SpringMVC 中的Interceptor 是链式的调用的，在一个应用中或者说是在一个请求中可以同时存在多个Interceptor 。每个Interceptor 的调用会依据它的声明顺序依次执行，而且最先执行的都是Interceptor 中的preHandle 方法。

• postHandle():
  该方法在请求处理之后执行,但是他会在 DispatcherServlet 进行视图返回渲染之前被调用,所以我们可以在这个方法中对Controller处理之后的 ModeAndView 对象进行操作.需要注意的是,如果 Controller 执行过程中出现了异常,那么并不会执行该方法,而是执行 afterCompletion方法。

• afterCompletion():
  在postHandle执行之后执行，发生异常也会执行，通常用于释放系统资源。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

@Slf4j
@Component
public class JsonConvertInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                           @Nullable ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle ...");
//        ContentCachingResponseWrapper responseWrapper=(ContentCachingResponseWrapper) response;
//        WrapperedResponse wrapResponse = new WrapperedResponse(response);
//        // 获取请求的返回值
//        byte[] data = wrapResponse.getResponseData();
//        String responseBody = new String(data, StandardCharsets.UTF_8);
//        log.info("原始返回数据： " + responseBody);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                                @Nullable Exception ex) throws Exception {
        System.out.println("afterCompletion ...");
    }

}

需要在WebMvcConfigurer 中注册。

问题

（1）拦截器不生效
我在测试拦截器的时候，出现了部分路径无法匹配的问题，后来我还是找到了解决方法。

1
2
3
4
5
6
7
8
9
10
11

@Autowired
private AuthInterceptor authInterceptor; // 认证拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
    // 不生效
    registry.addInterceptor(authInterceptor).addPathPatterns("**/api/**")
    // 生效
    registry.addInterceptor(authInterceptor).addPathPatterns("/**")
    // 生效
    registry.addInterceptor(authInterceptor).addPathPatterns("/**/api/v1/**")
}

3.过滤器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

@Slf4j
public class DataFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        String contentType = request.getContentType();
        WrapperedResponse wrapResponse = new WrapperedResponse((HttpServletResponse) response);

        chain.doFilter(request, wrapResponse);

        byte[] data = wrapResponse.getResponseData();
        String responseBody = new String(data, StandardCharsets.UTF_8);
        log.info("原始返回数据： " + responseBody);
        // 返回报文
        String responseBodyStr = responseBody;
        log.info("处理后返回数据： " + responseBodyStr);
        writeResponse(response, responseBodyStr);
    }

    @Override
    public void destroy() {

    }

    private void writeResponse(ServletResponse response, String responseString) throws IOException {
        response.setContentLength(-1);
        PrintWriter out = response.getWriter();
        out.print(responseString);
        out.flush();
        out.close();
    }
}

4.ResponseBodyAdvice

在返回前端之前可以修改返回值，我使用了 jackson 的命名策略，使用 消息转换器，使用拦截器无法获取返回的内容，配置了过滤器，还没有实现，最后我通过 使用 ResponseBodyAdvice，更方便的解决了问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package com.openmap.drone.configuration;

import com.sun.istack.Nullable;
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.http.server.ServletServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

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

@ControllerAdvice
public class InterceptResponse implements ResponseBodyAdvice<Object> {
    @Override
    public boolean supports(MethodParameter methodParameter,
                            Class<? extends HttpMessageConverter<?>> aClass) {
        return true;
    }
    @Nullable
    @Override
    public Object beforeBodyWrite(@Nullable Object body, MethodParameter methodParameter, MediaType mediaType,
                                  Class<? extends HttpMessageConverter<?>> aClass,
                                  ServerHttpRequest serverHttpRequest,
                                  ServerHttpResponse serverHttpResponse) {
        ServletServerHttpResponse responseTemp = (ServletServerHttpResponse) serverHttpResponse;
        HttpServletResponse resp = responseTemp.getServletResponse();
        ServletServerHttpRequest sshr = (ServletServerHttpRequest) serverHttpRequest;
        HttpServletRequest req = sshr.getServletRequest();
        return body;
    }
}

实现了这个接口的类，处理返回的json值在传递给HttpMessageConverter之前。

5.消息转换器

除了上面的过滤器和拦截器之外，还有消息转换器可以进行返回值的处理。参考文章5写的挺明白的，使用转换器的时候，有下面的注意事项：

（1）系统有默认配置的消息转换器集合。

（2）处理过程会按集合顺序匹配合适的消息转换器，如果有合适的，就会使用该消息转换器处理（读、写），后续的消息转换器不再执行。

（3）自定义的消息转换器要想生效，必须放到集合中相同类型的消息转换器前面，原因参考第二点。
思考：既然自定义的消息转换器必须放到集合中相同类型的消息转换器前面，那是否能直接改动集合中原有的消息转换器来达到自定义的效果，而不必在加一个（暂未没研究）。

（4）添加自定义消息转换器时注意默认消息转换器是否生效

WebMvcConfigurer.configureMessageConverters方法会覆盖默认消息转换器集合
WebMvcConfigurer.extendMessageConverters方法不会覆盖默认消息转换器集合

我们继承了泛型类AbstractHttpMessageConverter，并重写了它的几个方法。

• supports：设置处理哪些类。

• readInternal：处理输入内容，即处理请求值。

• writeInternal：处理输出内容，即处理返回值。

• 构造方法定义了要处理的MediaType。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

  public class ResultMessageConverter extends AbstractHttpMessageConverter<Object> { public ResultMessageConverter(){ super(new MediaType("application", "json", Charset.forName("UTF-8"))); } @Override protected boolean supports(Class<?> clazz) { return HttpResultResponse.class.isAssignableFrom(clazz); // return true; } @Override protected void writeInternal(Object httpResultResponse, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { ObjectMapper objectMapper = new ObjectMapper(); //处理bigDecimal objectMapper.enable(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN); objectMapper.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS); //处理失败 objectMapper.configure(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES, false); objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false); objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_CREATOR_PROPERTIES, false); //默认的处理日期时间格式 objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")); JavaTimeModule javaTimeModule = new JavaTimeModule(); javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))); javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd"))); javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss"))); javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))); javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd"))); javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss"))); objectMapper.registerModule(javaTimeModule); // 命名策略,下划线 objectMapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE); // 执行消息转换 String dataStr=objectMapper.writeValueAsString(httpResultResponse); byte[] bytes = dataStr.getBytes(StandardCharsets.UTF_8); // 写入返回值 outputMessage.getBody().write(bytes); } @Override protected Object readInternal(Class<? extends Object> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException { String source = StreamUtils.copyToString(inputMessage.getBody(),Charset.forName("UTF-8")); return new ObjectMapper().readValue(source, clazz); } }