@Override public boolean isAssignableFrom(ResolvableType other) { Class<?> otherClass = other.getRawClass(); return (otherClass != null && (clazz == null || ClassUtils.isAssignable(clazz, otherClass))); } };
@Override public boolean supportsEventType(ResolvableType eventType) { Class<?> type = eventType.getRawClass(); if (type == null) { return false; } return ApplicationReadyEvent.class.isAssignableFrom(type) || WebServerInitializedEvent.class.isAssignableFrom(type); }
@Override public boolean supportsEventType(ResolvableType resolvableType) { Class<?> type = resolvableType.getRawClass(); if (type == null) { return false; } return ApplicationEnvironmentPreparedEvent.class.isAssignableFrom(type) || ApplicationFailedEvent.class.isAssignableFrom(type); }
@Override public boolean isAssignableFrom(ResolvableType other) { Class<?> otherClass = other.getRawClass(); return (otherClass != null && (clazz == null || ClassUtils.isAssignable(clazz, otherClass))); } };
@Override public Object createMock(String name) { return detachedMockFactory.Stub(Collections.singletonMap("name", (Object)name), type.getRawClass()); }
@Override public boolean supportsEventType(ResolvableType resolvableType) { return isAssignableFrom(resolvableType.getRawClass(), EVENT_TYPES); }
@Test public void forInstanceProvider() { ResolvableType type = ResolvableType.forInstance(new MyGenericInterfaceType<>(String.class)); assertThat(type.getRawClass(), equalTo(MyGenericInterfaceType.class)); assertThat(type.getGeneric().resolve(), equalTo(String.class)); }
@Test public void forClass() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class); assertThat(type.getType(), equalTo((Type) ExtendsList.class)); assertThat(type.getRawClass(), equalTo(ExtendsList.class)); assertTrue(type.isAssignableFrom(ExtendsList.class)); assertFalse(type.isAssignableFrom(ArrayList.class)); }
@Test public void forClassWithNull() throws Exception { ResolvableType type = ResolvableType.forClass(null); assertThat(type.getType(), equalTo((Type) Object.class)); assertThat(type.getRawClass(), equalTo(Object.class)); assertTrue(type.isAssignableFrom(Object.class)); assertTrue(type.isAssignableFrom(String.class)); }
@Test public void forRawClass() throws Exception { ResolvableType type = ResolvableType.forRawClass(ExtendsList.class); assertThat(type.getType(), equalTo((Type) ExtendsList.class)); assertThat(type.getRawClass(), equalTo(ExtendsList.class)); assertTrue(type.isAssignableFrom(ExtendsList.class)); assertFalse(type.isAssignableFrom(ArrayList.class)); }
@Test public void forRawClassWithNull() throws Exception { ResolvableType type = ResolvableType.forRawClass(null); assertThat(type.getType(), equalTo((Type) Object.class)); assertThat(type.getRawClass(), equalTo(Object.class)); assertTrue(type.isAssignableFrom(Object.class)); assertTrue(type.isAssignableFrom(String.class)); }
Class<?> rawClass = resolvedType.getRawClass(); if (rawClass != null) { return ResolvableType.forClassWithGenerics(rawClass, generics).getType();
Class<?> rawClass = resolvedType.getRawClass(); if (rawClass != null) { return ResolvableType.forClassWithGenerics(rawClass, generics).getType();
private static Class<?> getRawType(ResolvableType type) { Class<?> rawType = type.getRawClass(); return rawType == null ? Object.class : rawType; } }
private static Class<?> getRawType(ResolvableType type) { Class<?> rawType = type.getRawClass(); return rawType == null ? Object.class : rawType; } }
private static Class<?> getRawType(ResolvableType type) { Class<?> rawType = type.getRawClass(); return rawType == null ? Object.class : rawType; }
private static Type getType(Type type, Class<?> contextClass) { if (contextClass != null) { ResolvableType resolvedType = ResolvableType.forType(type); if (type instanceof TypeVariable) { ResolvableType resolvedTypeVariable = resolveVariable((TypeVariable) type, ResolvableType.forClass(contextClass)); if (resolvedTypeVariable != ResolvableType.NONE) { return resolvedTypeVariable.resolve(); } } else if (type instanceof ParameterizedType && resolvedType.hasUnresolvableGenerics()) { ParameterizedType parameterizedType = (ParameterizedType) type; Class<?>[] generics = new Class[parameterizedType.getActualTypeArguments().length]; Type[] typeArguments = parameterizedType.getActualTypeArguments(); for (int i = 0; i < typeArguments.length; ++i) { Type typeArgument = typeArguments[i]; if (typeArgument instanceof TypeVariable) { ResolvableType resolvedTypeArgument = resolveVariable((TypeVariable) typeArgument, ResolvableType.forClass(contextClass)); if (resolvedTypeArgument != ResolvableType.NONE) { generics[i] = resolvedTypeArgument.resolve(); } else { generics[i] = ResolvableType.forType(typeArgument).resolve(); } } else { generics[i] = ResolvableType.forType(typeArgument).resolve(); } } return ResolvableType.forClassWithGenerics(resolvedType.getRawClass(), generics).getType(); } } return type; }
@Override public boolean supportsEventType(ResolvableType eventType) { Class<?> type = eventType.getRawClass(); if (type == null) { return false; } return ContextRefreshedEvent.class.isAssignableFrom(type) || ClassPathChangedEvent.class.isAssignableFrom(type); }
private static ResolvableType getInterfaceBaseImplementingClass(Map<String, java.lang.reflect.Type> genericTypes, ResolvableType searchClass, Class<?> implementedInterface) { while (!Object.class.equals(searchClass.getRawClass()) && searchClass.getSuperType() != NONE && implementedInterface.isAssignableFrom(searchClass.getSuperType().getRawClass())) { searchClass = searchClass.getSuperType(); addGenericsToMap(genericTypes, searchClass); } return implementedInterface.isAssignableFrom(searchClass.getRawClass()) ? searchClass : null; }
public static List<String> findPropertyNames(ResolvableType resolvableType) { if (resolvableType.getRawClass().equals(Resource.class)) { return findPropertyNames(resolvableType.resolveGeneric(0)); } else { return findPropertyNames(resolvableType.getRawClass()); } }