Java 类com.fasterxml.jackson.databind.type.ClassKey 实例源码

private void _addSerializer(Class<?> cls, JsonSerializer<?> ser)
{
    ClassKey key = new ClassKey(cls);
    // Interface or class type?
    if (cls.isInterface()) {
        if (_interfaceMappings == null) {
            _interfaceMappings = new HashMap<ClassKey,JsonSerializer<?>>();
        }
        _interfaceMappings.put(key, ser);
    } else { // nope, class:
        if (_classMappings == null) {
            _classMappings = new HashMap<ClassKey,JsonSerializer<?>>();
        }
        _classMappings.put(key, ser);
    }
}

/**
 * Method for adding a mapping from super type to specific subtype.
 * Arguments will be checked by method, to ensure that <code>superType</code>
 * is abstract (since resolver is never called for concrete classes);
 * as well as to ensure that there is supertype/subtype relationship
 * (to ensure there won't be cycles during resolution).
 * 
 * @param superType Abstract type to resolve
 * @param subType Sub-class of superType, to map superTo to
 * 
 * @return This resolver, to allow chaining of initializations
 */
public <T> SimpleAbstractTypeResolver addMapping(Class<T> superType, Class<? extends T> subType)
{
    // Sanity checks, just in case someone tries to force typing...
    if (superType == subType) {
        throw new IllegalArgumentException("Can not add mapping from class to itself");
    }
    if (!superType.isAssignableFrom(subType)) {
        throw new IllegalArgumentException("Can not add mapping from class "+superType.getName()
                +" to "+subType.getName()+", as latter is not a subtype of former");
    }
    if (!Modifier.isAbstract(superType.getModifiers())) {
        throw new IllegalArgumentException("Can not add mapping from class "+superType.getName()
                +" since it is not abstract");
    }
    _mappings.put(new ClassKey(superType), subType);
    return this;
}

@Test
public void testPageModule() throws Exception {
    PageModuleProvider pmp = new PageModuleProvider();
    Module module = pmp.getModule();
    assertTrue(module instanceof SimpleModule);
    Field field = module.getClass().getDeclaredField("_serializers");
    field.setAccessible(true);
    SimpleSerializers simpleSerializers = (SimpleSerializers) field.get(module);
    field = simpleSerializers.getClass().getDeclaredField("_interfaceMappings");
    field.setAccessible(true);
    HashMap<ClassKey, JsonSerializer<?>> classMappings = (HashMap) field.get(simpleSerializers);
    assertTrue(classMappings.containsKey(new ClassKey(Page.class)));
}

public MapperConfigBase(BaseSettings paramBaseSettings, SubtypeResolver paramSubtypeResolver, Map<ClassKey, Class<?>> paramMap)
{
  super(paramBaseSettings, DEFAULT_MAPPER_FEATURES);
  this._mixInAnnotations = paramMap;
  this._subtypeResolver = paramSubtypeResolver;
  this._rootName = null;
  this._view = null;
}

public MapperConfigBase(MapperConfigBase<CFG, T> paramMapperConfigBase, Map<ClassKey, Class<?>> paramMap)
{
  super(paramMapperConfigBase);
  this._mixInAnnotations = paramMap;
  this._subtypeResolver = paramMapperConfigBase._subtypeResolver;
  this._rootName = paramMapperConfigBase._rootName;
  this._view = paramMapperConfigBase._view;
}

private void _addSerializer(Class<?> paramClass, JsonSerializer<?> paramJsonSerializer)
{
  ClassKey localClassKey = new ClassKey(paramClass);
  if (paramClass.isInterface())
  {
    if (this._interfaceMappings == null)
      this._interfaceMappings = new HashMap();
    this._interfaceMappings.put(localClassKey, paramJsonSerializer);
    return;
  }
  if (this._classMappings == null)
    this._classMappings = new HashMap();
  this._classMappings.put(localClassKey, paramJsonSerializer);
}

