@Bean(name = "objectMapper") public ObjectMapper getObjectMapper() { ObjectMapper mapper = new ObjectMapper(); mapper.registerModule(new GuavaModule()); mapper.registerModule(new Jdk8Module()); mapper.registerModule(new JodaModule()); mapper.setAnnotationIntrospector(new JacksonAnnotationIntrospector() { // borrowed from: http://jackson-users.ning.com/forum/topics/how-to-not-include-type-info-during-serialization-with @Override protected TypeResolverBuilder<?> _findTypeResolver(MapperConfig<?> config, Annotated ann, JavaType baseType) { // Don't serialize JsonTypeInfo Property includes if (ann.hasAnnotation(JsonTypeInfo.class) && ann.getAnnotation(JsonTypeInfo.class).include() == JsonTypeInfo.As.PROPERTY && SerializationConfig.class.isAssignableFrom(config.getClass())) { return null; } return super._findTypeResolver(config, ann, baseType); } }); return mapper; }
public static AnnotatedClass build(final Class<?> declaringClass, final SerializationConfig serializationConfig) { for (final Method method : AnnotatedClass.class.getMethods()) { if (CONSTRUCT_METHOD_NAME.equals(method.getName()) && method.getParameterTypes().length == 3) { return ExceptionUtil.wrapCatchedExceptions(new Callable<AnnotatedClass>() { @Override public AnnotatedClass call() throws Exception { return buildAnnotatedClass(method, declaringClass, serializationConfig); } }, "Exception while building AnnotatedClass"); } } throw new IllegalStateException(CANNOT_FIND_PROPER_METHOD); }
protected Optional<String> getName(Method method) { ObjectMapper objectMapper = context.getObjectMapper(); SerializationConfig serializationConfig = objectMapper.getSerializationConfig(); if (serializationConfig != null && serializationConfig.getPropertyNamingStrategy() != null) { String name = ClassUtils.getGetterFieldName(method); Annotation[] declaredAnnotations = method.getDeclaredAnnotations(); AnnotationMap annotationMap = buildAnnotationMap(declaredAnnotations); int paramsLength = method.getParameterAnnotations().length; AnnotationMap[] paramAnnotations = new AnnotationMap[paramsLength]; for (int i = 0; i < paramsLength; i++) { AnnotationMap parameterAnnotationMap = buildAnnotationMap(method.getParameterAnnotations()[i]); paramAnnotations[i] = parameterAnnotationMap; } AnnotatedClass annotatedClass = AnnotatedClassBuilder.build(method.getDeclaringClass(), serializationConfig); AnnotatedMethod annotatedField = AnnotatedMethodBuilder.build(annotatedClass, method, annotationMap, paramAnnotations); return Optional.of(serializationConfig.getPropertyNamingStrategy().nameForGetterMethod(serializationConfig, annotatedField, name)); } return Optional.empty(); }
@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; } }); }
@Override public BeanSerializerBuilder updateBuilder(SerializationConfig config, BeanDescription beanDesc, BeanSerializerBuilder builder) { for (BeanPropertyWriter writer : builder.getProperties()) { JavaType propertyType = writer.getMember().getType(); Class<?> type = propertyType.getRawClass(); List<BeanPropertyDefinition> properties = getProperties(propertyType, config); Optional.ofNullable(AnnotationUtils.findAnnotation(type, ValueObject.class))// .filter(it -> properties.size() == 1)// .flatMap(it -> properties.stream().findFirst())// .ifPresent(it -> writer.assignSerializer(new PropertyAccessingSerializer(it))); } return builder; }
@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; } }); }
public JacksonClientModule() { setSerializerModifier(new BeanSerializerModifier() { @Override public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) { for (BeanPropertyWriter writer : beanProperties) { if (writer.getAnnotation(LinkedResource.class) != null) { writer.assignSerializer(new LinkedResourceUriSerializer()); } } return beanProperties; } }); setMixInAnnotation(Resource.class, ResourceMixin.class); }
public DefaultMethodSkippingModuleProvider() { module = new SimpleModule(); module.setSerializerModifier(new BeanSerializerModifier() { @Override public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) { return super.changeProperties(config, beanDesc, beanProperties.stream().filter(bpw -> { final AnnotatedMember jacksonMember = bpw.getMember(); final Member member = jacksonMember.getMember(); if (member instanceof Method) { final Method method = (Method) member; if (method.isDefault()) { // only exclude default methods if they are defined on interfaces from the core components return !method.getDeclaringClass().getName().startsWith(PACKAGE_CORE_COMPONENTS); } } return true; }).collect(Collectors.toList())); } }); }
@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; }
@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 JavaType _figureFallbackType(SerializationConfig config, JavaType persistentType) { // Alas, PersistentTypes are NOT generics-aware... meaning can't specify parameterization Class<?> raw = persistentType.getRawClass(); TypeFactory tf = config.getTypeFactory(); if (Map.class.isAssignableFrom(raw)) { return tf.constructMapType(Map.class, Object.class, Object.class); } if (List.class.isAssignableFrom(raw)) { return tf.constructCollectionType(List.class, Object.class); } if (Set.class.isAssignableFrom(raw)) { return tf.constructCollectionType(Set.class, Object.class); } // ok, just Collection of some kind return tf.constructCollectionType(Collection.class, Object.class); }
@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; } }); }
@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); }
public TypeSerializer buildTypeSerializer(SerializationConfig paramSerializationConfig, JavaType paramJavaType, Collection<NamedType> paramCollection) { if (this._idType == JsonTypeInfo.Id.NONE) return null; TypeIdResolver localTypeIdResolver = idResolver(paramSerializationConfig, paramJavaType, paramCollection, true, false); switch (1.$SwitchMap$com$fasterxml$jackson$annotation$JsonTypeInfo$As[this._includeAs.ordinal()]) { default: break; case 1: return new AsArrayTypeSerializer(localTypeIdResolver, null); case 2: return new AsPropertyTypeSerializer(localTypeIdResolver, null, this._typeProperty); case 3: return new AsWrapperTypeSerializer(localTypeIdResolver, null); case 4: return new AsExternalTypeSerializer(localTypeIdResolver, null, this._typeProperty); } throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: " + this._includeAs); }
protected void processViews(SerializationConfig paramSerializationConfig, BeanSerializerBuilder paramBeanSerializerBuilder) { List localList = paramBeanSerializerBuilder.getProperties(); boolean bool = paramSerializationConfig.isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION); int i = localList.size(); int j = 0; BeanPropertyWriter[] arrayOfBeanPropertyWriter = new BeanPropertyWriter[i]; for (int k = 0; k < i; k++) { BeanPropertyWriter localBeanPropertyWriter = (BeanPropertyWriter)localList.get(k); Class[] arrayOfClass = localBeanPropertyWriter.getViews(); if (arrayOfClass == null) { if (bool) arrayOfBeanPropertyWriter[k] = localBeanPropertyWriter; } else { j++; arrayOfBeanPropertyWriter[k] = constructFilteredBeanWriter(localBeanPropertyWriter, arrayOfClass); } } if ((bool) && (j == 0)) return; paramBeanSerializerBuilder.setFilteredProperties(arrayOfBeanPropertyWriter); }
protected JsonSerializer<?> buildEnumSerializer(SerializationConfig paramSerializationConfig, JavaType paramJavaType, BeanDescription paramBeanDescription) { JsonFormat.Value localValue = paramBeanDescription.findExpectedFormat(null); if ((localValue != null) && (localValue.getShape() == JsonFormat.Shape.OBJECT)) { ((BasicBeanDescription)paramBeanDescription).removeProperty("declaringClass"); return null; } Object localObject = EnumSerializer.construct(paramJavaType.getRawClass(), paramSerializationConfig, paramBeanDescription, localValue); if (this._factoryConfig.hasSerializerModifiers()) { Iterator localIterator = this._factoryConfig.serializerModifiers().iterator(); while (localIterator.hasNext()) localObject = ((BeanSerializerModifier)localIterator.next()).modifyEnumSerializer(paramSerializationConfig, paramJavaType, paramBeanDescription, (JsonSerializer)localObject); } return localObject; }
public TypeSerializer createTypeSerializer(SerializationConfig paramSerializationConfig, JavaType paramJavaType) { AnnotatedClass localAnnotatedClass = paramSerializationConfig.introspectClassAnnotations(paramJavaType.getRawClass()).getClassInfo(); AnnotationIntrospector localAnnotationIntrospector = paramSerializationConfig.getAnnotationIntrospector(); TypeResolverBuilder localTypeResolverBuilder = localAnnotationIntrospector.findTypeResolver(paramSerializationConfig, localAnnotatedClass, paramJavaType); Collection localCollection; if (localTypeResolverBuilder == null) { localTypeResolverBuilder = paramSerializationConfig.getDefaultTyper(paramJavaType); localCollection = null; } else { localCollection = paramSerializationConfig.getSubtypeResolver().collectAndResolveSubtypes(localAnnotatedClass, paramSerializationConfig, localAnnotationIntrospector); } if (localTypeResolverBuilder == null) return null; return localTypeResolverBuilder.buildTypeSerializer(paramSerializationConfig, paramJavaType, localCollection); }
protected final JsonSerializer<?> findSerializerByLookup(JavaType paramJavaType, SerializationConfig paramSerializationConfig, BeanDescription paramBeanDescription, boolean paramBoolean) { String str = paramJavaType.getRawClass().getName(); JsonSerializer localJsonSerializer1 = (JsonSerializer)_concrete.get(str); if (localJsonSerializer1 == null) { Class localClass = (Class)_concreteLazy.get(str); if (localClass != null) try { JsonSerializer localJsonSerializer2 = (JsonSerializer)localClass.newInstance(); return localJsonSerializer2; } catch (Exception localException) { throw new IllegalStateException("Failed to instantiate standard serializer (of type " + localClass.getName() + "): " + localException.getMessage(), localException); } } return localJsonSerializer1; }
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) { JacksonHydraSerializer jacksonHydraSerializer = new JacksonHydraSerializer( (BeanSerializerBase) serializer, proxyUnwrapper); return jacksonHydraSerializer; } else { return serializer; } } }); }
@Override public JsonSerializer<?> modifyCollectionSerializer(SerializationConfig config, CollectionType valueType, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (valueType.getRawClass() == ArrayList.class) { return new IiifIndexedListSerializer((IndexedListSerializer) serializer, config.getTypeFactory()); } return super.modifyCollectionSerializer(config, valueType, beanDesc, serializer); }
@Override public JsonSerializer<?> modifySerializer(SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (Resource.class.isAssignableFrom(beanDesc.getBeanClass())) { return new ResourceSerializer((JsonSerializer<Object>) serializer); } else if (Profile.class.isAssignableFrom(beanDesc.getBeanClass())) { return new ProfileSerializer((JsonSerializer<Object>) serializer); } return super.modifySerializer(config, beanDesc, serializer); }
private static AnnotatedClass buildAnnotatedClass(Method method, Class<?> declaringClass, SerializationConfig serializationConfig) throws InvocationTargetException, IllegalAccessException { if (method.getParameterTypes()[0] == Class.class) { return buildOldAnnotatedClass(method, declaringClass, serializationConfig); } else { PreconditionUtil.assertEquals("unexpected method signature", method.getParameterTypes()[0], JavaType.class); return buildNewAnnotatedClass(method, declaringClass, serializationConfig); } }
private static AnnotatedClass buildOldAnnotatedClass(Method method, Class<?> declaringClass, SerializationConfig serializationConfig) throws InvocationTargetException, IllegalAccessException { boolean useAnnotations = serializationConfig.isAnnotationProcessingEnabled(); AnnotationIntrospector aintr = useAnnotations ? serializationConfig.getAnnotationIntrospector() : null; return AnnotatedClass.class.cast(method.invoke(null, declaringClass, aintr, serializationConfig)); }
protected Optional<String> getName(Field field) { ObjectMapper objectMapper = context.getObjectMapper(); SerializationConfig serializationConfig = objectMapper.getSerializationConfig(); if (serializationConfig != null && serializationConfig.getPropertyNamingStrategy() != null) { AnnotationMap annotationMap = buildAnnotationMap(field.getDeclaredAnnotations()); AnnotatedClass annotatedClass = AnnotatedClassBuilder.build(field.getDeclaringClass(), serializationConfig); AnnotatedField annotatedField = AnnotatedFieldBuilder.build(annotatedClass, field, annotationMap); return Optional.of(serializationConfig.getPropertyNamingStrategy().nameForField(serializationConfig, annotatedField, field.getName())); } return Optional.empty(); }
public SupernodeModule(Supplier<Boolean> production) { super("Supernode"); this.formatter = HyperLedgerSettings.getInstance().getTxWireFormatter(); addDeserializer(MasterPrivateKey.class, new MasterPrivateKeyDeserializer()); addDeserializer(MasterPublicKey.class, new MasterPublicKeyDeserializer()); addDeserializer(Script.class, new ScriptDeserializer()); addDeserializer(UIAddress.class, new AddressDeserializer()); addDeserializer(Transaction.class, new TransactionDeserializer(formatter)); addDeserializer(Hash.class, new HashDeserializer()); addDeserializer(TID.class, new TIDDeserializer()); addDeserializer(BID.class, new BIDDeserializer()); addSerializer(MasterPrivateKey.class, new MasterPrivateKeySerializer()); addSerializer(MasterPublicKey.class, new MasterPublicKeySerializer()); addSerializer(Script.class, new ScriptSerializer()); addSerializer(UIAddress.class, new AddressSerializer()); addSerializer(Transaction.class, new TransactionSerializer()); addSerializer(Outpoint.class, new OutpointSerializer()); addSerializer(Hash.class, new HashSerializer()); addSerializer(TID.class, new TIDSerializer()); addSerializer(BID.class, new BIDSerializer()); this.setSerializerModifier(new BeanSerializerModifier() { @Override public JsonSerializer<?> modifySerializer(SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (serializer instanceof MasterPublicKeySerializer) { MasterPublicKeySerializer.class.cast(serializer).setProduction(production.get()); } if (serializer instanceof MasterPrivateKeySerializer) { MasterPrivateKeySerializer.class.cast(serializer).setProduction(production.get()); } return serializer; } }); }
@Override public JsonSerializer<?> modifySerializer(SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (BeanAnnotationProcessor.isOwlClassEntity(beanDesc.getBeanClass())) { return new JacksonJsonLdSerializer<>(); } return serializer; }
public static JsonSerializer<Object> getBeanSerializer(SerializerProvider sp, Class<?> cls) throws JsonMappingException { final SerializationConfig config = sp.getConfig(); final JavaType type = config.constructType(cls); final BeanDescription beanDesc = config.introspect(type); return BeanSerializerFactory.instance.findBeanSerializer(sp, type, beanDesc); }
private void registerForSerializationIn(ObjectMapper objectMapper) { SerializationConfig serializationConfig = objectMapper.getSerializationConfig(); ClassIntrospector classIntrospector = serializationConfig.getClassIntrospector(); if (!(classIntrospector instanceof JacksonaticClassIntrospector)) { objectMapper.setConfig(serializationConfig.with(new JacksonaticClassIntrospector())); } JacksonaticClassIntrospector basicClassIntrospector = (JacksonaticClassIntrospector) objectMapper.getSerializationConfig().getClassIntrospector(); basicClassIntrospector.register(this); }
public static AnnotatedClass build(Class<?> declaringClass, SerializationConfig serializationConfig) { for (Method method : AnnotatedClass.class.getMethods()) { if (CONSTRUCT_METHOD_NAME.equals(method.getName()) && method.getParameterTypes().length == 3) { try { return buildAnnotatedClass(method, declaringClass, serializationConfig); } catch (InvocationTargetException | IllegalAccessException e) { throw new InternalException("Exception while building " + AnnotatedClass.class.getCanonicalName(), e); } } } throw new InternalException(CANNOT_FIND_PROPER_METHOD); }
private static AnnotatedClass buildAnnotatedClass(Method method, Class<?> declaringClass, SerializationConfig serializationConfig) throws InvocationTargetException, IllegalAccessException { if (method.getParameterTypes()[0] == Class.class) { return buildOldAnnotatedClass(method, declaringClass, serializationConfig); } else if (method.getParameterTypes()[0] == JavaType.class) { return buildNewAnnotatedClass(method, declaringClass, serializationConfig); } else { throw new InternalException(CANNOT_FIND_PROPER_METHOD); } }
@Override public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) { List<BeanPropertyWriter> result = new ArrayList<BeanPropertyWriter>(); for (BeanPropertyWriter writer : beanProperties) { boolean readable = isReadable(beanDesc, writer); if (readable) { result.add(writer); } } return result; }
@Override public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) { List<BeanPropertyWriter> result = new ArrayList<BeanPropertyWriter>(); for (BeanPropertyWriter writer : beanProperties) { AnnotatedMethod setter = beanDesc.findMethod( "set" + StringUtils.capitalize(writer.getName()), new Class<?>[] { writer.getType().getRawClass() }); if (setter != null && this.conversionService.canConvert(String.class, writer.getType().getRawClass())) { result.add(writer); } } return result; }
/** * Gets a module wrapping this serializer as an adapter for the Jackson * ObjectMapper. * * @param mapper the object mapper for default serializations * @return a simple module to be plugged onto Jackson ObjectMapper. */ public static SimpleModule getModule(final ObjectMapper mapper) { SimpleModule module = new SimpleModule(); module.setSerializerModifier(new BeanSerializerModifier() { @Override public JsonSerializer<?> modifySerializer(SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (beanDesc.getBeanClass().getAnnotation(JsonFlatten.class) != null) { return new FlatteningSerializer(beanDesc.getBeanClass(), serializer, mapper); } return serializer; } }); return module; }
@Override public JsonSerializer<?> modifyMapSerializer(SerializationConfig config, MapType valueType, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (serializer instanceof MapSerializer) { // TODO: We should probably be propagating the NON_EMPTY inclusion here, but it's breaking // discovery. return new DeepEmptyCheckingSerializer<>(serializer); } return serializer; }
@Override public void setupModule(SetupContext context) { // Modify the Map serializer to the delegate if it matches Map<String, ?> context.addBeanSerializerModifier(new BeanSerializerModifier() { @Override public JsonSerializer<?> modifyMapSerializer(SerializationConfig config, MapType valueType, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (valueType.getKeyType().equals(SimpleType.construct(String.class))) { return new DelegatingMapSerializer(serializer); } return serializer; } }); }
private static BeanDescription introspect(Class<?> type) { final JavaType javaType; SerializationConfig sc = Rosetta.getMapper().getSerializationConfig().withView(RosettaProperty.class); javaType = Rosetta.getMapper().getTypeFactory().constructType(type); return sc.introspect(javaType); }