/** * A constructor that finds {@link MessageExceptionHandler} methods in the given type. * @param handlerType the type to introspect */ public AnnotationExceptionHandlerMethodResolver(Class<?> handlerType) { super(initExceptionMappings(handlerType)); }
/** * Create a new instance with the invalid {@code MethodParameter} and a * {@link org.springframework.validation.BindingResult}. */ public MethodArgumentNotValidException(Message<?> message, MethodParameter parameter, BindingResult bindingResult) { super(message, parameter, getValidationErrorMessage(bindingResult)); this.bindingResult = bindingResult; }
private MessageHandlerMethodFactory createDefaultJmsHandlerMethodFactory() { DefaultMessageHandlerMethodFactory defaultFactory = new DefaultMessageHandlerMethodFactory(); if (beanFactory != null) { defaultFactory.setBeanFactory(beanFactory); } defaultFactory.afterPropertiesSet(); return defaultFactory; } }
protected List<HandlerMethodArgumentResolver> initArgumentResolvers() { List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(); ConfigurableBeanFactory cbf = (this.beanFactory instanceof ConfigurableBeanFactory ? (ConfigurableBeanFactory) this.beanFactory : null); // Annotation-based argument resolution resolvers.add(new HeaderMethodArgumentResolver(this.conversionService, cbf)); resolvers.add(new HeadersMethodArgumentResolver()); // Type-based argument resolution resolvers.add(new MessageMethodArgumentResolver(this.messageConverter)); if (this.customArgumentResolvers != null) { resolvers.addAll(this.customArgumentResolvers); } resolvers.add(new PayloadArgumentResolver(this.messageConverter, this.validator)); return resolvers; }
private DefaultMessageHandlerMethodFactory createInstance() { DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory(); factory.setBeanFactory(new StaticListableBeanFactory()); return factory; }
private void initializeFactory(DefaultMessageHandlerMethodFactory factory) { factory.setBeanFactory(new StaticListableBeanFactory()); factory.afterPropertiesSet(); }
@Test public void customArgumentResolver() throws Exception { DefaultMessageHandlerMethodFactory instance = createInstance(); List<HandlerMethodArgumentResolver> customResolvers = new ArrayList<>(); customResolvers.add(new CustomHandlerMethodArgumentResolver()); instance.setCustomArgumentResolvers(customResolvers); instance.afterPropertiesSet(); InvocableHandlerMethod invocableHandlerMethod = createInvocableHandlerMethod(instance, "customArgumentResolver", Locale.class); invocableHandlerMethod.invoke(MessageBuilder.withPayload(123).build()); assertMethodInvocation(sample, "customArgumentResolver"); }
@Test public void noValidationByDefault() throws Exception { DefaultMessageHandlerMethodFactory instance = createInstance(); instance.afterPropertiesSet(); InvocableHandlerMethod invocableHandlerMethod = createInvocableHandlerMethod(instance, "payloadValidation", String.class); invocableHandlerMethod.invoke(MessageBuilder.withPayload("failure").build()); assertMethodInvocation(sample, "payloadValidation"); }
@Override protected AbstractExceptionHandlerMethodResolver createExceptionHandlerMethodResolverFor(Class<?> beanType) { return new AnnotationExceptionHandlerMethodResolver(beanType); }
@Test public void supportsParameter() throws Exception { assertTrue(this.resolver.supportsParameter(this.paramAnnotated)); assertTrue(this.resolver.supportsParameter(this.paramNotAnnotated)); PayloadArgumentResolver strictResolver = new PayloadArgumentResolver( new StringMessageConverter(), testValidator(), false); assertTrue(strictResolver.supportsParameter(this.paramAnnotated)); assertFalse(strictResolver.supportsParameter(this.paramNotAnnotated)); }
/** * Obtain the named value for the given method parameter. */ private NamedValueInfo getNamedValueInfo(MethodParameter parameter) { NamedValueInfo namedValueInfo = this.namedValueInfoCache.get(parameter); if (namedValueInfo == null) { namedValueInfo = createNamedValueInfo(parameter); namedValueInfo = updateNamedValueInfo(parameter, namedValueInfo); this.namedValueInfoCache.put(parameter, namedValueInfo); } return namedValueInfo; }
private InvocableHandlerMethod createInvocableHandlerMethod( DefaultMessageHandlerMethodFactory factory, String methodName, Class<?>... parameterTypes) { return factory.createInvocableHandlerMethod(sample, getListenerMethod(methodName, parameterTypes)); }
@Test public void resolveArgumentNativeHeaderAmbiguity() throws Exception { TestMessageHeaderAccessor headers = new TestMessageHeaderAccessor(); headers.setHeader("param1", "foo"); headers.setNativeHeader("param1", "native-foo"); Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeaders(headers).build(); assertEquals("foo", this.resolver.resolveArgument(this.paramRequired, message)); assertEquals("native-foo", this.resolver.resolveArgument(this.paramNativeHeader, message)); }
@Test // SPR-11326 public void resolveArgumentNativeHeader() throws Exception { TestMessageHeaderAccessor headers = new TestMessageHeaderAccessor(); headers.setNativeHeader("param1", "foo"); Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeaders(headers).build(); assertEquals("foo", this.resolver.resolveArgument(this.paramRequired, message)); }
protected MessagingMessageListenerAdapter createInstance(Method m) { MessagingMessageListenerAdapter adapter = new MessagingMessageListenerAdapter(); adapter.setHandlerMethod(factory.createInvocableHandlerMethod(sample, m)); return adapter; }
@Test public void resolveArgumentMessageHeaderAccessorSubclass() throws Exception { Object resolved = this.resolver.resolveArgument(this.paramMessageHeaderAccessorSubclass, this.message); assertTrue(resolved instanceof TestMessageHeaderAccessor); TestMessageHeaderAccessor headers = (TestMessageHeaderAccessor) resolved; assertEquals("bar", headers.getHeader("foo")); }
public static TestMessageHeaderAccessor wrap(Message<?> message) { return new TestMessageHeaderAccessor(message); } }
@Test(expected = IllegalStateException.class) public void resolveArgumentAnnotatedNotMap() throws Exception { this.resolver.resolveArgument(this.paramAnnotatedNotMap, this.message); }
protected List<HandlerMethodArgumentResolver> initArgumentResolvers() { ApplicationContext context = getApplicationContext(); ConfigurableBeanFactory beanFactory = (context instanceof ConfigurableApplicationContext ? ((ConfigurableApplicationContext) context).getBeanFactory() : null); List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(); // Annotation-based argument resolution resolvers.add(new HeaderMethodArgumentResolver(this.conversionService, beanFactory)); resolvers.add(new HeadersMethodArgumentResolver()); resolvers.add(new DestinationVariableMethodArgumentResolver(this.conversionService)); // Type-based argument resolution resolvers.add(new PrincipalMethodArgumentResolver()); resolvers.add(new MessageMethodArgumentResolver(this.messageConverter)); resolvers.addAll(getCustomArgumentResolvers()); resolvers.add(new PayloadArgumentResolver(this.messageConverter, this.validator)); return resolvers; }
private void initializeFactory(DefaultMessageHandlerMethodFactory factory) { factory.setBeanFactory(new StaticListableBeanFactory()); factory.afterPropertiesSet(); }