protected JsonSerializer<?> _findInterfaceMapping(Class<?> paramClass, ClassKey paramClassKey)
{
  for (Class localClass : paramClass.getInterfaces())
  {
    paramClassKey.reset(localClass);
    JsonSerializer localJsonSerializer1 = (JsonSerializer)this._interfaceMappings.get(paramClassKey);
    if (localJsonSerializer1 != null)
      return localJsonSerializer1;
    JsonSerializer localJsonSerializer2 = _findInterfaceMapping(localClass, paramClassKey);
    if (localJsonSerializer2 != null)
      return localJsonSerializer2;
  }
  return null;
}

public SimpleKeyDeserializers addDeserializer(Class<?> paramClass, KeyDeserializer paramKeyDeserializer)
{
  if (this._classMappings == null)
    this._classMappings = new HashMap();
  this._classMappings.put(new ClassKey(paramClass), paramKeyDeserializer);
  return this;
}

public ValueInstantiator findValueInstantiator(DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, ValueInstantiator paramValueInstantiator)
{
  ValueInstantiator localValueInstantiator = (ValueInstantiator)this._classMappings.get(new ClassKey(paramBeanDescription.getBeanClass()));
  if (localValueInstantiator == null)
    return paramValueInstantiator;
  return localValueInstantiator;
}

public <T> void addDeserializer(Class<T> paramClass, JsonDeserializer<? extends T> paramJsonDeserializer)
{
  ClassKey localClassKey = new ClassKey(paramClass);
  if (this._classMappings == null)
    this._classMappings = new HashMap();
  this._classMappings.put(localClassKey, paramJsonDeserializer);
}

public <T> SimpleAbstractTypeResolver addMapping(Class<T> paramClass, Class<? extends T> paramClass1)
{
  if (paramClass == paramClass1)
    throw new IllegalArgumentException("Can not add mapping from class to itself");
  if (!paramClass.isAssignableFrom(paramClass1))
    throw new IllegalArgumentException("Can not add mapping from class " + paramClass.getName() + " to " + paramClass1.getName() + ", as latter is not a subtype of former");
  if (!Modifier.isAbstract(paramClass.getModifiers()))
    throw new IllegalArgumentException("Can not add mapping from class " + paramClass.getName() + " since it is not abstract");
  this._mappings.put(new ClassKey(paramClass), paramClass1);
  return this;
}

public JavaType findTypeMapping(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType)
{
  Class localClass1 = paramJavaType.getRawClass();
  Class localClass2 = (Class)this._mappings.get(new ClassKey(localClass1));
  if (localClass2 == null)
    return null;
  return paramJavaType.narrowBy(localClass2);
}

protected SerializationConfig(SerializationConfig paramSerializationConfig, Map<ClassKey, Class<?>> paramMap)
{
  super(paramSerializationConfig, paramMap);
  this._serFeatures = paramSerializationConfig._serFeatures;
  this._serializationInclusion = paramSerializationConfig._serializationInclusion;
  this._filterProvider = paramSerializationConfig._filterProvider;
}

protected DeserializationConfig(DeserializationConfig paramDeserializationConfig, Map<ClassKey, Class<?>> paramMap)
{
  super(paramDeserializationConfig, paramMap);
  this._deserFeatures = paramDeserializationConfig._deserFeatures;
  this._problemHandlers = paramDeserializationConfig._problemHandlers;
  this._nodeFactory = paramDeserializationConfig._nodeFactory;
}

public DeserializationConfig(BaseSettings paramBaseSettings, SubtypeResolver paramSubtypeResolver, Map<ClassKey, Class<?>> paramMap)
{
  super(paramBaseSettings, paramSubtypeResolver, paramMap);
  this._deserFeatures = collectFeatureDefaults(DeserializationFeature.class);
  this._nodeFactory = JsonNodeFactory.instance;
  this._problemHandlers = null;
}

