Java 类com.fasterxml.jackson.databind.JsonSerializer 实例源码

@Bean
public Jackson2ObjectMapperBuilderCustomizer configProtobufSerializer() {
    return new Jackson2ObjectMapperBuilderCustomizer() {

        @Override
        public void customize(
                Jackson2ObjectMapperBuilder builder) {
            builder.serializerByType(Message.class, new JsonSerializer<Message>(){

                @Override
                public void serialize(Message message, JsonGenerator generator,
                        SerializerProvider provider) throws IOException {
                    if(message == null)
                        return;
                    JsonJacksonFormat format = new JsonJacksonFormat();
                    format.print(message, generator);
                }});

        }
    };
}

@Override
public void setupModule(SetupContext setupContext) {
    super.setupModule(setupContext);
    setupContext.addBeanSerializerModifier(new BeanSerializerModifier() {
        @SuppressWarnings("unchecked")
        @Override
        public JsonSerializer<?> modifySerializer(SerializationConfig serializationConfig, BeanDescription beanDescription, JsonSerializer<?> jsonSerializer) {
            Class<?> beanClass = beanDescription.getBeanClass();
            if (Cause.class.isAssignableFrom(beanClass)) {
                return new CauseSerializer((JsonSerializer<Object>) jsonSerializer);
            } else if (StackTraceElement.class.isAssignableFrom(beanClass)) {
                return new StackTraceElementSerializer();
            }
            return jsonSerializer;
        }
    });
}

protected JsonSerializer<Object> findSerializer(
        SerializerProvider provider, Object value) throws IOException,
        JsonProcessingException {
    /*
     * TODO: if Hibernate did use generics, or we wanted to allow use of
     * Jackson annotations to indicate type, should take that into user.
     */
    Class<?> type = value.getClass();
    /*
     * we will use a map to contain serializers found so far, keyed by type:
     * this avoids potentially costly lookup from global caches and/or
     * construction of new serializers
     */
    /*
     * 18-Oct-2013, tatu: Whether this is for the primary property or
     * secondary is really anyone's guess at this point; proxies can exist
     * at any level?
     */
    PropertySerializerMap.SerializerAndMapResult result = _dynamicSerializers
            .findAndAddPrimarySerializer(type, provider, null);
    if (_dynamicSerializers != result.map) {
        _dynamicSerializers = result.map;
    }
    return result.serializer;
}

public JsonMapper()
{
    super();
    // 允许单引号  
    //this.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
    // 字段和值都加引号  
    this.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
    // 数字也加引号  
    this.configure(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS, true);
    this.configure(JsonGenerator.Feature.QUOTE_NON_NUMERIC_NUMBERS, true);
    // 空值处理为空串  
    this.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>()
    {
        @Override
        public void serialize(Object value, JsonGenerator jg, SerializerProvider sp) throws IOException,
                JsonProcessingException
        {
            jg.writeString("");
        }
    });

}

private static <T1, T2> SimpleModule newWrappingModule(final Class<T1> wrapped, final Class<T2> wrapper, final Converter<T1, T2> converter) {
  SimpleModule module = new SimpleModule();
  module.addDeserializer(wrapper, new JsonDeserializer<T2>() {
    @Override
    public T2 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
      return converter.convert(ctxt.readValue(p, wrapped));
    }
  });
  module.addSerializer(wrapper, new JsonSerializer<T2>() {
    @Override
    public void serialize(T2 value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
      serializers.defaultSerializeValue(converter.revert(value), gen);
    }
  });
  return module;
}

@Override
public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {
    if (beanProperty != null) {
        // System.err.println("beanProperty:" + beanProperty + " name:" + beanProperty.getName() + " type:" + beanProperty.getMember().getGenericType());
        Class<A> clazz = annotation();
        A anno = beanProperty.getAnnotation(clazz);
        if (anno == null) {
            anno = beanProperty.getContextAnnotation(clazz);
        }
        if (anno != null) {
            try {
                return this.create(clazz, anno, beanProperty);
            }
            catch (Exception e) {
                throw new RuntimeException(e.getMessage(), e);
            }
        }
        return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
    }
    return serializerProvider.findNullValueSerializer(beanProperty);
}

