如何在不使用@ControllerAdvice或HandlerInterceptor的情况下在Jackson序列化前处理响应

Absolutely! There are a couple of underrated, Spring-native approaches to intercept and modify controller responses before they’re serialized and passed to the HttpServlet—no @ControllerAdvice or HandlerInterceptor required. Let’s dive into the most practical options:

1. Custom HttpMessageConverter (Jackson-Specific) #

Spring uses HttpMessageConverter instances to handle the serialization/deserialization of request/response bodies. For Jackson-based JSON responses, you can extend MappingJackson2HttpMessageConverter and override its core serialization method to inject your custom logic.

This approach hooks directly into the serialization pipeline, making it a precise way to modify objects or adjust Jackson settings right before they’re converted to JSON.

Here’s a concrete example:

@Component
public class CustomJacksonConverter extends MappingJackson2HttpMessageConverter {

    @Override
    protected void writeInternal(Object object, Type type, HttpOutputMessage outputMessage) throws IOException {
        // Add your pre-serialization logic here
        if (object instanceof UserResponse) {
            // Modify the response object directly
            ((UserResponse) object).setLastUpdated(LocalDateTime.now());
        }

        // Optional: Temporarily adjust Jackson configuration
        ObjectMapper mapper = getObjectMapper();
        boolean originalTimestampSetting = mapper.isEnabled(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        try {
            // Disable timestamp formatting for this response
            mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
            // Proceed with default serialization
            super.writeInternal(object, type, outputMessage);
        } finally {
            // Restore original configuration to avoid side effects
            mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, originalTimestampSetting);
        }
    }
}

2. ResponseBodyAdvice (Registered as a Plain Bean) #

You might think ResponseBodyAdvice requires @ControllerAdvice, but that’s not true! You can implement this interface and register it as a regular Spring @Component—Spring’s request processing pipeline will automatically pick it up.

This lets you modify the response body right before it’s passed to the message converter for serialization. It’s great for cross-cutting changes like adding metadata or sanitizing fields.

Example implementation:

@Component
public class PreSerializationResponseAdvice implements ResponseBodyAdvice<Object> {

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        // Only apply to Jackson-based JSON responses
        return converterType.isAssignableFrom(MappingJackson2HttpMessageConverter.class);
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
                                  Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                  ServerHttpRequest request, ServerHttpResponse response) {
        // Modify the response body or add custom headers
        if (body instanceof ApiResponse<?>) {
            ((ApiResponse<?>) body).setRequestId(request.getHeaders().getFirst("X-Request-ID"));
        }
        return body;
    }
}

3. Custom DispatcherServlet Wrapper (Low-Level Control) #

For full, low-level control over the entire request/response lifecycle, you can extend DispatcherServlet and override its doDispatch method. This lets you intercept the response after it’s processed by the controller but before it’s sent to the HttpServlet.

Note: This is more complex because you’ll need to wrap the HttpServletResponse to capture and modify the output stream (since the response might already be committed by the time you intercept it).

Example skeleton:

public class CustomDispatcherServlet extends DispatcherServlet {

    @Override
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // Wrap the response to capture output
        ContentCachingResponseWrapper wrappedResponse = new ContentCachingResponseWrapper(response);
        
        // Let Spring process the request normally
        super.doDispatch(request, wrappedResponse);
        
        // Modify the response if it hasn't been committed yet
        if (!wrappedResponse.isCommitted()) {
            // Read the cached response content
            byte[] responseBytes = wrappedResponse.getContentAsByteArray();
            String responseBody = new String(responseBytes, wrappedResponse.getCharacterEncoding());
            
            // Apply your custom logic (e.g., modify JSON content)
            String modifiedBody = responseBody.replace("\"status\":\"success\"", "\"status\":\"custom-success\"");
            
            // Write the modified content back to the original response
            wrappedResponse.resetBuffer();
            wrappedResponse.getOutputStream().write(modifiedBody.getBytes(wrappedResponse.getCharacterEncoding()));
            wrappedResponse.copyBodyToResponse();
        }
    }
}

To use this, you’ll need to register your custom servlet in your Spring configuration (replacing the default DispatcherServlet).

Recommendation #

For most use cases, Option 1 or 2 is the way to go. They integrate seamlessly with Spring’s existing response processing flow, are easier to maintain, and avoid the complexity of low-level stream manipulation.

内容的提问来源于stack exchange，提问作者MaxExplode