@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; } }); }
private static ObjectMapper configureObjectMapper( ObjectMapper objectMapper, boolean shouldIncludeRawResponses) { if (shouldIncludeRawResponses) { SimpleModule module = new SimpleModule(); module.setDeserializerModifier(new BeanDeserializerModifier() { @Override public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) { if (Response.class.isAssignableFrom(beanDesc.getBeanClass())) { return new RawResponseDeserializer(deserializer); } return deserializer; } }); objectMapper.registerModule(module); } objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true); objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); return objectMapper; }
@Override public void setupModule(final SetupContext context) { super.setupModule(context); context.addBeanDeserializerModifier(new BeanDeserializerModifier() { @Override public JsonDeserializer<?> modifyCollectionDeserializer(final DeserializationConfig config, final CollectionType type, final BeanDescription beanDesc, final JsonDeserializer<?> deserializer) { if (deserializer instanceof CollectionDeserializer) { return new ListDeserializer((CollectionDeserializer) deserializer); } else { return super.modifyCollectionDeserializer(config, type, beanDesc, deserializer); } } }); }
@Override public JsonDeserializer<?> modifyMapDeserializer( DeserializationConfig config, MapType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer) { // statements if (isMapOfStringAndListOfStatements(type)) { return new ModifiedMapDeserializer<String, List<JacksonStatement>>(deserializer); } // labels and descriptions else if (isMapOfStringAndMonolingualTextValue(type)) { return new ModifiedMapDeserializer<String, JacksonMonolingualTextValue>(deserializer); } // sitelinks else if (isMapOfStringAndSitelink(type)) { return new ModifiedMapDeserializer<String, JacksonSiteLink>(deserializer); } // aliases and miscallaneous that does not need this workaround else { return deserializer; } }
@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; }
@Bean public ObjectMapper objectMapper() { ObjectMapper mapper = new ObjectMapper(); SimpleModule module = new SimpleModule(); module.setDeserializerModifier( new BeanDeserializerModifier() { @Override public JsonDeserializer<Enum> modifyEnumDeserializer( DeserializationConfig config, final JavaType type, BeanDescription beanDesc, final JsonDeserializer<?> deserializer ) { return new JsonDeserializer<Enum>() { @Override public Enum deserialize( JsonParser jp, DeserializationContext ctxt ) throws IOException { Class<? extends Enum> rawClass = (Class<Enum<?>>) type.getRawClass(); return Enum.valueOf( rawClass, jp.getValueAsString().toUpperCase() ); } }; } } ); module.addDeserializer( Expression.class, new ExpressionDeserializer( expressionParser() ) ); module.addDeserializer( Range.class, new RangeDeserializer() ); mapper.registerModule( module ); return mapper; }
@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; }
@SuppressFBWarnings(value = "REC_CATCH_EXCEPTION", justification = "Need to wrap all runtime exceptions before they are given to the user") @Override public Set<String> getSerialisedFields(final String className) { final Class<?> clazz; try { clazz = Class.forName(className); } catch (final Exception e) { throw new IllegalArgumentException("Class name was not recognised: " + className, e); } final ObjectMapper mapper = new ObjectMapper(); final JavaType type = mapper.getTypeFactory().constructType(clazz); final BeanDescription introspection = mapper.getSerializationConfig().introspect(type); final List<BeanPropertyDefinition> properties = introspection.findProperties(); final Set<String> fields = new HashSet<>(); for (final BeanPropertyDefinition property : properties) { fields.add(property.getName()); } return fields; }
@SuppressFBWarnings(value = "REC_CATCH_EXCEPTION", justification = "Need to wrap all runtime exceptions before they are given to the user") @Override public Response getSerialisedFields(final String className) { final Class<?> clazz; try { clazz = Class.forName(className); } catch (final Exception e) { throw new IllegalArgumentException("Class name was not recognised: " + className, e); } final ObjectMapper mapper = new ObjectMapper(); final JavaType type = mapper.getTypeFactory().constructType(clazz); final BeanDescription introspection = mapper.getSerializationConfig() .introspect(type); final List<BeanPropertyDefinition> properties = introspection.findProperties(); final Set<String> fields = new HashSet<>(); for (final BeanPropertyDefinition property : properties) { fields.add(property.getName()); } return Response.ok(fields) .header(GAFFER_MEDIA_TYPE_HEADER, GAFFER_MEDIA_TYPE) .build(); }
@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 String idFromValue(Object paramObject) { Class localClass = paramObject.getClass(); String str1 = localClass.getName(); synchronized (this._typeToId) { String str2 = (String)this._typeToId.get(str1); String str3 = str2; if (str2 == null) { if (this._config.isAnnotationProcessingEnabled()) { BeanDescription localBeanDescription = this._config.introspectClassAnnotations(localClass); str3 = this._config.getAnnotationIntrospector().findTypeName(localBeanDescription.getClassInfo()); } if (str3 == null) str3 = _defaultTypeId(localClass); this._typeToId.put(str1, str3); } return str3; } }
protected void addInjectables(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, BeanDeserializerBuilder paramBeanDeserializerBuilder) { Map localMap = paramBeanDescription.findInjectables(); if (localMap != null) { boolean bool = paramDeserializationContext.canOverrideAccessModifiers(); Iterator localIterator = localMap.entrySet().iterator(); while (localIterator.hasNext()) { Map.Entry localEntry = (Map.Entry)localIterator.next(); AnnotatedMember localAnnotatedMember = (AnnotatedMember)localEntry.getValue(); if (bool) localAnnotatedMember.fixAccess(); paramBeanDeserializerBuilder.addInjectable(localAnnotatedMember.getName(), paramBeanDescription.resolveType(localAnnotatedMember.getGenericType()), paramBeanDescription.getClassAnnotations(), localAnnotatedMember, localEntry.getKey()); } } }
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; }
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; }
protected final JsonSerializer<?> findSerializerByPrimaryType(SerializerProvider paramSerializerProvider, JavaType paramJavaType, BeanDescription paramBeanDescription, boolean paramBoolean) { Class localClass = paramJavaType.getRawClass(); if (InetAddress.class.isAssignableFrom(localClass)) return InetAddressSerializer.instance; if (TimeZone.class.isAssignableFrom(localClass)) return TimeZoneSerializer.instance; if (Charset.class.isAssignableFrom(localClass)) return ToStringSerializer.instance; JsonSerializer localJsonSerializer = findOptionalStdSerializer(paramSerializerProvider, paramJavaType, paramBeanDescription, paramBoolean); if (localJsonSerializer != null) return localJsonSerializer; if (Number.class.isAssignableFrom(localClass)) return NumberSerializers.NumberSerializer.instance; if (Enum.class.isAssignableFrom(localClass)) return buildEnumSerializer(paramSerializerProvider.getConfig(), paramJavaType, paramBeanDescription); if (Calendar.class.isAssignableFrom(localClass)) return CalendarSerializer.instance; if (java.util.Date.class.isAssignableFrom(localClass)) return DateSerializer.instance; return null; }
protected final JsonDeserializer<Object> _createDeserializer(DeserializationContext paramDeserializationContext, DeserializerFactory paramDeserializerFactory, JavaType paramJavaType) { DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig(); if ((paramJavaType.isAbstract()) || (paramJavaType.isMapLikeType()) || (paramJavaType.isCollectionLikeType())) paramJavaType = paramDeserializerFactory.mapAbstractType(localDeserializationConfig, paramJavaType); BeanDescription localBeanDescription = localDeserializationConfig.introspect(paramJavaType); JsonDeserializer localJsonDeserializer = findDeserializerFromAnnotation(paramDeserializationContext, localBeanDescription.getClassInfo()); if (localJsonDeserializer != null) return localJsonDeserializer; JavaType localJavaType1 = modifyTypeByAnnotation(paramDeserializationContext, localBeanDescription.getClassInfo(), paramJavaType); if (localJavaType1 != paramJavaType) { paramJavaType = localJavaType1; localBeanDescription = localDeserializationConfig.introspect(localJavaType1); } Class localClass = localBeanDescription.findPOJOBuilder(); if (localClass != null) return paramDeserializerFactory.createBuilderBasedDeserializer(paramDeserializationContext, paramJavaType, localBeanDescription, localClass); Converter localConverter = localBeanDescription.findDeserializationConverter(); if (localConverter == null) return _createDeserializer2(paramDeserializationContext, paramDeserializerFactory, paramJavaType, localBeanDescription); JavaType localJavaType2 = localConverter.getInputType(paramDeserializationContext.getTypeFactory()); if (!localJavaType2.hasRawClass(paramJavaType.getRawClass())) localBeanDescription = localDeserializationConfig.introspect(localJavaType2); return new StdDelegatingDeserializer(localConverter, localJavaType2, _createDeserializer2(paramDeserializationContext, paramDeserializerFactory, localJavaType2, localBeanDescription)); }
public AbstractDeserializer(BeanDeserializerBuilder paramBeanDeserializerBuilder, BeanDescription paramBeanDescription, Map<String, SettableBeanProperty> paramMap) { this._baseType = paramBeanDescription.getType(); this._objectIdReader = paramBeanDeserializerBuilder.getObjectIdReader(); this._backRefProperties = paramMap; Class localClass = this._baseType.getRawClass(); this._acceptString = localClass.isAssignableFrom(String.class); boolean bool1; if ((localClass == Boolean.TYPE) || (localClass.isAssignableFrom(Boolean.class))) bool1 = true; else bool1 = false; this._acceptBoolean = bool1; boolean bool2; if ((localClass == Integer.TYPE) || (localClass.isAssignableFrom(Integer.class))) bool2 = true; else bool2 = false; this._acceptInt = bool2; boolean bool3; if ((localClass == Double.TYPE) || (localClass.isAssignableFrom(Double.class))) bool3 = true; else bool3 = false; this._acceptDouble = bool3; }
public static KeyDeserializer findStringBasedKeyDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType) { BeanDescription localBeanDescription = paramDeserializationConfig.introspect(paramJavaType); Constructor localConstructor = localBeanDescription.findSingleArgConstructor(new Class[] { String.class }); if (localConstructor != null) { if (paramDeserializationConfig.canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(localConstructor); return new StdKeyDeserializer.StringCtorKeyDeserializer(localConstructor); } Method localMethod = localBeanDescription.findFactoryMethod(new Class[] { String.class }); if (localMethod != null) { if (paramDeserializationConfig.canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(localMethod); return new StdKeyDeserializer.StringFactoryKeyDeserializer(localMethod); } return null; }
protected JsonDeserializer<?> findStdDeserializer(DeserializationContext paramDeserializationContext, JavaType paramJavaType, BeanDescription paramBeanDescription) { JsonDeserializer localJsonDeserializer = findDefaultDeserializer(paramDeserializationContext, paramJavaType, paramBeanDescription); if (localJsonDeserializer != null) return localJsonDeserializer; if (AtomicReference.class.isAssignableFrom(paramJavaType.getRawClass())) { JavaType[] arrayOfJavaType = paramDeserializationContext.getTypeFactory().findTypeParameters(paramJavaType, AtomicReference.class); JavaType localJavaType; if ((arrayOfJavaType == null) || (arrayOfJavaType.length <= 0)) localJavaType = TypeFactory.unknownType(); else localJavaType = arrayOfJavaType[0]; return new JdkDeserializers.AtomicReferenceDeserializer(localJavaType); } return findOptionalStdDeserializer(paramDeserializationContext, paramJavaType, paramBeanDescription); }
public JsonDeserializer<?> createMapLikeDeserializer(DeserializationContext paramDeserializationContext, MapLikeType paramMapLikeType, BeanDescription paramBeanDescription) { JavaType localJavaType1 = paramMapLikeType.getKeyType(); JavaType localJavaType2 = paramMapLikeType.getContentType(); DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig(); JsonDeserializer localJsonDeserializer1 = (JsonDeserializer)localJavaType2.getValueHandler(); KeyDeserializer localKeyDeserializer = (KeyDeserializer)localJavaType1.getValueHandler(); TypeDeserializer localTypeDeserializer1 = (TypeDeserializer)localJavaType2.getTypeHandler(); TypeDeserializer localTypeDeserializer2 = localTypeDeserializer1; if (localTypeDeserializer1 == null) localTypeDeserializer2 = findTypeDeserializer(localDeserializationConfig, localJavaType2); JsonDeserializer localJsonDeserializer2 = _findCustomMapLikeDeserializer(paramMapLikeType, localDeserializationConfig, paramBeanDescription, localKeyDeserializer, localTypeDeserializer2, localJsonDeserializer1); JsonDeserializer localJsonDeserializer3 = localJsonDeserializer2; if ((localJsonDeserializer2 != null) && (this._factoryConfig.hasDeserializerModifiers())) { Iterator localIterator = this._factoryConfig.deserializerModifiers().iterator(); while (localIterator.hasNext()) localJsonDeserializer3 = ((BeanDeserializerModifier)localIterator.next()).modifyMapLikeDeserializer(localDeserializationConfig, paramMapLikeType, paramBeanDescription, localJsonDeserializer3); } return localJsonDeserializer3; }
@Override public JsonDeserializer<?> modifyEnumDeserializer(DeserializationConfig config, JavaType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer) { if (Arrays.asList(Quality.class, Format.class).contains(type.getRawClass())) { return new EnumDeserializer((Class<? extends Enum>) type.getRawClass()); } return super.modifyEnumDeserializer(config, type, beanDesc, deserializer); }
@Override public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) { // We don't use the @JsonDeserialize annotation since we only want the // custom deserializer for the abstract type and not for the actual types. if (Service.class == beanDesc.getBeanClass()) { return new ServiceDeserializer(); } else if (Resource.class == beanDesc.getBeanClass()) { return new ResourceDeserializer(); } else if (Profile.class == beanDesc.getBeanClass()) { return new ProfileDeserializer((JsonDeserializer<Object>) deserializer); } return super.modifyDeserializer(config, beanDesc, deserializer); }
@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); }
@Override public ValueInstantiator findValueInstantiator(DeserializationConfig config, BeanDescription beanDesc, ValueInstantiator defaultInstantiator) { if (DEFAULT_NO_DESER_CLASS_NAMES.contains(beanDesc.getClassInfo().getRawType().getName())) { throw new IllegalArgumentException("Illegal type " + beanDesc.getClassInfo().getRawType().getName() + " to deserialize: prevented for security reasons"); } return super.findValueInstantiator(config, beanDesc, defaultInstantiator); }
@Override public JsonDeserializer<Enum> modifyEnumDeserializer(DeserializationConfig config, final JavaType type, BeanDescription beanDesc, final JsonDeserializer<?> deserializer) { return new EnumJsonDeserializer(type); }
@Override public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) { if (Artifact.class.isAssignableFrom(beanDesc.getType().getRawClass())) { return new ArtifactDeserializer(); } return super.modifyDeserializer(config, beanDesc, deserializer); }
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; } }); }
protected void serializeField( Entity entity, JsonGenerator gen, SerializerProvider serializers, BeanDescription beanDescription, BeanPropertyDefinition beanPropertyDefinition) throws Exception { serializeFieldTyped(entity, gen, serializers, beanDescription, beanPropertyDefinition, null); }
protected void serializeFieldTyped( Entity entity, JsonGenerator gen, SerializerProvider serializers, BeanDescription beanDescription, BeanPropertyDefinition beanPropertyDefinition, TypeSerializer typeSerializer) throws Exception { try { if (typeSerializer == null) { typeSerializer = serializers.findTypeSerializer(serializers.constructType(beanPropertyDefinition.getAccessor().getRawType())); } if (typeSerializer == null) { // if not static type if available use dynamic type if available Object propertyValue = beanPropertyDefinition.getAccessor().getValue(entity); if (propertyValue != null) { typeSerializer = serializers.findTypeSerializer(serializers.constructType(propertyValue.getClass())); } } BeanPropertyWriter bpw = new BeanPropertyWriter( beanPropertyDefinition, beanPropertyDefinition.getAccessor(), beanDescription.getClassAnnotations(), beanPropertyDefinition.getAccessor().getType(), null, // will be searched automatically typeSerializer, // will not be searched automatically beanPropertyDefinition.getAccessor().getType(), suppressNulls(serializers.getConfig().getDefaultPropertyInclusion()), suppressableValue(serializers.getConfig().getDefaultPropertyInclusion())); bpw.serializeAsField(entity, gen, serializers); } catch (JsonMappingException ex) { Logger.getLogger(EntitySerializer.class.getName()).log(Level.SEVERE, null, ex); } }
@Override public JsonSerializer<?> modifySerializer(SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (BeanAnnotationProcessor.isOwlClassEntity(beanDesc.getBeanClass())) { return new JacksonJsonLdSerializer<>(); } return serializer; }
@Override public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) { if (BeanAnnotationProcessor.isOwlClassEntity(beanDesc.getBeanClass())) { return new JacksonJsonLdDeserializer(deserializer, beanDesc.getBeanClass()); } return deserializer; }
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); }
@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; }