Java 类com.fasterxml.jackson.databind.jsontype.TypeIdResolver 实例源码

@Override
public JavaType handleUnknownTypeId(final DeserializationContext ctxt, final JavaType baseType,
                                    final String subTypeId, final TypeIdResolver idResolver,
                                    final String failureMsg) throws IOException {

    try {
        if (subTypeId.contains("org.jasig.")) {
            final String newTypeName = subTypeId.replaceAll("jasig", "apereo");
            LOGGER.warn("Found legacy CAS JSON definition type identified as [{}]. "
                            + "While CAS will attempt to convert the legacy definition to [{}] for the time being, "
                            + "the definition SHOULD manually be upgraded to the new supported syntax",
                    subTypeId, newTypeName);
            final Class newType = ClassUtils.getClass(newTypeName);
            return SimpleType.construct(newType);
        }
        return null;
    } catch (final Exception e) {
        throw Throwables.propagate(e);
    }
}

protected TypeIdResolver idResolver(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, Collection<NamedType> paramCollection, boolean paramBoolean1, boolean paramBoolean2)
{
  if (this._customIdResolver != null)
    return this._customIdResolver;
  if (this._idType == null)
    throw new IllegalStateException("Can not build, 'init()' not yet called");
  switch (1.$SwitchMap$com$fasterxml$jackson$annotation$JsonTypeInfo$Id[this._idType.ordinal()])
  {
  default:
    break;
  case 1:
    return new ClassNameIdResolver(paramJavaType, paramMapperConfig.getTypeFactory());
  case 2:
    return new MinimalClassNameIdResolver(paramJavaType, paramMapperConfig.getTypeFactory());
  case 3:
    return TypeNameIdResolver.construct(paramMapperConfig, paramJavaType, paramCollection, paramBoolean1, paramBoolean2);
  case 4:
    return null;
  }
  throw new IllegalStateException("Do not know how to construct standard type id resolver for idType: " + this._idType);
}

public TypeSerializer buildTypeSerializer(SerializationConfig config,
        JavaType baseType, Collection<NamedType> subtypes)
{
    if (_idType == JsonTypeInfo.Id.NONE) {
        return null;
    }
    TypeIdResolver idRes = idResolver(config, baseType, subtypes, true, false);
    switch (_includeAs) {
    case WRAPPER_ARRAY:
        return new AsArrayTypeSerializer(idRes, null);
    case PROPERTY:
        return new AsPropertyTypeSerializer(idRes, null,
                _typeProperty);
    case WRAPPER_OBJECT:
        return new AsWrapperTypeSerializer(idRes, null);
    case EXTERNAL_PROPERTY:
        return new AsExternalTypeSerializer(idRes, null,
                _typeProperty);
    }
    throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: "+_includeAs);
}

public TypeDeserializer buildTypeDeserializer(DeserializationConfig config,
        JavaType baseType, Collection<NamedType> subtypes)
{
    if (_idType == JsonTypeInfo.Id.NONE) {
        return null;
    }

    TypeIdResolver idRes = idResolver(config, baseType, subtypes, false, true);

    // First, method for converting type info to type id:
    switch (_includeAs) {
    case WRAPPER_ARRAY:
        return new AsArrayTypeDeserializer(baseType, idRes,
                _typeProperty, _typeIdVisible, _defaultImpl);
    case PROPERTY:
        return new AsPropertyTypeDeserializer(baseType, idRes,
                _typeProperty, _typeIdVisible, _defaultImpl);
    case WRAPPER_OBJECT:
        return new AsWrapperTypeDeserializer(baseType, idRes,
                _typeProperty, _typeIdVisible, _defaultImpl);
    case EXTERNAL_PROPERTY:
        return new AsExternalTypeDeserializer(baseType, idRes,
                _typeProperty, _typeIdVisible, _defaultImpl);
    }
    throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: "+_includeAs);
}

/**
 * Helper method that will either return configured custom
 * type id resolver, or construct a standard resolver
 * given configuration.
 */
