Java 类com.fasterxml.jackson.databind.util.Converter 实例源码

public JsonSerializer<?> findConvertingContentSerializer(SerializerProvider paramSerializerProvider, BeanProperty paramBeanProperty, JsonSerializer<?> paramJsonSerializer)
{
  AnnotationIntrospector localAnnotationIntrospector = paramSerializerProvider.getAnnotationIntrospector();
  if ((localAnnotationIntrospector != null) && (paramBeanProperty != null))
  {
    Object localObject = localAnnotationIntrospector.findSerializationContentConverter(paramBeanProperty.getMember());
    if (localObject != null)
    {
      Converter localConverter = paramSerializerProvider.converterInstance(paramBeanProperty.getMember(), localObject);
      JavaType localJavaType = localConverter.getOutputType(paramSerializerProvider.getTypeFactory());
      if (paramJsonSerializer == null)
        paramJsonSerializer = paramSerializerProvider.findValueSerializer(localJavaType, paramBeanProperty);
      return new StdDelegatingSerializer(localConverter, localJavaType, paramJsonSerializer);
    }
  }
  return paramJsonSerializer;
}

protected JsonDeserializer<?> findConvertingContentDeserializer(DeserializationContext paramDeserializationContext, BeanProperty paramBeanProperty, JsonDeserializer<?> paramJsonDeserializer)
{
  AnnotationIntrospector localAnnotationIntrospector = paramDeserializationContext.getAnnotationIntrospector();
  if ((localAnnotationIntrospector != null) && (paramBeanProperty != null))
  {
    Object localObject = localAnnotationIntrospector.findDeserializationContentConverter(paramBeanProperty.getMember());
    if (localObject != null)
    {
      Converter localConverter = paramDeserializationContext.converterInstance(paramBeanProperty.getMember(), localObject);
      JavaType localJavaType = localConverter.getInputType(paramDeserializationContext.getTypeFactory());
      if (paramJsonDeserializer == null)
        paramJsonDeserializer = paramDeserializationContext.findContextualValueDeserializer(localJavaType, paramBeanProperty);
      return new StdDelegatingDeserializer(localConverter, localJavaType, paramJsonDeserializer);
    }
  }
  return paramJsonDeserializer;
}

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 JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property)
    throws JsonMappingException
{
    // First: figure out what is the fully generic delegate type:
    TypeFactory tf = provider.getTypeFactory();
    JavaType implType = tf.constructType(_converter.getClass());
    JavaType[] params = tf.findTypeParameters(implType, Converter.class);
    if (params == null || params.length != 2) {
        throw new JsonMappingException("Could not determine Converter parameterization for "
                +implType);
    }
    // and then we can find serializer to delegate to, construct a new instance:
    JavaType delegateType = params[1];
    return withDelegate(_converter, delegateType,
            provider.findValueSerializer(delegateType, property));
}

public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property)
    throws JsonMappingException
{
    // First: figure out what is the fully generic delegate type:
    TypeFactory tf = ctxt.getTypeFactory();
    JavaType implType = tf.constructType(_converter.getClass());
    JavaType[] params = tf.findTypeParameters(implType, Converter.class);
    if (params == null || params.length != 2) {
        throw new JsonMappingException("Could not determine Converter parameterization for "
                +implType);
    }
    // and then we can find serializer to delegate to, construct a new instance:
    JavaType delegateType = params[0];
    return withDelegate(_converter, delegateType,
            ctxt.findContextualValueDeserializer(delegateType, property));
}

/** Helper function to create Converter from lambda **/
private <T> Converter<String, T> fromString(Function<String, ? extends T> fun) {
  return new StdConverter<String, T>() {
    @Override
    public T convert(String value) {
      return fun.apply(value);
    }
  };
}

