Java Converter类代码示例

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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;
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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;
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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));
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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));
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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));
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
/** 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);
    }
  };
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
/** 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);
    }
  };
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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;
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
public StdDelegatingSerializer(Converter<?, ?> paramConverter)
{
  super(Object.class);
  this._converter = paramConverter;
  this._delegateType = null;
  this._delegateSerializer = null;
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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));
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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);
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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);
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
public StdDelegatingDeserializer(Converter<?, T> paramConverter)
{
  super(Object.class);
  this._converter = paramConverter;
  this._delegateType = null;
  this._delegateDeserializer = null;
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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);
}
 

import com.fasterxml.jackson.databind.util.Converter; //导入依赖的package包/类
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);
}