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

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

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

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

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