@Override
public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
    // gen.writeObject(value);
    // String fieldName = gen.getOutputContext().getCurrentName();
    // System.err.println("FieldDetailJsonSerializer serialize: className:" + className);
    try {
        Class<?> clazz;
        String className = anno.className();
        if (className.length() <= 0) {
            clazz = anno.using();
        }
        else {
            clazz = Class.forName(className);
        }
        @SuppressWarnings("unchecked")
        JsonSerializer<Object> serializer = (JsonSerializer<Object>) clazz.newInstance();
        serializer.serialize(value, gen, serializers);
    }
    catch (Exception e) {
        throw new RuntimeException(e.getMessage(), e);
    }
    // System.err.println("JsonDetailJsonSerializer serialize value:" + value + " fieldName:" + fieldName + " type:" + beanProperty.getMember().getGenericType().getTypeName());
    // Object detail = null;
    // gen.writeObject(detail);
}

@Override
public void setupModule(final SetupContext context) {
    super.setupModule(context);

    context.addBeanSerializerModifier(new BeanSerializerModifier() {

        public JsonSerializer<?> modifySerializer(
                final SerializationConfig config,
                final BeanDescription beanDesc,
                final JsonSerializer<?> serializer) {
            Class<?> valueClass = beanDesc.getType().getRawClass();

            if (serializer instanceof BeanSerializerBase
                    && MODIFIABLE_CLASSES.contains(valueClass)) {
                return new FlatteningModifySerializer(
                        (BeanSerializerBase) serializer);
            }

            return serializer;
        }
    });
}

private void addJsonBean(Object bean) {
    if (bean instanceof JsonSerializer) {
        addSerializerWithDeducedType((JsonSerializer<?>) bean);
    }
    if (bean instanceof JsonDeserializer) {
        addDeserializerWithDeducedType((JsonDeserializer<?>) bean);
    }
    for (Class<?> innerClass : bean.getClass().getDeclaredClasses()) {
        if (JsonSerializer.class.isAssignableFrom(innerClass)
                || JsonDeserializer.class.isAssignableFrom(innerClass)) {
            try {
                addJsonBean(innerClass.newInstance());
            }
            catch (Exception ex) {
                throw new IllegalStateException(ex);
            }
        }
    }
}

@Bean
public Module jacksonModule() {
    SimpleModule module = new SimpleModule();
    module.addSerializer(Foo.class, new JsonSerializer<Foo>() {

        @Override
        public void serialize(Foo value, JsonGenerator jgen,
                SerializerProvider provider)
                        throws IOException, JsonProcessingException {
            jgen.writeStartObject();
            jgen.writeStringField("foo", "bar");
            jgen.writeEndObject();
        }
    });
    return module;
}

public ProgramDumpModule() {
    addSerializer(OperatorNode.class, new JsonSerializer<OperatorNode>() {
        @Override
        public void serialize(OperatorNode value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
            Operator op = value.getOperator();
            jgen.writeStartObject();
            if (value.getLocation() != null) {
                jgen.writeArrayFieldStart("location");
                jgen.writeNumber(value.getLocation().getLineNumber());
                jgen.writeNumber(value.getLocation().getCharacterOffset());
                jgen.writeEndArray();
            }
            jgen.writeStringField("type", op.getClass().getName());
            jgen.writeStringField("operator", op.toString());
            if (!value.getAnnotations().isEmpty()) {
                jgen.writeObjectField("annotations", value.getAnnotations());
            }
            jgen.writeFieldName("arguments");
            provider.defaultSerializeValue(value.getArguments(), jgen);
            jgen.writeEndObject();
        }
    });
}

