Java 类com.fasterxml.jackson.databind.ser.BeanPropertyWriter 实例源码

@Test
public void MetadataPropertyWriter_serializeAsField_still_works_for_non_Error_objects() throws Exception {
    // given
    final MetadataPropertyWriter mpw = new MetadataPropertyWriter(mock(BeanPropertyWriter.class));

    // when
    Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            mpw.serializeAsField(new Object(), mock(JsonGenerator.class), mock(SerializerProvider.class));
        }
    });

    // then
    // We expect a NPE because mocking a base BeanPropertyWriter is incredibly difficult and not worth the effort.
    assertThat(ex).isInstanceOf(NullPointerException.class);
}

@Test
public void SmartErrorCodePropertyWriter_serializeAsField_still_works_for_non_Error_objects() throws Exception {
    // given
    final SmartErrorCodePropertyWriter secpw = new SmartErrorCodePropertyWriter(mock(BeanPropertyWriter.class));

    // when
    Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            secpw.serializeAsField(new Object(), mock(JsonGenerator.class), mock(SerializerProvider.class));
        }
    });

    // then
    // We expect a NPE because mocking a base BeanPropertyWriter is incredibly difficult and not worth the effort.
    assertThat(ex).isInstanceOf(NullPointerException.class);
}

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

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

/**
 * {@inheritDoc}
 *
 * @deprecated Provided for compatibility with deprecated method in Jackson.
 */
@Override
@Deprecated
public void serializeAsField(
        final Object pojo,
        final JsonGenerator jgen,
        final SerializerProvider prov,
        final BeanPropertyWriter writer) throws Exception {
    if (writer.getAnnotation(LogRedact.class) == null) {
        super.serializeAsField(pojo, jgen, prov, writer);
    } else { // since 2.3
        if (_allowNull && writer.get(pojo) == null) {
            super.serializeAsField(pojo, jgen, prov, writer);
        } else {
            jgen.writeStringField(writer.getSerializedName().getValue(), REDACTION_STRING);
        }
    }
}

@Override
public void serializeAsField(
        final Object pojo,
        final JsonGenerator jgen,
        final SerializerProvider prov,
        final PropertyWriter writer) throws Exception {
    if (writer instanceof BeanPropertyWriter) {
        final BeanPropertyWriter beanPropertyWriter = (BeanPropertyWriter) writer;
        if (beanPropertyWriter.getAnnotation(LogRedact.class) == null) {
            super.serializeAsField(pojo, jgen, prov, writer);
        } else {
            if (_allowNull && beanPropertyWriter.get(pojo) == null) {
                super.serializeAsField(pojo, jgen, prov, writer);
            } else {
                jgen.writeStringField(beanPropertyWriter.getSerializedName().getValue(), REDACTION_STRING);
            }
        }
    } else {
        super.serializeAsField(pojo, jgen, prov, writer);
    }
}

