How to access default serializer when writing custom serialiser

[Tim Dudgeon]

Hi,

I'm writing a custom serialiizer, extending StdSerializer.

In the 

public void serialize(MoleculeObject mo, JsonGenerator jg, SerializerProvider sp)

method I need to be able to access the default json serialization mechanism, but I don't see how to do this.

I can't call super.serialize() as its abstract, and using JsonGenerator.writeObject() or SerializerProvider.defaultSerializeValue() end up calling my custom serialize() method and end up with stack overflow.

How should I be doing this?

Tim

[Tatu Saloranta]

The main method for doing this is bit indirect: you need to register BeanSerializerModifier, and in method `modifySerializer(...)` you are handed the default serializer. You can then construct your own serializer, retaining reference to the default, and use it as appropriate.

Other methods will not work since they would simply find serializer you have registered.

-+ Tatu +-

--
You received this message because you are subscribed to the Google Groups "jackson-user" group.
To unsubscribe from this group and stop receiving emails from it, send an email to jackson-user...@googlegroups.com.
To post to this group, send email to jackso...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Tim Dudgeon]

So to be sure I've understood this

1. create my own BeanSerializerModifier  and implement this method:

public JsonSerializer<?> modifySerializer(SerializationConfig config,

                                 BeanDescription beanDesc,

                                 JsonSerializer<?> serializer)

Then in that method somehow (using beanDesc.getBeanClass() ?)  find out of its the serializer for my class, if so return my custom JsonSerializer keeping a reference to the default one, if not return the default one.

And if I needed to do this for a lot of different classes I'd end up with a big  if ... else statement.

2. specify that BeanSerializerModifier using SimpleModule.setSerializerModifier( ... )

Thanks

Tim

[Tatu Saloranta]

Yes, exactly.

-+ Tatu +-

[Zsolt Balanyi]

Hi All!

But what can I do when I want to use annotation, and I don't have access to the mapper?
Eg:

@JsonSerialize(using = ASerializer.class)
public class AClass {
...
}

BR, Zsolt

[Tatu Saloranta]

Not 100% sure I understand the question, but if you want to access
information about annotations on property, from your custom
serializer, you need to implement `ContextualSerializer`, and then its
`createContextual()` gets called with `BeanProperty`.
`BeanProperty` has accessors for annotation directly; or, you can then
call `AnnotationIntrospector` (accessible from `SerializerProvider`
that is also passed).

-+ Tatu +-

[Zsolt Balanyi]

Hi!

What I meant is that I would like to get (or create ) the default Jackson Serializer for the object being serialized, and store as default.

Then I could implement serialize as follows:

@Override

public void serialize(Object o, JsonGenerator jg, SerializerProvider sp) throws IOException {

  doMyStuff...

  default.serialize(o, jg, sp);

}

The challenge here is that only a no-arg constructor is called for the serializer if the serializer is used in annotation like this: @JsonSerialize(using = UIElementSerializer.class)

BR, Zsolt

[Tatu Saloranta]

This can not be done from annotation-based serializer: it will
override default logic.
The only way to access what would otherwise be created/used as the
standard serializer is to register `BeanSerializerModifier`, and
override handling of `modifySerializer`.

-+ Tatu +-

[Zsolt Balanyi]

Hi!

OK, thanks, then I'll go that way!

BR, Zsolt

[Tatu Saloranta]

Good luck! That approach is used quite a lot so it should work fine.
Note, too, that it may be combined with ContextualSerializer if you do
need to access annotations.
In fact you can use `createContextual()` sometimes to simply decide if
override is needed at all; if not, return default serializer from that
method and you are good to go (but if so, remember to delegate call).

It would be great to find better ways to allow such "partial"
overrides, in a more convenient way.
But until then, Bean(De)SerializerModifier is the way to go.

-+ Tatu +-

[Zsolt Balanyi]

Hi!

This is exactly what I was wondering... if there is a way to automate the default serializer injection, when the custom serializer gets detected.
I am also willing to contribute to the code, if I am provided some guidance.

BR, Zsolt

[Zsolt Balanyi]

This article points out exactly the fact, that the usage of BeanSerializerModifier makes in unnecessary to use the annotation!
So I would happily contribute to make the @JsonSerialize smarter. :)

BR, Zsolt

[Zsolt Balanyi]

http://stackoverflow.com/questions/31056215/how-to-access-default-jackson-serialization-in-a-custom-serializer