/** * The property type: e.g. {@code java.lang.String} */ public Class<?> getType() { return this.methodParameter.getParameterType(); }
@Override public boolean supportsParameter(MethodParameter parameter) { Class<?> paramType = parameter.getParameterType(); return Principal.class.isAssignableFrom(paramType); }
@Override public boolean supportsParameter(MethodParameter parameter) { Class<?> paramType = parameter.getParameterType(); return Errors.class.isAssignableFrom(paramType); }
@Override public boolean supportsReturnType(MethodParameter returnType) { return (HttpEntity.class.isAssignableFrom(returnType.getParameterType()) && !RequestEntity.class.isAssignableFrom(returnType.getParameterType())); }
@Override public boolean supportsReturnType(MethodParameter returnType) { Class<?> paramType = returnType.getParameterType(); return (void.class == paramType || CharSequence.class.isAssignableFrom(paramType)); }
/** * Return the type of the value to be written to the response. Typically this is * a simple check via getClass on the value but if the value is null, then the * return type needs to be examined possibly including generic type determination * (e.g. {@code ResponseEntity<T>}). */ protected Class<?> getReturnValueType(@Nullable Object value, MethodParameter returnType) { return (value != null ? value.getClass() : returnType.getParameterType()); }
@Nullable protected static Object findProvidedArgument(MethodParameter parameter, @Nullable Object... providedArgs) { if (!ObjectUtils.isEmpty(providedArgs)) { for (Object providedArg : providedArgs) { if (parameter.getParameterType().isInstance(providedArg)) { return providedArg; } } } return null; }
@Nullable protected static Object findProvidedArgument(MethodParameter parameter, @Nullable Object... providedArgs) { if (!ObjectUtils.isEmpty(providedArgs)) { for (Object providedArg : providedArgs) { if (parameter.getParameterType().isInstance(providedArg)) { return providedArg; } } } return null; }
/** * Return {@code true} if the method return type is void, {@code false} otherwise. */ public boolean isVoid() { return Void.TYPE.equals(getReturnType().getParameterType()); }
@Override protected void handleMissingValue(String headerName, MethodParameter parameter, Message<?> message) { throw new MessageHandlingException(message, "Missing header '" + headerName + "' for method parameter type [" + parameter.getParameterType() + "]"); }
@Override public boolean supportsParameter(MethodParameter parameter) { return (parameter.hasParameterAnnotation(RequestHeader.class) && Map.class.isAssignableFrom(parameter.getParameterType())); }
@Override public ListenableFuture<?> toListenableFuture(Object returnValue, MethodParameter returnType) { ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnType.getParameterType(), returnValue); Assert.state(adapter != null, () -> "No ReactiveAdapter found for " + returnType.getParameterType()); return new MonoToListenableFutureAdapter<>(Mono.from(adapter.toPublisher(returnValue))); }
/** * Returns {@code true} if the parameter is annotated with * {@link ModelAttribute} or, if in default resolution mode, for any * method parameter that is not a simple type. */ @Override public boolean supportsParameter(MethodParameter parameter) { return (parameter.hasParameterAnnotation(ModelAttribute.class) || (this.annotationNotRequired && !BeanUtils.isSimpleProperty(parameter.getParameterType()))); }
@Override public Object resolveArgument(MethodParameter methodParameter, NativeWebRequest webRequest) { if (methodParameter.getParameterType().equals(MySpecialArg.class)) { return new MySpecialArg("myValue"); } return UNRESOLVED; } }
@Override public Mono<Object> resolveArgument( MethodParameter parameter, BindingContext context, ServerWebExchange exchange) { Mono<Principal> principal = exchange.getPrincipal(); ReactiveAdapter adapter = getAdapterRegistry().getAdapter(parameter.getParameterType()); return (adapter != null ? Mono.just(adapter.fromPublisher(principal)) : Mono.from(principal)); }
@Override public Mono<Object> resolveArgument( MethodParameter parameter, BindingContext bindingContext, ServerWebExchange exchange) { Class<?> entityType = parameter.getParameterType(); return readBody(parameter.nested(), parameter, false, bindingContext, exchange) .map(body -> createEntity(body, entityType, exchange.getRequest())) .defaultIfEmpty(createEntity(null, entityType, exchange.getRequest())); }
@SuppressWarnings("unchecked") private <T> T resolveValueWithEmptyBody(MethodParameter param) { ServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.post("/path")); Mono<Object> result = this.resolver.resolveArgument(param, new BindingContext(), exchange); Object value = result.block(Duration.ofSeconds(5)); if (value != null) { assertTrue("Unexpected parameter type: " + value, param.getParameterType().isAssignableFrom(value.getClass())); } //no inspection unchecked return (T) value; }
@SuppressWarnings("unchecked") private <T> T resolveArgument(MethodParameter param, MultipartBodyBuilder builder) { ServerWebExchange exchange = createExchange(builder); Mono<Object> result = this.resolver.resolveArgument(param, new BindingContext(), exchange); Object value = result.block(Duration.ofSeconds(5)); assertNotNull(value); assertTrue(param.getParameterType().isAssignableFrom(value.getClass())); return (T) value; }
@SuppressWarnings("unchecked") private <T> T resolveValue(MethodParameter param, String body) { ServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.post("/path").body(body)); Mono<Object> result = this.resolver.readBody(param, true, new BindingContext(), exchange); Object value = result.block(Duration.ofSeconds(5)); assertNotNull(value); assertTrue("Unexpected return value type: " + value, param.getParameterType().isAssignableFrom(value.getClass())); //no inspection unchecked return (T) value; }
private void wrapConcurrentResult_ResponseBody(Object handler, Object result, Class<?> expectedReturnType) throws Exception { this.returnValueHandlers.addHandler(new ModelAndViewMethodReturnValueHandler()); this.returnValueHandlers.addHandler(new RequestResponseBodyMethodProcessor(this.converters)); ServletInvocableHandlerMethod handlerMethod = getHandlerMethod(handler, "handle"); handlerMethod = handlerMethod.wrapConcurrentResult(result); handlerMethod.invokeAndHandle(this.webRequest, this.mavContainer); assertEquals((result != null ? result.toString() : ""), this.response.getContentAsString()); assertEquals(expectedReturnType, handlerMethod.getReturnValueType(result).getParameterType()); }