@Override
public void serializeAsField(Object bean, JsonGenerator jgen, SerializerProvider provider, BeanPropertyWriter writer) throws Exception {
    if (include(writer)) {
        Field[] fields = bean.getClass().getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];

            if(field.getType() == Integer.TYPE) {
                int value = (int) field.get(bean);
                if(value <= 0) {
                    writer.serializeAsField(bean, jgen, provider);
                }
                else
                    super.serializeAsField(bean, jgen, provider, writer);
            }
            else {

            }
        }
    }
  }

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 void serialize(DataMessage value, JsonGenerator jgen, SerializerProvider provider)
    throws IOException
{
    Class<?> eventType = value.getEventType();
    EventBeanSerializer serializer = (EventBeanSerializer)findSerializer(eventType, provider, true);
    BeanPropertyWriter[] props = serializer.getProps();

    jgen.writeStartArray();
    if (value.isSendScheme())
        serializeScheme(eventType, jgen, props);
    else
        jgen.writeString(eventType.getSimpleName());
    jgen.writeStartArray();
    for (EventType<?> event : value.getEvents())
        for (BeanPropertyWriter prop : props)
            if (EVENT_SYMBOL.equals(prop.getName()))
                jgen.writeString(value.getSymbolMap().get(event.getEventSymbol()));
            else {
                Object propValue;
                try {
                    propValue = prop.get(event); // access property via reflection
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                serializeValue(propValue, jgen, provider);
            }
    jgen.writeEndArray();
    jgen.writeEndArray();
}

private void serializeScheme(Class<?> eventType, JsonGenerator jgen, BeanPropertyWriter[] props)
    throws IOException
{
    jgen.writeStartArray();
    jgen.writeString(eventType.getSimpleName());
    jgen.writeStartArray();
    for (BeanPropertyWriter prop : props)
        jgen.writeString(prop.getName());
    jgen.writeEndArray();
    jgen.writeEndArray();
}

protected BeanPropertyWriter findPropWriter(List<BeanPropertyWriter> propWriters, String desiredFieldName) {
    for (BeanPropertyWriter propWriter : propWriters) {
        if (desiredFieldName.equals(propWriter.getName())) {
            return propWriter;
        }
    }

    return null;
}

@Test
public void ErrorContractSerializationFactory_findPropWriter_returns_null_if_it_cannot_find_() {
    // given
    ErrorContractSerializationFactory impl = new ErrorContractSerializationFactory(null, true, true);

    // when
    BeanPropertyWriter result = impl.findPropWriter(Collections.<BeanPropertyWriter>emptyList(), UUID.randomUUID().toString());

    // then
    assertThat(result).isNull();
}

@Override
public void serializeAsField(Object bean, JsonGenerator jgen, SerializerProvider provider, BeanPropertyWriter writer)
    throws Exception {
    if (include(bean, writer)) {
        super.serializeAsField(bean, jgen, provider, writer);
    }
}

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

private boolean isReadable(BeanDescription beanDesc, BeanPropertyWriter writer) {
    Class<?> parentType = beanDesc.getType().getRawClass();
    Class<?> type = writer.getType().getRawClass();
    AnnotatedMethod setter = findSetter(beanDesc, writer);
    // If there's a setter, we assume it's OK to report on the value,
    // similarly, if there's no setter but the package names match, we assume
    // that its a nested class used solely for binding to config props, so it
    // should be kosher. This filter is not used if there is JSON metadata for
    // the property, so it's mainly for user-defined beans.
    return (setter != null) || ClassUtils.getPackageName(parentType)
            .equals(ClassUtils.getPackageName(type));
}

private AnnotatedMethod findSetter(BeanDescription beanDesc,
        BeanPropertyWriter writer) {
    String name = "set" + StringUtils.capitalize(writer.getName());
    Class<?> type = writer.getType().getRawClass();
    AnnotatedMethod setter = beanDesc.findMethod(name, new Class<?>[] { type });
    // The enabled property of endpoints returns a boolean primitive but is set
    // using a Boolean class
    if (setter == null && type.equals(Boolean.TYPE)) {
        setter = beanDesc.findMethod(name, new Class<?>[] { Boolean.class });
    }
    return setter;
}

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

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

private boolean isReadable(BeanDescription beanDesc, BeanPropertyWriter writer) {
    String parentType = beanDesc.getType().getRawClass().getName();
    String type = writer.getType().getTypeName();
    AnnotatedMethod setter = findSetter(beanDesc, writer);
    // If there's a setter, we assume it's OK to report on the value,
    // similarly, if there's no setter but the package names match, we assume
    // that its a nested class used solely for binding to config props, so it
    // should be kosher. This filter is not used if there is JSON metadata for
    // the property, so it's mainly for user-defined beans.
    return (setter != null) || ClassUtils.getPackageName(parentType)
            .equals(ClassUtils.getPackageName(type));
}

private AnnotatedMethod findSetter(BeanDescription beanDesc,
        BeanPropertyWriter writer) {
    String name = "set" + StringUtils.capitalize(writer.getName());
    Class<?> type = writer.getType().getRawClass();
    AnnotatedMethod setter = beanDesc.findMethod(name, new Class<?>[] { type });
    // The enabled property of endpoints returns a boolean primitive but is set
    // using a Boolean class
    if (setter == null && type.equals(Boolean.TYPE)) {
        setter = beanDesc.findMethod(name, new Class<?>[] { Boolean.class });
    }
    return setter;
}

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

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

private boolean isReadable(BeanDescription beanDesc, BeanPropertyWriter writer) {
    String parentType = beanDesc.getType().getRawClass().getName();
    String type = writer.getPropertyType().getName();
    AnnotatedMethod setter = findSetter(beanDesc, writer);
    // If there's a setter, we assume it's OK to report on the value,
    // similarly, if there's no setter but the package names match, we assume
    // that its a nested class used solely for binding to config props, so it
    // should be kosher. This filter is not used if there is JSON metadata for
    // the property, so it's mainly for user-defined beans.
    return (setter != null) || ClassUtils.getPackageName(parentType)
            .equals(ClassUtils.getPackageName(type));
}

private AnnotatedMethod findSetter(BeanDescription beanDesc,
        BeanPropertyWriter writer) {
    String name = "set" + StringUtils.capitalize(writer.getName());
    Class<?> type = writer.getPropertyType();
    AnnotatedMethod setter = beanDesc.findMethod(name, new Class<?>[] { type });
    // The enabled property of endpoints returns a boolean primitive but is set
    // using a Boolean class
    if (setter == null && type.equals(Boolean.TYPE)) {
        setter = beanDesc.findMethod(name, new Class<?>[] { Boolean.class });
    }
    return setter;
}

@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.getPropertyType() });
        if (setter != null && this.conversionService.canConvert(String.class,
                writer.getPropertyType())) {
            result.add(writer);
        }
    }
    return result;
}