public SerializedString findRootName(Class<?> paramClass, MapperConfig<?> paramMapperConfig)
{
  try
  {
    ClassKey localClassKey = new ClassKey(paramClass);
    if (this._rootNames == null)
    {
      this._rootNames = new LRUMap(20, 200);
    }
    else
    {
      SerializedString localSerializedString1 = (SerializedString)this._rootNames.get(localClassKey);
      if (localSerializedString1 != null)
        return localSerializedString1;
    }
    BeanDescription localBeanDescription = paramMapperConfig.introspectClassAnnotations(paramClass);
    PropertyName localPropertyName = paramMapperConfig.getAnnotationIntrospector().findRootName(localBeanDescription.getClassInfo());
    String str;
    if ((localPropertyName == null) || (!localPropertyName.hasSimpleName()))
      str = paramClass.getSimpleName();
    else
      str = localPropertyName.getSimpleName();
    SerializedString localSerializedString2 = new SerializedString(str);
    this._rootNames.put(localClassKey, localSerializedString2);
    return localSerializedString2;
  }
  finally
  {
  }
}

/**
 * Constructor used when creating a new instance (compared to
 * that of creating fluent copies)
 */
protected MapperConfigBase(BaseSettings base,
        SubtypeResolver str, Map<ClassKey,Class<?>> mixins)
{
    super(base, DEFAULT_MAPPER_FEATURES);
    _mixInAnnotations = mixins;
    _subtypeResolver = str;
    _rootName = null;
    _view = null;
}

/**
 * @since 2.1
 */
protected MapperConfigBase(MapperConfigBase<CFG,T> src, Map<ClassKey,Class<?>> mixins)
{
    super(src);
    _mixInAnnotations = mixins;
    _subtypeResolver = src._subtypeResolver;
    _rootName = src._rootName;
    _view = src._view;
}

protected JsonSerializer<?> _findInterfaceMapping(Class<?> cls, ClassKey key)
{
    for (Class<?> iface : cls.getInterfaces()) {
        key.reset(iface);
        JsonSerializer<?> ser = _interfaceMappings.get(key);
        if (ser != null) {
            return ser;
        }
        ser = _findInterfaceMapping(iface, key);
        if (ser != null) {
            return ser;
        }
    }
    return null;
}

public SimpleKeyDeserializers addDeserializer(Class<?> forClass, KeyDeserializer deser)
{
    if (_classMappings == null) {
        _classMappings = new HashMap<ClassKey,KeyDeserializer>();
    }
    _classMappings.put(new ClassKey(forClass), deser);
    return this;
}

public KeyDeserializer findKeyDeserializer(JavaType type,
        DeserializationConfig config, BeanDescription beanDesc)
{
    if (_classMappings == null) {
        return null;
    }
    return _classMappings.get(new ClassKey(type.getRawClass()));
}

@Override
public ValueInstantiator findValueInstantiator(DeserializationConfig config,
        BeanDescription beanDesc, ValueInstantiator defaultInstantiator)
{
    ValueInstantiator inst = _classMappings.get(new ClassKey(beanDesc.getBeanClass()));
    return (inst == null) ? defaultInstantiator : inst;
}

@Override
public JavaType findTypeMapping(DeserializationConfig config, JavaType type)
{
    // this is the main mapping base, so let's 
    Class<?> src = type.getRawClass();
    Class<?> dst = _mappings.get(new ClassKey(src));
    if (dst == null) {
        return null;
    }
    return type.narrowBy(dst);
}

/**
 * Constructor used by ObjectMapper to create default configuration object instance.
 */
public SerializationConfig(BaseSettings base,
        SubtypeResolver str, Map<ClassKey,Class<?>> mixins)
{
    super(base, str, mixins);
    _serFeatures = collectFeatureDefaults(SerializationFeature.class);
    _filterProvider = null;
}

/**
 * @since 2.1
 */
protected SerializationConfig(SerializationConfig src, Map<ClassKey,Class<?>> mixins)
{
    super(src, mixins);
    _serFeatures = src._serFeatures;
    _serializationInclusion = src._serializationInclusion;
    _filterProvider = src._filterProvider;
}

