Using @JsonProperty during serialization on nested records interferes with the default property order

[safdevke]

Hi, this is a trivial case that I came across. Using nested records changes the order of the properties in the serialized output. Here's a simple example:

public record NestedRecordOne(
    String id,

    String email,

    @JsonProperty(value = "yikes!")
    NestedRecordTwo nestedRecordTwo) {}

public record NestedRecordTwo (
    String id,

    String passport) {}

public static void main(String[] args) throws IOException {

        ObjectMapper objectMapper = new ObjectMapper();
        NestedRecordTwo nestedRecordTwo = new NestedRecordTwo("2", "111110");
        NestedRecordOne nestedRecordOne = new NestedRecordOne("1", "test@records.com", nestedRecordTwo);

        objectMapper.writeValue(new File("nested-record.json"), nestedRecordOne);
    }

The output is:

{
    "yikes!": {
        "id": "2",
        "passport": "111110"
    },
    "id": "1",
    "email": "test@records.com"
}

Performing the same test on classes seems to work fine:

public class NestedClassOne {

    private String id;

    private String name;

    @JsonProperty(value = "all is fine!")
    private NestedClassTwo nestedClassTwo;

    // All args constructor + getters + setters
}

public class NestedClassTwo {

    private String id;

    // All args constructor + getters + setters
}

    NestedClassOne nestedClassOne = new NestedClassOne("1", new NestedClassTwo("2"), "test class");
    
    objectMapper.writeValue(new File("nested-class.json"), nestedClassOne);

Produces:

{
    "id": "1",
    "name": "test class",
    "all is fine!": {
        "id": "2"
    }
}

This could be easily fixed by using @JsonPropertyOrder. I wonder why it behaves this way for records. I didn't think this warranted creating an issue.

[pjfanning]

please provide the version of Jackson - there were big changes in the code for Record support in Jackson 2.15.0

[safdevke]

I tested on Jackson 2.15.0

[pjfanning]

possibly down to this - https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html#getDeclaredFields--

says 'not sorted'

[safdevke]

That possibly answers it. Thanks!

[pjfanning]

I tested this and it does seem to be an issue - the order does appear to be based on the record definition when no JsonProperty annotations are used. I'll turn this into an issue.

[yihtserns]

Serialization uses either field or method, the order of the entries returned when calling Class.get*Methods or Class.get*Fields is highly dependent NOT on the order they are declared in the source code, but by the JVM implementation.

You may get the same order as declared in the source code when running using JRE/JDK A, it can be different when using JRE/JDK B.

[pjfanning]

JDK14Util has code for getting the right property order. And this works unless JsonProperty annotations are used. I don't think JsonProperty annotations should affect the order.

[yihtserns]

I mean it's fine if someone wants to request that the fields ordering of JSON serialized from a Record to follow the Record header's.

I just want to note that users should never assume the fields order of their POJO classes to always follow the source code's, else they might be in for an unpleasant surprised one day after a JRE/JDK upgrade/change in production.

[yihtserns]

Phew, I thought this was caused by #3724, but that's not the case.

The JSON produced is different because the setup weren't actually equivalent:

Record

non-Record equivalent

public record NestedRecordOne( String id, String email, @JsonProperty(value = "yikes!") NestedRecordTwo nestedRecordTwo) { }

NOTE: Must be static class if is declared inside another class, else Jackson will not analyze the constructor. public class NestedClassOne { private String id; private String name; @JsonProperty(value = "all is fine!") private NestedClassTwo nestedClassTwo; public NestedClassOne(String id, String name, // 👇 The annotation on the constructor parameter is the cause @JsonProperty(value = "all is fine!") NestedClassTwo nestedClassTwo) { this.id = id; this.name = name; this.nestedClassTwo = nestedClassTwo; } // getters }

...and the output (ie field ordering) would be the same as Record's:

{
  "all is fine!": {
    "id": "2",
    "passport": "111110"
  },
  "id": "1",
  "name": "test@records.com"
}

[yihtserns]

Also, the Record's equivalent of:

public class NestedClassOne {

    private String id;

    private String name;

    @JsonProperty(value = "all is fine!")
    private NestedClassTwo nestedClassTwo;

    // All args constructor + getters + setters
}

...is:

public record NestedRecordOne(
        String id,
        String email,
        NestedRecordTwo nestedRecordTwo) {

    @JsonProperty(value = "yikes!") // Even though it's on getter, this name will also be used during deserialization
    @Override
    public NestedRecordTwo nestedRecordTwo() {
        return nestedRecordTwo;
    }
}

...which will produce:

{
  "id": "1",
  "email": "test@records.com",
  "yikes!": {
    "id": "2",
    "passport": "111110"
  }
}

[cowtowncoder]

Quick note: due to major property introspection rewrite (#4515) it would be possible to revisit this issue too, if that was necessary.
But if so, please open a new issue or discussion, with ref to this one.