Cache JsonSerializer "per" ObjectMapper

[brenuart]

This PR adresses issue #642.

The primary objective of these changes is to maintain a separate cache of JsonProvider per ObjectMapper instance.

It also contains the following changes that are functional equivalent as the original implementation but delegate more of the work to Jackson itself:

• do not create a new instance of SerializerProvider ourselves but instead use ObjectMapper#getSerializerProviderInstance introduced in Jackson 2.7
• do not create a JsonSerializer for the class to serialize ourselves but instead delegate to Jackson SerializerProvider#findValueSerializer(Class) and therefore leverage its internal cache

[brenuart]

As mentioned in the Javadoc, I'm also "worried" about maintaining a static cache of JsonProvider... :-(
There is an easy alternative however that does not require any caching at all. It basically relies on Jackson's ability to convert from one type to another... The writeTo method could be reduced to the following:

public void writeTo(JsonGenerator generator) throws IOException {
    if (this.object != null) {
        try {
            ObjectMapper mapper = (ObjectMapper) generator.getCodec();
            Map<String, Object> converted = mapper.convertValue(this.object, Map.class);
            for (Map.Entry<String, Object> entry: converted.entrySet()) {
                generator.writeObjectField(entry.getKey(), entry.getValue());
            }
        } catch (IllegalArgumentException e) {
            // thrown when object is not unwrappable
        }
    }
}

[brenuart]

@philsttr The more I think about the alternative approach described above, the more I believe it is a very good alternative. Overhead seems to be limited to the intermediate map, without the burden of maintaining static caches... Seems to be a good tradeoff.

[philsttr]

Creating an intermediary map every time the marker is written seems like too much overhead to me (for both memory and performance).

Using mapper.convertValue and then writing each entry from a Map is not guaranteed to result in the same JSON as the current behavior since it does not take some annotations like @JsonSerialize into consideration. This will surprising to users expecting Jackson's behavior, with no clear way to revert to the old behavior.

The number of ObjectMapper instances will be small... one per CompositeJsonFormatter, of which there are very few per application.

Given all the above, a static cache seems better to me.