Jackson3 Deserialization with Properties Based constructor fails with tools.jackson.databind.exc.InvalidDefinitionException

[buksvdl]

Search before asking

• I searched in the issues and found nothing similar.

Describe the bug

Deserialization fails with InvalidDefinitionException: Cannot construct instance of AuditEvent (no Creators, like default constructor, exist): cannot deserialize from Object value (no delegate- or property-based Creator)

Version Information

3.0.3

Reproduction

The Test attempts to serialize and deserialize the AuditEvent class described below but fails on Deserialization with:
tools.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of AuditEvent` (no Creators, like default constructor, exist): cannot deserialize from Object value (no delegate- or property-based Creator)
at [Source: (String)"{"timestamp":"2026-01-17T21:00:44.532975Z","principal":"user","type":"type","data":{"keyA":"ValueA","KeyB":"ValueB"}}"; line: 1, column: 2]

at tools.jackson.databind.exc.InvalidDefinitionException.from(InvalidDefinitionException.java:70)
at tools.jackson.databind.DeserializationContext.reportBadDefinition(DeserializationContext.java:1950)
at tools.jackson.databind.DatabindContext.reportBadDefinition(DatabindContext.java:448)
at tools.jackson.databind.DeserializationContext.handleMissingInstantiator(DeserializationContext.java:1480)
at tools.jackson.databind.deser.bean.BeanDeserializerBase.deserializeFromObjectUsingNonDefault(BeanDeserializerBase.java:1432)
at tools.jackson.databind.deser.bean.BeanDeserializer.deserializeFromObject(BeanDeserializer.java:480)
at tools.jackson.databind.deser.bean.BeanDeserializer.deserialize(BeanDeserializer.java:200)
at tools.jackson.databind.deser.DeserializationContextExt.readRootValue(DeserializationContextExt.java:265)`

Class for Serialization/Deserialization tests:

/**
 * Copied from Spring Boot 4.0.0 for testing purposes.
 * {@link org.springframework.boot.actuate.audit.AuditEvent}
 * Simplified version for Jackson3 Deserializer issues.
 */
public class AuditEvent implements Serializable {
    
    private final Instant timestamp;    
    private final String principal;    
    private final String type;    
    private final Map<String, @Nullable Object> data;
    
    /**
     * Create a new audit event for the current time from data provided as name-value
     * pairs.
     * @param principal the user principal responsible
     * @param type the event type
     * @param data the event data in the form 'key=value' or simply 'key'
     */
    public AuditEvent(@Nullable String principal, String type, String... data) {
        this(Instant.now(), principal, type, convert(data));
    }
    
    /**
     * Create a new audit event.
     * @param timestamp the date/time of the event
     * @param principal the user principal responsible
     * @param type the event type
     * @param data the event data
     */
    public AuditEvent(Instant timestamp, @Nullable String principal, String type, Map<String, @Nullable Object> data) {
        Assert.notNull(timestamp, "'timestamp' must not be null");
        Assert.notNull(type, "'type' must not be null");
        this.timestamp = timestamp;
        this.principal = (principal != null) ? principal : "";
        this.type = type;
        this.data = Collections.unmodifiableMap(data);
    }
    
    private static Map<String, @Nullable Object> convert(String[] data) {
        Map<String, @Nullable Object> result = new HashMap<>();
        for (String entry : data) {
            int index = entry.indexOf('=');
            if (index != -1) {
                result.put(entry.substring(0, index), entry.substring(index + 1));
            }
            else {
                result.put(entry, null);
            }
        }
        return result;
    }
............................

The Test:

@ActiveProfiles("test")
@SpringJUnitConfig({JacksonConfig.class})
@WebMvcTest
public class AuditEventDeserializeMvcItVal {
    
    @Autowired
    private JsonMapper jsonMapper;
    
    private AuditEvent startAuditEvent;
    private String startAuditEventJson;
    private String startAuditEventString;
    
    private JsonMapper jsonMapperManual;
    
    @BeforeEach
    void serialize(){
        
        startAuditEvent = new AuditEvent("user", "type", "keyA=ValueA","KeyB=ValueB");
        startAuditEventJson = jsonMapper.writeValueAsString(startAuditEvent);
        startAuditEventString = startAuditEvent.toString();
        System.out.println("Starting AuditEvent Json: %s".formatted(startAuditEventJson));
        System.out.println("Starting AuditEvent String: %s".formatted(startAuditEventString));
        
        jsonMapperManual =
            JsonMapper
                .builder()
                .enable(StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION)
                .constructorDetector(ConstructorDetector.USE_PROPERTIES_BASED)
                .build();
    }
    
    @Test
    void deserializeWithSpringMapper() {
        
        AuditEvent auditEvent =
            jsonMapper.readValue(
                startAuditEventJson,
                AuditEvent.class);
        
        Assertions.assertNotNull(auditEvent);
        Assertions.assertEquals("user", auditEvent.getPrincipal());
        Assertions.assertEquals("type", auditEvent.getType());
        Assertions.assertEquals(2, auditEvent.getData().size());
    }
    
