JAX-RS应用中无需修改POJO配置Jackson多态序列化与反序列化

Great question—this is such a common scenario when working with locked-down or third-party POJOs in JAX-RS apps. The good news is Jackson has built-in, robust ways to handle polymorphic serialization/deserialization without touching your existing POJOs at all. Here are the two most reliable approaches:

1. Use Jackson Mix-In Annotations #

This is the most straightforward and widely adopted method. Mix-ins let you "attach" Jackson annotations to a class indirectly, no edits to the original POJO required.

Step 1: Create a Mix-In Class #

Define a dummy abstract class (or interface) with the @JsonTypeInfo and @JsonSubTypes annotations you’d normally add to your base POJO:

// No actual logic here—this just carries the annotations we need
@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.PROPERTY,
    property = "type" // The field Jackson will use to identify subtypes
)
@JsonSubTypes({
    @JsonSubTypes.Type(value = OrderSubType.class, name = "order"),
    @JsonSubTypes.Type(value = PaymentSubType.class, name = "payment")
})
public abstract class BaseEntityMixIn {}

Step 2: Bind the Mix-In to Your Base POJO #

Register the mix-in with Jackson’s ObjectMapper so it applies to your immutable base class. In a JAX-RS app, you’ll do this via a ContextResolver to ensure your custom mapper is used globally:

@Provider
public class CustomObjectMapperProvider implements ContextResolver<ObjectMapper> {
    private final ObjectMapper objectMapper;

    public CustomObjectMapperProvider() {
        objectMapper = new ObjectMapper();
        // Link the mix-in to your actual base POJO class
        objectMapper.addMixIn(BaseEntity.class, BaseEntityMixIn.class);
    }

    @Override
    public ObjectMapper getContext(Class<?> type) {
        return objectMapper;
    }
}

Don’t forget to register this provider with your JAX-RS runtime (e.g., in your Application subclass, or via web.xml if you’re using an older setup like Jersey or RESTEasy).

2. Programmatic Type Resolver Configuration via a Jackson Module #

If you want to avoid annotations entirely (even on mix-ins), you can build a custom Module to set up polymorphic handling programmatically:

Step 1: Create a Custom Module #

public class PolymorphicTypeModule extends SimpleModule {
    @Override
    public void setupModule(SetupContext context) {
        super.setupModule(context);
        
        // Build a type resolver for your base POJO
        TypeResolverBuilder<?> typeResolver = new StdTypeResolverBuilder()
            .init(JsonTypeInfo.Id.NAME, null)
            .inclusion(JsonTypeInfo.As.PROPERTY)
            .typeProperty("type")
            .registerSubtypes(
                new NamedType(OrderSubType.class, "order"),
                new NamedType(PaymentSubType.class, "payment")
            );
        
        // Apply this resolver to your base POJO
        context.addTypeResolver(typeResolver);
    }
}

Step 2: Register the Module with Your ObjectMapper #

Again, use a ContextResolver to make this module available to all JAX-RS endpoints:

@Provider
public class CustomObjectMapperProvider implements ContextResolver<ObjectMapper> {
    private final ObjectMapper objectMapper;

    public CustomObjectMapperProvider() {
        objectMapper = new ObjectMapper();
        objectMapper.registerModule(new PolymorphicTypeModule());
    }

    @Override
    public ObjectMapper getContext(Class<?> type) {
        return objectMapper;
    }
}

Quick Tips for JAX-RS Environments #

• Double-check that your CustomObjectMapperProvider is properly registered—this ensures endpoints don’t fall back to the default, unconfigured mapper.
• Adjust JsonTypeInfo parameters (like include or property) to match your desired JSON structure (e.g., use As.WRAPPER_OBJECT if you prefer wrapping subtypes instead of adding a type property).
• Both methods support multiple base POJOs—just add more mix-ins or extend the module logic to cover additional classes.

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