Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove use of Optional in SyncHandlerMethodArgumentResolver

Browse Source 
... and a couple more protected methods in WebFlux

Issue: SPR-15718
This commit is contained in:
Rossen Stoyanchev
2017-06-29 17:01:28 -04:00
parent 7de6cfa1df
commit 8f4eb23540
12 changed files with 66 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
spring-web/src/main/java/org/springframework/http/codec/json/Jackson2CodecSupport.java
View File

@@ -23,7 +23,6 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import com.fasterxml.jackson.annotation.JsonView;
import com.fasterxml.jackson.databind.JavaType;
@@ -91,19 +90,21 @@ public abstract class Jackson2CodecSupport {
}
protected Map<String, Object> getHints(ResolvableType resolvableType) {
return getParameter(resolvableType)
.flatMap(parameter -> Optional.ofNullable(getAnnotation(parameter, JsonView.class))
.map(annotation -> {
Class<?>[] classes = annotation.value();
Assert.isTrue(classes.length == 1, JSON_VIEW_HINT_ERROR + parameter);
return Collections.<String, Object>singletonMap(JSON_VIEW_HINT, classes[0]);
}))
.orElse(Collections.emptyMap());
MethodParameter param = getParameter(resolvableType);
if (param != null) {
JsonView annotation = getAnnotation(param, JsonView.class);
if (annotation != null) {
Class<?>[] classes = annotation.value();
Assert.isTrue(classes.length == 1, JSON_VIEW_HINT_ERROR + param);
return Collections.singletonMap(JSON_VIEW_HINT, classes[0]);
}
}
return Collections.emptyMap();
}
protected Optional<MethodParameter> getParameter(ResolvableType type) {
return Optional.ofNullable(type.getSource() instanceof MethodParameter ?
(MethodParameter) type.getSource() : null);
@Nullable
protected MethodParameter getParameter(ResolvableType type) {
return type.getSource() instanceof MethodParameter ? (MethodParameter) type.getSource() : null;
}
@Nullable

3
spring-web/src/main/java/org/springframework/http/codec/json/Jackson2JsonDecoder.java
View File

@@ -109,7 +109,8 @@ public class Jackson2JsonDecoder extends Jackson2CodecSupport implements HttpMes
Assert.notNull(tokens, "'tokens' must not be null");
Assert.notNull(elementType, "'elementType' must not be null");
Class<?> contextClass = getParameter(elementType).map(MethodParameter::getContainingClass).orElse(null);
MethodParameter param = getParameter(elementType);
Class<?> contextClass = (param != null ? param.getContainingClass() : null);
JavaType javaType = getJavaType(elementType.getType(), contextClass);
Class<?> jsonView = (hints != null ? (Class<?>) hints.get(Jackson2CodecSupport.JSON_VIEW_HINT) : null);

8
spring-webflux/src/main/java/org/springframework/web/reactive/result/method/SyncHandlerMethodArgumentResolver.java
View File

@@ -21,6 +21,7 @@ import java.util.Optional;
import reactor.core.publisher.Mono;
import org.springframework.core.MethodParameter;
import org.springframework.lang.Nullable;
import org.springframework.web.reactive.BindingContext;
import org.springframework.web.server.ServerWebExchange;
@@ -50,9 +51,10 @@ public interface SyncHandlerMethodArgumentResolver extends HandlerMethodArgument
* @param parameter the method parameter
* @param bindingContext the binding context to use
* @param exchange the current exchange
* @return an {@code Optional} with the resolved value, possibly empty
* @return the resolved value, if any
*/
Optional<Object> resolveArgumentValue(
MethodParameter parameter, BindingContext bindingContext, ServerWebExchange exchange);
@Nullable
Object resolveArgumentValue(MethodParameter parameter, BindingContext bindingContext,
ServerWebExchange exchange);
}

10
spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractNamedValueSyncArgumentResolver.java
View File