/**
 * Method called by {@link BeanDeserializerFactory} to see if there might be a standard
 * deserializer registered for given type.
 */
@SuppressWarnings("unchecked")
protected JsonDeserializer<Object> findStdDeserializer(DeserializationConfig config,
        JavaType type)
    throws JsonMappingException
{
    Class<?> cls = type.getRawClass();
    // note: we do NOT check for custom deserializers here; that's for sub-class to do
    JsonDeserializer<Object> deser = _simpleDeserializers.get(new ClassKey(cls));
    if (deser != null) {
        return deser;
    }

    // [JACKSON-283]: AtomicReference is a rather special type...
    if (AtomicReference.class.isAssignableFrom(cls)) {
        // Must find parameterization
        TypeFactory tf = config.getTypeFactory();
        JavaType[] params = tf.findTypeParameters(type, AtomicReference.class);
        JavaType referencedType;
        if (params == null || params.length < 1) { // untyped (raw)
            referencedType = TypeFactory.unknownType();
        } else {
            referencedType = params[0];
        }

        JsonDeserializer<?> d2 = new JdkDeserializers.AtomicReferenceDeserializer(referencedType);
        return (JsonDeserializer<Object>)d2;
    }
    // [JACKSON-386]: External/optional type handlers are handled somewhat differently
    JsonDeserializer<?> d = optionalHandlers.findDeserializer(type, config);
    if (d != null) {
        return (JsonDeserializer<Object>)d;
    }
    return null;
}

/**
     * Helper method called to (try to) locate deserializer for given sub-type of
     * type that this deserializer handles.
     */
    protected JsonDeserializer<Object> _findSubclassDeserializer(DeserializationContext ctxt,
            Object bean, TokenBuffer unknownTokens)
        throws IOException, JsonProcessingException
    {  
        JsonDeserializer<Object> subDeser;

        // First: maybe we have already created sub-type deserializer?
        synchronized (this) {
            subDeser = (_subDeserializers == null) ? null : _subDeserializers.get(new ClassKey(bean.getClass()));
        }
        if (subDeser != null) {
            return subDeser;
        }
        // If not, maybe we can locate one. First, need provider
        JavaType type = ctxt.constructType(bean.getClass());
        /* 30-Jan-2012, tatu: Ideally we would be passing referring
         *   property; which in theory we could keep track of via
         *   ResolvableDeserializer (if we absolutely must...).
         *   But for now, let's not bother.
         */
//        subDeser = ctxt.findValueDeserializer(type, _property);
        subDeser = ctxt.findRootValueDeserializer(type);
        // Also, need to cache it
        if (subDeser != null) {
            synchronized (this) {
                if (_subDeserializers == null) {
                    _subDeserializers = new HashMap<ClassKey,JsonDeserializer<Object>>();;
                }
                _subDeserializers.put(new ClassKey(bean.getClass()), subDeser);
            }            
        }
        return subDeser;
    }

/**
 * Constructor used by ObjectMapper to create default configuration object instance.
 */
public DeserializationConfig(BaseSettings base,
        SubtypeResolver str, Map<ClassKey,Class<?>> mixins)
{
    super(base, str, mixins);
    _deserFeatures = collectFeatureDefaults(DeserializationFeature.class);
    _nodeFactory = JsonNodeFactory.instance;
    _problemHandlers = null;
}

/**
 * @since 2.1
 */
protected DeserializationConfig(DeserializationConfig src, Map<ClassKey,Class<?>> mixins)
{
    super(src, mixins);
    _deserFeatures = src._deserFeatures;
    _problemHandlers = src._problemHandlers;
    _nodeFactory = src._nodeFactory;
}

public final Class<?> findMixInClassFor(Class<?> paramClass)
{
  if (this._mixInAnnotations == null)
    return null;
  return (Class)this._mixInAnnotations.get(new ClassKey(paramClass));
}

