Use default serializer in a custom serializer

[Blackbaud-JasonBodnar]

I have a custom serializer that should only do its custom serialization when a) the object mapper has been configured with a certain attribute and b) when a field has an annotation. If those conditions don't exist I want to fall back to Jackson's default serialization.

@Override
public void serialize(Object value, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
    if (shouldMask) {
        jsonGenerator.writeString(RegExUtils.replaceAll(value.toString(), ".", "*"));
    } else {
        String nonMaskedValue = ((ObjectMapper) jsonGenerator.getCodec()).writeValueAsString(value);
        jsonGenerator.writeRawValue(nonMaskedValue);
    }
}

Example class:

@Data
class ClassToBeMasked {
    @JsonMask
    String firstName
    @JsonMask
    String lastName
    @JsonMask
    int age
    int luckyNumber
    String shirtSize
    Address address
    @JsonMask
    ContributorEntity createdBy
}

@Data
@NoArgsConstructor
class ContributorEntity {
    private UUID userId
    private String givenName
    private String familyName
    private String sourceSystem
}

If I write a test where shouldMask is false I get an error when serializing createdBy:

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class com.blackbaud.jackson.annotations.MaskingSerializerSpec$ContributorEntity and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) (through reference chain: com.blackbaud.jackson.annotations.MaskingSerializerSpec$ClassToBeMasked["createdBy"])

Instead of using an ObjectMapper for default serialization I also tried:

serializerProvider.defaultSerializeValue(value, jsonGenerator);

Is there a way to let Jackson do its default serialization from a custom serializer?

[cowtowncoder]

Yes; but it needs to be done bit differently -- you need to get hold of the default serializer during serializer initialization, as it's too late in serialize() (assuming you need it for the type your custom serializer has been registered for).

So you need to register BeanSerializerModifier and implement one of methods (I think there is modifySerializer()), passing default serializer given to the custom serializer which will then keep that reference if needed.

[Blackbaud-JasonBodnar]

I found an example of using BeanSerializerModifier. It creates an instance of the custom serializer and passes the default serializer based on the class of the bean. In my case, I have an annotation that uses my custom serializer:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@JacksonAnnotationsInside
@JsonSerialize(using = MaskingSerializer.class)
public @interface JsonMask {
}

If I understand how BeanSerializerModifier works it is called once per type. Is that correct? If so, then it's not possible for me to return my custom serializer based on an individual fields annotations. Perhaps I can't use @JsonSerialize in this case and will need to inspect the annotations in my serializer.

[cowtowncoder]

If I understand how BeanSerializerModifier works it is called once per type.

Yes.

Right, @JsonSerialize won't work probably: not all callbacks are necessarily called, and specifically no default serializer likely passed even if they were. So BeanSerializerModifier works for globally registered serializers.

You can introspect annotations on createContextual() method if implementing "ContextualSerializer".
That gets called once per serializer, before first use.
You can then access default per-type Serializer since one being used is not globally register (no infinite looping :) ).

[Blackbaud-JasonBodnar]

Thank you. Got it working with:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface JsonMask {
}

public class MaskingSerializerModifier extends BeanSerializerModifier {
    @Override
    public JsonSerializer<?> modifySerializer(SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) {
        //noinspection unchecked
        return new MaskingSerializer((JsonSerializer<Object>) serializer, false);
    }
}

@NoArgsConstructor
public class MaskingSerializer extends JsonSerializer<Object> implements ContextualSerializer {
    private JsonSerializer<Object> defaultSerializer = null;
    private boolean shouldMask = false;

    public MaskingSerializer(JsonSerializer<Object> defaultSerializer, boolean shouldMask) {
        this.defaultSerializer = defaultSerializer;
        this.shouldMask = shouldMask;
    }

    @Override
    public void serialize(Object value, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        if (shouldMask) {
            jsonGenerator.writeString(RegExUtils.replaceAll(value.toString(), ".", "*"));
        } else {
            defaultSerializer.serialize(value, jsonGenerator, serializerProvider);
        }
    }

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty property) {
        if (property != null && property.getMember().hasAnnotation(JsonMask.class)) {
            return new MaskingSerializer(defaultSerializer, true);
        }
        return this;
    }
}

[cowtowncoder]

Ok good! Great you got it working & thank you for sharing for others!