@@ -16,8 +16,6 @@
package org.springframework.web.reactive.result.method.annotation;
import java.util.Optional;
import reactor.core.publisher.Mono;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
@@ -64,13 +62,11 @@ public abstract class AbstractNamedValueSyncArgumentResolver extends AbstractNam
}
@Override
public Optional<Object> resolveArgumentValue(
MethodParameter parameter, BindingContext context, ServerWebExchange exchange) {
public Object resolveArgumentValue(MethodParameter parameter, BindingContext context,
ServerWebExchange exchange) {
// This won't block since resolveName below doesn't
Object value = resolveArgument(parameter, context, exchange).block();
return Optional.ofNullable(value);
return resolveArgument(parameter, context, exchange).block();
}
@Override

11
spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/ControllerMethodResolver.java
View File

@@ -21,7 +21,6 @@ import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
@@ -53,7 +52,7 @@ import org.springframework.web.reactive.result.method.InvocableHandlerMethod;
import org.springframework.web.reactive.result.method.SyncHandlerMethodArgumentResolver;
import org.springframework.web.reactive.result.method.SyncInvocableHandlerMethod;
import static org.springframework.core.MethodIntrospector.*;
import static org.springframework.core.MethodIntrospector.selectMethods;
/**
* Package-private class to assist {@link RequestMappingHandlerAdapter} with
@@ -284,8 +283,8 @@ class ControllerMethodResolver {
* Find an {@code @ExceptionHandler} method in {@code @ControllerAdvice}
* components or in the controller of the given {@code @RequestMapping} method.
*/
public Optional<InvocableHandlerMethod> getExceptionHandlerMethod(Throwable ex,
HandlerMethod handlerMethod) {
@Nullable
public InvocableHandlerMethod getExceptionHandlerMethod(Throwable ex, HandlerMethod handlerMethod) {
Class<?> handlerType = handlerMethod.getBeanType();
@@ -309,12 +308,12 @@ class ControllerMethodResolver {
}
if (targetMethod == null) {
return Optional.empty();
return null;
}
InvocableHandlerMethod invocable = new InvocableHandlerMethod(targetBean, targetMethod);
invocable.setArgumentResolvers(this.exceptionHandlerResolvers);
return Optional.of(invocable);
return invocable;
}

8
spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/ModelArgumentResolver.java
View File

@@ -16,8 +16,6 @@
package org.springframework.web.reactive.result.method.annotation;
import java.util.Optional;
import org.springframework.core.MethodParameter;
import org.springframework.core.ReactiveAdapterRegistry;
import org.springframework.ui.Model;
@@ -47,11 +45,11 @@ public class ModelArgumentResolver extends HandlerMethodArgumentResolverSupport
}
@Override
public Optional<Object> resolveArgumentValue(MethodParameter methodParameter,
BindingContext context, ServerWebExchange exchange) {
public Object resolveArgumentValue(MethodParameter methodParameter, BindingContext context,
ServerWebExchange exchange) {
Assert.isAssignable(Model.class, methodParameter.getParameterType());
return Optional.of(context.getModel());
return context.getModel();
}
}

8
spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/PathVariableMapMethodArgumentResolver.java
View File

@@ -18,7 +18,6 @@ package org.springframework.web.reactive.result.method.annotation;
import java.util.Collections;
import java.util.Map;
import java.util.Optional;
import org.springframework.core.MethodParameter;
import org.springframework.core.ReactiveAdapterRegistry;
@@ -59,12 +58,11 @@ public class PathVariableMapMethodArgumentResolver extends HandlerMethodArgument
@Override
public Optional<Object> resolveArgumentValue(MethodParameter methodParameter,
BindingContext context, ServerWebExchange exchange) {
public Object resolveArgumentValue(MethodParameter methodParameter, BindingContext context,
ServerWebExchange exchange) {
String name = HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE;
Object value = exchange.getAttributeOrDefault(name, Collections.emptyMap());
return Optional.of(value);
return exchange.getAttributeOrDefault(name, Collections.emptyMap());
}
}

5
spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/RequestHeaderMapMethodArgumentResolver.java
View File

@@ -17,7 +17,6 @@
package org.springframework.web.reactive.result.method.annotation;
import java.util.Map;
import java.util.Optional;
import org.springframework.core.MethodParameter;
import org.springframework.core.ReactiveAdapterRegistry;
@@ -61,14 +60,14 @@ public class RequestHeaderMapMethodArgumentResolver extends HandlerMethodArgumen
@Override
public Optional<Object> resolveArgumentValue(MethodParameter methodParameter,
public Object resolveArgumentValue(MethodParameter methodParameter,
BindingContext context, ServerWebExchange exchange) {
Class<?> paramType = methodParameter.getParameterType();
boolean isMultiValueMap = MultiValueMap.class.isAssignableFrom(paramType);
HttpHeaders headers = exchange.getRequest().getHeaders();
return Optional.of(isMultiValueMap ? headers : headers.toSingleValueMap());
return isMultiValueMap ? headers : headers.toSingleValueMap();
}
}

35
spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/RequestMappingHandlerAdapter.java
View File

@@ -197,24 +197,23 @@ public class RequestMappingHandlerAdapter implements HandlerAdapter, Application
private Mono<HandlerResult> handleException(Throwable ex, HandlerMethod handlerMethod,
BindingContext bindingContext, ServerWebExchange exchange) {
return this.methodResolver.getExceptionHandlerMethod(ex, handlerMethod)
.map(invocable -> {
try {
if (logger.isDebugEnabled()) {
logger.debug("Invoking @ExceptionHandler method: " + invocable.getMethod());
}
bindingContext.getModel().asMap().clear();
Throwable cause = ex.getCause() != null ? ex.getCause() : ex;
return invocable.invoke(exchange, bindingContext, cause, handlerMethod);
}
catch (Throwable invocationEx) {
if (logger.isWarnEnabled()) {
logger.warn("Failed to invoke: " + invocable.getMethod(), invocationEx);
}
return null;
}
})
.orElseGet(() -> Mono.error(ex));
InvocableHandlerMethod invocable = this.methodResolver.getExceptionHandlerMethod(ex, handlerMethod);
if (invocable != null) {
try {
if (logger.isDebugEnabled()) {
logger.debug("Invoking @ExceptionHandler method: " + invocable.getMethod());
}
bindingContext.getModel().asMap().clear();
Throwable cause = ex.getCause() != null ? ex.getCause() : ex;
return invocable.invoke(exchange, bindingContext, cause, handlerMethod);
}
catch (Throwable invocationEx) {
if (logger.isWarnEnabled()) {
logger.warn("Failed to invoke: " + invocable.getMethod(), invocationEx);
}
}
}
return Mono.error(ex);
}
}

