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

@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;
}