Java ParameterizedType类代码示例

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
public static Type canonicalize(Type type) {
    if (type instanceof Class) {
        Class<?> c = (Class) type;
        return c.isArray() ? new GenericArrayTypeImpl(C$Gson$Types.canonicalize(c.getComponentType())) : c;
    } else if (type instanceof ParameterizedType) {
        ParameterizedType p = (ParameterizedType) type;
        return new ParameterizedTypeImpl(p.getOwnerType(), p.getRawType(), p.getActualTypeArguments());
    } else if (type instanceof GenericArrayType) {
        return new GenericArrayTypeImpl(((GenericArrayType) type).getGenericComponentType());
    } else {
        if (!(type instanceof WildcardType)) {
            return type;
        }
        WildcardType w = (WildcardType) type;
        return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());
    }
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
/**
 * Returns a type that is functionally equal but not necessarily equal
 * according to {@link Object#equals(Object) Object.equals()}. The returned
 * type is {@link java.io.Serializable}.
 */
public static Type canonicalize(Type type) {
  if (type instanceof Class) {
    Class<?> c = (Class<?>) type;
    return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;

  } else if (type instanceof ParameterizedType) {
    ParameterizedType p = (ParameterizedType) type;
    return new ParameterizedTypeImpl(p.getOwnerType(),
        p.getRawType(), p.getActualTypeArguments());

  } else if (type instanceof GenericArrayType) {
    GenericArrayType g = (GenericArrayType) type;
    return new GenericArrayTypeImpl(g.getGenericComponentType());

  } else if (type instanceof WildcardType) {
    WildcardType w = (WildcardType) type;
    return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());

  } else {
    // type is either serializable as-is or unsupported
    return type;
  }
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
private static String formatTypeWithoutSpecialCharacter(Type type) {
    if (type instanceof Class) {
        Class clazz = (Class) type;
        return clazz.getCanonicalName();
    }
    if (type instanceof ParameterizedType) {
        ParameterizedType pType = (ParameterizedType) type;
        String typeName = formatTypeWithoutSpecialCharacter(pType.getRawType());
        for (Type typeArg : pType.getActualTypeArguments()) {
            typeName += "_";
            typeName += formatTypeWithoutSpecialCharacter(typeArg);
        }
        return typeName;
    }
    if (type instanceof GenericArrayType) {
        GenericArrayType gaType = (GenericArrayType) type;
        return formatTypeWithoutSpecialCharacter(gaType.getGenericComponentType()) + "_array";
    }
    throw new AJsoupReaderException("unsupported type: " + type + ", of class " + type.getClass());
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
CollectionMapping(Type targetType,
                  ArrayType<?> openArrayType,
                  Class<?> openArrayClass,
                  MXBeanMapping elementMapping) {
    super(targetType, openArrayType);
    this.elementMapping = elementMapping;

    /* Determine the concrete class to be used when converting
       back to this Java type.  We convert all Lists to ArrayList
       and all Sets to TreeSet.  (TreeSet because it is a SortedSet,
       so works for both Set and SortedSet.)  */
    Type raw = ((ParameterizedType) targetType).getRawType();
    Class<?> c = (Class<?>) raw;
    final Class<?> collC;
    if (c == List.class)
        collC = ArrayList.class;
    else if (c == Set.class)
        collC = HashSet.class;
    else if (c == SortedSet.class)
        collC = TreeSet.class;
    else { // can't happen
        assert(false);
        collC = null;
    }
    collectionClass = Util.cast(collC);
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
private ArgumentMarshaller getObjectToMapMarshaller(Type type) {
    Type localType = type;
    if (localType instanceof ParameterizedType) {
        localType = ((ParameterizedType) localType).getRawType();
    }

    if (!(localType instanceof Class)) {
        throw new DynamoDbMappingException(
                "Cannot convert " + type + " to a class");
    }

    Class<?> clazz = (Class<?>) localType;
    if (StandardAnnotationMaps.of(clazz).attributeType() != DynamoDbAttributeType.M) {
        throw new DynamoDbMappingException(
                "Cannot marshall type " + type
                + " without a custom marshaler or @DynamoDBDocument "
                + "annotation.");
    }

    return new ObjectToMapMarshaller(this);
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
private Class<?> getCreatedClass(Creator<?> creator) {
    String typeName = ((ParameterizedType) creator.getClass()
                                                  .getGenericSuperclass()).getActualTypeArguments()[0]
            .getTypeName();
    int typeParametersIndex = typeName.indexOf('<');

    if (typeParametersIndex != -1) {
        typeName = typeName.substring(0, typeParametersIndex);
    }

    Class<?> clazz;

    try {
        clazz = Class.forName(typeName);
    } catch (ClassNotFoundException e) {
        throw new IllegalStateException("Can not find a Class for '" + typeName + "'.", e);
    }

    return clazz;
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
public void testGetSubtype_recursiveTypeBoundInSubtypeTranslatedAsIs() {
  class BaseWithTypeVar<T> {}
  class Outer<O> {
    class Sub<X> extends BaseWithTypeVar<List<X>> {}
    class Sub2<Y extends Sub2<Y>> extends BaseWithTypeVar<List<Y>> {}
  }
  ParameterizedType subtype = (ParameterizedType) new TypeToken<BaseWithTypeVar<List<?>>>() {}
          .getSubtype(Outer.Sub.class)
          .getType();
  assertEquals(Outer.Sub.class, subtype.getRawType());
  assertThat(subtype.getActualTypeArguments()[0]).isInstanceOf(WildcardType.class);
  ParameterizedType owner = (ParameterizedType) subtype.getOwnerType();
  assertEquals(Outer.class, owner.getRawType());
  // This returns a strange ? extends Sub2<Y> type, which isn't ideal.
  TypeToken<?> unused = new TypeToken<BaseWithTypeVar<List<?>>>() {}.getSubtype(Outer.Sub2.class);
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
/**
 * Converts a standard library Java representation of JSON data to an object of the class provided
 * through the GenericTypeIndicator
 *
 * @param object The representation of the JSON data
 * @param typeIndicator The indicator providing class of the object to convert to
 * @return The POJO object.
 */
public static <T> T convertToCustomClass(Object object, GenericTypeIndicator<T> typeIndicator) {
  Class<?> clazz = typeIndicator.getClass();
  Type genericTypeIndicatorType = clazz.getGenericSuperclass();
  if (genericTypeIndicatorType instanceof ParameterizedType) {
    ParameterizedType parameterizedType = (ParameterizedType) genericTypeIndicatorType;
    if (!parameterizedType.getRawType().equals(GenericTypeIndicator.class)) {
      throw new DatabaseException(
          "Not a direct subclass of GenericTypeIndicator: " + genericTypeIndicatorType);
    }
    // We are guaranteed to have exactly one type parameter
    Type type = parameterizedType.getActualTypeArguments()[0];
    return deserializeToType(object, type);
  } else {
    throw new DatabaseException(
        "Not a direct subclass of GenericTypeIndicator: " + genericTypeIndicatorType);
  }
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
private <T> void setField(final T resultObject, final Field field, final Object unmarshalledValue)
    throws IllegalAccessException, IOException {

    final Class<?> fieldType = field.getType();
    final Type genericType = field.getGenericType();

    if (fieldType.isPrimitive()) {
        reflectionUtil.setField(resultObject, field, unmarshalledValue);

    } else if (genericType instanceof ParameterizedType) {
        final Class<?>[] actualTypeArguments = reflectionUtil.geClassArgumentsFromGeneric(genericType);

        final JavaType typedField;
        if (actualTypeArguments.length == 1) {
            typedField = objectMapper.getTypeFactory().constructParametricType(fieldType, actualTypeArguments[0]);
        } else {
            typedField = objectMapper.getTypeFactory()
                .constructMapLikeType(fieldType, actualTypeArguments[0], actualTypeArguments[1]);
        }

        reflectionUtil.setField(resultObject, field, objectMapper.convertValue(unmarshalledValue, typedField));

    } else {
        reflectionUtil.setField(resultObject, field, objectMapper.convertValue(unmarshalledValue, fieldType));
    }
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
static Type resolveTypeVariable(Type context, Class<?> contextRawType, TypeVariable<?> unknown) {
  Class<?> declaredByRaw = declaringClassOf(unknown);

  // we can't reduce this further
  if (declaredByRaw == null) {
    return unknown;
  }

  Type declaredBy = getGenericSupertype(context, contextRawType, declaredByRaw);
  if (declaredBy instanceof ParameterizedType) {
    int index = indexOf(declaredByRaw.getTypeParameters(), unknown);
    return ((ParameterizedType) declaredBy).getActualTypeArguments()[index];
  }

  return unknown;
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
/**
 * Returns a two element array containing this map's key and value types in
 * positions 0 and 1 respectively.
 */
public static Type[] getMapKeyAndValueTypes(Type context, Class<?> contextRawType) {
  /*
   * Work around a problem with the declaration of java.util.Properties. That
   * class should extend Hashtable<String, String>, but it's declared to
   * extend Hashtable<Object, Object>.
   */
  if (context == Properties.class) {
    return new Type[] { String.class, String.class }; // TODO: test subclasses of Properties!
  }

  Type mapType = getSupertype(context, contextRawType, Map.class);
  // TODO: strip wildcards?
  if (mapType instanceof ParameterizedType) {
    ParameterizedType mapParameterizedType = (ParameterizedType) mapType;
    return mapParameterizedType.getActualTypeArguments();
  }
  return new Type[] { Object.class, Object.class };
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
private static TypeResult getTypeParameter(Class<?> clazz, Type argType) {
	if (argType instanceof Class<?>) {
		return new TypeResult((Class<?>) argType, -1, 0);
	} else if (argType instanceof ParameterizedType) {
		return new TypeResult((Class<?>) ((ParameterizedType) argType).getRawType(), -1, 0);
	} else if (argType instanceof GenericArrayType) {
		Type arrayElementType = ((GenericArrayType) argType).getGenericComponentType();
		TypeResult result = getTypeParameter(clazz, arrayElementType);
		result.incrementDimension(1);
		return result;
	} else {
		TypeVariable<?>[] tvs = clazz.getTypeParameters();
		for (int i = 0; i < tvs.length; i++) {
			if (tvs[i].equals(argType)) {
				return new TypeResult(null, i, 0);
			}
		}
		return null;
	}
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
/**
 * 通过反射, 获得Class定义中声明的父类的泛型参数的类型.
 * 如无法找到, 返回Object.class.
 * 
 * 如public UserDao extends HibernateDao<User,Long>
 *
 * @param clazz clazz The class to introspect
 * @param index the Index of the generic ddeclaration,start from 0.
 * @return the index generic declaration, or Object.class if cannot be determined
 */
public static Class getClassGenricType(final Class clazz, final int index) {

	Type genType = clazz.getGenericSuperclass();

	if (!(genType instanceof ParameterizedType)) {
		logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
		return Object.class;
	}

	Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

	if (index >= params.length || index < 0) {
		logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
				+ params.length);
		return Object.class;
	}
	if (!(params[index] instanceof Class)) {
		logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
		return Object.class;
	}

	return (Class) params[index];
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
public ArrayListTypeFieldDeserializer(ParserConfig mapping, Class<?> clazz, FieldInfo fieldInfo){
    super(clazz, fieldInfo);

    Type fieldType = fieldInfo.fieldType;
    if (fieldType instanceof ParameterizedType) {
        Type argType = ((ParameterizedType) fieldInfo.fieldType).getActualTypeArguments()[0];
        if (argType instanceof WildcardType) {
            WildcardType wildcardType = (WildcardType) argType;
            Type[] upperBounds = wildcardType.getUpperBounds();
            if (upperBounds.length == 1) {
                argType = upperBounds[0];
            }
        }
        this.itemType = argType;
    } else {
        this.itemType = Object.class;
    }
}
 

import java.lang.reflect.ParameterizedType; //导入依赖的package包/类
private boolean isTypeMatch(Type type, Type targetType) {
    if (type instanceof Class && targetType instanceof Class) {
        if (((Class) type).isAssignableFrom((Class) targetType)) {
            return true;
        }
    } else if (type instanceof ParameterizedType && targetType instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;
        ParameterizedType parameterizedTargetType = (ParameterizedType) targetType;
        if (isTypeMatch(parameterizedType.getRawType(), ((ParameterizedType) targetType).getRawType())) {
            Type[] types = parameterizedType.getActualTypeArguments();
            Type[] targetTypes = parameterizedTargetType.getActualTypeArguments();
            if (types == null || targetTypes == null || types.length != targetTypes.length) {
                return false;
            }
            int len = types.length;
            for (int i = 0; i < len; i++) {
                if (!isTypeMatch(types[i], targetTypes[i])) {
                    return false;
                }
            }
            return true;
        }
    }
    return false;
}