Java 类com.fasterxml.jackson.databind.introspect.AnnotationIntrospectorPair 实例源码

/**
 * Create an <code>ObjectMapper</code> for Pipeline configuration.
 *
 * @param injector The Guice <code>Injector</code> instance.
 * @return An <code>ObjectMapper</code> for Pipeline configuration.
 */
public static ObjectMapper createObjectMapper(final Injector injector) {
    final ObjectMapper objectMapper = ObjectMapperFactory.createInstance();

    final SimpleModule module = new SimpleModule("Pipeline");
    module.addDeserializer(Statistic.class, new StatisticDeserializer());

    objectMapper.registerModules(module);

    final GuiceAnnotationIntrospector guiceIntrospector = new GuiceAnnotationIntrospector();
    objectMapper.setInjectableValues(new GuiceInjectableValues(injector));
    objectMapper.setAnnotationIntrospectors(
            new AnnotationIntrospectorPair(
                    guiceIntrospector, objectMapper.getSerializationConfig().getAnnotationIntrospector()),
            new AnnotationIntrospectorPair(
                    guiceIntrospector, objectMapper.getDeserializationConfig().getAnnotationIntrospector()));

    return objectMapper;
}

private JsonFactory createJsonFactory() {
    final ObjectMapper objectMapper = new ObjectMapper();

    objectMapper.setAnnotationIntrospector(
            new AnnotationIntrospectorPair(
                    new JacksonAnnotationIntrospector(),
                    new JaxbAnnotationIntrospector(TypeFactory.defaultInstance())));

    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    objectMapper.configure(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS, true);

    final DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
    df.setTimeZone(TimeZone.getTimeZone("GMT"));
    objectMapper.setDateFormat(df);

    return objectMapper.getFactory();
}

@PostConstruct
public void init() {
    objectMapper = new ObjectMapper()
            .setAnnotationIntrospector(
                    new AnnotationIntrospectorPair(
                            new JaxbAnnotationIntrospector(TypeFactory.defaultInstance())
                            , new JacksonAnnotationIntrospector()
                    )
            )
            .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}

public RowSerializer(){
    mapper = new ObjectMapper();
    mapper.setAnnotationIntrospector(new AnnotationIntrospectorPair(
            new JacksonAnnotationIntrospector(),
            new JaxbAnnotationIntrospector(mapper.getTypeFactory())
    ));
}

public static RowSerializer getJAXBandJacksonSerializer(){
    RowSerializer serializer = new RowSerializer();
    serializer.mapper.setAnnotationIntrospector(new AnnotationIntrospectorPair(
            new JacksonAnnotationIntrospector(),
            new JaxbAnnotationIntrospector(serializer.mapper.getTypeFactory())
    ));
    return serializer;
}

public JacksonProvider() {
    AnnotationIntrospector introspector = new JaxbAnnotationIntrospector(TypeFactory.defaultInstance());
    // if using BOTH JAXB annotations AND Jackson annotations:
    AnnotationIntrospector secondary = new JacksonAnnotationIntrospector();

    ObjectMapper mapper = new ObjectMapper().registerModule(new Hibernate4Module())
            .setSerializationInclusion(Include.NON_NULL)
            .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false).enable(SerializationFeature.INDENT_OUTPUT)
            .setAnnotationIntrospector(new AnnotationIntrospectorPair(introspector, secondary));
    // mapper = mapper.setSerializationInclusion(Include)
    setMapper(mapper);
}

public ObjectMapperResolver() {
    objectMapper = new ObjectMapper();
    AnnotationIntrospector introspector = new JaxbAnnotationIntrospector(TypeFactory.defaultInstance());
    AnnotationIntrospector secondary = new JacksonAnnotationIntrospector();
    objectMapper = objectMapper.setAnnotationIntrospector(new AnnotationIntrospectorPair(introspector, secondary));
    objectMapper = objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
    objectMapper.registerModule(new Hibernate4Module());
}

/**
 * Creates a configured mapper supporting JAXB.
 * @see #createObjectMapper(com.fasterxml.jackson.databind.ObjectMapper)
 */