/** Helper function to create Converter from lambda **/
private <T> Converter<T, String> toString(Function<T, String> fun) {
  return new StdConverter<T, String>() {
    @Override
    public String convert(T value) {
      return fun.apply(value);
    }
  };
}

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 StdDelegatingSerializer(Converter<?, ?> paramConverter)
{
  super(Object.class);
  this._converter = paramConverter;
  this._delegateType = null;
  this._delegateSerializer = null;
}

public StdDelegatingSerializer(Converter<Object, ?> paramConverter, JavaType paramJavaType, JsonSerializer<?> paramJsonSerializer)
{
  super(paramJavaType);
  this._converter = paramConverter;
  this._delegateType = paramJavaType;
  this._delegateSerializer = paramJsonSerializer;
}

public <T> StdDelegatingSerializer(Class<T> paramClass, Converter<T, ?> paramConverter)
{
  super(paramClass, false);
  this._converter = paramConverter;
  this._delegateType = null;
  this._delegateSerializer = null;
}

public JsonSerializer<Object> createSerializer(SerializerProvider paramSerializerProvider, JavaType paramJavaType)
{
  SerializationConfig localSerializationConfig = paramSerializerProvider.getConfig();
  BeanDescription localBeanDescription = localSerializationConfig.introspect(paramJavaType);
  JsonSerializer localJsonSerializer = findSerializerFromAnnotation(paramSerializerProvider, localBeanDescription.getClassInfo());
  if (localJsonSerializer != null)
    return localJsonSerializer;
  JavaType localJavaType1 = modifyTypeByAnnotation(localSerializationConfig, localBeanDescription.getClassInfo(), paramJavaType);
  boolean bool;
  if (localJavaType1 == paramJavaType)
  {
    bool = false;
  }
  else
  {
    bool = true;
    if (!localJavaType1.hasRawClass(paramJavaType.getRawClass()))
      localBeanDescription = localSerializationConfig.introspect(localJavaType1);
  }
  Converter localConverter = localBeanDescription.findSerializationConverter();
  if (localConverter == null)
    return _createSerializer2(paramSerializerProvider, localJavaType1, localBeanDescription, bool);
  JavaType localJavaType2 = localConverter.getOutputType(paramSerializerProvider.getTypeFactory());
  if (!localJavaType2.hasRawClass(localJavaType1.getRawClass()))
    localBeanDescription = localSerializationConfig.introspect(localJavaType2);
  return new StdDelegatingSerializer(localConverter, localJavaType2, _createSerializer2(paramSerializerProvider, localJavaType2, localBeanDescription, true));
}

protected Converter<Object, Object> findConverter(SerializerProvider paramSerializerProvider, Annotated paramAnnotated)
{
  Object localObject = paramSerializerProvider.getAnnotationIntrospector().findSerializationConverter(paramAnnotated);
  if (localObject == null)
    return null;
  return paramSerializerProvider.converterInstance(paramAnnotated, localObject);
}

protected JsonSerializer<?> findConvertingSerializer(SerializerProvider paramSerializerProvider, Annotated paramAnnotated, JsonSerializer<?> paramJsonSerializer)
{
  Converter localConverter = findConverter(paramSerializerProvider, paramAnnotated);
  if (localConverter == null)
    return paramJsonSerializer;
  return new StdDelegatingSerializer(localConverter, localConverter.getOutputType(paramSerializerProvider.getTypeFactory()), paramJsonSerializer);
}

public StdDelegatingDeserializer(Converter<?, T> paramConverter)
{
  super(Object.class);
  this._converter = paramConverter;
  this._delegateType = null;
  this._delegateDeserializer = null;
}

public StdDelegatingDeserializer(Converter<Object, T> paramConverter, JavaType paramJavaType, JsonDeserializer<?> paramJsonDeserializer)
{
  super(paramJavaType);
  this._converter = paramConverter;
  this._delegateType = paramJavaType;
  this._delegateDeserializer = paramJsonDeserializer;
}

