How to provide brand new jackson deserialization for object

[babyfish-ct]

In order to support object deserialization, jackson provides these ways

• Default constructor.
• @JsonCreator for parameterized constructor of static factory.
• The builder of @JsonDeserialize.
• Customized deserializer.

The first three didn't meet my requirements, and the implementation of the last one was flawed (I'm not Jackson expert. T_T). To explain this, we need to go back to my introduction of a completely new programming model for the JVM.

In order to introduce a very powerful immutable object architecture to the JVM, my framework ported a poplular JavaScript framework immer: 26.8k github star to the JVM ecosystem. (If you are interested, please refer to: immutable)

Now, we can declare immutable type like this

@Immutable
public interface TreeNode {
    String name();
    List<TreeNode> childNodes();
}

In order to create immutable object, developer can:

1. Open a temporary scope based on null or an existing immutable data structure.

2. Within this scope, developers can obtain a draft data structure with the same shape and initial values as the original data structure (it it is not null), which can be modified at will, including modifying any deeply nested sub-objects.

3. After the scope ends, the draft data structure will create a new data structure based on the collected modification operations. Unmodified parts will be optimized and reuse the old objects.

For example

// 1. Create data structure from scratcth
TreeNode treeNode = TreeNodeDraft.$.produce(root -> {
    root.setName("Root").addIntoChildNodes(food -> {
        food
            .setName("Food")
            .addIntoChildNodes(drink -> {
                drink
                    .setName("Drink")
                    .addIntoChildNodes(cococola -> {
                        cococola.setName("Cococola");
                    })
                    .addIntoChildNodes(fanta -> {
                        fanta.setName("Fanta");
                    });
                ;
            });
        ;
    });
});

// 2. Create new data based on existing data
TreeNode newTreeNode = TreeNodeDraft.$.produce(
        treeNode, // existing data
        root -> {
            root
                .childNodes(false).get(0) // Food
                .childNodes(false).get(0) // Drink
                .childNodes(false).get(0) // Cococola
                .setName("Cococola(Sugar-free)");
        }
);

System.out.println("treeNode:" + treeNode);
System.out.println("newTreeNode:" + newTreeNode);

Here, 'TreeNodeDraft' is the type that the Annotation Processor generates at compile time. The final print result is as follows.

treeNode: {
    "name":"Root",
    "childNodes":[
        {
            "name":"Food",
            "childNodes":[
                {
                    "name":"Drink",
                    "childNodes":[
                        {"name":"Coco Cola"},
                        {"name":"Fanta"}
                    ]
                }
            ]
        }
    ]
}
newTreeNode: {
    "name":"Root",
    "childNodes":[
        {
            "name":"Food",
            "childNodes":[
                {
                    "name":"Drink",
                    "childNodes":[
                        {"name":"Coco Cola(Sugar-free)"}, // Changed
                        {"name":"Fanta"}
                    ]
                }
            ]
        }
    ]
}

This is a very powerful immutable object programming model that first appeared in the JVM.

As a result, the default constructor, @JsonCreator, and builder of @JsonDeserilze discussed earlier cannot handle it directly. So I have to write customized deserializer provide a brand deserialization mechanism for this new programming model.

I created ImmutableDeserializer to provide jackson deserialization for this new programming model. However, my implementation was unable to accommodate some of the advanced features of native Jackson, such as formatting control, @JsonAlias and polymorphism. Over the past nearly two years, users have submitted many related bugs, which has been bothering me a lot. Though I can use my way to let each broken features compatible with original behavior of jackson one by one, there seems to be no end in sight.

Is there better solution to support brand new deserialization?

[babyfish-ct]

I found the solution AnnotationIntrospector