public JsonMapper(Inclusion inclusion, DateFormat df, boolean replaceNull) 
    {
        mapper = new ObjectMapper();
        // 设置输出时包含属性的风格
//      mapper.setSerializationInclusion(inclusion);
//      // 设置输入时忽略在JSON字符串中存在但Java对象实际没有的属性
//      mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
//      // 禁止使用int代表Enum的order()來反序列化Enum
//      mapper.configure(DeserializationConfig.Feature.FAIL_ON_NUMBERS_FOR_ENUMS, true);
        // 允许单引号
        mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        mapper.setDateFormat(df);
        if (replaceNull) {
            // null 转换为 ""
            mapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() 
            {
                @Override
                public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException 
                {
                    jgen.writeString("");
                }

            });
        }
    }

@ResponseBody
public String listAll() throws Exception {
    List<Group> gs = groupService.list(null);
    Group g = new Group();
    g.setId(-1);
    g.setName("--无--");
    gs.add(0, g);
    Jacksons j = mvnJacksons.addJsonSerializer(Group.class, new JsonSerializer<Group>(){

        @Override
        public void serialize(Group value, JsonGenerator gen,
                SerializerProvider serializers) throws IOException {
            gen.writeStartObject();
            gen.writeObjectField("id", value.getId());
            gen.writeObjectField("pId", value.getParentId());
            gen.writeStringField("name", value.getName());
            gen.writeEndObject();
        }

    });
    return j.toJson(gs);
}

/**
 * 根据项目ID获取权限
 * @param projectId
 * @return
 * @throws Exception
 */
@ResponseBody
public String listByProject(Integer projectId) throws Exception {
    List<Permission> os = permissionService.list(projectId, null, null);
    Permission no = new Permission();
    no.setId(-1L);
    no.setName("--无--");
    os.add(0, no);
    Jacksons j = mvnJacksons.addJsonSerializer(Permission.class, new JsonSerializer<Permission>(){

        @Override
        public void serialize(Permission value, JsonGenerator gen,
                SerializerProvider serializers) throws IOException {
            gen.writeStartObject();
            gen.writeObjectField("id", value.getId());
            gen.writeObjectField("pId", value.getParentId());
            gen.writeBooleanField("isParent", !(value.getIsMenu() == null || value.getIsMenu() == YesNo.NO));
            gen.writeStringField("name", value.getName());
            gen.writeEndObject();
        }

    });
    return j.toJson(os);
}

@ResponseBody
public String cfgPermissionByRoleId(Integer roleId) throws Exception {
    List<Permission> os = permissionService.listAllGroupByProject(roleId);
    Jacksons j = mvnJacksons.addJsonSerializer(Permission.class, new JsonSerializer<Permission>(){

        @Override
        public void serialize(Permission value, JsonGenerator gen,
                SerializerProvider serializers) throws IOException {
            gen.writeStartObject();
            gen.writeObjectField("id", value.getId());
            if(value.getId() == null) {
                gen.writeObjectField("projectId", value.getProject().getId());
            }
            gen.writeObjectField("children", value.getChildren());
            gen.writeStringField("name", value.getName());
            gen.writeBooleanField("isParent", !(value.getIsMenu() == null || value.getIsMenu() == YesNo.NO));
            gen.writeObjectField("checked", value.getIsOwn() != null && value.getIsOwn() == YesNo.YES);
            gen.writeEndObject();
        }

    });
    return j.toJson(os);
}

public ObjectMappingCustomer() {
        super();
        //过滤值为null的属性
//      this.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false);
        //配置方法
        /*<property name="objectMapper">
            <bean class="com.moshi.base.json.ObjectMappingCustomer">
                <property name="serializationInclusion">
                    <value type="com.fasterxml.jackson.annotation.JsonInclude.Include">NON_NULL</value>
                </property>
            </bean>
        </property>*/

        // 空值处理成字符串
        this.getSerializerProvider().setNullValueSerializer(
                new JsonSerializer<Object>() {
                    @Override
                    public void serialize(Object value, JsonGenerator jg,
                            SerializerProvider sp) throws IOException,
                            JsonProcessingException {
                        jg.writeString("");
                    }
                });
    }