public BeanSerializerBase(JavaType paramJavaType, BeanSerializerBuilder paramBeanSerializerBuilder, BeanPropertyWriter[] paramArrayOfBeanPropertyWriter1, BeanPropertyWriter[] paramArrayOfBeanPropertyWriter2)
{
  super(paramJavaType);
  this._props = paramArrayOfBeanPropertyWriter1;
  this._filteredProps = paramArrayOfBeanPropertyWriter2;
  BeanSerializerBase localBeanSerializerBase;
  JsonFormat.Shape localShape;
  if (paramBeanSerializerBuilder == null)
  {
    this._typeId = null;
    this._anyGetterWriter = null;
    this._propertyFilterId = null;
    this._objectIdWriter = null;
    localBeanSerializerBase = this;
    localShape = null;
  }
  else
  {
    this._typeId = paramBeanSerializerBuilder.getTypeId();
    this._anyGetterWriter = paramBeanSerializerBuilder.getAnyGetter();
    this._propertyFilterId = paramBeanSerializerBuilder.getFilterId();
    this._objectIdWriter = paramBeanSerializerBuilder.getObjectIdWriter();
    JsonFormat.Value localValue = paramBeanSerializerBuilder.getBeanDescription().findExpectedFormat(null);
    localBeanSerializerBase = this;
    if (localValue == null)
      localShape = null;
    else
      localShape = localValue.getShape();
  }
  localBeanSerializerBase._serializationShape = localShape;
}

public BeanSerializerBase(BeanSerializerBase paramBeanSerializerBase, BeanPropertyWriter[] paramArrayOfBeanPropertyWriter1, BeanPropertyWriter[] paramArrayOfBeanPropertyWriter2)
{
  super(paramBeanSerializerBase._handledType);
  this._props = paramArrayOfBeanPropertyWriter1;
  this._filteredProps = paramArrayOfBeanPropertyWriter2;
  this._typeId = paramBeanSerializerBase._typeId;
  this._anyGetterWriter = paramBeanSerializerBase._anyGetterWriter;
  this._objectIdWriter = paramBeanSerializerBase._objectIdWriter;
  this._propertyFilterId = paramBeanSerializerBase._propertyFilterId;
  this._serializationShape = paramBeanSerializerBase._serializationShape;
}

