Is it possible to specify to the value serializer that an object should be serialized as a specific type knowing its runtime information?

[WannabeSoftwareEngineer]

Hi all,
I would like to know if it is possible to specify to the value serializer that an object should be serialized as one of its supertypes (not necessary a direct ancestor) according to its runtime type and custom annotations.

The class that needs to be serialized has this form:

class Farm {
    @CustomAnnotation(
        subtypes = { Bird.class, Fish.class }
    )
    private Animal animal;
   
    // getters and setters
}

class Animal {
    ...
}

class Fish extends Animal {
    ...
}

class Bird extends Animal {
    ...
}

class Parrot extends Bird {
    private latinName;
    // setters and getters
}

The chain of inheritance looks as follow:
Animal <- Bird <- Parrot
Animal <- Fish

and the object that needs to be serialized is:

    Parrot aParrot = new Parrot();
    aParrot.setLatinName("I am latin")
   
    Farm myFarm = new Farm();
    myFarm.setAnimal(aParrot);

What I would like for the serializer to do is to serialize the myFarm.animal as a Bird (closest ancestor of Parrot) rather than Parrot, so the output JSON should not have the field latinName in it.

What I would like to know if it is possible for me to tell to the serializer the type that the object should be serialized as, knowing its runtime type and not its declared type (i.e., Parrot and not Animal)

Constraints

• can't guarantee that all the possible subtypes are defined in CustomAnnotation, so I need to find the closest ancestor
• can't switch to use JsonTypeInfo and JsonSubTypes because I need to support this CustomAnnotation in my application

Type information

For the type information, I implemented a custom TypeIdResolver that maps the runtime type of the object to one of the subtypes defined in CustomAnnotation.

Solution that I already attempted

1. I have implemented a CustomAnnotationIntrospector extends NopAnnotationIntrospector class, and I overrode this method

    @Override
    public JavaType refineSerializationType(final MapperConfig<?> config,
                                            final Annotated a,
                                            final JavaType baseType) {
          CustomAnnotation foundAnnotation = a.getAnnotation(CustomAnnotation.class);
          for (Class<?> type: foundAnnotation.subtypes() ) {
                // find the type that is the closest ancestor of baseType
               // return the found type
          }
    }

Problem: the baseType is always the declared type, i.e. Animal, and not the runtime type

Research I have done

• My (non) solution is inspired by how Jackson reads and uses the annotation JsonSerialize(as = ...)
• I converted my CustomAnnotation to something analogous using Jackson annotations (JsonTypeInfo and JsonSubTypes) in order to see what is the default behavior. What I got as output JSON was the full Parrot, even tough I defined in JsonSubTypes only Fish and Bird. The type indicator property assumes whatever value you get from the method you defined in JsonTypeInfo.

[cowtowncoder]

I am not sure I fully understand the question but:

1. When serializing, actual runtime type is indeed used for locating serializer, EXCEPT
2. When including (polymorphic) type information, base type is taken from declared type. This is by design and cannot be changed
3. Type Id is ONLY USED if @JsonTypeInfo (polymorphic (de)serialization) is enabled -- that or Default Typing

But as to the thing you are trying to achieve: if you want to just exclude some properties on sub-classes, maybe simple @JsonIgnore would work?

[WannabeSoftwareEngineer]

Hi,
thank you for the quick reply @cowtowncoder.

I can't use @JsonIgnore because of:

1. I am not the end user. I am writing some wrapper on top of Jackson
2. I need to support a CustomAnnotation that semantically is almost the same as @JsonTypeInfo + @JsonSubTypes.
   When an end user puts a CustomAnnotation on top of a property, it is equivalent of saying:
   "serialize the runtime object as one of the types defined in this annotation. If an exact match is not found, search for the closest ancestor, otherwise fail".

The part where I am stuck is that I don't know how (or it is even possible) to instruct the serializer to use this type instead of ..., where this type needs to be computed dynamically. Something along the line of:

Class<?> runtimeType = .... // ??
Class<?> minType = null;
for (Class<?> type : customAnnotation.subtypes()) {
    if (type.isAssignableFrom(runtimeType)) {
        if (minType == null || minType.isAssignableFrom(type)) {
            minType = type;
        }
    }
}

if (minType == null) {
    throw new RuntimeException(...)
}

// use this `minType` to serialize the object instead of `runtimeType`, 
// so that the output JSON contains only the properties declared in `type` and its supertypes
return minType;

For the type id part, I resolved it by implementing a TypeIdResolver, overriding public String idFromValue(Object value); and returning the TypeIdResolver from a custom AnnotationIntrospector.

I was wondering if we had something similar for the value serializer, where I actually get the Object or if can achieve my goal with other means.

[cowtowncoder]

Ok yeah. I don't know. This gets bit too complicated for standard handling so I don't think you are missing any existing pieces.

Generally Jackson tries to avoid determining any types during per-read/per-write and instead tries to do these during construction or contextualization (part where annotations from Methods, Fields etc are available).
Ideally you would be able to determine type during contextualization and construct new (de)Serializer instances if need be. I am not quite sure you need runtime type, if mapping to super types only relies on static information. But note that none of declaration information is passed during actual (de)serialization: this is by design. So anything that needs to be retained from declarations must be passed by contextualization and stored by (de)serializer.