private void addJsonBean(Object bean) {
    if (bean instanceof JsonSerializer) {
        addSerializerWithDeducedType((JsonSerializer<?>) bean);
    }
    if (bean instanceof JsonDeserializer) {
        addDeserializerWithDeducedType((JsonDeserializer<?>) bean);
    }
    for (Class<?> innerClass : bean.getClass().getDeclaredClasses()) {
        if (JsonSerializer.class.isAssignableFrom(innerClass)
                || JsonDeserializer.class.isAssignableFrom(innerClass)) {
            try {
                addJsonBean(innerClass.newInstance());
            }
            catch (Exception ex) {
                throw new IllegalStateException(ex);
            }
        }
    }
}

@Bean
public Module jacksonModule() {
    SimpleModule module = new SimpleModule();
    module.addSerializer(Foo.class, new JsonSerializer<Foo>() {

        @Override
        public void serialize(Foo value, JsonGenerator jgen,
                SerializerProvider provider)
                        throws IOException, JsonProcessingException {
            jgen.writeStartObject();
            jgen.writeStringField("foo", "bar");
            jgen.writeEndObject();
        }
    });
    return module;
}

@Bean
public MappingJackson2HttpMessageConverter jsonV1Converter(ObjectMapper objectMapper) {

    // Serialize numbers as strings
    objectMapper.configure(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS, true);

    // Serialize booleans as strings
    SimpleModule booleanAsString = new SimpleModule("BooleanAsString");
    booleanAsString.addSerializer(Boolean.class, new JsonSerializer<Boolean>() {
        @Override public void serialize(Boolean value, JsonGenerator jgen, SerializerProvider provider)
                throws IOException, JsonProcessingException {
            jgen.writeString(value.toString());

        }
    });
    objectMapper.registerModule(booleanAsString);

    objectMapper.addMixIn(ContextElement.class, EntityIdMixIn.class);
    objectMapper.addMixIn(AppendContextElementResponse.class, EntityIdMixIn.class);

    return new MappingJackson2HttpMessageConverter(objectMapper);
}

/**
 * Constructor
 * Adds the provided list of custom serializers to the object mapper returned by this class.
 * @param jsonObjectSerializers list of custom serializers to be used by the object mapper
 */
@Autowired
public JsonObjectMapper(JsonObjectSerializers jsonObjectSerializers) {
    SimpleModule entityModule = new SimpleModule("de.oliverwetterau.neo4j.websockets");

    entityModule.addSerializer(Result.class, new ResultSerializer());
    entityModule.addSerializer(de.oliverwetterau.neo4j.websockets.core.data.Error.class, new ErrorSerializer());

    entityModule.addDeserializer(Result.class, new ResultDeserializer());

    if (jsonObjectSerializers != null) {
        for (Map.Entry<Class,JsonSerializer> jsonSerializer : jsonObjectSerializers.getSerializers().entrySet()) {
            entityModule.addSerializer(jsonSerializer.getKey(), jsonSerializer.getValue());
        }

        for (Map.Entry<Class,JsonDeserializer> jsonDeserializer : jsonObjectSerializers.getDeserializers().entrySet()) {
            entityModule.addDeserializer(jsonDeserializer.getKey(), jsonDeserializer.getValue());
        }
    }

    textObjectMapper.registerModule(entityModule);
    binaryObjectMapper.registerModule(entityModule);
}

