MethodParameter doesn't see parameter annotations if method is proxied [SPR-16294]

[spring-projects-issues]

Artem Bilan opened SPR-16294 and commented

My use-case is like: we have a @Transactional service method with the @Header annotation on one of the parameter. When we perform this method via InvocableHandlerMethod we end up with the problem that @Header isn't visible and Framework attempts to fallback to the payload for this parameter.

The test-case to reproduce:

	@Test
	public void testProxyAndHeaderAnnotation() throws Exception {
		final AtomicReference<Object> payloadReference = new AtomicReference<>();
		final AtomicReference<UUID> idReference = new AtomicReference<>();

		class MyHandler {

			public void handle(@Header(MessageHeaders.ID) UUID id, @Payload Object payload) {
				idReference.set(id);
				payloadReference.set(payload);
			}

		}

		MyHandler service = new MyHandler();

		ProxyFactory proxyFactory = new ProxyFactory(service);

		service = (MyHandler) proxyFactory.getProxy(getClass().getClassLoader());

		DefaultMessageHandlerMethodFactory handlerMethodFactory = new DefaultMessageHandlerMethodFactory();
		handlerMethodFactory.afterPropertiesSet();

		Method method = ClassUtils.getMethod(service.getClass(), "handle", null);
		InvocableHandlerMethod handlerMethod = handlerMethodFactory.createInvocableHandlerMethod(service, method);

		GenericMessage<String> testMessage = new GenericMessage<>("foo");
		handlerMethod.invoke(testMessage);

		assertEquals(testMessage.getPayload(), payloadReference.get());
		assertEquals(testMessage.getHeaders().getId(), idReference.get());
	}

When we comment out getProxy() everything works well as expected.

Not sure what is wrong, but looks like when we try to get annotations from the method parameter on proxied method, we don't get them. I just followed the debug from the HeaderMethodArgumentResolver.supportsParameter().

See the related JIRA for more information: https://jira.spring.io/browse/INT-4367

---

Affects: 5.0.2

Issue Links:

• INT-4367 Definition of service-activator in pojo-style does not work with annotaded parameters

[spring-projects-issues]

Artem Bilan commented

Well, as a fix I see AopUtils.getTargetClass() to extract the target user method for annotations discovery, but still use the real proxied method for invocation.

[spring-projects-issues]

Juergen Hoeller commented

It all comes down to the method handle that is being passed to InvocableHandlerMethod and co: Ideally that needs to be an original method declaration, e.g. coming from interface introspection, not from proxy class introspection.

In several places in the core framework, we use MethodIntrospector.selectMethods for this, specifically handling proxy types by only looking at the implemented interfaces there. You could reuse this or follow a similar algorithm at least.

[spring-projects-issues]

Artem Bilan commented

I might miss something, but I somehow think that we talk about different processes.

Looks like you use (JmsListenerAnnotationBeanPostProcessor for example) MethodIntrospector.selectMethods() to filter method for the further process but then in the end I see this:

Method invocableMethod = AopUtils.selectInvocableMethod(mostSpecificMethod, bean.getClass());

Which ends up as a proxied method and that result goes already to the InvocableHandlerMethod what is exactly the same I have. The MethodArgumentResolvers work later, at runtime during invocation. And already here we can't determine method parameter annotations. See InvocableHandlerMethod.getMethodArgumentValues().

Otherwise, please, let me know how to modify that my test-case to make it working with the @Header and be proxy at the same time.

Thanks

[spring-projects-issues]

Juergen Hoeller commented

Good point, while we have proxy detection logic in place even in selectInvocableMethod, it only covers interface-based proxies... and you are using a CGLIB proxy there. We might have to refine selectInvocableMethod to take the method from the user-declared superclass, if possible.

For your test case, the correct fix (in the sense of the correct outcome of a revised selectInvocableMethod call) would be:

Method method = ClassUtils.getMethod(MyHandler.class, "handle", null);

[spring-projects-issues]

Juergen Hoeller commented

As far as I can tell, this works for JmsListenerAnnotationBeanPostProcessor already: selectInvocableMethod returns the original method declaration in case of a CGLIB proxy. So I'd recommend to simply try that same algorithm on your end, passing a method derived from the user class into createInvocableHandlerMethod.

[spring-projects-issues]

Artem Bilan commented

OK!

Thank you Juergen for clarification and your help.

Looks like this is the solution for me:

Class<?> classForMethod =
	ClassUtils.isCglibProxy(targetObject)
			? targetObject.getClass().getSuperClass()
			: targetObject.getClass();
Method methodToCall = AopUtils.selectInvocableMethod(method, classForMethod);
InvocableHandlerMethod invocableHandlerMethod =
		this.messageHandlerMethodFactory.createInvocableHandlerMethod(targetObject, methodToCall);

This way I cover all the use-cases when we don't get proxy, when it is JDK Proxy or finally CGLIB one.

I leave this up to you to close it as invalid or really fix that selectInvocableMethod() to cover these case on the core level.

[spring-projects-issues]

Juergen Hoeller commented

Since this works alright for our purposes in the core framework, I tend to see this as working as designed.

As for your solution, you could simplify that class retrieval to
Class<?> classForMethod = ClassUtils.getUserClass(targetObject);
which does pretty much exactly that.

[spring-projects-issues]

Artem Bilan commented

Ah! ClassUtils.getUserClass()! That is what I've missed before for selecting the the method to call.

Thank you Juergen for all your help!

Indeed, Works as Designed from your side :)