如何为第三方Option类配置Jackson的content级自定义序列化与反序列化？

Got it, let's tackle this problem with the third-party Option class and Jackson's content-level serialization/deserialization. The core issue here is that Jackson doesn't natively recognize your third-party Option as a container type (unlike java.util.Optional), so we need to teach Jackson how to treat it as one first, then enable the contentUsing annotations to work as expected.

Step 1: Create Container Serializer/Deserializer for the Third-Party Option #

First, we need to write custom serializers and deserializers that tell Jackson this third-party Option holds a single value, just like Optional. These will act as wrappers that delegate to the content-level serializers/deserializers you specify later.

Assuming your third-party Option has methods like isPresent(), get(), empty(), and of() (adjust method names if your library uses different ones):

Third-Party Option Serializer #

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import java.io.IOException;

public class ThirdPartyOptionSerializer extends StdSerializer<com.thirdparty.Option<?>> implements ContextualSerializer {
    private final JsonSerializer<Object> contentSerializer;

    // Default constructor for global registration
    public ThirdPartyOptionSerializer() {
        this(null);
    }

    // Constructor with content serializer (used for contextual setup)
    public ThirdPartyOptionSerializer(JsonSerializer<Object> contentSerializer) {
        super((Class<com.thirdparty.Option<?>>) (Class<?>) com.thirdparty.Option.class);
        this.contentSerializer = contentSerializer;
    }

    @Override
    public void serialize(com.thirdparty.Option<?> value, JsonGenerator gen, SerializerProvider provider) throws IOException {
        if (value.isPresent()) {
            Object content = value.get();
            // Use the content-level serializer if specified, else default
            if (contentSerializer != null) {
                contentSerializer.serialize(content, gen, provider);
            } else {
                provider.defaultSerializeValue(content, gen);
            }
        } else {
            gen.writeNull();
        }
    }

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider prov, com.fasterxml.jackson.databind.BeanProperty property) throws com.fasterxml.jackson.databind.JsonMappingException {
        // Extract the content serializer specified in @JsonSerialize(contentUsing=...)
        if (property != null) {
            com.fasterxml.jackson.databind.annotation.JsonSerialize.TypedSerializeConfig config = property.getAnnotation(com.fasterxml.jackson.databind.annotation.JsonSerialize.class).contentUsing();
            JsonSerializer<Object> serializer = prov.serializerInstance(property.getType().getContentType(), config);
            return new ThirdPartyOptionSerializer(serializer);
        }
        return this;
    }
}

Third-Party Option Deserializer #

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import java.io.IOException;

public class ThirdPartyOptionDeserializer extends StdDeserializer<com.thirdparty.Option<?>> implements ContextualDeserializer {
    private final JsonDeserializer<Object> contentDeserializer;
    private final com.fasterxml.jackson.databind.JavaType contentType;

    // Default constructor for global registration
    public ThirdPartyOptionDeserializer() {
        this(null, null);
    }

    // Constructor with content deserializer and type (used for contextual setup)
    public ThirdPartyOptionDeserializer(JsonDeserializer<Object> contentDeserializer, com.fasterxml.jackson.databind.JavaType contentType) {
        super((Class<com.thirdparty.Option<?>>) (Class<?>) com.thirdparty.Option.class);
        this.contentDeserializer = contentDeserializer;
        this.contentType = contentType;
    }

    @Override
    public com.thirdparty.Option<?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        if (p.getCurrentToken().isNull()) {
            return com.thirdparty.Option.empty();
        }
        // Use the content-level deserializer if specified, else default
        Object content;
        if (contentDeserializer != null && contentType != null) {
            content = contentDeserializer.deserialize(p, ctxt);
        } else {
            content = ctxt.readValue(p, ctxt.getContextualType().getContentType());
        }
        return com.thirdparty.Option.of(content);
    }

    @Override
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, com.fasterxml.jackson.databind.BeanProperty property) throws com.fasterxml.jackson.databind.JsonMappingException {
        if (property != null) {
            com.fasterxml.jackson.databind.JavaType contentType = property.getType().getContentType();
            // Extract the content deserializer specified in @JsonDeserialize(contentUsing=...)
            com.fasterxml.jackson.databind.annotation.JsonDeserialize.TypedDeserializeConfig config = property.getAnnotation(com.fasterxml.jackson.databind.annotation.JsonDeserialize.class).contentUsing();
            JsonDeserializer<Object> deserializer = ctxt.deserializerInstance(property.getType().getContentType(), config);
            return new ThirdPartyOptionDeserializer(deserializer, contentType);
        }
        return this;
    }
}

Step 2: Register the Serializers/Deserializers with Jackson #

Next, we need to register these custom handlers with Jackson's ObjectMapper so it recognizes the third-party Option class globally:

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;

public class JacksonConfig {
    public static ObjectMapper createConfiguredMapper() {
        ObjectMapper mapper = new ObjectMapper();
        SimpleModule thirdPartyOptionModule = new SimpleModule();
        thirdPartyOptionModule.addSerializer(com.thirdparty.Option.class, new ThirdPartyOptionSerializer());
        thirdPartyOptionModule.addDeserializer(com.thirdparty.Option.class, new ThirdPartyOptionDeserializer());
        mapper.registerModule(thirdPartyOptionModule);
        return mapper;
    }
}

Step 3: Use the Content-Level Annotations on Your Container Class #

Now that Jackson treats the third-party Option as a container, you can use the same @JsonSerialize(contentUsing=...) and @JsonDeserialize(contentUsing=...) annotations just like you did with java.util.Optional:

class ThirdPartyContainer {
    @JsonDeserialize(contentUsing = MyDeserializer.class)
    @JsonSerialize(contentUsing = MySerializer.class)
    com.thirdparty.Option<MyClass> content;

    // Getters and setters
}

Key Notes #

• Adjust the method names (like isPresent(), get(), empty(), of()) in the serializers/deserializers to match the actual methods provided by your third-party Option class.
• The ContextualSerializer and ContextualDeserializer interfaces ensure that Jackson picks up the content-level serializer/deserializer specified on individual fields, rather than using a global one for all Option instances.

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