public static ObjectMapper createJaxbMapper() {
    ObjectMapper om = createObjectMapper(createObjectMapper());
    JaxbAnnotationIntrospector jaxbIntr = new JaxbAnnotationIntrospector(om.getTypeFactory());
    JacksonAnnotationIntrospector jsonIntr = new JacksonAnnotationIntrospector();
    om.setAnnotationIntrospector(new AnnotationIntrospectorPair(jsonIntr, jaxbIntr));
    return om;
}

public JacksonSerializer build() {
  final ObjectMapper objectMapper = mapperFromJSONFactory(jsonFactory);

  if (usePropertyForTypeInformation) {
    objectMapper.enableDefaultTypingAsProperty(ObjectMapper.DefaultTyping.NON_FINAL, "@class");
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  } else {
    objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  }

  if (usePrettyOutput) {
    objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
  }

  if (injectableValues != null) {
    // this is from jackson-module-guice's ObjectMapperModule.get()
    // we do this in a separate method because we do not currently want to inject the ObjectMapper
    objectMapper.setInjectableValues(injectableValues);
    objectMapper.setAnnotationIntrospectors(
        new AnnotationIntrospectorPair(
            annotationIntrospector,
            objectMapper.getSerializationConfig().getAnnotationIntrospector()
        ),
        new AnnotationIntrospectorPair(
            annotationIntrospector,
            objectMapper.getDeserializationConfig().getAnnotationIntrospector()
        )
    );
  }

  return new JacksonSerializer(objectMapper);
}

private StreamClient(final String endpoint, final String username, final String password,
    final SSLConfiguration sslConfiguration, final Consumer<Event> consumer,
    final Runnable beforeReconnection, final Runnable afterReconnection,
    final boolean reconnect, final int reconnectAttempts,
    final int pauseBeforeReconnectInSeconds)
{
    this.endpoint = checkNotNull(endpoint, "endpoint cannot be null");
    this.username = checkNotNull(username, "username cannot be null");
    this.password = checkNotNull(password, "password cannot be null");
    this.consumer = checkNotNull(consumer, "consumer cannot be null");
    this.sslConfiguration = sslConfiguration;
    this.reconnect = checkNotNull(reconnect);
    if (this.reconnect)
    {
        this.reconnectAttempts = checkNotNull(reconnectAttempts,
            "reconnect attempts cannot be null if reconnection has been enabled");
        this.pauseBeforeReconnectInSeconds = checkNotNull(pauseBeforeReconnectInSeconds,
            "pause seconds before reconnect cannot be null if reconnection has been enabled");
        this.beforeReconnection = beforeReconnection;
        this.afterReconnection = afterReconnection;
    }
    else
    {
        this.beforeReconnection = null;
        this.afterReconnection = null;
    }

    json = new ObjectMapper()
        .setAnnotationIntrospector( //
            new AnnotationIntrospectorPair(new JacksonAnnotationIntrospector(),
                new JaxbAnnotationIntrospector(TypeFactory.defaultInstance()))) //
        .registerModule(new AbiquoModule());
}

public JacksonJsonMapper() {
        mapper = new ObjectMapper();
//        mapper.setSerializationInclusion(Include.NON_NULL);
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        AnnotationIntrospector primary = new JacksonAnnotationIntrospector();
        AnnotationIntrospector secondary = new JaxbAnnotationIntrospector(mapper.getTypeFactory());

        AnnotationIntrospector pair = AnnotationIntrospectorPair.create(primary, secondary);
        mapper.setAnnotationIntrospector(pair);
    }

public JacksonJsonMapper() {
        mapper = new ObjectMapper();
//        mapper.setSerializationInclusion(Include.NON_NULL);
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        AnnotationIntrospector primary = new JacksonAnnotationIntrospector();
        AnnotationIntrospector secondary = new JaxbAnnotationIntrospector(mapper.getTypeFactory());

        AnnotationIntrospector pair = AnnotationIntrospectorPair.create(primary, secondary);
        mapper.setAnnotationIntrospector(pair);
    }

public static void reportXml(Writer out, Report report) throws IOException {
    XmlMapper mapper = new XmlMapper();
    mapper.addMixIn(Report.class, ReportMixIn.class);
    AnnotationIntrospector first = new SimpleTypesAsAttributesAnnotationIntrospector();
    AnnotationIntrospector second = new JacksonXmlAnnotationIntrospector(false);
    mapper.setAnnotationIntrospector(new AnnotationIntrospectorPair(first, second));

    out.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
    mapper.writeValue(out, report);
}

