Nested @JsonUnwrapped property names not correctly handled

[plovell]

We are using @JsonUnwrapped to serialise objects with three levels of nesting. If we serialise the top level object first, then we get the JSON we expect, but if we serialise the second level object first and then try to serialise the top level object, it is as if the @JsonUnwrapped annotation is ignored for the top level object. We are using Jackson databind version 2.9.9.3.

The following test case demonstrates the problem:

@Test
public void jsonMappingOrderTest() throws JsonProcessingException {
    ObjectMapper mapperOrder1 = new ObjectMapper();
    ObjectMapper mapperOrder2 = new ObjectMapper();

    BaseContainer inner = new BaseContainer(new Base("12345"));
    BaseContainerContainer outer = new BaseContainerContainer(inner);

    assertEquals("{\"container.base.id\":\"12345\"}", mapperOrder1.writeValueAsString(outer));
    assertEquals("{\"base.id\":\"12345\"}", mapperOrder1.writeValueAsString(inner));
    assertEquals("{\"container.base.id\":\"12345\"}", mapperOrder1.writeValueAsString(outer));

    assertEquals("{\"base.id\":\"12345\"}", mapperOrder2.writeValueAsString(inner));
    //  Will fail here
    assertEquals("{\"container.base.id\":\"12345\"}", mapperOrder2.writeValueAsString(outer));
}

static class Base {
    private String id;

    Base(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

static class BaseContainer {
    private Base base;

    BaseContainer(Base base) {
        this.base = base;
    }

    @JsonUnwrapped(prefix = "base.")
    public Base getBase() {
        return base;
    }
}

static class BaseContainerContainer {
    private BaseContainer container;

    BaseContainerContainer(BaseContainer container) {
        this.container = container;
    }

    @JsonUnwrapped(prefix = "container.")
    public BaseContainer getContainer() {
        return container;
    }
}

[cowtowncoder]

That sounds wrong. Thank you for reporting the problem.

[cowtowncoder]

Yes, I can reproduce that. Gnarly...

[cowtowncoder]

Trying to figure this out: not sure if this is specifically related to caching, but is definitely due to something in logic that handles contextualization related to fetching serializer.

[cowtowncoder]

Ok. I give up, for now. I suspect this is due to multiple levels of nesting, and contextualization being applied by one level, but not across multiple levels.

So at this point I would recommend not attempting unwrapping to be used for nesting more than one level.

[plovell]

Thanks for looking.

We do have a workaround that seems to function correctly.

We use the object mapper effectively as a singleton and we have found that if we ensure that the equivalent object to BaseContainerContainer is always serialised first then we no longer get the error when serialising either of the two objects. So we initialise our object mappers on application startup using an example object instance.

[cowtowncoder]

@plovell Glad to hear you have a work-around. I hope I can eventually figure this out -- I was really hoping to find a solution in time for 2.10.0, but that is not happening.

But there is now a test, and at least it is not (I think!) something specific about mapper-wide caching: it may well be due to per-property serializer caching but that would be more local to solve.

One other thing I was thinking but forgot to write down is that specifying

    @JsonSerialize(typing = Typing.STATIC)

for property might help, as it would allow eager fetching of serializer(s). But I did not test this so have no idea if it can make things work correctly.

[caiquebispoferreira]

Is there any solution for that?
I have a similar issue but it just happens on my application when it is running on Ubuntu.
Both applications (Windows and Linux) are using the JDK 15.0.2.
What's the simplest solution for that?

[cowtowncoder]

There is no solution to this problem at this point. You may have to refactor handling to eliminate a level, or flatten object structure (you can use "multi-level" naming like @JsonUnwrapped(prefix="base.container.")).

[caiquebispoferreira]

Thank you for your response.
I am trying to find other ways that I could do a similar thing minimizing efforts to serialize and deserialize.
Is there any way to set up the object mapper to unwrap all custom class objects by default using the property name as the prefix?

from:

{
     myObject : {
        a : 1,
        b: {
          c: "hi"
        }
      },
     d : ""
}

to:

{
      myObject_a : 1,
      myObject_b_c : "hi",
      d :  ""
}

What would you recommend?

[cowtowncoder]

@caiquebispoferreira No, not really. Perhaps you could extend JacksonAnnotationIntrospector and override method that is called to detect @JsonUnwrapped, to indicate desire to "find" unwrapping information based on whatever logic you want (method findUnwrappingNameTransformer(...)).
It would only need to handle a single layer as introspection happens recursively as necessary.

[cowtowncoder]

@JooHyukKim Here's an old and tricky problem -- there's a (failing) unit test for reproducing. Just in case you wanted to find yet more things to work on :)

(was reminded of this as the issue was reported on Kotlin module)

[JooHyukKim]

Just sharing things in case it might help anybody. So ordering does matter. My observation is that caching issue happens at UnwrappingBeanPropertyWriter.java#L224. Disabling it makes UnwrappedCaching2461Test pass.

While my analysis on @JsonUnwrapped continues, potential approaches might involve:

• Managing "multi-level" unwrapping or,
• Employing back-tracking during serialization.

These thoughts are just draft, open for guides or collaboration 😆