`@JsonUnwrapped` fields with matching `@JsonIgnore`d getter in outer class are ignored

[sguillope]

From @sguillope on December 5, 2015 15:23

I'm assuming that the following is not expected behaviour. If a field in a JsonUnwrapped object has a matching getter in the outer class, then the field won't get deserialized. In this example id is not deserialized although I'd expect it to be.
Removing the getter getId() from the Outer class fixes the issue.

@Test
public void jsonUnwrappedShouldDeserializeFieldsWithGetterInOuterClass() throws IOException {
    final String JSON = "{\"id\": 1, \"name\": \"John\"}";
    Outer outer = new ObjectMapper().readValue(JSON, Outer.class);
    assertNotNull(outer.getId());
}

static class Outer {
    @JsonUnwrapped
    private Inner inner;

    @JsonIgnore
    public Long getId() {
        return inner.id;
    }
}

static class Inner {
    @JsonProperty
    Long id;

    @JsonProperty
    String name;
}

Inspecting the outer object shows:

outer = {Outer@1288} 
 inner = {Inner@1289} 
  id = null
  name = "John"

Copied from original issue: FasterXML/jackson#38

[sguillope]

From @cowtowncoder on December 6, 2015 18:33

Yes, ideally this is not how it should work. But I think what happens is that there is big difference between Outer not having anything indicating property id, and there being suppressed (ignored) id due to getId()'. As such, deserializer considers id to be an ignored property, and proceeds to do just that.

Thank you for reporting this: I hope it can be fixed. But that may take some time, depending on exact details of handling. Additionally code that deals with unwrapping is rather complicated and has some related issues, wrt existence of properties that do not map to anything -- essentially, outer deserialize simply buffers properties it knows nothing of, and then delegates them to unwrapping deserializers to see if any of them knows how to handle it.

[tjwilson90]

@cowtowncoder, to expand on this example slightly, on the latest release 2.10.3

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonUnwrapped;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Test {

    public static class Outer {
        @JsonUnwrapped
        Inner inner;

        @JsonIgnore
        public String getFoo() {
            return inner.foo;
        }

        @JsonIgnore
        public String bar() {
            return inner.bar;
        }
    }

    public static class Inner {
        @JsonProperty
        String foo;

        @JsonProperty
        String bar;
    }

    public static void main(String[] args) throws JsonProcessingException {
        Outer outer = new ObjectMapper().readValue("{\"foo\":\"a\",\"bar\":\"b\"}", Outer.class);
        System.out.println(outer.inner.foo);
        System.out.println(outer.inner.bar);
    }
}

outputs

null
b

It appears that only java beans style fields in the outer class propagate @JsonIgnore to the inner class.

[cowtowncoder]

@tjwilson90 I think that is related but separate problem so could file a separate issue. But at this point fine to leave as a comment in case I (or someone else) has time to work in this problem; most likely as part of rewrite for bean introspection for 3.0.