public AtmospherePermissionCheckResource() {
    om = new ObjectMapper();
    // JAXB annotation
    AnnotationIntrospector jaxbIntrospector = new JaxbAnnotationIntrospector(TypeFactory.defaultInstance());
    AnnotationIntrospector jacksonIntrospector = new JacksonAnnotationIntrospector();
    om.setAnnotationIntrospector(new AnnotationIntrospectorPair(jaxbIntrospector, jacksonIntrospector));
}

public AbstractWSResource() {
    //api = Freedomotic.INJECTOR.getInstance(API.class);
    om = new ObjectMapper();
    // JAXB annotation
    AnnotationIntrospector jaxbIntrospector = new JaxbAnnotationIntrospector(TypeFactory.defaultInstance());
    AnnotationIntrospector jacksonIntrospector = new JacksonAnnotationIntrospector();
    om.setAnnotationIntrospector(new AnnotationIntrospectorPair(jaxbIntrospector, jacksonIntrospector));

}

private void setAnnotationIntrospectors(ObjectMapper mapper) {
    AnnotationIntrospector curSerIntro = mapper.getSerializationConfig().getAnnotationIntrospector();
    AnnotationIntrospector newSerIntro = AnnotationIntrospectorPair.pair(curSerIntro,
            new MaskableSensitiveDataAnnotationIntrospector());
    mapper.setAnnotationIntrospector(newSerIntro);
}

@Inject
@SuppressWarnings({ "unchecked", "rawtypes" })
public MergerServiceImpl() {
    JacksonXmlModule module = new JacksonXmlModule();

    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.addSerializer(Enum.class, new StdSerializer<Enum>(Enum.class) {
        private static final long serialVersionUID = 4951133737173200158L;

        @Override
        public void serialize(Enum value, JsonGenerator jgen, SerializerProvider provider)
                throws IOException {
            jgen.writeString(StringUtils.capitalize(value.name().toLowerCase()));
        }
    });

    // Extra non-JAXB annotations are needed to process abstract classes.
    module.setMixInAnnotation(AbstractSourceT.class, AbstractMixIn.class);

    mapper = new XmlMapper(module);

    AnnotationIntrospector primary = new JacksonAnnotationIntrospector();
    AnnotationIntrospector secondary = new JaxbAnnotationIntrospector(mapper.getTypeFactory());

    AnnotationIntrospector pair = AnnotationIntrospectorPair.create(primary, secondary);
    mapper.setAnnotationIntrospector(pair);

    SimpleDateFormat sdf = new SimpleDateFormat(Utils.LONG_DATE_FORMAT);
    mapper.setDateFormat(sdf);

    // Serialization options
    mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
    mapper.setSerializationInclusion(Include.NON_NULL);
}

public final BaseSettings withAppendedAnnotationIntrospector(AnnotationIntrospector paramAnnotationIntrospector)
{
  return withAnnotationIntrospector(AnnotationIntrospectorPair.create(this._annotationIntrospector, paramAnnotationIntrospector));
}

public final BaseSettings withInsertedAnnotationIntrospector(AnnotationIntrospector paramAnnotationIntrospector)
{
  return withAnnotationIntrospector(AnnotationIntrospectorPair.create(paramAnnotationIntrospector, this._annotationIntrospector));
}

public static AnnotationIntrospector pair(AnnotationIntrospector paramAnnotationIntrospector1, AnnotationIntrospector paramAnnotationIntrospector2)
{
  return new AnnotationIntrospectorPair(paramAnnotationIntrospector1, paramAnnotationIntrospector2);
}

public BaseSettings withInsertedAnnotationIntrospector(AnnotationIntrospector ai) {
    return withAnnotationIntrospector(AnnotationIntrospectorPair.create(ai, _annotationIntrospector));
}

public BaseSettings withAppendedAnnotationIntrospector(AnnotationIntrospector ai) {
    return withAnnotationIntrospector(AnnotationIntrospectorPair.create(_annotationIntrospector, ai));
}