如何在Jackson序列化/反序列化器中获取ContainerRequestContext或HttpHeaders？

问题概述 #

在无Spring依赖的Jersey+Jackson环境中，需要在Jackson的序列化/反序列化器中访问ContainerRequestContext或HttpHeaders，但当前基于ImprovedThreadLocal的实现不稳定，尝试通过DeserializationContext传递请求属性，但对线程安全性存疑。

你尝试的方案的问题 #

你在ContainerRequestFilter中创建新ObjectMapper并修改其DeserializationConfig的方式存在两个核心问题：

• 无效性：Jersey会使用全局配置的ObjectMapper实例处理序列化/反序列化，你创建的新ObjectMapper不会被框架采用，属性传递根本不生效。
• 线程安全风险：如果误操作全局ObjectMapper的配置（而非创建独立的DeserializationConfig实例），会导致多请求间的配置污染，因为ObjectMapper的setConfig方法会替换全局状态。

正确的线程安全实现方式 #

要安全地将请求上下文传递到Jackson的反序列化器，需要利用Jersey的请求作用域注入和Jackson不可变配置的特性，实现步骤如下：

1. 自定义Jackson Provider #

创建继承自JacksonJaxbJsonProvider的自定义Provider，通过@Context注入当前请求的ContainerRequestContext，并在反序列化时为当前请求创建独立的DeserializationConfig：

@Provider
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class RequestAwareJacksonProvider extends JacksonJaxbJsonProvider {

    @Context
    private ContainerRequestContext requestContext;

    @Override
    public Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, 
                           MediaType mediaType, MultivaluedMap<String, String> httpHeaders, 
                           InputStream entityStream) throws IOException {
        ObjectMapper mapper = locateMapper(type, mediaType);
        // 基于全局配置创建带请求上下文的独立配置（DeserializationConfig是不可变的，线程安全）
        DeserializationConfig modifiedConfig = mapper.getDeserializationConfig()
                .withAttribute("containerRequestContext", requestContext);
        
        JsonParser parser = mapper.getFactory().createParser(entityStream);
        // 使用独立配置创建反序列化上下文
        DeserializationContext ctx = mapper.getDeserializationContext(parser, modifiedConfig);
        
        try {
            return mapper.readValue(parser, genericType, ctx);
        } finally {
            parser.close();
        }
    }
}

2. 在反序列化器中获取请求上下文 #

修改你的MyDeserializer，直接从DeserializationContext中获取注入的请求上下文：

public class MyDeserializer<T> extends StdDeserializer<T> {
    public MyDeserializer() {
        super((Class<?>) null);
    }

    @Override
    public T deserialize(JsonParser pJsonParser, DeserializationContext pDeserializationContext) 
            throws IOException {
        // 获取请求上下文
        ContainerRequestContext requestContext = 
                (ContainerRequestContext) pDeserializationContext.getAttribute("containerRequestContext");
        
        // 访问HttpHeaders等信息
        HttpHeaders headers = requestContext.getHeaders();
        String targetHeader = headers.getFirst("X-Custom-Header");
        
        // 执行你的反序列化业务逻辑
        return null;
    }
}

线程安全性说明 #

这种实现是线程安全的，原因如下：

• Jackson配置的不可变性：DeserializationConfig是不可变对象，withAttribute方法会返回一个全新的配置实例，不会修改全局配置，因此多请求间不会互相干扰。
• 请求上下文的隔离：每个请求的DeserializationContext都是独立创建的，仅绑定当前请求的上下文属性，不存在线程间的状态共享。
• Jersey的注入机制：@Context注入的ContainerRequestContext会由Jersey保证在请求处理线程中获取到当前请求的实例，即使是单例Provider也能安全访问请求上下文。

替代方案：使用Jackson InjectableValues #

如果需要更灵活的属性注入，也可以使用Jackson的InjectableValues机制，在Provider中注入请求相关属性：

@Override
public Object readFrom(...) throws IOException {
    ObjectMapper mapper = locateMapper(type, mediaType);
    InjectableValues injectableValues = new InjectableValues.Std()
            .addValue(ContainerRequestContext.class, requestContext);
    
    return mapper.readerFor(genericType)
            .with(injectableValues)
            .readValue(entityStream);
}

然后在反序列化器中通过构造函数或字段注入获取：

public class MyDeserializer<T> extends StdDeserializer<T> {
    private final ContainerRequestContext requestContext;

    @Autowired
    public MyDeserializer(ContainerRequestContext requestContext) {
        super((Class<?>) null);
        this.requestContext = requestContext;
    }

    @Override
    public T deserialize(JsonParser pJsonParser, DeserializationContext pDeserializationContext) 
            throws IOException {
        // 使用注入的requestContext
        return null;
    }
}

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