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

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

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

protected SerializerFactoryConfig(Serializers[] paramArrayOfSerializers1, Serializers[] paramArrayOfSerializers2, BeanSerializerModifier[] paramArrayOfBeanSerializerModifier)
{
  Serializers[] arrayOfSerializers1;
  if (paramArrayOfSerializers1 == null)
    arrayOfSerializers1 = NO_SERIALIZERS;
  else
    arrayOfSerializers1 = paramArrayOfSerializers1;
  this._additionalSerializers = arrayOfSerializers1;
  Serializers[] arrayOfSerializers2;
  if (paramArrayOfSerializers2 == null)
    arrayOfSerializers2 = NO_SERIALIZERS;
  else
    arrayOfSerializers2 = paramArrayOfSerializers2;
  this._additionalKeySerializers = arrayOfSerializers2;
  BeanSerializerModifier[] arrayOfBeanSerializerModifier;
  if (paramArrayOfBeanSerializerModifier == null)
    arrayOfBeanSerializerModifier = NO_MODIFIERS;
  else
    arrayOfBeanSerializerModifier = paramArrayOfBeanSerializerModifier;
  this._modifiers = arrayOfBeanSerializerModifier;
}

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

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

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

public final SerializerFactoryConfig withSerializerModifier(BeanSerializerModifier paramBeanSerializerModifier)
{
  if (paramBeanSerializerModifier == null)
    throw new IllegalArgumentException("Can not pass null modifier");
  BeanSerializerModifier[] arrayOfBeanSerializerModifier = (BeanSerializerModifier[])ArrayBuilders.insertInListNoDup(this._modifiers, paramBeanSerializerModifier);
  return new SerializerFactoryConfig(this._additionalSerializers, this._additionalKeySerializers, arrayOfBeanSerializerModifier);
}

@Before
public void setUp() {
    mapper = new ObjectMapper();
    // see https://github.com/json-ld/json-ld.org/issues/76
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

    mapper.registerModule(new SimpleModule() {

        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 JacksonHydraSerializer(
                                (BeanSerializerBase) serializer);
                    } else {
                        return serializer;
                    }
                }
            });
        }
    });

}

public static BeanSerializerModifier createJsonSerializerModifier() {//final KeyFormatter keyFormatter, final boolean compactMode) {
    return new BeanSerializerModifier() {
        @Override
        public JsonSerializer<?> modifySerializer(SerializationConfig config,
                                                  BeanDescription beanDesc, JsonSerializer<?> serializer) {
            /*if (beanDesc.getBeanClass().isAssignableFrom(Applications.class)) {
                return new ApplicationsJsonBeanSerializer((BeanSerializerBase) serializer, keyFormatter);
            }*/
            if (beanDesc.getBeanClass().isAssignableFrom(InstanceInfo.class)) {
                return new InstanceInfoJsonBeanSerializer((BeanSerializerBase) serializer, false);
            }
            return serializer;
        }
    };
}

public void setBeanSerializerModifiers(List<BeanSerializerModifier> beanSerializerModifiers) {
    this.beanSerializerModifiers = beanSerializerModifiers;
}

public final Iterable<BeanSerializerModifier> serializerModifiers()
{
  return ArrayBuilders.arrayAsIterable(this._modifiers);
}

public SimpleModule setSerializerModifier(BeanSerializerModifier paramBeanSerializerModifier)
{
  this._serializerModifier = paramBeanSerializerModifier;
  return this;
}