    @Test
    void deserializeWithLocalMapperDef() {
        
        AuditEvent auditEvent =
            jsonMapperManual.readValue(
                startAuditEventJson,
                AuditEvent.class);
        
        Assertions.assertNotNull(auditEvent);
        Assertions.assertEquals("user", auditEvent.getPrincipal());
        Assertions.assertEquals("type", auditEvent.getType());
        Assertions.assertEquals(2, auditEvent.getData().size());
    }
}

Expected behavior

AuditEvent should be constructed as a public constructor for the properties supplied exists.

Additional context

The defaut builder(which was always enough in Jackson2) fails but I have a Spring config which fails as well.

@Bean
    public JsonMapperBuilderCustomizer includeSourceInLocationCustomizer() {
        return builder -> {
            builder.enable(StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION);
            builder.constructorDetector(
                ConstructorDetector.USE_PROPERTIES_BASED
                    .withAllowImplicitWithDefaultConstructor(ConstructorDetector.DEFAULT_ALLOW_IMPLICIT_WITH_DEFAULT_CONSTRUCTOR)
                    .withRequireAnnotation(false)
                    .withAllowJDKTypeConstructors(true)
                    .withSingleArgMode(ConstructorDetector.SingleArgConstructor.PROPERTIES));
        };
    }

[JooHyukKim]

@buksvdl
You need to build Mapper without Spring.
Just keep J-unit and Jackson.

Reproduction without Spring.

[cowtowncoder]

With multiple arguments-taking public Constructors you will need to annotate one with @JsonCreator to indicate which one to use.

[buksvdl]

@JooHyukKim - Test fails with or without Spring. I test both.
@cowtowncoder - The AuditEvent class is not in my control.

[pjfanning]

relates to #5427

[pjfanning]

@buksvdl if you can't modify AuditEvent, you can use mixins to provide annotation hints - have a look at:

• https://github.com/FasterXML/jackson-docs/wiki/JacksonMixinAnnotations
• https://medium.com/virtuslab/how-a-little-known-jackson-feature-helped-secure-my-domain-code-4ce31755c49a

[buksvdl]

@pjfanning - thanks.
@cowtowncoder - Thanks, finding appropriate constructor and instantiating the class myself. Any chance for an enhancement request here?

[pjfanning]

What enhancement are you looking for? And can you explain why the existing approaches of using annotations and mixins are not enough?

[JacksonJang]

@pjfanning I think this issue can be broadly divided into two parts.
The first issue seems to occur when running with the following configuration, where the constructor is not explicitly marked with @JsonCreator.

public AuditEvent(Instant timestamp, String principal,
                  String type, Map<String, Object> data) {
    this.timestamp = timestamp;
    this.principal = (principal != null) ? principal : "";
    this.type = type;
    this.data = Collections.unmodifiableMap(data);
}

JsonMapper.builder()
    .build();

In the test code I wrote, the behavior works as expected when @JsonCreator is explicitly added to the constructor.

@JsonCreator
public AuditEvent(Instant timestamp, String principal,
                  String type, Map<String, Object> data) {
    this.timestamp = timestamp;
    this.principal = (principal != null) ? principal : "";
    this.type = type;
    this.data = Collections.unmodifiableMap(data);
}

The second issue appears when using the following configuration.
However, at this point, it is difficult to determine the exact cause, so further investigation seems necessary.

ObjectMapper mapper = JsonMapper.builder()
    .annotationIntrospector(new ImplicitNameIntrospector())
    .enable(StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION)
    .constructorDetector(ConstructorDetector.USE_PROPERTIES_BASED)
    .build();

That said, @pjfanning mentioned, using a MixIn does indeed resolve the issue.
Like this @buksvdl

    static abstract class AuditEventMixIn {
        @JsonCreator
        public AuditEventMixIn(
                @JsonProperty("timestamp") Instant timestamp,
                @JsonProperty("principal") String principal,
                @JsonProperty("type") String type,
                @JsonProperty("data") Map<String, Object> data) {
        }
    }

    @Test
    public void testWithMixInWorkaround() throws Exception
    {
        ObjectMapper mapper = JsonMapper.builder()
                .enable(StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION)
                .addMixIn(AuditEvent.class, AuditEventMixIn.class)
                .build();

        String json = a2q("{"
                + "'timestamp':'2026-01-17T21:00:44.532975Z',"
                + "'principal':'user',"
                + "'type':'type',"
                + "'data':{'keyA':'ValueA','keyB':'ValueB'}"
                + "}");

        AuditEvent result = mapper.readValue(json, AuditEvent.class);

[JacksonJang]

@cowtowncoder
When USE_PROPERTIES_BASED is enabled, and the JSON contains the 4 properties timestamp, principal, type, and data,
is it correct that the JSON should be mapped to the constructor?

public AuditEvent(Instant timestamp, String principal, String type, Map<String, Object> data)

If so, it appears that USE_PROPERTIES_BASED needs to be fixed when it is enabled.

[cowtowncoder]

@JacksonJang I am not sure I understand the question?

Note on ConstructorDetector.USE_PROPERTIES_BASED: that only ever affects potentially ambiguous case of 1-parameter Constructors -- this constructor should always be detected if (but only if!) there is just 1 public constructor.

If there are 2 or more, explicit annotation must be used: there is no logic for trying to guess the right one statically.
And there is never dynamic selection based on JSON input (aside from simple Shape matching; JSON Object to Properties-based).