public BeanSerializerBase(BeanSerializerBase paramBeanSerializerBase, String[] paramArrayOfString)
{
  super(paramBeanSerializerBase._handledType);
  HashSet localHashSet = ArrayBuilders.arrayToSet(paramArrayOfString);
  BeanPropertyWriter[] arrayOfBeanPropertyWriter1 = paramBeanSerializerBase._props;
  BeanPropertyWriter[] arrayOfBeanPropertyWriter2 = paramBeanSerializerBase._filteredProps;
  int i = arrayOfBeanPropertyWriter1.length;
  ArrayList localArrayList1 = new ArrayList(i);
  ArrayList localArrayList2;
  if (arrayOfBeanPropertyWriter2 == null)
    localArrayList2 = null;
  else
    localArrayList2 = new ArrayList(i);
  for (int j = 0; j < i; j++)
  {
    BeanPropertyWriter localBeanPropertyWriter = arrayOfBeanPropertyWriter1[j];
    if (!localHashSet.contains(localBeanPropertyWriter.getName()))
    {
      localArrayList1.add(localBeanPropertyWriter);
      if (arrayOfBeanPropertyWriter2 != null)
        localArrayList2.add(arrayOfBeanPropertyWriter2[j]);
    }
  }
  this._props = ((BeanPropertyWriter[])localArrayList1.toArray(new BeanPropertyWriter[localArrayList1.size()]));
  BeanPropertyWriter[] arrayOfBeanPropertyWriter3;
  if (localArrayList2 == null)
    arrayOfBeanPropertyWriter3 = null;
  else
    arrayOfBeanPropertyWriter3 = (BeanPropertyWriter[])localArrayList2.toArray(new BeanPropertyWriter[localArrayList2.size()]);
  this._filteredProps = arrayOfBeanPropertyWriter3;
  this._typeId = paramBeanSerializerBase._typeId;
  this._anyGetterWriter = paramBeanSerializerBase._anyGetterWriter;
  this._objectIdWriter = paramBeanSerializerBase._objectIdWriter;
  this._propertyFilterId = paramBeanSerializerBase._propertyFilterId;
  this._serializationShape = paramBeanSerializerBase._serializationShape;
}

private static final BeanPropertyWriter[] rename(BeanPropertyWriter[] paramArrayOfBeanPropertyWriter, NameTransformer paramNameTransformer)
{
  if ((paramArrayOfBeanPropertyWriter == null) || (paramArrayOfBeanPropertyWriter.length == 0) || (paramNameTransformer == null) || (paramNameTransformer == NameTransformer.NOP))
    return paramArrayOfBeanPropertyWriter;
  int i = paramArrayOfBeanPropertyWriter.length;
  BeanPropertyWriter[] arrayOfBeanPropertyWriter = new BeanPropertyWriter[i];
  for (int j = 0; j < i; j++)
  {
    BeanPropertyWriter localBeanPropertyWriter = paramArrayOfBeanPropertyWriter[j];
    if (localBeanPropertyWriter != null)
      arrayOfBeanPropertyWriter[j] = localBeanPropertyWriter.rename(paramNameTransformer);
  }
  return arrayOfBeanPropertyWriter;
}

protected JsonSerializer<Object> findConvertingSerializer(SerializerProvider paramSerializerProvider, BeanPropertyWriter paramBeanPropertyWriter)
{
  AnnotationIntrospector localAnnotationIntrospector = paramSerializerProvider.getAnnotationIntrospector();
  if (localAnnotationIntrospector != null)
  {
    Object localObject = localAnnotationIntrospector.findSerializationConverter(paramBeanPropertyWriter.getMember());
    if (localObject != null)
    {
      Converter localConverter = paramSerializerProvider.converterInstance(paramBeanPropertyWriter.getMember(), localObject);
      JavaType localJavaType = localConverter.getOutputType(paramSerializerProvider.getTypeFactory());
      return new StdDelegatingSerializer(localConverter, localJavaType, paramSerializerProvider.findValueSerializer(localJavaType, paramBeanPropertyWriter));
    }
  }
  return null;
}

public JsonNode getSchema(SerializerProvider paramSerializerProvider, Type paramType)
{
  ObjectNode localObjectNode1 = createSchemaNode("object", true);
  JsonSerializableSchema localJsonSerializableSchema = (JsonSerializableSchema)this._handledType.getAnnotation(JsonSerializableSchema.class);
  if (localJsonSerializableSchema != null)
  {
    String str = localJsonSerializableSchema.id();
    if ((str != null) && (str.length() > 0))
      localObjectNode1.put("id", str);
  }
  ObjectNode localObjectNode2 = localObjectNode1.objectNode();
  BeanPropertyFilter localBeanPropertyFilter;
  if (this._propertyFilterId != null)
    localBeanPropertyFilter = findFilter(paramSerializerProvider);
  else
    localBeanPropertyFilter = null;
  for (int i = 0; i < this._props.length; i++)
  {
    BeanPropertyWriter localBeanPropertyWriter = this._props[i];
    if (localBeanPropertyFilter == null)
      localBeanPropertyWriter.depositSchemaProperty(localObjectNode2, paramSerializerProvider);
    else
      localBeanPropertyFilter.depositSchemaProperty(localBeanPropertyWriter, localObjectNode2, paramSerializerProvider);
  }
  localObjectNode1.put("properties", localObjectNode2);
  return localObjectNode1;
}