@SuppressWarnings("rawtypes")
@Bean
public Module springDataPageModule() {
    return new SimpleModule().addSerializer(Page.class, new JsonSerializer<Page>() {
        @Override
        public void serialize(Page value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            gen.writeStartObject();
            gen.writeNumberField("totalElements", value.getTotalElements());
            gen.writeNumberField("totalPages", value.getTotalPages());
            gen.writeNumberField("numberOfElements", value.getNumberOfElements());
            gen.writeObjectField("sort", value.getSort());
            gen.writeBooleanField("last", value.isLast());
            gen.writeBooleanField("first", value.isFirst());
            gen.writeFieldName("content");
            serializers.defaultSerializeValue(value.getContent(), gen);
            gen.writeEndObject();
        }
    });
}

/**
 * JAVADOC Method Level Comments
 *
 * @throws Exception JAVADOC.
 */
@SuppressWarnings({"rawtypes", "unchecked"})
@Override
public void afterPropertiesSet()
    throws Exception {
    //Set up 
    SimpleModule module = new SimpleModule("user",
            new Version(1, 0, 0, "User serializer/deserializer", null, null));

    if (CollectionUtils.isNotEmpty(serialisers)) {
        for (JsonSerializer<?> serialiser : serialisers) {
            module.addSerializer(serialiser);
        }
    }

    if (MapUtils.isNotEmpty(deserialisers)) {
        for (Map.Entry<Class, JsonDeserializer> deserialiserEntry : deserialisers.entrySet()) {
            module.addDeserializer(deserialiserEntry.getKey(), deserialiserEntry.getValue());
        }
    }

    mapper.registerModule(module);
}

@Bean
public Module jacksonModule() {
    SimpleModule module = new SimpleModule();
    module.addSerializer(Foo.class, new JsonSerializer<Foo>() {

        @Override
        public void serialize(Foo value, JsonGenerator jgen,
                SerializerProvider provider)
                        throws IOException, JsonProcessingException {
            jgen.writeStartObject();
            jgen.writeStringField("foo", "bar");
            jgen.writeEndObject();
        }
    });
    return module;
}

@Override
public JsonSerializer<?> modifySerializer( SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer ) {

    Class<?> klass = beanDesc.getBeanClass();

    if( klass == Boolean.class ) {
        return new BooleanSerializer( serializer );
    } else if( klass == Integer.class ) {
        return new IntegerSerializer( serializer );
    } else if( klass == Long.class ) {
        return new LongSerializer( serializer );
    } else if( klass == Float.class ) {
        return new FloatSerializer( serializer );
    } else if( klass == Double.class ) {
        return new DoubleSerializer( serializer );
    } else if( klass == BigDecimal.class ) {
        return new BigDecimalSerializer( serializer );
    } else if( ClassUtil.isExtendedBy( klass, Date.class ) ) {
        return new DateSerializer( serializer );
    }

    return serializer;

}

/**
 * We need to resolve actual serializer once we know the context; specifically
 * must know type of property being serialized.
 * If not known
 */
@Override
public JsonSerializer<?> createContextual(SerializerProvider provider,
        BeanProperty property)
                throws JsonMappingException
                {
    /* If we have property, should be able to get actual polymorphic type
     * information.
     * May need to refine in future, in case nested types are used, since
     * 'property' refers to field/method and main type, but contents of
     * that type may also be resolved... in which case this would fail.
     */
    if (property != null) {
        return new PersistentCollectionSerializer(property, property.getType(),
                _forceLazyLoading);
    }
    return this;
                }

@Override
public JsonSerializer<?> findSerializer(
        SerializationConfig config, JavaType type,
        BeanDescription beanDesc)
        {
    Class<?> raw = type.getRawClass();

    /* Note: PersistentCollection does not implement Collection, so we
     * may get some types here...
     */
    if (PersistentCollection.class.isAssignableFrom(raw)) {
        // TODO: handle iterator types? Or PersistentArrayHolder?
    }

    if (HibernateProxy.class.isAssignableFrom(raw)) {
        return new HibernateProxySerializer(isEnabled(Feature.FORCE_LAZY_LOADING));
    }
    return null;
        }

