private Mono<?> decodeData(String data, ResolvableType dataType, Map<String, Object> hints) { if (String.class == dataType.resolve()) { return Mono.just(data.substring(0, data.length() - 1)); } if (this.decoder == null) { return Mono.error(new CodecException("No SSE decoder configured and the data is not String.")); } byte[] bytes = data.getBytes(StandardCharsets.UTF_8); Mono<DataBuffer> input = Mono.just(bufferFactory.wrap(bytes)); return this.decoder.decodeToMono(input, dataType, MediaType.TEXT_EVENT_STREAM, hints); }
@Test public void resolveTypeVariableFromSuperType() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class); assertThat(type.resolve(), equalTo((Class) ExtendsList.class)); assertThat(type.asCollection().resolveGeneric(), equalTo((Class) CharSequence.class)); }
@Override @SuppressWarnings("unchecked") public boolean supportsEventType(ResolvableType eventType) { if (this.delegate instanceof SmartApplicationListener) { Class<? extends ApplicationEvent> eventClass = (Class<? extends ApplicationEvent>) eventType.resolve(); return (eventClass != null && ((SmartApplicationListener) this.delegate).supportsEventType(eventClass)); } else { return (this.declaredEventType == null || this.declaredEventType.isAssignableFrom(eventType)); } }
@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(); }
@Override public boolean canEncode(ResolvableType elementType, @Nullable MimeType mimeType) { Class<?> clazz = elementType.toClass(); return supportsMimeType(mimeType) && (Object.class == clazz || (!String.class.isAssignableFrom(elementType.resolve(clazz)) && getObjectMapper().canSerialize(clazz))); }
@Test public void resolveGenericMultiArrayType() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("genericMultiArrayType")); assertThat(type.resolve(), equalTo((Class) List[][][].class)); assertThat(type.getComponentType().resolve(), equalTo((Class) List[][].class)); }
@Test public void resolveTypeVaraibleFromMethodReturnWithInstanceClass() throws Exception { ResolvableType type = ResolvableType.forMethodReturnType( Methods.class.getMethod("typedReturn"), TypedMethods.class); assertThat(type.resolve(), equalTo((Class) String.class)); }
@Test public void getSuperType() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class).getSuperType(); assertThat(type.resolve(), equalTo((Class) ArrayList.class)); type = type.getSuperType(); assertThat(type.resolve(), equalTo((Class) AbstractList.class)); type = type.getSuperType(); assertThat(type.resolve(), equalTo((Class) AbstractCollection.class)); type = type.getSuperType(); assertThat(type.resolve(), equalTo((Class) Object.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 resolveBoundedTypeVariableResult() throws Exception { ResolvableType type = ResolvableType.forMethodReturnType(Methods.class.getMethod("boundedTypeVaraibleResult")); assertThat(type.resolve(), equalTo((Class) CharSequence.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)); }
@Test public void canResolveVoid() throws Exception { ResolvableType type = ResolvableType.forClass(void.class); assertThat(type.resolve(), equalTo(void.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 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")); }
@Test public void hasUnresolvableGenericsWhenImplementesRawInterface() throws Exception { ResolvableType type = ResolvableType.forClass(MySimpleInterfaceTypeWithImplementsRaw.class); for (ResolvableType generic : type.getGenerics()) { assertThat(generic.resolve(), not(nullValue())); } assertThat(type.hasUnresolvableGenerics(), equalTo(true)); }
@Test public void forArrayComponent() throws Exception { ResolvableType elementType = ResolvableType.forField(Fields.class.getField("stringList")); ResolvableType type = ResolvableType.forArrayComponent(elementType); assertThat(type.toString(), equalTo("java.util.List<java.lang.String>[]")); assertThat(type.resolve(), equalTo(List[].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 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 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)); }