/** * Convenience method to return this type as a resolvable {@link Collection} type. * Returns {@link #NONE} if this type does not implement or extend * {@link Collection}. * @see #as(Class) * @see #asMap() */ public ResolvableType asCollection() { return as(Collection.class); }
/** * Resolve the top-level parameter type of the given {@code MethodParameter}. * @param methodParameter the method parameter to resolve * @since 4.1.9 * @see MethodParameter#setParameterType */ static void resolveMethodParameter(MethodParameter methodParameter) { Assert.notNull(methodParameter, "MethodParameter must not be null"); ResolvableType owner = forType(methodParameter.getContainingClass()).as(methodParameter.getDeclaringClass()); methodParameter.setParameterType( forType(null, new MethodParameterTypeProvider(methodParameter), owner.asVariableResolver()).resolve()); }
/** * Convenience method to return this type as a resolvable {@link Map} type. * Returns {@link #NONE} if this type does not implement or extend * {@link Map}. * @see #as(Class) * @see #asCollection() */ public ResolvableType asMap() { return as(Map.class); }
@Test public void resolveTypeVariableFromTypeWithVariableResolver() throws Exception { Type sourceType = Methods.class.getMethod("typedReturn").getGenericReturnType(); ResolvableType type = ResolvableType.forType( sourceType, ResolvableType.forClass(TypedMethods.class).as(Methods.class).asVariableResolver()); assertThat(type.resolve(), equalTo((Class) String.class)); assertThat(type.getType().toString(), equalTo("T")); }
@Nullable static ResolvableType resolveDeclaredEventType(Class<?> listenerType) { ResolvableType eventType = eventTypeCache.get(listenerType); if (eventType == null) { eventType = ResolvableType.forClass(listenerType).as(ApplicationListener.class).getGeneric(); eventTypeCache.put(listenerType, eventType); } return (eventType != ResolvableType.NONE ? eventType : null); }
@Nullable private ResolvableType[] getRequiredTypeInfo(Class<?> converterClass, Class<?> genericIfc) { ResolvableType resolvableType = ResolvableType.forClass(converterClass).as(genericIfc); ResolvableType[] generics = resolvableType.getGenerics(); if (generics.length < 2) { return null; } Class<?> sourceType = generics[0].resolve(); Class<?> targetType = generics[1].resolve(); if (sourceType == null || targetType == null) { return null; } return generics; }
private Class<?> getPayloadType(MethodParameter parameter) { Type genericParamType = parameter.getGenericParameterType(); ResolvableType resolvableType = ResolvableType.forType(genericParamType).as(Message.class); return resolvableType.getGeneric().toClass(); }
@Test public void asSelf() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class); assertThat(type.as(ExtendsList.class), equalTo(type)); }
@Test public void doesResolveFromOuterOwner() throws Exception { ResolvableType type = ResolvableType.forField( Fields.class.getField("listOfListOfUnknown")).as(Collection.class); assertThat(type.getGeneric(0).resolve(), equalTo((Class) List.class)); assertThat(type.getGeneric(0).as(Collection.class).getGeneric(0).as(Collection.class).resolve(), nullValue()); }
@Test public void asFromInterface() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class).as(List.class); assertThat(type.getType().toString(), equalTo("java.util.List<E>")); }
@Test public void asFromInheritedInterface() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class).as(Collection.class); assertThat(type.getType().toString(), equalTo("java.util.Collection<E>")); }
@Test public void asFromSuperType() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class).as(ArrayList.class); assertThat(type.getType().toString(), equalTo("java.util.ArrayList<java.lang.CharSequence>")); }
@Test public void asFromInheritedSuperType() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class).as(List.class); assertThat(type.getType().toString(), equalTo("java.util.List<E>")); }
@Test public void resolveTypeVaraibleFromSimpleInterfaceType() { ResolvableType type = ResolvableType.forClass( MySimpleInterfaceType.class).as(MyInterfaceType.class); assertThat(type.resolveGeneric(), equalTo((Class) String.class)); }
@Test public void resolveTypeVaraibleFromSimpleSuperclassType() { ResolvableType type = ResolvableType.forClass( MySimpleSuperclassType.class).as(MySuperclassType.class); assertThat(type.resolveGeneric(), equalTo((Class) String.class)); }
@Test public void resolveTypeVaraibleFromSimpleCollectionInterfaceType() { ResolvableType type = ResolvableType.forClass( MyCollectionInterfaceType.class).as(MyInterfaceType.class); assertThat(type.resolveGeneric(), equalTo((Class) Collection.class)); assertThat(type.resolveGeneric(0, 0), equalTo((Class) String.class)); }
@Test public void resolveTypeVaraibleFromSimpleCollectionSuperclassType() { ResolvableType type = ResolvableType.forClass( MyCollectionSuperclassType.class).as(MySuperclassType.class); assertThat(type.resolveGeneric(), equalTo((Class) Collection.class)); assertThat(type.resolveGeneric(0, 0), equalTo((Class) String.class)); }
@Test public void asNotFound() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class).as(Map.class); assertThat(type, sameInstance(ResolvableType.NONE)); }
@Test public void resolveVariableFromInheritedFieldSwitched() throws Exception { ResolvableType type = ResolvableType.forField( Fields.class.getField("stringIntegerMultiValueMapSwitched")).as(Map.class); assertThat(type.getGeneric(0).resolve(), equalTo((Class) String.class)); assertThat(type.getGeneric(1).resolve(), equalTo((Class) List.class)); assertThat(type.getGeneric(1, 0).resolve(), equalTo((Class) Integer.class)); }
@Test public void resolveVariableFromInheritedField() throws Exception { ResolvableType type = ResolvableType.forField( Fields.class.getField("stringIntegerMultiValueMap")).as(Map.class); assertThat(type.getGeneric(0).resolve(), equalTo((Class) String.class)); assertThat(type.getGeneric(1).resolve(), equalTo((Class) List.class)); assertThat(type.getGeneric(1, 0).resolve(), equalTo((Class) Integer.class)); }