protected final Converter<Object, Object> findConverter(DeserializationContext paramDeserializationContext, Annotated paramAnnotated)
{
  Object localObject = paramDeserializationContext.getAnnotationIntrospector().findDeserializationConverter(paramAnnotated);
  if (localObject == null)
    return null;
  return paramDeserializationContext.converterInstance(paramAnnotated, localObject);
}

protected final JsonDeserializer<Object> findConvertingDeserializer(DeserializationContext paramDeserializationContext, Annotated paramAnnotated, JsonDeserializer<Object> paramJsonDeserializer)
{
  Converter localConverter = findConverter(paramDeserializationContext, paramAnnotated);
  if (localConverter == null)
    return paramJsonDeserializer;
  return new StdDelegatingDeserializer(localConverter, localConverter.getInputType(paramDeserializationContext.getTypeFactory()), paramJsonDeserializer);
}

protected JsonDeserializer<Object> findConvertingDeserializer(DeserializationContext paramDeserializationContext, SettableBeanProperty paramSettableBeanProperty)
{
  AnnotationIntrospector localAnnotationIntrospector = paramDeserializationContext.getAnnotationIntrospector();
  if (localAnnotationIntrospector != null)
  {
    Object localObject = localAnnotationIntrospector.findDeserializationConverter(paramSettableBeanProperty.getMember());
    if (localObject != null)
    {
      Converter localConverter = paramDeserializationContext.converterInstance(paramSettableBeanProperty.getMember(), localObject);
      JavaType localJavaType = localConverter.getInputType(paramDeserializationContext.getTypeFactory());
      return new StdDelegatingDeserializer(localConverter, localJavaType, paramDeserializationContext.findContextualValueDeserializer(localJavaType, paramSettableBeanProperty));
    }
  }
  return null;
}

@SuppressWarnings("unchecked")
public StdDelegatingSerializer(Converter<?,?> converter)
{
    super(Object.class);
    _converter = (Converter<Object,?>)converter;
    _delegateType = null;
    _delegateSerializer = null;
}

@SuppressWarnings("unchecked")
public <T> StdDelegatingSerializer(Class<T> cls, Converter<T,?> converter)
{
    super(cls, false);
    _converter = (Converter<Object,?>)converter;
    _delegateType = null;
    _delegateSerializer = null;
}

@SuppressWarnings("unchecked")
protected StdDelegatingSerializer(Converter<Object,?> converter,
        JavaType delegateType, JsonSerializer<?> delegateSerializer)
{
    super(delegateType);
    _converter = converter;
    _delegateType = delegateType;
    _delegateSerializer = (JsonSerializer<Object>) delegateSerializer;
}

/**
 * Method used for creating resolved contextual instances. Must be
 * overridden when sub-classing.
 */
protected StdDelegatingSerializer withDelegate(Converter<Object,?> converter,
        JavaType delegateType, JsonSerializer<?> delegateSerializer)
{
    if (getClass() != StdDelegatingSerializer.class) {
        throw new IllegalStateException("Sub-class "+getClass().getName()+" must override 'withDelegate'");
    }
    return new StdDelegatingSerializer(converter, delegateType, delegateSerializer);
}

@SuppressWarnings("unchecked")
public StdDelegatingDeserializer(Converter<?,T> converter)
{
    super(Object.class);
    _converter = (Converter<Object,T>)converter;
    _delegateType = null;
    _delegateDeserializer = null;
}

@SuppressWarnings("unchecked")
protected StdDelegatingDeserializer(Converter<Object,T> converter,
        JavaType delegateType, JsonDeserializer<?> delegateDeserializer)
{
    super(delegateType);
    _converter = converter;
    _delegateType = delegateType;
    _delegateDeserializer = (JsonDeserializer<Object>) delegateDeserializer;
}

/**
 * Method used for creating resolved contextual instances. Must be
 * overridden when sub-classing.
 */
protected StdDelegatingDeserializer<T> withDelegate(Converter<Object,T> converter,
        JavaType delegateType, JsonDeserializer<?> delegateDeserializer)
{
    if (getClass() != StdDelegatingDeserializer.class) {
        throw new IllegalStateException("Sub-class "+getClass().getName()+" must override 'withDelegate'");
    }
    return new StdDelegatingDeserializer<T>(converter, delegateType, delegateDeserializer);
}

