@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(""); } }); }
@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); }
@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()); } }
@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; }
@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); }