Examples with ResolvableType org.springframework.core.ResolvableType used on opensource projects

Example 86 with ResolvableType

use of org.springframework.core.ResolvableType in project spring-framework by spring-projects.

the class MessageReaderArgumentResolverTests method monoList.

@Test
public void monoList() throws Exception {
    String body = "[{\"bar\":\"b1\",\"foo\":\"f1\"},{\"bar\":\"b2\",\"foo\":\"f2\"}]";
    ResolvableType type = forClassWithGenerics(Mono.class, forClassWithGenerics(List.class, TestBean.class));
    MethodParameter param = this.testMethod.arg(type);
    Mono<?> mono = resolveValue(param, body);
    List<?> list = (List<?>) mono.block(Duration.ofSeconds(5));
    assertEquals(Arrays.asList(new TestBean("f1", "b1"), new TestBean("f2", "b2")), list);
}

Example 87 with ResolvableType

use of org.springframework.core.ResolvableType in project spring-framework by spring-projects.

the class AbstractMessageConverterMethodArgumentResolver method readWithMessageConverters.

/**
	 * Create the method argument value of the expected parameter type by reading
	 * from the given HttpInputMessage.
	 * @param <T> the expected type of the argument value to be created
	 * @param inputMessage the HTTP input message representing the current request
	 * @param parameter the method parameter descriptor (may be {@code null})
	 * @param targetType the target type, not necessarily the same as the method
	 * parameter type, e.g. for {@code HttpEntity<String>}.
	 * @return the created method argument value
	 * @throws IOException if the reading from the request fails
	 * @throws HttpMediaTypeNotSupportedException if no suitable message converter is found
	 */
@SuppressWarnings("unchecked")
protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
    MediaType contentType;
    boolean noContentType = false;
    try {
        contentType = inputMessage.getHeaders().getContentType();
    } catch (InvalidMediaTypeException ex) {
        throw new HttpMediaTypeNotSupportedException(ex.getMessage());
    }
    if (contentType == null) {
        noContentType = true;
        contentType = MediaType.APPLICATION_OCTET_STREAM;
    }
    Class<?> contextClass = (parameter != null ? parameter.getContainingClass() : null);
    Class<T> targetClass = (targetType instanceof Class ? (Class<T>) targetType : null);
    if (targetClass == null) {
        ResolvableType resolvableType = (parameter != null ? ResolvableType.forMethodParameter(parameter) : ResolvableType.forType(targetType));
        targetClass = (Class<T>) resolvableType.resolve();
    }
    HttpMethod httpMethod = ((HttpRequest) inputMessage).getMethod();
    Object body = NO_VALUE;
    try {
        inputMessage = new EmptyBodyCheckingHttpInputMessage(inputMessage);
        for (HttpMessageConverter<?> converter : this.messageConverters) {
            Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
            if (converter instanceof GenericHttpMessageConverter) {
                GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter<?>) converter;
                if (genericConverter.canRead(targetType, contextClass, contentType)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
                    }
                    if (inputMessage.getBody() != null) {
                        inputMessage = getAdvice().beforeBodyRead(inputMessage, parameter, targetType, converterType);
                        body = genericConverter.read(targetType, contextClass, inputMessage);
                        body = getAdvice().afterBodyRead(body, inputMessage, parameter, targetType, converterType);
                    } else {
                        body = getAdvice().handleEmptyBody(null, inputMessage, parameter, targetType, converterType);
                    }
                    break;
                }
            } else if (targetClass != null) {
                if (converter.canRead(targetClass, contentType)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
                    }
                    if (inputMessage.getBody() != null) {
                        inputMessage = getAdvice().beforeBodyRead(inputMessage, parameter, targetType, converterType);
                        body = ((HttpMessageConverter<T>) converter).read(targetClass, inputMessage);
                        body = getAdvice().afterBodyRead(body, inputMessage, parameter, targetType, converterType);
                    } else {
                        body = getAdvice().handleEmptyBody(null, inputMessage, parameter, targetType, converterType);
                    }
                    break;
                }
            }
        }
    } catch (IOException ex) {
        throw new HttpMessageNotReadableException("Could not read document: " + ex.getMessage(), ex);
    }
    if (body == NO_VALUE) {
        if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod) || (noContentType && inputMessage.getBody() == null)) {
            return null;
        }
        throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);
    }
    return body;
}

Example 88 with ResolvableType

use of org.springframework.core.ResolvableType in project spring-boot by spring-projects.

the class AbstractJsonMarshalTesterTests method writeArrayShouldReturnJsonContent.

@Test
public void writeArrayShouldReturnJsonContent() throws Exception {
    ResolvableType type = ResolvableTypes.get("arrayOfExampleObject");
    ExampleObject[] value = new ExampleObject[] { OBJECT };
    JsonContent<Object> content = createTester(type).write(value);
    assertThat(content).isEqualToJson(ARRAY_JSON);
}

Example 89 with ResolvableType

use of org.springframework.core.ResolvableType in project spring-boot by spring-projects.

the class DefinitionsParser method parseSpyBeanAnnotation.

private void parseSpyBeanAnnotation(SpyBean annotation, AnnotatedElement element) {
    Set<ResolvableType> typesToSpy = getOrDeduceTypes(element, annotation.value());
    Assert.state(!typesToSpy.isEmpty(), "Unable to deduce type to spy from " + element);
    if (StringUtils.hasLength(annotation.name())) {
        Assert.state(typesToSpy.size() == 1, "The name attribute can only be used when spying a single class");
    }
    for (ResolvableType typeToSpy : typesToSpy) {
        SpyDefinition definition = new SpyDefinition(annotation.name(), typeToSpy, annotation.reset(), annotation.proxyTargetAware(), QualifierDefinition.forElement(element));
        addDefinition(element, definition, "spy");
    }
}

Example 90 with ResolvableType

use of org.springframework.core.ResolvableType in project spring-boot by spring-projects.

the class AbstractJsonMarshalTesterTests method parseListShouldReturnContent.

@Test
public void parseListShouldReturnContent() throws Exception {
    ResolvableType type = ResolvableTypes.get("listOfExampleObject");
    AbstractJsonMarshalTester<Object> tester = createTester(type);
    assertThat(tester.parse(ARRAY_JSON)).asList().containsOnly(OBJECT);
}