public static String toJson(Service service) {
    ObjectMapper objectMapper = new ObjectMapper();

    SimpleModule module = new SimpleModule("JsonService", Version.unknownVersion()) {

        private static final long serialVersionUID = -5062700192805231474L;

        @Override
        public void setupModule(SetupContext context) {
            context.addBeanSerializerModifier(new BeanSerializerModifier() {

                @Override
                public JsonSerializer<?> modifySerializer(SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) {
                    Class<?> handledType = serializer.handledType();

                    if(serializer instanceof BeanSerializerBase) {
                        BeanSerializerBase beanSerializerBase = (BeanSerializerBase)serializer;

                        if(Service.class.equals(handledType)) {
                            return new ServiceSerializer(beanSerializerBase);
                        }

                        if(DatasetLayer.class.isAssignableFrom(handledType)) {
                            return new DatasetLayerSerializer(beanSerializerBase);
                        }
                    }

                    return serializer;
                }
            });
        }       
    };

    objectMapper.registerModule(new Jdk8Module());
    objectMapper.registerModule(module);

    objectMapper.setSerializationInclusion(Include.NON_EMPTY);

    objectMapper.addMixIn(Service.class, ServiceMixin.class);
    objectMapper.addMixIn(DatasetLayerRef.class, DatasetLayerRefMixin.class);
    objectMapper.addMixIn(VectorDatasetLayer.class, VectorDatasetLayerMixin.class);
    objectMapper.addMixIn(GroupLayerRef.class, GroupLayerRefMixin.class);
    objectMapper.addMixIn(GroupLayer.class, GroupLayerMixin.class);
    objectMapper.addMixIn(StyleRef.class, StyleRefMixin.class);     
    objectMapper.addMixIn(Tiling.class, TilingMixin.class);

    try {
        return objectMapper.writeValueAsString(service);
    } catch(Exception e) {
        throw new RuntimeException("Couldn't generate json from service", e);
    }
}

/**
 * Constructs and initializes a JsonService with an {@link ObjectService}.
 * 
 * @param objectService
 */
public DefaultJsonService(final ObjectService objectService) {

    idToObjDeserializer = new UntypedObjectDeserializer(null, null) {

        @Override
        public Object deserialize(JsonParser p, DeserializationContext ctxt)
            throws IOException, JsonProcessingException
        {
            final Object obj = super.deserialize(p, ctxt);
            if (!(obj instanceof String && ((String) obj).startsWith("object:")))
                return obj;
            final String id = (String) obj;
            if (!objectService.contains(id)) {
                throw new JsonMappingException(p, "Object does not exist");
            }
            final ObjectInfo info = objectService.find(id);
            info.updateLastUsed();
            return info.getObject();
        }
    };

    final JsonSerializer<Object> objToIdSerializer =
        new JsonSerializer<Object>()
    {

            @Override
            public void serialize(Object value, JsonGenerator gen,
                SerializerProvider serializers) throws IOException,
                JsonProcessingException
        {
                gen.writeString(objectService.register(value, "DefaultJsonService"));
            }

        };

    final SimpleModule objToIdModule = new SimpleModule();
    objToIdModule.setSerializerModifier(new BeanSerializerModifier() {

        @Override
        public JsonSerializer<?> modifySerializer(SerializationConfig config,
            BeanDescription beanDesc, JsonSerializer<?> serializer)
        {
            if (Mixins.support(beanDesc.getBeanClass())) return serializer;
            // If the serialized class is unknown (i.e. serialized using the general
            // BeanSerializer) or should not be serialized (i.e. complicated class
            // implemented interfaces such as Iterable), would be serialized as an
            // ID.
            if (serializer instanceof BeanSerializer) return objToIdSerializer;
            if (notSerialized(beanDesc.getBeanClass())) return objToIdSerializer;
            return serializer;

        }
    });
    objToIdMapper = new ObjectMapper();
    objToIdMapper.registerModule(objToIdModule);

    // register Jackson MixIns to obtain better json output format for some
    // specific types
    Mixins.registerMixIns(objToIdMapper);
}

/**
 * Method that module can use to register additional modifier objects to
 * customize configuration and construction of bean serializers.
 * 
 * @param mod Modifier to register
 */
public void addBeanSerializerModifier(BeanSerializerModifier mod);

public abstract void addBeanSerializerModifier(BeanSerializerModifier paramBeanSerializerModifier);