private CustomDelegatingSerializerProvider(SerializerProvider serializerProvider,
                                           Converter<?, ?> converter)
{
    super(converter);
    this.serializerProvider = serializerProvider;
}

@Override
protected StdDelegatingSerializer withDelegate(Converter<Object,?> converter,
                                               JavaType delegateType, JsonSerializer<?> delegateSerializer)
{
    return new StdDelegatingSerializer(converter, delegateType, delegateSerializer);
}

@Override
public Class<? extends Converter<?, ?>> converter() {
    return converter;
}

@Override
public Class<? extends Converter<?, ?>> contentConverter() {
    return contentConverter;
}

@Override
public Class<? extends Converter<?, ?>> converter() {
    return converter;
}

@Override
public Class<? extends Converter<?, ?>> contentConverter() {
    return contentConverter;
}

private CustomDelegatingSerializerProvider(SerializerProvider serializerProvider,
                                           Converter<?, ?> converter)
{
    super(converter);
    this.serializerProvider = serializerProvider;
}

@Override
protected StdDelegatingSerializer withDelegate(Converter<Object,?> converter,
                                               JavaType delegateType, JsonSerializer<?> delegateSerializer)
{
    return new StdDelegatingSerializer(converter, delegateType, delegateSerializer);
}

@SuppressWarnings("rawtypes")
protected void injectJacksonAnnotation(EntityType model) {
    JsonSerialize jacksonAnnotation = new JsonSerialize() {
        @Override
        public Class<? extends Annotation> annotationType() {
            return JsonSerialize.class;
        }

        @Override
        public Class<? extends JsonSerializer> using() {
            return ToStringSerializer.class;
        }

        @Override
        public Class<? extends JsonSerializer> contentUsing() {
            return null;
        }

        @Override
        public Class<? extends JsonSerializer> keyUsing() {
            return null;
        }

        @Override
        public Class<? extends JsonSerializer> nullsUsing() {
            return null;
        }

        @Override
        public Class<?> as() {
            return null;
        }

        @Override
        public Class<?> keyAs() {
            return null;
        }

        @Override
        public Class<?> contentAs() {
            return null;
        }

        @Override
        public Typing typing() {
            return null;
        }

        @Override
        public Class<? extends Converter> converter() {
            return null;
        }

        @Override
        public Class<? extends Converter> contentConverter() {
            return null;
        }

        @SuppressWarnings("deprecation")
        @Override
        public Inclusion include() {
            return null;
        }

    };

    for(Property property : model.getProperties()) {
        if(Long.class.equals(property.getType().getJavaClass())) {
            property.addAnnotation(jacksonAnnotation);
        }
    }
}

public Converter<?, ?> converterInstance(MapperConfig<?> paramMapperConfig, Annotated paramAnnotated, Class<?> paramClass)
{
  return null;
}

protected Converter<Object, ?> getConverter()
{
  return this._converter;
}

protected StdDelegatingSerializer withDelegate(Converter<Object, ?> paramConverter, JavaType paramJavaType, JsonSerializer<?> paramJsonSerializer)
{
  if (getClass() != StdDelegatingSerializer.class)
    throw new IllegalStateException("Sub-class " + getClass().getName() + " must override 'withDelegate'");
  return new StdDelegatingSerializer(paramConverter, paramJavaType, paramJsonSerializer);
}

public Converter<Object, Object> findDeserializationConverter()
{
  if (this._annotationIntrospector == null)
    return null;
  return _createConverter(this._annotationIntrospector.findDeserializationConverter(this._classInfo));
}

public Converter<Object, Object> findSerializationConverter()
{
  if (this._annotationIntrospector == null)
    return null;
  return _createConverter(this._annotationIntrospector.findSerializationConverter(this._classInfo));
}