/** * @since 2.7 */ public static Type getGenericSuperclass(Class<?> cls) { return cls.getGenericSuperclass(); }
public static <T> Class<T> resolveGenericType(Class<?> declaredClass) { ParameterizedType parameterizedType = (ParameterizedType) declaredClass.getGenericSuperclass(); Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); return (Class<T>) actualTypeArguments[0]; } }
public static <T> Class<T> resolveGenericType(Class<?> declaredClass) { ParameterizedType parameterizedType = (ParameterizedType) declaredClass.getGenericSuperclass(); Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); return (Class<T>) actualTypeArguments[0]; } }
/** Returns the captured type. */ final Type capture() { Type superclass = getClass().getGenericSuperclass(); checkArgument(superclass instanceof ParameterizedType, "%s isn't parameterized", superclass); return ((ParameterizedType) superclass).getActualTypeArguments()[0]; } }
/** * 获取类泛型class * @return */ public Class<Mapper> getMapperClass() { return (Class<Mapper>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]; }
protected ParameterizedTypeReference() { Class<?> parameterizedTypeReferenceSubclass = findParameterizedTypeReferenceSubclass(getClass()); Type type = parameterizedTypeReferenceSubclass.getGenericSuperclass(); Assert.isInstanceOf(ParameterizedType.class, type, "Type must be a parameterized type"); ParameterizedType parameterizedType = (ParameterizedType) type; Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); Assert.isTrue(actualTypeArguments.length == 1, "Number of type arguments must be 1"); this.type = actualTypeArguments[0]; }
private static ClassOwnership detectJvmBehavior() { class LocalClass<T> {} Class<?> subclass = new LocalClass<String>() {}.getClass(); ParameterizedType parameterizedType = (ParameterizedType) subclass.getGenericSuperclass(); for (ClassOwnership behavior : ClassOwnership.values()) { if (behavior.getOwnerType(LocalClass.class) == parameterizedType.getOwnerType()) { return behavior; } } throw new AssertionError(); } }
/** * Return a {@link ResolvableType} representing the direct supertype of this type. * If no supertype is available this method returns {@link #NONE}. * <p>Note: The resulting {@link ResolvableType} instance may not be {@link Serializable}. * @see #getInterfaces() */ public ResolvableType getSuperType() { Class<?> resolved = resolve(); if (resolved == null || resolved.getGenericSuperclass() == null) { return NONE; } ResolvableType superType = this.superType; if (superType == null) { superType = forType(resolved.getGenericSuperclass(), this); this.superType = superType; } return superType; }
/** Returns the captured type. */ final Type capture() { Type superclass = getClass().getGenericSuperclass(); checkArgument(superclass instanceof ParameterizedType, "%s isn't parameterized", superclass); return ((ParameterizedType) superclass).getActualTypeArguments()[0]; } }
@Override void visitClass(Class<?> clazz) { visit(clazz.getGenericSuperclass()); visit(clazz.getGenericInterfaces()); }
private static ClassOwnership detectJvmBehavior() { class LocalClass<T> {} Class<?> subclass = new LocalClass<String>() {}.getClass(); ParameterizedType parameterizedType = (ParameterizedType) subclass.getGenericSuperclass(); for (ClassOwnership behavior : ClassOwnership.values()) { if (behavior.getOwnerType(LocalClass.class) == parameterizedType.getOwnerType()) { return behavior; } } throw new AssertionError(); } }
@Override void visitClass(Class<?> clazz) { visit(clazz.getGenericSuperclass()); visit(clazz.getGenericInterfaces()); }
private static void doTestNewParameterizedType_staticLocalClass() { class LocalClass<T> {} Type jvmType = new LocalClass<String>() {}.getClass().getGenericSuperclass(); Type ourType = Types.newParameterizedType(LocalClass.class, String.class); assertEquals(jvmType, ourType); }
public void testNewParameterizedType_nonStaticLocalClass() { class LocalClass<T> {} Type jvmType = new LocalClass<String>() {}.getClass().getGenericSuperclass(); Type ourType = Types.newParameterizedType(LocalClass.class, String.class); assertEquals(jvmType, ourType); }
public void testVisitNull() { new BaseTypeVisitor() .visit(((ParameterizedType) ArrayList.class.getGenericSuperclass()).getOwnerType()); }
public void testAssignableParameterizedTypeToType() { TypeToken<List<String>> tokenL = new TypeToken<List<String>>() {}; assertTrue(tokenL.isSupertypeOf(StringList.class.getGenericInterfaces()[0])); assertFalse(tokenL.isSupertypeOf(IntegerList.class.getGenericInterfaces()[0])); TypeToken<First<String>> tokenF = new TypeToken<First<String>>() {}; assertTrue(tokenF.isSupertypeOf(ConcreteIS.class.getGenericSuperclass())); assertFalse(tokenF.isSupertypeOf(ConcreteSI.class.getGenericSuperclass())); }
private static void doTestStaticLocalClass() { class Local<T> {} TypeToken<Local<String>> type = new TypeToken<Local<String>>() {}; assertEquals(Types.newParameterizedType(Local.class, String.class), type.getType()); assertEquals(new Local<String>() {}.getClass().getGenericSuperclass(), type.getType()); }
public void testNonStaticLocalClass() { class Local<T> {} TypeToken<Local<String>> type = new TypeToken<Local<String>>() {}; assertEquals(Types.newParameterizedType(Local.class, String.class), type.getType()); assertEquals(new Local<String>() {}.getClass().getGenericSuperclass(), type.getType()); }
@Test public void getSource() throws Exception { Class<?> classType = MySimpleInterfaceType.class; Field basicField = Fields.class.getField("classType"); Field field = Fields.class.getField("charSequenceList"); Method method = Methods.class.getMethod("charSequenceParameter", List.class); MethodParameter methodParameter = MethodParameter.forExecutable(method, 0); assertThat(ResolvableType.forField(basicField).getSource(), equalTo((Object) basicField)); assertThat(ResolvableType.forField(field).getSource(), equalTo((Object) field)); assertThat(ResolvableType.forMethodParameter(methodParameter).getSource(), equalTo((Object) methodParameter)); assertThat(ResolvableType.forMethodParameter(method, 0).getSource(), equalTo((Object) methodParameter)); assertThat(ResolvableType.forClass(classType).getSource(), equalTo((Object) classType)); assertThat(ResolvableType.forClass(classType).getSuperType().getSource(), equalTo((Object) classType.getGenericSuperclass())); }
public void testAssignableParameterizedTypeToClass() { @SuppressWarnings("rawtypes") // Trying to test raw class TypeToken<List> tokL = new TypeToken<List>() {}; assertTrue(tokL.isSupertypeOf(StringList.class)); assertTrue(tokL.isSupertypeOf(StringList.class.getGenericInterfaces()[0])); @SuppressWarnings("rawtypes") // Trying to test raw class TypeToken<Second> tokS = new TypeToken<Second>() {}; assertTrue(tokS.isSupertypeOf(Second.class)); assertTrue(tokS.isSupertypeOf(Third.class.getGenericSuperclass())); }