Add JsonTypeInfo.Id.SIMPLE_NAME which defaults type id to `Class.getSimpleName()`

[ooraini]

Is your feature request related to a problem? Please describe.

Add JsonTypeInfo.Id.SIMPLE_NAME that would use Class::getSimpleName for type ids.

My use case is sealed hierarchies where there is single sealed super interface, it would result in cleaner type ids. My work around:

            // AnnotationIntrospector
            @Override
            public String findTypeName(AnnotatedClass ac) {
                if (Arrays.stream(ac.getAnnotated().getInterfaces()).filter(Class::isSealed).count() == 1) {
                    return ac.getAnnotated().getSimpleName();
                }

                return super.findTypeName(ac);
            }

Describe the solution you'd like

JsonTypeInfo.Id.SIMPLE_NAME

Usage example

No response

Additional context

No response

[JooHyukKim]

@ooraini Have you checked out JsonTypeInfo.Id.MINIMAL_CLASS? Sounds like it might solve your issue 🤔

Or could you provide some usage example and what it's trying to solve? Because there might be solution for existing use case and it will be clearer what the feature will be. Hopefully without using sealed.

[ooraini]

Hi @JooHyukKim, I wanted to frame the request more generally without it being too specific on sealed. MINIMAL_CLASS does include the names of enclosing classes so you get something that looks like A$B$C which is not friendly to refactoring, what I would like with SIMPLE_NAME is to get C as the type ID.

Given:

        @JsonTypeInfo(use = JsonTypeInfo.Id.NAME)
        sealed interface Super {
        }

        record A(int i) implements Super {}
        record B(String s) implements Super {}

And serializing new A(1):

{"@type":"JacksonSealedSerdeTest$AsProperty$A","i":1}

With minimal class:

{"@c":".JacksonSealedSerdeTest$AsProperty$A","i":1}

This is not specific to sealed and the general case is similar:

    @JsonTypeInfo(
      use = JsonTypeInfo.Id.SIMPLE_NAME, // NEW
      include = As.PROPERTY, 
      property = "type")
    @JsonSubTypes({
        @JsonSubTypes.Type(value = Dog.class, name = "Dog"),
        @JsonSubTypes.Type(value = Cat.class, name = "Cat")
    })
    public static class Animal {
        public String name;
    }


    public static class Dog extends Animal {
        public double barkVolume;
    }


    public static class Cat extends Animal {
        boolean likesCream;
        public int lives;
    }

SIMPLE_NAME would use Class::getSimpleName when serializing objects, and the above would work:

{
  "type": "Dog",
  "name": "Tom",
  "barkVolume": 1.5

}

Again, I want to emphasis that this is not specific to sealed, it would work really well with sealed. I mentioned sealed just as a motivation for the feature. Hope this clears things

[JooHyukKim]

@ooraini I see, thank you for the explanation 👍🏻 Suggested use-case seem to make sense and general. Will there also be other values (aside from Class::getSimpleName) that users might want 🤔🤔

WDYT, @cowtowncoder?

[cowtowncoder]

I am bit confused about shown use case:

    @JsonTypeInfo(
      use = JsonTypeInfo.Id.SIMPLE_NAME, // NEW
      include = As.PROPERTY, 
      property = "type")
    @JsonSubTypes({
        @JsonSubTypes.Type(value = Dog.class, name = "Dog"),
        @JsonSubTypes.Type(value = Cat.class, name = "Cat")
    })
    public static class Animal {
        public String name;
    }

since this already declares names to use, so use of JsonTypeInfo.Id seems redundant?
Is this just accidental copy-paste?

Second: when using JsonTypeInfo.Id.NAME default Type Id choice is indeed to use simple name.

So I guess I am not quite sure what would be provided here.

But if such an option makes sense the only thing I'd suggest is that instead of SIMPLE_NAME it should be either SIMPLE_CLASS or SIMPLE_CLASS_NAME; otherwise relationship to existing NAME option would be confusing (NAME uses logical name from @JsonTypeName, or, if missing, then Class.getSimpleName() as defaulting).

