Java ParameterizedType.getRawType方法代码示例

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()}.
 */
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) {
    if (type instanceof ParameterizedTypeImpl) return type;
    ParameterizedType p = (ParameterizedType) type;
    return new ParameterizedTypeImpl(p.getOwnerType(),
        p.getRawType(), p.getActualTypeArguments());

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

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

  } else {
    return type; // This type is unsupported!
  }
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
/**
 * Getting parametrized classes of {@code JAXBElement<...>} property
 * @param p property which parametrized types we will try to get
 * @return null - if it's not JAXBElement property, or it's not parametrized, and array of parametrized classes in other case
 */
private Class[] getParametrizedTypes(PropertyInfo p) {
    try {
        Type pType = ((RuntimePropertyInfo) p).getIndividualType();
        if (pType instanceof ParameterizedType) {
            ParameterizedType prmzdType = (ParameterizedType) pType;
            if (prmzdType.getRawType() == JAXBElement.class) {
                Type[] actualTypes = prmzdType.getActualTypeArguments();
                Class[] result = new Class[actualTypes.length];
                for (int i = 0; i < actualTypes.length; i++) {
                    result[i] = (Class) actualTypes[i];
                }
                return result;
            }
        }
    } catch (Exception e) {
        logger.log(Level.FINE, "Error in ModelBuilder.getParametrizedTypes. " + e.getMessage());
    }
    return null;
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
private static Object convert(Type targetType, Object sourceObject, ViewDecoration decoration, ViewGraphDetails graphDetails) {
    if (targetType instanceof ParameterizedType) {
        ParameterizedType parameterizedTargetType = (ParameterizedType) targetType;
        if (parameterizedTargetType.getRawType() instanceof Class) {
            Class<?> rawClass = (Class<?>) parameterizedTargetType.getRawType();
            if (Iterable.class.isAssignableFrom(rawClass)) {
                Type targetElementType = getElementType(parameterizedTargetType, 0);
                return convertCollectionInternal(rawClass, targetElementType, (Iterable<?>) sourceObject, decoration, graphDetails);
            }
            if (Map.class.isAssignableFrom(rawClass)) {
                Type targetKeyType = getElementType(parameterizedTargetType, 0);
                Type targetValueType = getElementType(parameterizedTargetType, 1);
                return convertMap(rawClass, targetKeyType, targetValueType, (Map<?, ?>) sourceObject, decoration, graphDetails);
            }
        }
    }
    if (targetType instanceof Class) {
        if (((Class) targetType).isPrimitive()) {
            return sourceObject;
        }
        return createView((Class) targetType, sourceObject, decoration, graphDetails);
    }
    throw new UnsupportedOperationException(String.format("Cannot convert object of %s to %s.", sourceObject.getClass(), targetType));
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    ParameterizedType paramType = (ParameterizedType) type;
    Type itemType = paramType.getActualTypeArguments()[0];

    Object itemObject = parser.parseObject(itemType);

    Type rawType = paramType.getRawType();
    if (rawType == AtomicReference.class) {
        return (T) new AtomicReference(itemObject);
    }

    if (rawType == WeakReference.class) {
        return (T) new WeakReference(itemObject);
    }

    if (rawType == SoftReference.class) {
        return (T) new SoftReference(itemObject);
    }

    throw new UnsupportedOperationException(rawType.toString());
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
/**
 * Gets the generic type parameter from an interface of type interfaceClass declared on class declaringClass.
 */
public static final Type getGenericInterfaceType(final Class<?> declaringClass, final Class<?> interfaceClass)
{
	for (Type type : declaringClass.getGenericInterfaces())
	{
		if (type instanceof ParameterizedType)
		{
			final ParameterizedType parameterizedType = (ParameterizedType)type;
			if (parameterizedType.getRawType() == interfaceClass)
			{
				return parameterizedType.getActualTypeArguments()[0];
			}
		}
	}
	return null;
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
public Type onParameterizdType(ParameterizedType p, BinderArg args) {
    Type[] params = p.getActualTypeArguments();

    boolean different = false;
    for (int i = 0; i < params.length; i++) {
        Type t = params[i];
        params[i] = visit(t, args);
        different |= t != params[i];
    }

    Type newOwner = p.getOwnerType();
    if (newOwner != null) {
        newOwner = visit(newOwner, args);
    }
    different |= p.getOwnerType() != newOwner;

    if (!different) {
        return p;
    }

    return new ParameterizedTypeImpl((Class<?>) p.getRawType(), params, newOwner);
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
static Type typeArg(Type type, Class<?> wantedRawType, int index) {
    if (type instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;
        Type rawType = parameterizedType.getRawType();
        if (rawType instanceof Class && wantedRawType.isAssignableFrom((Class) rawType)) {
            Type result = parameterizedType.getActualTypeArguments()[index];
            if (result instanceof TypeVariable) {
                throw new ParserException("Generic types must be explicit");
            }
            return result;
        } else {
            return null;
        }
    } else {
        return null;
    }
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
static String toStringPT(ParameterizedType pt) {
    StringBuilder sb = new StringBuilder();
    Type ownerType = pt.getOwnerType();
    Class<?> rawType = (Class<?>) pt.getRawType();
    Type[] actualTypeArguments = pt.getActualTypeArguments();
    sb.append(rawType.getName().replace('$', '.'));

    if (actualTypeArguments != null && actualTypeArguments.length > 0) {
        sb.append("<");
        boolean first = true;
        for (Type t : actualTypeArguments) {
            if (!first)
                sb.append(", ");
            sb.append(((Class<?>) t).getName());
            first = false;
        }
        sb.append(">");
    }

    return sb.toString();
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
@Override
public boolean equals(Object o) {
  if (o instanceof ParameterizedType) {
    ParameterizedType that = (ParameterizedType) o;
    if (this == that) {
      return true;
    }
    Type thatOwner = that.getOwnerType();
    Type thatRawType = that.getRawType();
    return Objects.equals(ownerType, thatOwner) &&
        Objects.equals(rawType, thatRawType) &&
        Arrays.equals(actualTypeArguments, that.getActualTypeArguments());
  } else {
    return false;
  }
}
 

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()}.
 */
private 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) {
    if (type instanceof ParameterizedTypeImpl) return type;
    ParameterizedType p = (ParameterizedType) type;
    return new ParameterizedTypeImpl(p.getOwnerType(),
      p.getRawType(), p.getActualTypeArguments());
  } else if (type instanceof GenericArrayType) {
    if (type instanceof GenericArrayTypeImpl) return type;
    GenericArrayType g = (GenericArrayType) type;
    return new GenericArrayTypeImpl(g.getGenericComponentType());
  } else if (type instanceof WildcardType) {
    if (type instanceof WildcardTypeImpl) return type;
    WildcardType w = (WildcardType) type;
    return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());
  } else {
    return type; // This type is unsupported!
  }
}
 

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()}.
 */
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) {
        if (type instanceof ParameterizedTypeImpl) return type;
        ParameterizedType p = (ParameterizedType) type;
        return new ParameterizedTypeImpl(p.getOwnerType(),
                                                p.getRawType(), p.getActualTypeArguments());

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

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

    } else {
        return type; // This type is unsupported!
    }
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
static Class<?> getRawType(Type type) {
    if (type == null) throw new NullPointerException("type == null");

    if (type instanceof Class<?>) {
        // Type is a normal class.
        return (Class<?>) type;
    }
    if (type instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;

        // I'm not exactly sure why getRawType() returns Type instead of Class. Neal isn't either but
        // suspects some pathological case related to nested classes exists.
        Type rawType = parameterizedType.getRawType();
        if (!(rawType instanceof Class)) throw new IllegalArgumentException();
        return (Class<?>) rawType;
    }
    if (type instanceof GenericArrayType) {
        Type componentType = ((GenericArrayType) type).getGenericComponentType();
        return Array.newInstance(getRawType(componentType), 0).getClass();
    }
    if (type instanceof TypeVariable) {
        // We could use the variable's bounds, but that won't work if there are multiple. Having a raw
        // type that's more general than necessary is okay.
        return Object.class;
    }
    if (type instanceof WildcardType) {
        return getRawType(((WildcardType) type).getUpperBounds()[0]);
    }

    throw new IllegalArgumentException("Expected a Class, ParameterizedType, or "
            + "GenericArrayType, but <" + type + "> is of type " + type.getClass().getName());
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
public static Class<?> getRawType(Type type) {
  if (type instanceof Class<?>) {
    // type is a normal class.
    return (Class<?>) type;

  } else if (type instanceof ParameterizedType) {
    ParameterizedType parameterizedType = (ParameterizedType) type;

    // I'm not exactly sure why getRawType() returns Type instead of Class.
    // Neal isn't either but suspects some pathological case related
    // to nested classes exists.
    Type rawType = parameterizedType.getRawType();
    checkArgument(rawType instanceof Class);
    return (Class<?>) rawType;

  } else if (type instanceof GenericArrayType) {
    Type componentType = ((GenericArrayType)type).getGenericComponentType();
    return Array.newInstance(getRawType(componentType), 0).getClass();

  } else if (type instanceof TypeVariable) {
    // we could use the variable's bounds, but that won't work if there are multiple.
    // having a raw type that's more general than necessary is okay
    return Object.class;

  } else if (type instanceof WildcardType) {
    return getRawType(((WildcardType) type).getUpperBounds()[0]);

  } else {
    String className = type == null ? "null" : type.getClass().getName();
    throw new IllegalArgumentException("Expected a Class, ParameterizedType, or "
        + "GenericArrayType, but <" + type + "> is of type " + className);
  }
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
private Class<?> getRawType(Type type) {
    if (type == null) throw new NullPointerException("type == null");

    if (type instanceof Class<?>) {
        // Type is a normal class.
        return (Class<?>) type;
    }
    if (type instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;

        // I'm not exactly sure why getRawType() returns Type instead of Class. Neal isn't either but
        // suspects some pathological case related to nested classes exists.
        Type rawType = parameterizedType.getRawType();
        if (!(rawType instanceof Class)) throw new IllegalArgumentException();
        return (Class<?>) rawType;
    }
    if (type instanceof GenericArrayType) {
        Type componentType = ((GenericArrayType) type).getGenericComponentType();
        return Array.newInstance(getRawType(componentType), 0).getClass();
    }
    if (type instanceof TypeVariable) {
        // We could use the variable's bounds, but that won't work if there are multiple. Having a raw
        // type that's more general than necessary is okay.
        return Object.class;
    }
    if (type instanceof WildcardType) {
        return getRawType(((WildcardType) type).getUpperBounds()[0]);
    }

    throw new IllegalArgumentException("Expected a Class, ParameterizedType, or "
            + "GenericArrayType, but <" + type + "> is of type " + type.getClass().getName());
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
/**
 * 创建解析器
 *
 * @param cacheKey
 * @param type
 * @param annotations
 * @return
 */
private static Decoder gen(String cacheKey, Type type, Annotation[] annotations) {
    Decoder decoder = getDecoder(cacheKey);
    if (decoder != null) {
        return decoder;
    }

    type = ReflectKit.chooseImpl(type);

    Type[] typeArgs = new Type[0];
    Class clazz;
    if (type instanceof ParameterizedType) {
        ParameterizedType pType = (ParameterizedType) type;
        clazz = (Class) pType.getRawType();
        typeArgs = pType.getActualTypeArguments();
    } else {
        clazz = (Class) type;
    }
    decoder = NATIVE_DECODERS.get(clazz);//基本数据类型
    if (decoder != null) {
        return decoder;
    }
    decoder = registerDecoder.get(clazz); //自定义的解析器
    if (decoder == null) {
        decoder = ReflectionDecoderFactory.create(clazz, annotations, typeArgs);  //注解解析器
    }
    cacheDecoder(cacheKey, decoder);
    return decoder;
}