public JsonSerializer<?> findSerializer(SerializationConfig paramSerializationConfig, JavaType paramJavaType, BeanDescription paramBeanDescription)
{
  Object localObject1 = paramJavaType.getRawClass();
  ClassKey localClassKey = new ClassKey((Class)localObject1);
  if (((Class)localObject1).isInterface())
  {
    if (this._interfaceMappings != null)
    {
      JsonSerializer localJsonSerializer5 = (JsonSerializer)this._interfaceMappings.get(localClassKey);
      if (localJsonSerializer5 != null)
        return localJsonSerializer5;
    }
  }
  else if (this._classMappings != null)
  {
    JsonSerializer localJsonSerializer3 = (JsonSerializer)this._classMappings.get(localClassKey);
    if (localJsonSerializer3 != null)
      return localJsonSerializer3;
    for (Object localObject2 = localObject1; localObject2 != null; localObject2 = ((Class)localObject2).getSuperclass())
    {
      localClassKey.reset((Class)localObject2);
      JsonSerializer localJsonSerializer4 = (JsonSerializer)this._classMappings.get(localClassKey);
      if (localJsonSerializer4 != null)
        return localJsonSerializer4;
    }
  }
  if (this._interfaceMappings != null)
  {
    JsonSerializer localJsonSerializer1 = _findInterfaceMapping((Class)localObject1, localClassKey);
    if (localJsonSerializer1 != null)
      return localJsonSerializer1;
    if (!((Class)localObject1).isInterface())
    {
      JsonSerializer localJsonSerializer2;
      do
      {
        Class localClass = ((Class)localObject1).getSuperclass();
        localObject1 = localClass;
        if (localClass == null)
          break;
        localJsonSerializer2 = _findInterfaceMapping((Class)localObject1, localClassKey);
      }
      while (localJsonSerializer2 == null);
      return localJsonSerializer2;
    }
  }
  return null;
}

public KeyDeserializer findKeyDeserializer(JavaType paramJavaType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription)
{
  if (this._classMappings == null)
    return null;
  return (KeyDeserializer)this._classMappings.get(new ClassKey(paramJavaType.getRawClass()));
}

public SimpleValueInstantiators addValueInstantiator(Class<?> paramClass, ValueInstantiator paramValueInstantiator)
{
  this._classMappings.put(new ClassKey(paramClass), paramValueInstantiator);
  return this;
}

public JsonDeserializer<?> findArrayDeserializer(ArrayType paramArrayType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
{
  if (this._classMappings == null)
    return null;
  return (JsonDeserializer)this._classMappings.get(new ClassKey(paramArrayType.getRawClass()));
}

public JsonDeserializer<?> findBeanDeserializer(JavaType paramJavaType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription)
{
  if (this._classMappings == null)
    return null;
  return (JsonDeserializer)this._classMappings.get(new ClassKey(paramJavaType.getRawClass()));
}

public JsonDeserializer<?> findCollectionDeserializer(CollectionType paramCollectionType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
{
  if (this._classMappings == null)
    return null;
  return (JsonDeserializer)this._classMappings.get(new ClassKey(paramCollectionType.getRawClass()));
}

public JsonDeserializer<?> findCollectionLikeDeserializer(CollectionLikeType paramCollectionLikeType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
{
  if (this._classMappings == null)
    return null;
  return (JsonDeserializer)this._classMappings.get(new ClassKey(paramCollectionLikeType.getRawClass()));
}

public JsonDeserializer<?> findEnumDeserializer(Class<?> paramClass, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription)
{
  if (this._classMappings == null)
    return null;
  return (JsonDeserializer)this._classMappings.get(new ClassKey(paramClass));
}

public JsonDeserializer<?> findMapDeserializer(MapType paramMapType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
{
  if (this._classMappings == null)
    return null;
  return (JsonDeserializer)this._classMappings.get(new ClassKey(paramMapType.getRawClass()));
}

public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType paramMapLikeType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
{
  if (this._classMappings == null)
    return null;
  return (JsonDeserializer)this._classMappings.get(new ClassKey(paramMapLikeType.getRawClass()));
}