private boolean hasSingleElement(SerializerProvider paramSerializerProvider)
{
  BeanPropertyWriter[] arrayOfBeanPropertyWriter;
  if ((this._filteredProps != null) && (paramSerializerProvider.getActiveView() != null))
    arrayOfBeanPropertyWriter = this._filteredProps;
  else
    arrayOfBeanPropertyWriter = this._props;
  return arrayOfBeanPropertyWriter.length == 1;
}

@Override
public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc,
        List<BeanPropertyWriter> beanProperties)
{
    for (int i = 0; i < beanProperties.size(); ++i) {
        final BeanPropertyWriter writer = beanProperties.get(i);
        if (Option.class.isAssignableFrom(writer.getPropertyType()))
            beanProperties.set(i, new OptionBeanPropertyWriter(writer));
    }

    return beanProperties;
}

@Override
public List<BeanPropertyWriter> changeProperties(
        final SerializationConfig config,
        final BeanDescription beanDesc,
        final List<BeanPropertyWriter> beanProperties) {
    final List<BeanPropertyWriter> beanPropertyWriters = super.changeProperties(config, beanDesc, beanProperties);

    // Determine if the bean is annotated with @Loggable
    Boolean isLoggable = LOGGABLE_CLASSES.get(beanDesc.getBeanClass());
    if (isLoggable == null) {
        isLoggable = beanDesc.getBeanClass().getAnnotation(Loggable.class) != null;
        LOGGABLE_CLASSES.put(beanDesc.getBeanClass(), isLoggable);
    }

    // Non-loggable beans under safe encoding should not log properties
    final boolean clearProperties = !isLoggable && _stenoEncoder.isSafe();
    if (clearProperties) {
        beanProperties.clear();
    }

    // Beans with cleared properties or with bean identifier injection enabled should include identifiers
    if (clearProperties || _stenoEncoder.isInjectBeanIdentifier()) {
        beanPropertyWriters.add(0, new BeanIdentifierPropertyWriter(config));
        beanPropertyWriters.add(1, new BeanClassPropertyWriter(config));
    }

    return beanPropertyWriters;
}

@Override
public Void answer(final InvocationOnMock invocation) throws Throwable {
    // CHECKSTYLE.ON: IllegalThrows
    if (invocation.getArguments()[3] instanceof BeanPropertyWriter) {
        _redactionFilter.serializeAsField(invocation.getArguments()[0], (JsonGenerator) invocation.getArguments()[1],
                (SerializerProvider) invocation.getArguments()[2], (BeanPropertyWriter) invocation.getArguments()[3]);
    } else {
        _redactionFilter.serializeAsField(invocation.getArguments()[0],
                (JsonGenerator) invocation.getArguments()[1],
                (SerializerProvider) invocation.getArguments()[2],
                (PropertyWriter) invocation.getArguments()[3]);
    }
    return null;
}

@Override
public List<BeanPropertyWriter> changeProperties(SerializationConfig config,
                                                 BeanDescription beanDesc,
                                                 List<BeanPropertyWriter> beanProperties) {
    if (!Registration.class.isAssignableFrom(beanDesc.getBeanClass())) {
        return beanProperties;
    }

    beanProperties.stream()
                  .filter(beanProperty -> "metadata".equals(beanProperty.getName()))
                  .forEach(beanProperty -> beanProperty.assignSerializer(metadataSerializer));
    return beanProperties;
}

public void serializeAsField(Object bean, JsonGenerator jgen,
        SerializerProvider provider, BeanPropertyWriter writer) throws Exception
{
    if (include(writer)) {
        writer.serializeAsField(bean, jgen, provider);
    }
}

public void depositSchemaProperty(BeanPropertyWriter writer,
        ObjectNode propertiesNode, SerializerProvider provider)
    throws JsonMappingException
{
    if (include(writer)) {
        writer.depositSchemaProperty(propertiesNode, provider);
    }
}

public void depositSchemaProperty(BeanPropertyWriter writer,
        JsonObjectFormatVisitor objectVisitor, SerializerProvider provider)
    throws JsonMappingException
{
    if (include(writer)) {
        writer.depositSchemaProperty(objectVisitor);
    }
}