protected TypeIdResolver idResolver(MapperConfig<?> config,
        JavaType baseType, Collection<NamedType> subtypes,
        boolean forSer, boolean forDeser)
{
    // Custom id resolver?
    if (_customIdResolver != null) {
        return _customIdResolver;
    }
    if (_idType == null) {
        throw new IllegalStateException("Can not build, 'init()' not yet called");
    }
    switch (_idType) {
    case CLASS:
        return new ClassNameIdResolver(baseType, config.getTypeFactory());
    case MINIMAL_CLASS:
        return new MinimalClassNameIdResolver(baseType, config.getTypeFactory());
    case NAME:
        return TypeNameIdResolver.construct(config, baseType, subtypes, forSer, forDeser);
    case NONE: // hmmh. should never get this far with 'none'
        return null;
    case CUSTOM: // need custom resolver...
    }
    throw new IllegalStateException("Do not know how to construct standard type id resolver for idType: "+_idType);
}

protected TypeDeserializerBase(JavaType baseType, TypeIdResolver idRes,
        String typePropertyName, boolean typeIdVisible, Class<?> defaultImpl)
{
    _baseType = baseType;
    _idResolver = idRes;
    _typePropertyName = typePropertyName;
    _typeIdVisible = typeIdVisible;
    _deserializers = new HashMap<String,JsonDeserializer<Object>>();
    if (defaultImpl == null) {
        _defaultImpl = null;
    } else {
        /* 16-Oct-2011, tatu: should call this via TypeFactory; this is
         *    not entirely safe... however, since Collections/Maps are
         *    seldom (if ever) base types, may be ok.
         */
        _defaultImpl = baseType.forcedNarrowBy(defaultImpl);
    }

    _property = null;
}

@Override
public JavaType handleMissingTypeId(DeserializationContext ctxt, JavaType baseType, TypeIdResolver idResolver,
    String failureMsg) throws IOException {
  if (baseType.getRawClass() == Feature.class) {
    return idResolver.typeFromId(ctxt, "Feature");
  }
  return super.handleMissingTypeId(ctxt, baseType, idResolver, failureMsg);
}

protected AbstractTypedJacksonModule(
        Class<T> baseClass,
        Function<T, String> nameResolver,
        Function<String, Class<? extends T>> classResolver)
{
    super(baseClass.getSimpleName() + "Module", Version.unknownVersion());

    TypeIdResolver typeResolver = new InternalTypeResolver<>(nameResolver, classResolver);

    addSerializer(baseClass, new InternalTypeSerializer<>(baseClass, typeResolver));
    addDeserializer(baseClass, new InternalTypeDeserializer<>(baseClass, typeResolver));
}

@Override
protected TypeIdResolver idResolver(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser) {
    if (_customIdResolver != null) {
        return _customIdResolver;
    }
    if (_idType == null) {
        throw new IllegalStateException("Can not build, 'init()' not yet called");
    }
    if (_idType == JsonTypeInfo.Id.CLASS){
        return new WideningClassNameIdResolver(baseType, config.getTypeFactory());
    }
    return super.idResolver(config, baseType, subtypes, forSer, forDeser); //To change body of generated methods, choose Tools | Templates.
}

@Override
protected TypeIdResolver idResolver(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes,
        boolean forSer, boolean forDeser) {

    if (_idType == null) {
        throw new IllegalStateException("Can not build, 'init()' not yet called");
    }

    return new NsTypeIdResolver(baseType, config.getTypeFactory(), basicMetaData);
}

public TypeIdResolver typeIdResolverInstance(Annotated paramAnnotated, Class<? extends TypeIdResolver> paramClass)
{
  HandlerInstantiator localHandlerInstantiator = getHandlerInstantiator();
  if (localHandlerInstantiator != null)
  {
    TypeIdResolver localTypeIdResolver = localHandlerInstantiator.typeIdResolverInstance(this, paramAnnotated, paramClass);
    if (localTypeIdResolver != null)
      return localTypeIdResolver;
  }
  return (TypeIdResolver)ClassUtil.createInstance(paramClass, canOverrideAccessModifiers());
}

public StdTypeResolverBuilder init(JsonTypeInfo.Id paramId, TypeIdResolver paramTypeIdResolver)
{
  if (paramId == null)
    throw new IllegalArgumentException("idType can not be null");
  this._idType = paramId;
  this._customIdResolver = paramTypeIdResolver;
  this._typeProperty = paramId.getDefaultPropertyName();
  return this;
}

protected TypeDeserializerBase(JavaType paramJavaType, TypeIdResolver paramTypeIdResolver, String paramString, boolean paramBoolean, Class<?> paramClass)
{
  this._baseType = paramJavaType;
  this._idResolver = paramTypeIdResolver;
  this._typePropertyName = paramString;
  this._typeIdVisible = paramBoolean;
  this._deserializers = new HashMap();
  if (paramClass == null)
    this._defaultImpl = null;
  else
    this._defaultImpl = paramJavaType.forcedNarrowBy(paramClass);
  this._property = null;
}