protected JsonSerializer<Object> findSerializer(SerializerProvider provider, Object value)
    throws IOException, JsonProcessingException
    {
/* TODO: if Hibernate did use generics, or we wanted to allow use of Jackson
 *  annotations to indicate type, should take that into account.
 */
Class<?> type = value.getClass();
/* we will use a map to contain serializers found so far, keyed by type:
 * this avoids potentially costly lookup from global caches and/or construction
 * of new serializers
 */
PropertySerializerMap.SerializerAndMapResult result = _dynamicSerializers.findAndAddSerializer(type,
        provider, _property);
if (_dynamicSerializers != result.map) {
    _dynamicSerializers = result.map;
}
return result.serializer;
    }

@Test
public void shouldUpdateInstanceWithCustomModule() throws Exception {
    // Given
    final JsonSerializer<String> serialiser = mock(JsonSerializer.class);
    TestCustomJsonModules1.modules = Collections.singletonList(
            new SimpleModule("module1", new Version(1, 0, 0, null, null, null))
                    .addSerializer(String.class, serialiser)
    );
    System.setProperty(JSONSerialiser.JSON_SERIALISER_MODULES, TestCustomJsonModules1.class.getName());

    // When
    JSONSerialiser.update();

    // Then
    assertEquals(JSONSerialiser.class, JSONSerialiser.getInstance().getClass());
    JSONSerialiser.serialise("test");
    verify(serialiser).serialize(Mockito.eq("test"), Mockito.any(), Mockito.any());
}

@Override
public void serialize(T value, JsonGenerator generator, SerializerProvider provider)
        throws IOException
{
    if (value == null) {
        provider.defaultSerializeNull(generator);
        return;
    }

    try {
        Class<?> type = value.getClass();
        JsonSerializer<T> serializer = serializerCache.get(type, () -> createSerializer(provider, type));
        serializer.serializeWithType(value, generator, provider, typeSerializer);
    }
    catch (ExecutionException e) {
        propagateIfInstanceOf(e.getCause(), IOException.class);
        throw Throwables.propagate(e.getCause());
    }
}

@SuppressWarnings("rawtypes")
@Bean
public Module springDataPageModule() {
    return new SimpleModule().addSerializer(Page.class, new JsonSerializer<Page>() {
        @Override
        public void serialize(Page value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            gen.writeStartObject();
            gen.writeNumberField("totalElements", value.getTotalElements());
            gen.writeNumberField("totalPages", value.getTotalPages());
            gen.writeNumberField("numberOfElements", value.getNumberOfElements());
            gen.writeObjectField("sort", value.getSort());
            gen.writeBooleanField("last", value.isLast());
            gen.writeBooleanField("first", value.isFirst());
            gen.writeFieldName("content");
            serializers.defaultSerializeValue(value.getContent(), gen);
            gen.writeEndObject();
        }
    });
}

@Bean
public ObjectMapper jsonObjectMapper() {
    final ObjectMapper jsonMapper = new ObjectMapper();
    jsonMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
    jsonMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    jsonMapper.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
    jsonMapper.configure(Feature.ALLOW_SINGLE_QUOTES, true);
    jsonMapper.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, false);

    final SimpleModule module = new SimpleModule("FieldsMapping", Version.unknownVersion());
    module.setSerializerModifier(new BeanSerializerModifier() {
        @Override
        public JsonSerializer<?> modifyMapSerializer(final SerializationConfig config, final MapType valueType,
                final BeanDescription beanDesc, final JsonSerializer<?> serializer) {
            if (FieldsMap.class.isAssignableFrom(valueType.getRawClass())) {
                return new FieldsMapMixInLikeSerializer();
            } else {
                return super.modifyMapSerializer(config, valueType, beanDesc, serializer);
            }
        }
    });
    jsonMapper.registerModule(module);
    return jsonMapper;
}

