CODEWITHSUNDEEP
javajsonserializationjackson
sa_vedem
sa_vedem

Reputation: 767

How to serialize differently the same properties of the same entity using jackson

Suppose you have this entity:

class Foo{
 String propA;
 String propB;
}

and you want to serialize for one API like :

{propA: "ola",
 propB: "Holla"}

and for another API like : 

{fooPropA: "ola",
 fooPropB: "Holla"}

How can this be achieved using jackson and using the same entity. Creating 2 different entities is not an option :)

Upvotes: 3

Views: 636

Answers (2)

Alexey Gavrilov
Alexey Gavrilov

Reputation: 10853

There are several ways in which you can achieve this. You can enable a custom serializer (already covered by @se_vedem), register an annotation introspector which changes the property names for the corresponding class and so on.

However, if you are willing to only add a string prefix to all the property names, then the Jackson property name strategy is probably the best fit. The naming strategy class has the access to the serialized object type information, so you can make a decision whether to change the property name or not.

Here is an example using a custom annotation that defines the prefix:

public class JacksonNameStrategy {
    @Retention(RetentionPolicy.RUNTIME)
    public static @interface PropertyPrefix {
        String value();
    }

    @PropertyPrefix("foo_")
    public static class Foo {
        public String propA;
        public String propB;

        public Foo(String propA, String propB) {
            this.propA = propA;
            this.propB = propB;
        }
    }

    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setPropertyNamingStrategy(new MyPropertyNamingStrategyBase());
        System.out.println(mapper.writeValueAsString(new Foo("old", "Holla")));
    }

    private static class MyPropertyNamingStrategyBase extends PropertyNamingStrategy {

        @Override
        public String nameForField(MapperConfig<?> config,
                                   AnnotatedField field,
                                   String defaultName) {
            PropertyPrefix ann = field.getDeclaringClass().getAnnotation(PropertyPrefix.class);
            if (ann != null) {
                return ann.value() + defaultName;
            }
            return super.nameForField(config, field, defaultName);
        }
    }
}

Output:

{"foo_propA":"old","foo_propB":"Holla"}

In your API method you choose between two ObjectMapper instances one with the default naming naming strategy and one with the custom one.

Upvotes: 1

sa_vedem
sa_vedem

Reputation: 767

You can achieve this by using modules feature from Jackson.

Basically, each API would have it's own ObjectMapper and they will be configured with different modules. This way you can create 2 serializers for the same class and register them on the appropriate module. More read can be found here http://wiki.fasterxml.com/JacksonFeatureModules

However, be aware that serializers are loaded in a particular order. First it tries to get the annotated ones, if none is found it will try to get those registered from modules. So, for example if you have your class annotated with serializer, then that serializer(FooSerializer) would be chosen instead of the one configured in module(MySecondFooSerializer).

@JsonSerialize(using = FooSerializer.class)
class Foo{
 String propA;
 String propB;
}

module.addSerializer(Foo.class, new MySecondFooSerializer());

Upvotes: 0

Related Questions