/** * Constructor with an {@link ReactiveAdapterRegistry} instance. * @param writers writers for serializing to the response body * @param resolver to determine the requested content type * @param registry for adaptation to reactive types */ public ResponseEntityResultHandler(List<HttpMessageWriter<?>> writers, RequestedContentTypeResolver resolver, ReactiveAdapterRegistry registry) { super(writers, resolver, registry); setOrder(0); }
/** * Override to plug a sub-class of {@link RequestMappingHandlerMapping}. */ protected RequestMappingHandlerMapping createRequestMappingHandlerMapping() { return new RequestMappingHandlerMapping(); }
/** * Override to plug a sub-class of {@link RequestMappingHandlerAdapter}. */ protected RequestMappingHandlerAdapter createRequestMappingHandlerAdapter() { return new RequestMappingHandlerAdapter(); }
private RequestMappingHandlerAdapter createAdapter(ApplicationContext context) throws Exception { RequestMappingHandlerAdapter adapter = new RequestMappingHandlerAdapter(); adapter.setApplicationContext(context); adapter.afterPropertiesSet(); return adapter; }
/** * Constructor with an {@link ReactiveAdapterRegistry} instance. * @param writers writers for serializing to the response body * @param resolver to determine the requested content type * @param registry for adaptation to reactive types */ public ResponseBodyResultHandler(List<HttpMessageWriter<?>> writers, RequestedContentTypeResolver resolver, ReactiveAdapterRegistry registry) { super(writers, resolver, registry); setOrder(100); }
/** * Invoked when a named value is required, but * {@link #resolveName(String, MethodParameter, ServerWebExchange)} returned * {@code null} and there is no default value. Subclasses typically throw an * exception in this case. * @param name the name for the value * @param parameter the method parameter * @param exchange the current exchange */ @SuppressWarnings("UnusedParameters") protected void handleMissingValue(String name, MethodParameter parameter, ServerWebExchange exchange) { handleMissingValue(name, parameter); }
/** * Read the body from a method argument with {@link HttpMessageReader}. * @param bodyParameter the {@link MethodParameter} to read * @param isBodyRequired true if the body is required * @param bindingContext the binding context to use * @param exchange the current exchange * @return the body * @see #readBody(MethodParameter, MethodParameter, boolean, BindingContext, ServerWebExchange) */ protected Mono<Object> readBody(MethodParameter bodyParameter, boolean isBodyRequired, BindingContext bindingContext, ServerWebExchange exchange) { return this.readBody(bodyParameter, null, isBodyRequired, bindingContext, exchange); }
@Override public String toString() { return "FormBean[" + getFieldPart() + "," + partListDescription(getFileParts()) + "]"; } }
private void testSupports(Object controller, Method method) { HandlerResult handlerResult = getHandlerResult(controller, method); assertTrue(this.resultHandler.supports(handlerResult)); }
private static List<HandlerMethodArgumentResolver> requestMappingResolvers( ArgumentResolverConfigurer customResolvers, ReactiveAdapterRegistry reactiveRegistry, ConfigurableApplicationContext context, List<HttpMessageReader<?>> readers) { return initResolvers(customResolvers, reactiveRegistry, context, true, readers); }
@Override public Mono<Object> resolveArgument( MethodParameter parameter, BindingContext bindingContext, ServerWebExchange exchange) { // Flip the default implementation from SyncHandlerMethodArgumentResolver: // instead of delegating to (sync) resolveArgumentValue, // call (async) super.resolveArgument shared with non-blocking resolvers; // actual resolution below still sync... return super.resolveArgument(parameter, bindingContext, exchange); }
@Override public boolean supportsParameter(MethodParameter parameter) { return checkAnnotatedParamNoReactiveWrapper(parameter, PathVariable.class, this::allVariables); }
@Override public boolean supportsParameter(MethodParameter param) { return checkAnnotatedParamNoReactiveWrapper(param, Value.class, (ann, type) -> true); }
@Override public boolean supportsParameter(MethodParameter param) { return checkAnnotatedParamNoReactiveWrapper(param, RequestHeader.class, this::singleParam); }
@Override public boolean supportsParameter(MethodParameter param) { return checkAnnotatedParamNoReactiveWrapper(param, RequestHeader.class, this::allParams); }
@Override public boolean supportsParameter(MethodParameter parameter) { return checkParameterType(parameter, Principal.class::isAssignableFrom); }
@Override public boolean supportsParameter(MethodParameter parameter) { return checkParameterType(parameter, Errors.class::isAssignableFrom); }
@Override public boolean supportsParameter(MethodParameter param) { return checkAnnotatedParamNoReactiveWrapper(param, RequestParam.class, this::allParams); }
@Override public boolean supportsParameter(MethodParameter param) { return checkAnnotatedParamNoReactiveWrapper(param, CookieValue.class, (annot, type) -> true); }
@Override public boolean supportsParameter(MethodParameter parameter) { return checkAnnotatedParamNoReactiveWrapper(parameter, PathVariable.class, this::singlePathVariable); }