@SuppressWarnings("rawtypes")
@Bean
public Module springDataPageModule() {
    return new SimpleModule().addSerializer(Page.class, new JsonSerializer<Page>() {
        @Override
        public void serialize(Page value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            gen.writeStartObject();
            gen.writeNumberField("totalElements", value.getTotalElements());
            gen.writeNumberField("totalPages", value.getTotalPages());
            gen.writeNumberField("numberOfElements", value.getNumberOfElements());
            gen.writeObjectField("sort", value.getSort());
            gen.writeBooleanField("last", value.isLast());
            gen.writeBooleanField("first", value.isFirst());
            gen.writeFieldName("content");
            serializers.defaultSerializeValue(value.getContent(), gen);
            gen.writeEndObject();
        }
    });
}

@Override
public void setupModule(SetupContext context) {
    super.setupModule(context);

    context.addBeanSerializerModifier(new BeanSerializerModifier() {

        public JsonSerializer<?> modifySerializer(
                SerializationConfig config,
                BeanDescription beanDesc,
                JsonSerializer<?> serializer) {
            if (serializer instanceof BeanSerializerBase) {
                return new DictionaryObjectSerializer(
                        (BeanSerializerBase) serializer);
            }
            return serializer;
        }
    });
}

@Bean
public Module customJacksonModuleToSerializeInstantAsIso8601() {
    SimpleModule module = new SimpleModule();
    module.addDeserializer(Instant.class, new JsonDeserializer<Instant>() {
        @Override
        public Instant deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
            return Instant.from(DateTimeFormatter.ISO_INSTANT.parse(jsonParser.getText()));
        }
    });
    module.addSerializer(Instant.class, new JsonSerializer<Instant>() {
        @Override
        public void serialize(Instant instant, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
            jsonGenerator.writeString(DateTimeFormatter.ISO_INSTANT.format(instant));
        }
    });
    return module;
}

@Autowired
public ObjectMapperProvider(final JacksonProperties properties,
                            final JsonSerializer<RichBoolean> richBooleanSerialzer) {
    final ObjectMapper mapper = new ObjectMapper();
    mapper.setSerializationInclusion(NON_EMPTY);
    mapper.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

    properties.getSerialization().entrySet().forEach(e ->
            mapper.configure(e.getKey(), properties.getSerialization().get(e.getKey())));

    properties.getDeserialization().entrySet().forEach(e ->
            mapper.configure(e.getKey(), properties.getDeserialization().get(e.getKey())));

    final SimpleModule customSerializersModule = new SimpleModule();
    customSerializersModule.addSerializer(richBooleanSerialzer);

    mapper.registerModules(
            customSerializersModule,
            new Jdk8Module(),
            new JSR310Module()
    );
    this.mapper = mapper;
}

void write(Object val, int containedTypeIndex, JsonGenerator gen, SerializerProvider provider) throws IOException {
    if (val != null) {
        if (type.containedTypeCount() > containedTypeIndex) {
            JsonSerializer<Object> ser;
            JavaType containedType = type.containedType(containedTypeIndex);
            if (containedType != null && containedType.hasGenericTypes()) {
                List<JavaType> types = containedType.getBindings().getTypeParameters();
                JavaType[] generics = new JavaType[types.size()];
                for (int i = 0; i < types.size(); i++) {
                    generics[i] = types.get(i);
                }
                JavaType adjusted = provider.getTypeFactory().constructSimpleType(val.getClass(), generics);
                ser = provider.findTypedValueSerializer(adjusted, true, null);
            } else {
                ser = provider.findTypedValueSerializer(val.getClass(), true, null);
            }
            ser.serialize(val, gen, provider);
        } else {
            gen.writeObject(val);
        }
    } else {
        gen.writeNull();
    }
}

