How to reliably detect which ObjectMapper was used inside a ValueSerializer / ValueDeserializer in Jackson 3

[ditogam]

Hello everyone,

In my Spring Boot application, I maintain multiple ObjectMapper instances, for example:

• MAIN — primary mapper
• AUDIT — used for audit log serialization
• OPENSEARCH — used for OpenSearch indexing
• etc.

Inside some serializers/deserializers I need to determine which specific ObjectMapper instance is being used for the current serialization or deserialization.

Previous behavior

In Jackson 2.x I could simply check:

• JsonGenerator.getCodec()
• JsonParser.getCodec()

This allowed me to compare the returned codec with my known ObjectMapper instances.

Problem in Jackson 3

In Jackson 3, getCodec() no longer works reliably, and I cannot determine which mapper initiated the serialization/deserialization.

The only approach I’ve found is:

1. Embed a marker (enum value) into custom SerializationContextExt / DeserializationContextExt.
2. Access that marker via:
   • JsonParser.objectReadContext()
   • JsonGenerator.objectWriteContext()
3. Compare the marker to identify the mapper.

This works, but it feels fragile, overly complex, and likely to break in future versions.

Question

Is there a recommended or cleaner way in Jackson 3 to detect which ObjectMapper instance is being used inside a custom serializer or deserializer?

Any suggestions or hints would be greatly appreciated.

---

Current solution (works but feels too hacky)

ObjectMapperType marker

public enum ObjectMapperType {
    MAIN,
    AUDIT,
    OPENSEARCH
}

Custom JsonMapper.Builder injecting the marker into the context

final class CustomJsonMapperBuilder extends JsonMapper.Builder {
    private final ObjectMapperType type;

    CustomJsonMapperBuilder(ObjectMapperType type, JsonFactory jsonFactory) {
        super(jsonFactory);
        this.type = type;
    }

    @Override
    public JsonMapper build() {
        return new JsonMapper(this);
    }

    @Override
    protected SerializationContexts _defaultSerializationContexts() {
        return new CustomSerializationContexts(this.type);
    }

    @Override
    protected DeserializationContexts _defaultDeserializationContexts() {
        return new CustomDeserializationContexts(this.type);
    }

    public static JsonMapper.Builder builder(ObjectMapperType type) {
        return new CustomJsonMapperBuilder(type, new JsonFactory());
    }

    static final class CustomSerializationContexts extends SerializationContexts.DefaultImpl {
        private final ObjectMapperType type;

        CustomSerializationContexts(ObjectMapperType type) {
            super();
            this.type = type;
        }

        CustomSerializationContexts(TokenStreamFactory tsf, SerializerFactory serializerFactory, SerializerCache cache,
                                    ObjectMapperType type) {
            super(tsf, serializerFactory, cache);
            this.type = type;
        }

        @Override
        public SerializationContexts forMapper(Object mapper, TokenStreamFactory tsf, SerializerFactory serializerFactory,
                                               SerializerCache cache) {
            return new CustomSerializationContexts(tsf, serializerFactory, cache, type);
        }

        @Override
        public SerializationContextExt createContext(SerializationConfig config, GeneratorSettings genSettings) {
            return new CustomSerializationContextExt(_streamFactory, config, genSettings, _serializerFactory, _cache, type);
        }
    }

    @Getter
    static final class CustomSerializationContextExt extends SerializationContextExt {
        private final ObjectMapperType type;

        CustomSerializationContextExt(TokenStreamFactory streamFactory, SerializationConfig config, GeneratorSettings genSettings,
                                      SerializerFactory f, SerializerCache cache, ObjectMapperType type) {
            super(streamFactory, config, genSettings, f, cache);
            this.type = type;
        }
    }

    static final class CustomDeserializationContexts extends DeserializationContexts.DefaultImpl {
        private final ObjectMapperType type;

        CustomDeserializationContexts(ObjectMapperType type) {
            super();
            this.type = type;
        }

        CustomDeserializationContexts(TokenStreamFactory tsf, DeserializerFactory serializerFactory, DeserializerCache cache,
                                      ObjectMapperType type) {
            super(tsf, serializerFactory, cache);
            this.type = type;
        }

        @Override
        public DeserializationContexts forMapper(Object mapper, TokenStreamFactory tsf, DeserializerFactory serializerFactory,
                                                 DeserializerCache cache) {
            return new CustomDeserializationContexts(tsf, serializerFactory, cache, this.type);
        }

        @Override
        public DeserializationContextExt createContext(DeserializationConfig config, FormatSchema schema, InjectableValues injectables) {
            return new CustomDeserializationContextExt(_streamFactory, _deserializerFactory, _cache, config, schema, injectables, type);
        }
    }

    @Getter
    static final class CustomDeserializationContextExt extends DeserializationContextExt {
        private final ObjectMapperType type;

        CustomDeserializationContextExt(TokenStreamFactory tsf,
                                        DeserializerFactory deserializerFactory,
                                        DeserializerCache cache,
                                        DeserializationConfig config,
                                        FormatSchema schema,
                                        InjectableValues values,
                                        ObjectMapperType type) {
            super(tsf, deserializerFactory, cache, config, schema, values);
            this.type = type;
        }
    }
}

Utility methods

public class ObjectMapperUtils {
    public static boolean compareObjectMapper(ObjectMapperType expected, JsonParser p) {
        return p.objectReadContext() instanceof CustomJsonMapperBuilder.CustomDeserializationContextExt ctx
            && expected == ctx.getType();
    }

    public static boolean compareObjectMapper(ObjectMapperType expected, JsonGenerator g) {
        return g.objectWriteContext() instanceof CustomJsonMapperBuilder.CustomSerializationContextExt ctx
            && expected == ctx.getType();
    }
}

Summary

This approach works, but:

• it is verbose
  -it relies on Jackson SPI internals
  -I’m not confident it will remain compatible in the future

I’m looking for a cleaner, officially supported way to achieve this, or confirmation that this is the correct approach in Jackson 3.

Thanks!

[cowtowncoder]

Quick note: no, JsonParser no longer has reference to ObjectMapper that "owns" it -- the purpose for that (to allow calls to data-mapping functionality) is in 3.x fulfilled by passing DeserializationContext. This is intentional (both to remove back-reference itself and to allow proper access to active contexts, which solves a few otherwise tricky issues).

As to how to detect which mapper is being used, I'd probably consider use of "Attributes", which can be set for ObjectReader (public ObjectReader withAttribute(Object key, Object value)) and accessed via DeserializationContext.getAttribute(Object key), to pass some marker value.

I hope this helps!