@Nullable private static Class<?> getSingleGeneric(ResolvableType resolvableType) { Assert.isTrue(resolvableType.getGenerics().length == 1, () -> "Expected 1 type argument on generic interface [" + resolvableType + "] but found " + resolvableType.getGenerics().length); return resolvableType.getGeneric().resolve(); }
@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); }
public ConcurrentResultMethodParameter(Object returnValue) { super(-1); this.returnValue = returnValue; this.returnType = (returnValue instanceof ReactiveTypeHandler.CollectedValuesList ? ((ReactiveTypeHandler.CollectedValuesList) returnValue).getReturnType() : ResolvableType.forType(super.getGenericParameterType()).getGeneric()); }
@Test public void getGenericOutOfBounds() throws Exception { ResolvableType type = ResolvableType.forClass(List.class, ExtendsList.class); assertThat(type.getGeneric(0), not(equalTo(ResolvableType.NONE))); assertThat(type.getGeneric(1), equalTo(ResolvableType.NONE)); assertThat(type.getGeneric(0, 1), equalTo(ResolvableType.NONE)); }
private Class<?> getPayloadType(MethodParameter parameter) { Type genericParamType = parameter.getGenericParameterType(); ResolvableType resolvableType = ResolvableType.forType(genericParamType).as(Message.class); return resolvableType.getGeneric().toClass(); }
@Override public Flux<Object> read( ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints) { boolean shouldWrap = isServerSentEvent(elementType); ResolvableType valueType = (shouldWrap ? elementType.getGeneric() : elementType); return stringDecoder.decode(message.getBody(), STRING_TYPE, null, hints) .bufferUntil(line -> line.equals("")) .concatMap(lines -> buildEvent(lines, valueType, shouldWrap, hints)); }
@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)); }
@Test public void getGenericByIndex() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("stringIntegerMultiValueMap")); assertThat(type.getGeneric(0).getType(), equalTo((Type) String.class)); assertThat(type.getGeneric(1).getType(), equalTo((Type) Integer.class)); }
@Test public void getGenericOfGenericByIndexes() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("stringListList")); assertThat(type.getGeneric(0, 0).getType(), equalTo((Type) String.class)); }
@Test public void resolveWildcardLowerBounds() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("wildcardSuperType")); assertThat(type.getGeneric().resolve(), equalTo((Class) Number.class)); }
@Test public void resolveWildcardTypeUpperBounds() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("wildcardType")); assertThat(type.getGeneric().resolve(), equalTo((Class) Number.class)); }
@Test public void wildcardType() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("wildcardType")); assertThat(type.getType(), instanceOf(ParameterizedType.class)); assertThat(type.getGeneric().getType(), instanceOf(WildcardType.class)); }
@Test public void resolveVariableFromFieldTypeUnknown() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("parameterizedType")); assertThat(type.resolve(), equalTo((Class) List.class)); assertThat(type.getGeneric().resolve(), nullValue()); }
@Test public void resolveFromClassWithGenerics() throws Exception { ResolvableType type = ResolvableType.forClassWithGenerics(List.class, ResolvableType.forClassWithGenerics(List.class, String.class)); assertThat(type.asCollection().toString(), equalTo("java.util.Collection<java.util.List<java.lang.String>>")); assertThat(type.asCollection().getGeneric().toString(), equalTo("java.util.List<java.lang.String>")); assertThat(type.asCollection().getGeneric().asCollection().toString(), equalTo("java.util.Collection<java.lang.String>")); assertThat(type.toString(), equalTo("java.util.List<java.util.List<java.lang.String>>")); assertThat(type.asCollection().getGeneric().getGeneric().resolve(), equalTo((Type) String.class)); }
@Test public void resolveGenericArrayFromGeneric() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("stringArrayList")); ResolvableType generic = type.asCollection().getGeneric(); assertThat(generic.getType().toString(), equalTo("E")); assertThat(generic.isArray(), equalTo(true)); assertThat(generic.resolve(), equalTo((Class) String[].class)); }
@Test public void genericOfGenericWithAs() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("stringListList")).asCollection(); assertThat(type.toString(), equalTo("java.util.Collection<java.util.List<java.lang.String>>")); assertThat(type.getGeneric().asCollection().toString(), equalTo("java.util.Collection<java.lang.String>")); }
@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 resolveGenericArrayType() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("genericArrayType")); assertThat(type.resolve(), equalTo((Class) List[].class)); assertThat(type.getComponentType().resolve(), equalTo((Class) List.class)); assertThat(type.getComponentType().getGeneric().resolve(), equalTo((Class) String.class)); }
@Test public void getComponentTypeForVariableThatResolvesToGenericArray() throws Exception { ResolvableType type = ResolvableType.forClass(ListOfGenericArray.class).asCollection().getGeneric(); assertThat(type.isArray(), equalTo(true)); assertThat(type.getType(), instanceOf(TypeVariable.class)); assertThat(type.getComponentType().getType().toString(), equalTo("java.util.List<java.lang.String>")); }
@Test public void serialize() throws Exception { testSerialization(ResolvableType.forClass(List.class)); testSerialization(ResolvableType.forField(Fields.class.getField("charSequenceList"))); testSerialization(ResolvableType.forMethodParameter(Methods.class.getMethod("charSequenceParameter", List.class), 0)); testSerialization(ResolvableType.forMethodReturnType(Methods.class.getMethod("charSequenceReturn"))); testSerialization(ResolvableType.forConstructorParameter(Constructors.class.getConstructor(List.class), 0)); testSerialization(ResolvableType.forField(Fields.class.getField("charSequenceList")).getGeneric()); ResolvableType deserializedNone = testSerialization(ResolvableType.NONE); assertThat(deserializedNone, sameInstance(ResolvableType.NONE)); }