[JooHyukKim]

since this already declares names to use, so use of JsonTypeInfo.Id seems redundant?
Is this just accidental copy-paste?

More minimal reproduction would be below, Id.NAME still includes the enclosing class and the request is to omit even the enclosing class. Can you confirm @ooraini ?

public class TestPolymorphic extends BaseMapTest {

    @JsonTypeInfo(
            use = JsonTypeInfo.Id.SIMPLE_CLASS_NAME) // <<-----"NEW"
    @JsonSubTypes({
            @JsonSubTypes.Type(value = Sub4061A.class),
            @JsonSubTypes.Type(value = Sub4061B.class)
    })
    static class Super4061 { }

    static class Sub4061A extends Super4061 { }

    static class Sub4061B extends Super4061 { }

    public void test() throws Exception {
        // case (1) JsonTypeInfo.Id.NAME
        assertEquals(
                 "{\"@type\":\"TestPolymorphic$Sub4061A\"}",
                newJsonMapper().writeValueAsString(new Sub4061A()));

        // case (2) JsonTypeInfo.Id.SIMPLE_CLASS_NAME
        assertEquals(
                 "{\"name\":\"Sub4061A\"}",
                newJsonMapper().writeValueAsString(new Sub4061A()));
    }
}

But if such an option makes sense the only thing I'd suggest is that instead of SIMPLE_NAME it should be either SIMPLE_CLASS or SIMPLE_CLASS_NAME; otherwise relationship to existing NAME option would be confusing (NAME uses logical name from @JsonTypeName, or, if missing, then Class.getSimpleName() as defaulting).

+1 SIMPLE_CLASS_NAME, because it contains most characters from Class.getSimpleName().

[ooraini]

Hi @cowtowncoder, Regarding the example, it would not work if you used Id.NAME, you will need to annotate Dog and Cat with @JsonTypeName("Dog") and @JsonTypeName("Cat") respectively.

Indeed, Id.NAME uses the logical name from the @JsonTypeName, but it doesn't default to Class::getSimpleName , instead, it uses Class::getName.

            // TypeNameIdResolver.java
            if (name == null) {
                // And if still not found, let's choose default?
                name = _defaultTypeId(cls); // uses Class::getName
            }

👍🏻 for SIMPLE_CLASS_NAME.

Hope this helps.

[ooraini]

More minimal reproduction would be below, Id.NAME still includes the enclosing class and the request is to omit even the enclosing class. Can you confirm @ooraini ?

@JooHyukKim
👍🏻 Exactly

[cowtowncoder]

Ah. Ok, I misremembered defaulting; could have sworn it uses simple class name for Id.NAME; and I think it probably should have. Unfortunately not doing so is the default behavior so it cannot be changed due to backwards-compatibility reasons.

No objections to adding Id.SIMPLE_CLASS_NAME if someone has time and interest to work on a PR. Sounds like a good addition.

I also started re-thinking whether it really ought to be SIMPLE_NAME: although Class Name is used as the basis, it is not used as direct type (unlike CLASS or MINIMAL_CLASS) but rather more like a name that just happens to be generated from unqualified class.
So I am fine with SIMPLE_NAME after all :)

[JooHyukKim]

Can I get assigned on this? I have encountered a couple usecases, where I would have used Id.SIMPLE_CLASS_NAME if there was one. 👍🏻 Or @ooraini would you like to work on it?

[ooraini]

@JooHyukKim Feel free work on it, I haven't gotten around the code base yet 😅

[cowtowncoder]

First part is probably local modification of jackson-annotations to get new enum value. Then work on types in src/main/java/com/fasterxml/jackson/databind/jsontype/impl (like src/main/java/com/fasterxml/jackson/databind/jsontype/impl/TypeNameIdResolver.java).

[JooHyukKim]

Made a PR #4065, could you PTAL, @cowtowncoder? If implementation seems okay, I will file a PR in jackson-annotations module and start collecting more test cases.