8
spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/RequestParamMapMethodArgumentResolver.java
View File

@@ -17,7 +17,6 @@
package org.springframework.web.reactive.result.method.annotation;
import java.util.Map;
import java.util.Optional;
import org.springframework.core.MethodParameter;
import org.springframework.core.ReactiveAdapterRegistry;
@@ -65,13 +64,12 @@ public class RequestParamMapMethodArgumentResolver extends HandlerMethodArgument
@Override
public Optional<Object> resolveArgumentValue(MethodParameter methodParameter,
BindingContext context, ServerWebExchange exchange) {
public Object resolveArgumentValue(MethodParameter methodParameter, BindingContext context,
ServerWebExchange exchange) {
boolean isMultiValueMap = MultiValueMap.class.isAssignableFrom(methodParameter.getParameterType());
MultiValueMap<String, String> queryParams = exchange.getRequest().getQueryParams();
Object value = isMultiValueMap ? queryParams : queryParams.toSingleValueMap();
return Optional.of(value);
return isMultiValueMap ? queryParams : queryParams.toSingleValueMap();
}
}

14
spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/ServerWebExchangeArgumentResolver.java
View File

@@ -16,8 +16,6 @@
package org.springframework.web.reactive.result.method.annotation;
import java.util.Optional;
import org.springframework.core.MethodParameter;
import org.springframework.core.ReactiveAdapterRegistry;
import org.springframework.http.HttpMethod;
@@ -63,21 +61,21 @@ public class ServerWebExchangeArgumentResolver extends HandlerMethodArgumentReso
}
@Override
public Optional<Object> resolveArgumentValue(MethodParameter methodParameter,
BindingContext context, ServerWebExchange exchange) {
public Object resolveArgumentValue(MethodParameter methodParameter, BindingContext context,
ServerWebExchange exchange) {
Class<?> paramType = methodParameter.getParameterType();
if (ServerWebExchange.class.isAssignableFrom(paramType)) {
return Optional.of(exchange);
return exchange;
}
else if (ServerHttpRequest.class.isAssignableFrom(paramType)) {
return Optional.of(exchange.getRequest());
return exchange.getRequest();
}
else if (ServerHttpResponse.class.isAssignableFrom(paramType)) {
return Optional.of(exchange.getResponse());
return exchange.getResponse();
}
else if (HttpMethod.class == paramType) {
return Optional.ofNullable(exchange.getRequest().getMethod());
return exchange.getRequest().getMethod();
}
else {
// should never happen...

9
spring-webflux/src/test/java/org/springframework/web/reactive/result/method/annotation/ControllerMethodResolverTests.java
View File

@@ -187,11 +187,11 @@ public class ControllerMethodResolverTests {
@Test
public void exceptionHandlerArgumentResolvers() throws Exception {
Optional<InvocableHandlerMethod> optional =
InvocableHandlerMethod invocable =
this.methodResolver.getExceptionHandlerMethod(
new ResponseStatusException(HttpStatus.BAD_REQUEST, "reason"), this.handlerMethod);
InvocableHandlerMethod invocable = optional.orElseThrow(() -> new AssertionError("No match"));
assertNotNull("No match", invocable);
assertEquals(TestController.class, invocable.getBeanType());
List<HandlerMethodArgumentResolver> resolvers = invocable.getResolvers();
@@ -221,11 +221,10 @@ public class ControllerMethodResolverTests {
@Test
public void exceptionHandlerFromControllerAdvice() throws Exception {
Optional<InvocableHandlerMethod> optional =
InvocableHandlerMethod invocable =
this.methodResolver.getExceptionHandlerMethod(
new IllegalStateException("reason"), this.handlerMethod);
InvocableHandlerMethod invocable = optional.orElseThrow(() -> new AssertionError("No match"));
assertNotNull(invocable);
assertEquals(TestControllerAdvice.class, invocable.getBeanType());
}
@@ -286,7 +285,7 @@ public class ControllerMethodResolverTests {
implements SyncHandlerMethodArgumentResolver {
@Override
public Optional<Object> resolveArgumentValue(MethodParameter p, BindingContext c, ServerWebExchange e) {
public Object resolveArgumentValue(MethodParameter p, BindingContext c, ServerWebExchange e) {
return null;
}
}