protected TypeResolverBuilder<?> _findTypeResolver(MapperConfig<?> paramMapperConfig, Annotated paramAnnotated, JavaType paramJavaType)
{
  JsonTypeInfo localJsonTypeInfo = (JsonTypeInfo)paramAnnotated.getAnnotation(JsonTypeInfo.class);
  JsonTypeResolver localJsonTypeResolver = (JsonTypeResolver)paramAnnotated.getAnnotation(JsonTypeResolver.class);
  Object localObject;
  if (localJsonTypeResolver != null)
  {
    if (localJsonTypeInfo == null)
      return null;
    localObject = paramMapperConfig.typeResolverBuilderInstance(paramAnnotated, localJsonTypeResolver.value());
  }
  else
  {
    if (localJsonTypeInfo == null)
      return null;
    if (localJsonTypeInfo.use() == JsonTypeInfo.Id.NONE)
      return _constructNoTypeResolverBuilder();
    localObject = _constructStdTypeResolverBuilder();
  }
  JsonTypeIdResolver localJsonTypeIdResolver = (JsonTypeIdResolver)paramAnnotated.getAnnotation(JsonTypeIdResolver.class);
  TypeIdResolver localTypeIdResolver1;
  if (localJsonTypeIdResolver == null)
    localTypeIdResolver1 = null;
  else
    localTypeIdResolver1 = paramMapperConfig.typeIdResolverInstance(paramAnnotated, localJsonTypeIdResolver.value());
  TypeIdResolver localTypeIdResolver2 = localTypeIdResolver1;
  if (localTypeIdResolver1 != null)
    localTypeIdResolver2.init(paramJavaType);
  TypeResolverBuilder localTypeResolverBuilder1 = ((TypeResolverBuilder)localObject).init(localJsonTypeInfo.use(), localTypeIdResolver2);
  JsonTypeInfo.As localAs1 = localJsonTypeInfo.include();
  JsonTypeInfo.As localAs2 = localAs1;
  if ((localAs1 == JsonTypeInfo.As.EXTERNAL_PROPERTY) && ((paramAnnotated instanceof AnnotatedClass)))
    localAs2 = JsonTypeInfo.As.PROPERTY;
  TypeResolverBuilder localTypeResolverBuilder2 = localTypeResolverBuilder1.inclusion(localAs2).typeProperty(localJsonTypeInfo.property());
  Class localClass = localJsonTypeInfo.defaultImpl();
  if (localClass != JsonTypeInfo.None.class)
    localTypeResolverBuilder2 = localTypeResolverBuilder2.defaultImpl(localClass);
  return localTypeResolverBuilder2.typeIdVisibility(localJsonTypeInfo.visible());
}

@Override
public TypeSerializer buildTypeSerializer(SerializationConfig config, JavaType baseType, Collection<NamedType> subtypes) {
    TypeIdResolver idRes = TypeNameIdResolver.construct(config, baseType, subtypes, true, false);
    return new AsPropertyTypeSerializer(idRes, null, "type") {

        protected String idFromValue(Object value) {
            return ((NamedDefinition) value).name();
        }
    };
}

/**
 * Method that can be called to obtain an instance of <code>TypeIdResolver</code> of
 * specified type.
 */
public TypeIdResolver typeIdResolverInstance(Annotated annotated,
        Class<? extends TypeIdResolver> resolverClass)
{
    HandlerInstantiator hi = getHandlerInstantiator();
    if (hi != null) {
        TypeIdResolver builder = hi.typeIdResolverInstance(this, annotated, resolverClass);
        if (builder != null) {
            return builder;
        }
    }
    return (TypeIdResolver) ClassUtil.createInstance(resolverClass, canOverrideAccessModifiers());
}

public StdTypeResolverBuilder init(JsonTypeInfo.Id idType, TypeIdResolver idRes)
{
    // sanity checks
    if (idType == null) {
        throw new IllegalArgumentException("idType can not be null");
    }
    _idType = idType;
    _customIdResolver = idRes;
    // Let's also initialize property name as per idType default
    _typeProperty = idType.getDefaultPropertyName();
    return this;
}

@Override
public Class<? extends TypeIdResolver> value() {
    return SimpleClassNameIdResolver.class;
}