@Override
public JsonSerializer<?> findCollectionLikeSerializer(SerializationConfig config,
                                                      CollectionLikeType type, BeanDescription beanDesc,
                                                      TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) {
    Class<?> raw = type.getRawClass();
    if (raw == CharSeq.class) {
        return new CharSeqSerializer(type);
    }
    if (Seq.class.isAssignableFrom(raw)) {
        return new ArraySerializer<>(type);
    }
    if (Set.class.isAssignableFrom(raw)) {
        return new ArraySerializer<>(type);
    }
    if (PriorityQueue.class.isAssignableFrom(raw)) {
        return new ArraySerializer<>(type);
    }
    return super.findCollectionLikeSerializer(config, type, beanDesc, elementTypeSerializer, elementValueSerializer);
}

@Override
public void serialize(T value, JsonGenerator gen, SerializerProvider provider) throws IOException {
    Object obj = toJavaObj(value);
    if (obj == null) {
        provider.getDefaultNullValueSerializer().serialize(null, gen, provider);
    } else {
        JsonSerializer<Object> ser;
        try {
            JavaType emulated = emulatedJavaType(type, provider.getTypeFactory());
            if (emulated.getRawClass() != Object.class) {
                ser = provider.findTypedValueSerializer(emulated, true, null);
            } else {
                ser = provider.findTypedValueSerializer(obj.getClass(), true, null);
            }
        } catch (Exception ignore) {
            ser = provider.findTypedValueSerializer(obj.getClass(), true, null);
        }
        ser.serialize(obj, gen, provider);
    }
}

/**
 * Registering custom serializer allows to the JSonView to deal with custom serializations for certains field types.<br>
 * This way you could register for instance a JODA serialization as  a DateTimeSerializer. <br>
 * Thus, when JSonView find a field of that type (DateTime), it will delegate the serialization to the serializer specified.<br>
 * Example:<br>
 * <code>
 * JsonViewSupportFactoryBean bean = new JsonViewSupportFactoryBean( mapper );
 * bean.registerCustomSerializer( DateTime.class, new DateTimeSerializer() );
 * </code>
 *
 * @param <T>     Type class of the serializer
 * @param cls     {@link Class} The class type you want to add a custom serializer
 * @param forType {@link JsonSerializer} The serializer you want to apply for that type
 */
@SuppressWarnings("unchecked")
public <T> void registerCustomSerializer(Class<T> cls, JsonSerializer<T> forType) {
  if(customSerializersMap == null) {
    customSerializersMap = new HashMap<>();
  }

  if(cls == null) {
    throw new IllegalArgumentException("Class must not be null");
  } else if(cls.equals(JsonView.class)) {
    throw new IllegalArgumentException("Class cannot be " + JsonView.class);
  } else if(customSerializersMap.containsKey(cls)) {
    throw new IllegalArgumentException("Class " + cls + " already has a serializer registered (" + customSerializersMap.get(cls) + ")");
  }

  customSerializersMap.put(cls, (JsonSerializer<Object>) forType);
}

protected FindConfigFileService(final FilterProvider filterProvider,
                                final TextEncryptor textEncryptor,
                                final JsonSerializer<FieldPath> fieldPathSerializer,
                                final JsonDeserializer<FieldPath> fieldPathDeserializer) {

    final ObjectMapper objectMapper = new Jackson2ObjectMapperBuilder()
        .featuresToEnable(SerializationFeature.INDENT_OUTPUT)
        .mixIns(customMixins())
        .serializersByType(ImmutableMap.of(FieldPath.class, fieldPathSerializer))
        .deserializersByType(ImmutableMap.of(FieldPath.class, fieldPathDeserializer))
        .createXmlMapper(false)
        .build();

    setConfigFileLocation(CONFIG_FILE_LOCATION);
    setConfigFileName(CONFIG_FILE_NAME);
    setDefaultConfigFile(getDefaultConfigFile());
    setMapper(objectMapper);
    setTextEncryptor(textEncryptor);
    setFilterProvider(filterProvider);
}