result.add(new ExpressionValueMethodArgumentResolver(beanFactory, reactiveRegistry)); result.add(new SessionAttributeMethodArgumentResolver(beanFactory, reactiveRegistry)); result.add(new RequestAttributeMethodArgumentResolver(beanFactory, reactiveRegistry));
@Override protected Object resolveNamedValue(String name, MethodParameter parameter, ServerWebExchange exchange) { Object value = exchange.getAttribute(name); ReactiveAdapter toAdapter = getAdapterRegistry().getAdapter(parameter.getParameterType()); if (toAdapter != null) { if (value == null) { Assert.isTrue(toAdapter.supportsEmpty(), () -> "No request attribute '" + name + "' and target type " + parameter.getGenericParameterType() + " doesn't support empty values."); return toAdapter.fromPublisher(Mono.empty()); } if (parameter.getParameterType().isAssignableFrom(value.getClass())) { return value; } ReactiveAdapter fromAdapter = getAdapterRegistry().getAdapter(value.getClass()); Assert.isTrue(fromAdapter != null, () -> getClass().getSimpleName() + " doesn't support " + "reactive type wrapper: " + parameter.getGenericParameterType()); return toAdapter.fromPublisher(fromAdapter.toPublisher(value)); } return value; }
@Test public void resolveNotRequired() throws Exception { MethodParameter param = this.testMethod.annot(requestAttribute().name("foo").notRequired()).arg(); Mono<Object> mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); assertNull(mono.block()); Foo foo = new Foo(); this.exchange.getAttributes().put("foo", foo); mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); assertSame(foo, mono.block()); }
@Test public void supportsParameter() throws Exception { assertTrue(this.resolver.supportsParameter( this.testMethod.annot(requestAttribute().noName()).arg(Foo.class))); // SPR-16158 assertTrue(this.resolver.supportsParameter( this.testMethod.annotPresent(RequestAttribute.class).arg(Mono.class, Foo.class))); assertFalse(this.resolver.supportsParameter( this.testMethod.annotNotPresent(RequestAttribute.class).arg())); }
@Before @SuppressWarnings("resource") public void setup() throws Exception { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); context.refresh(); ReactiveAdapterRegistry registry = ReactiveAdapterRegistry.getSharedInstance(); this.resolver = new RequestAttributeMethodArgumentResolver(context.getBeanFactory(), registry); }
@Test // SPR-16158 public void resolveMonoParameter() throws Exception { MethodParameter param = this.testMethod.annot(requestAttribute().noName()).arg(Mono.class, Foo.class); // Mono attribute Foo foo = new Foo(); Mono<Foo> fooMono = Mono.just(foo); this.exchange.getAttributes().put("fooMono", fooMono); Mono<Object> mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); assertSame(fooMono, mono.block(Duration.ZERO)); // RxJava Single attribute Single<Foo> singleMono = Single.just(foo); this.exchange.getAttributes().clear(); this.exchange.getAttributes().put("fooMono", singleMono); mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); Object value = mono.block(Duration.ZERO); assertTrue(value instanceof Mono); assertSame(foo, ((Mono<?>) value).block(Duration.ZERO)); // No attribute --> Mono.empty this.exchange.getAttributes().clear(); mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); assertSame(Mono.empty(), mono.block(Duration.ZERO)); }
protected List<SyncHandlerMethodArgumentResolver> getDefaultInitBinderArgumentResolvers() { List<SyncHandlerMethodArgumentResolver> resolvers = new ArrayList<>(); // Annotation-based argument resolution resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false)); resolvers.add(new RequestParamMapMethodArgumentResolver()); resolvers.add(new PathVariableMethodArgumentResolver(getBeanFactory())); resolvers.add(new PathVariableMapMethodArgumentResolver()); resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory())); resolvers.add(new RequestHeaderMapMethodArgumentResolver()); resolvers.add(new CookieValueMethodArgumentResolver(getBeanFactory())); resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory())); resolvers.add(new RequestAttributeMethodArgumentResolver(getBeanFactory())); // Type-based argument resolution resolvers.add(new ModelArgumentResolver()); resolvers.add(new ServerWebExchangeArgumentResolver()); // Custom resolvers if (getCustomInitBinderArgumentResolvers() != null) { resolvers.addAll(getCustomInitBinderArgumentResolvers()); } // Catch-all resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true)); return resolvers; }
@Test public void resolveOptional() throws Exception { MethodParameter param = this.testMethod.annot(requestAttribute().name("foo")).arg(Optional.class, Foo.class); Mono<Object> mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); assertNotNull(mono.block()); assertEquals(Optional.class, mono.block().getClass()); assertFalse(((Optional<?>) mono.block()).isPresent()); ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer(); initializer.setConversionService(new DefaultFormattingConversionService()); BindingContext bindingContext = new BindingContext(initializer); Foo foo = new Foo(); this.exchange.getAttributes().put("foo", foo); mono = this.resolver.resolveArgument(param, bindingContext, this.exchange); assertNotNull(mono.block()); assertEquals(Optional.class, mono.block().getClass()); Optional<?> optional = (Optional<?>) mono.block(); assertTrue(optional.isPresent()); assertSame(foo, optional.get()); }
resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory())); resolvers.add(new SessionAttributeMethodArgumentResolver(getBeanFactory())); resolvers.add(new RequestAttributeMethodArgumentResolver(getBeanFactory()));
@Test public void resolve() throws Exception { MethodParameter param = this.testMethod.annot(requestAttribute().noName()).arg(Foo.class); Mono<Object> mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); StepVerifier.create(mono) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); Foo foo = new Foo(); this.exchange.getAttributes().put("foo", foo); mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); assertSame(foo, mono.block()); }
@Test public void resolveWithName() throws Exception { MethodParameter param = this.testMethod.annot(requestAttribute().name("specialFoo")).arg(); Foo foo = new Foo(); this.exchange.getAttributes().put("specialFoo", foo); Mono<Object> mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); assertSame(foo, mono.block()); }