@Override
public TypeIdResolver typeIdResolverInstance(MapperConfig<?> config,
        Annotated annotated, Class<?> resolverClass) {
    return (TypeIdResolver) this.beanFactory.createBean(resolverClass);
}

@Override
public TypeIdResolver typeIdResolverInstance(MapperConfig<?> config, Annotated annotated,
        Class<?> resolverClass) {
    return (TypeIdResolver) findHandlerInstance(resolverClass);
}

@Override
public TypeIdResolver typeIdResolverInstance(MapperConfig<?> config, Annotated annotated, Class<?> resolverClass) {
    return (TypeIdResolver) findInstance(resolverClass);
}

@Override
public MetadataTypeResolver init(JsonTypeInfo.Id idType, TypeIdResolver res) {
    return this;
}

@Override
protected TypeIdResolver idResolver(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser) {
    return new YahooTypeIdResolver(config);
}

@Override
public TypeIdResolver typeIdResolverInstance(MapperConfig<?> config, Annotated annotated, Class<?> resolverClass) {
    return null;
}

@Override
public TypeIdResolver typeIdResolverInstance(MapperConfig<?> config, Annotated annotated, Class<?> resolverClass) {
    return null;
}

@Override
public TypeIdResolver typeIdResolverInstance(
        MapperConfig<?> mapperConfig, Annotated annotated,
        Class<?> typeIdResolverClass) {
    return null;
}

@Override
public TypeIdResolver typeIdResolverInstance(MapperConfig<?> config,
                                             Annotated annotated, Class<?> resolverClass) {
    return (TypeIdResolver) this.beanFactory.createBean(resolverClass);
}

@Override
public TypeIdResolver typeIdResolverInstance(
        MapperConfig<?> mapperConfig, Annotated annotated,
        Class<?> typeIdResolverClass) {
    return null;
}

public InternalTypeDeserializer(Class<T> baseClass, TypeIdResolver typeIdResolver)
{
    super(baseClass);
    this.typeDeserializer = new AsPropertyTypeDeserializer(SimpleType.construct(baseClass), typeIdResolver, TYPE_PROPERTY, false, null);
}

public InternalTypeSerializer(Class<T> baseClass, TypeIdResolver typeIdResolver)
{
    super(baseClass);
    this.typeSerializer = new AsPropertyTypeSerializer(typeIdResolver, null, TYPE_PROPERTY);
}

public WideningAsPropertyTypeDeserializer(JavaType bt, TypeIdResolver idRes, String typePropertyName, boolean typeIdVisible, Class<?> defaultImpl) {
    super(bt, idRes, typePropertyName, typeIdVisible, defaultImpl);
}

public AsPropertyTypeDeserializer(JavaType paramJavaType, TypeIdResolver paramTypeIdResolver, String paramString, boolean paramBoolean, Class<?> paramClass)
{
  super(paramJavaType, paramTypeIdResolver, paramString, paramBoolean, paramClass);
}

public AsArrayTypeDeserializer(JavaType paramJavaType, TypeIdResolver paramTypeIdResolver, String paramString, boolean paramBoolean, Class<?> paramClass)
{
  super(paramJavaType, paramTypeIdResolver, paramString, paramBoolean, paramClass);
}

protected TypeSerializerBase(TypeIdResolver paramTypeIdResolver, BeanProperty paramBeanProperty)
{
  this._idResolver = paramTypeIdResolver;
  this._property = paramBeanProperty;
}

public TypeIdResolver getTypeIdResolver()
{
  return this._idResolver;
}

public AsWrapperTypeDeserializer(JavaType paramJavaType, TypeIdResolver paramTypeIdResolver, String paramString, boolean paramBoolean, Class<?> paramClass)
{
  super(paramJavaType, paramTypeIdResolver, paramString, paramBoolean, null);
}

public AsWrapperTypeSerializer(TypeIdResolver paramTypeIdResolver, BeanProperty paramBeanProperty)
{
  super(paramTypeIdResolver, paramBeanProperty);
}

public AsPropertyTypeSerializer(TypeIdResolver paramTypeIdResolver, BeanProperty paramBeanProperty, String paramString)
{
  super(paramTypeIdResolver, paramBeanProperty);
  this._typePropertyName = paramString;
}

public AsArrayTypeSerializer(TypeIdResolver paramTypeIdResolver, BeanProperty paramBeanProperty)
{
  super(paramTypeIdResolver, paramBeanProperty);
}

public TypeIdResolver getTypeIdResolver()
{
  return this._idResolver;
}