public static Class<?>[] getActualTypes(Type[] types){ Class<?>[] actualTypes = new Class<?>[types.length]; for(int i=0;i<types.length;i++){ actualTypes[i] = getActualType(types[i]); } return actualTypes; }
public static Class<?> getActualTypeArgument(Class<?> declaringClass, Type genericType) { if(null == declaringClass) { return getActualTypeArgument(genericType); }else{ return getActualType(declaringClass, getTypeArgument(genericType)); } }
Class<?> acturalTypeArgument = Types.getActualType(typeArgument); return null; beanType = Types.getActualType(types[1]);
public static Class<?> getActualType(Class<?> declaringClass, Type type) { if(null == declaringClass) { return getActualType(type); } if(type instanceof TypeVariable) { TypeVariable var = (TypeVariable)type; Class<?> actualType = getActualType(declaringClass.getGenericSuperclass(), var); if(null != actualType) { return actualType; } for(Type genericInterface : declaringClass.getGenericInterfaces()) { actualType = getActualType(genericInterface, var); if(null != actualType) { return actualType; } } } return getActualType(type); }
protected static Class<?> getActualType(Type type, TypeVariable var) { if(type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType)type; Class<?> rawClass = (Class<?>)parameterizedType.getRawType(); Type[] vars = rawClass.getTypeParameters(); Type[] typeArgs = parameterizedType.getActualTypeArguments(); for(int i=0;i<vars.length;i++) { if(vars[i].equals(var)) { return getActualType(typeArgs[i]); } } } return null; }
public static Class<?> getActualType(Type type) { if (type instanceof Class<?>) { // it is raw, no problem return (Class<?>) type; } if (type instanceof ParameterizedType) { // simple enough to get the raw type of a ParameterizedType return getRawType((ParameterizedType) type); } if (type instanceof TypeVariable<?>) { Type[] types = ((TypeVariable<?>) type).getBounds(); if (types.length == 1) { return getActualType(types[0]); } } if (type instanceof GenericArrayType) { // get raw component type Type t = ((GenericArrayType) type).getGenericComponentType(); Class<?> rawComponentType = getActualType(t); // create array type from raw component type and return its class return Array.newInstance(rawComponentType, 0).getClass(); } return null; }
protected static Map doConvert(ConvertContext context, Map from, Class<?> targetType, Type genericType) { Type[] typeArguments = Types.getTypeArguments(genericType); Class<?> keyType = Types.getActualType(typeArguments[0]); Class<?> valType = Types.getActualType(typeArguments[1]); Map to = createMap(targetType); for(Object o : from.entrySet()){ Entry entry = (Entry)o; Object key = Converts.convert(entry.getKey(), keyType, typeArguments[0], context); Object val = Converts.convert(entry.getValue(), valType, typeArguments[1], context); to.put(key,val); } return to; }
protected Type[] getDictionaryTypes(Class<?> type, Type genericType) { Type[] types = Types.getTypeArguments(genericType); if(types.length != 2) { for(Type genericInterface : type.getGenericInterfaces()) { Class<?> c = Types.getActualType(genericInterface); if(Map.class.isAssignableFrom(c)) { return getDictionaryTypes(c, genericInterface); } } Type genericSuperClass = type.getGenericSuperclass(); if(null != genericSuperClass) { Class<?> c = Types.getActualType(genericSuperClass); if(Map.class.isAssignableFrom(c)) { return getDictionaryTypes(c, genericSuperClass); } } } return types; }
public static Class<?> getActualTypeArgument(Type genericType) { Type type = getTypeArgument(genericType); return type == Object.class ? Object.class : getActualType(type);
protected MType getDictionaryType(MTypeContext context, Class<?> declaringType, Class<?> type, Type genericType, MTypeFactory root) { if(null == genericType) { return MDictionaryType.INSTANCE; } Type[] types = getDictionaryTypes(type, genericType); Type keyType = types[0]; Type valType = types[1]; MType keyMType = getMType(context, declaringType, Types.getActualType(keyType), keyType, root); MType valMType = getMType(context, declaringType, Types.getActualType(valType), valType, root); return new MDictionaryType(keyMType, valMType); }
Type typeArgument = Types.getTypeArgument(genericType); Class<?> elementClass = Types.getActualType(declaringType, typeArgument); genericType = typeArgument;
Type typeArgument = Types.getTypeArgument(genericType); type = Types.getActualType(declaringClass, typeArgument); genericType = typeArgument;