Add ResolvableTypeProvider

Provide a mean to detect the actual ResolvableType based on a instance as
a counter measure to type erasure.

Upgrade the event infrastructure to detect if the event (or the payload)
implements such interface. When this is the case, the return value of
`getResolvableType` is used to validate its generic type against the
method signature of the listener.

Issue: SPR-13069

Author: snicoll

spring-context/src/main/java/org/springframework/context/PayloadApplicationEvent.java

@@ -16,6 +16,8 @@
 
 package org.springframework.context;
 
+import org.springframework.core.ResolvableType;
+import org.springframework.core.ResolvableTypeProvider;
 import org.springframework.util.Assert;
 
 /**
@@ -28,7 +30,7 @@
  * @param <T> the payload type of the event
  */
 @SuppressWarnings("serial")
-public class PayloadApplicationEvent<T> extends ApplicationEvent {
+public class PayloadApplicationEvent<T> extends ApplicationEvent implements ResolvableTypeProvider {
 
 	private final T payload;
 
@@ -44,6 +46,11 @@ public PayloadApplicationEvent(Object source, T payload) {
 		this.payload = payload;
 	}
 
+	@Override
+	public ResolvableType getResolvableType() {
+		return ResolvableType.forClassWithGenerics(getClass(),
+				ResolvableType.forInstance(getPayload()));
+	}
 
 	/**
 	 * Return the payload of the event.

spring-context/src/main/java/org/springframework/context/event/ApplicationListenerMethodAdapter.java

@@ -124,10 +124,11 @@ public void processEvent(ApplicationEvent event) {
 	protected Object[] resolveArguments(ApplicationEvent event) {
 		if (!ApplicationEvent.class.isAssignableFrom(this.declaredEventType.getRawClass())
 				&& event instanceof PayloadApplicationEvent) {
-			@SuppressWarnings("rawtypes")
-			Object payload = ((PayloadApplicationEvent) event).getPayload();
-			if (this.declaredEventType.isAssignableFrom(ResolvableType.forClass(payload.getClass()))) {
-				return new Object[] {payload};
+			PayloadApplicationEvent<?> payloadEvent = (PayloadApplicationEvent<?>) event;
+			ResolvableType payloadType =  payloadEvent.getResolvableType()
+					.as(PayloadApplicationEvent.class).getGeneric(0);
+			if (this.declaredEventType.isAssignableFrom(payloadType)) {
+				return new Object[] {payloadEvent.getPayload()};
 			}
 		}
 		else {

spring-context/src/main/java/org/springframework/context/event/SimpleApplicationEventMulticaster.java

@@ -139,7 +139,7 @@ public void run() {
 	}
 
 	private ResolvableType resolveDefaultEventType(ApplicationEvent event) {
-		return ResolvableType.forType(event.getClass());
+		return ResolvableType.forInstance(event);
 	}
 
 	/**

spring-context/src/test/java/org/springframework/context/event/AbstractApplicationEventListenerTests.java

@@ -21,6 +21,7 @@
 import org.springframework.context.ApplicationEvent;
 import org.springframework.context.ApplicationListener;
 import org.springframework.core.ResolvableType;
+import org.springframework.core.ResolvableTypeProvider;
 
 /**
  * @author Stephane Nicoll
@@ -53,6 +54,23 @@ public T getPayload() {
 
 	}
 
+	protected static class SmartGenericTestEvent<T>
+			extends GenericTestEvent<T> implements ResolvableTypeProvider {
+
+		private final ResolvableType resolvableType;
+
+		public SmartGenericTestEvent(Object source, T payload) {
+			super(source, payload);
+			this.resolvableType = ResolvableType.forClassWithGenerics(
+					getClass(), payload.getClass());
+		}
+
+		@Override
+		public ResolvableType getResolvableType() {
+			return this.resolvableType;
+		}
+	}
+
 	protected static class StringEvent extends GenericTestEvent<String> {
 
 		public StringEvent(Object source, String payload) {

spring-context/src/test/java/org/springframework/context/event/ApplicationContextEventTests.java

@@ -75,7 +75,7 @@ public void multicastGenericEventWrongType() {
 				getGenericApplicationEventType("longEvent"));
 	}
 
-	@Test // Unfortunate - this should work as well
+	@Test
 	public void multicastGenericEventWildcardSubType() {
 		multicastEvent(false, StringEventListener.class, createGenericTestEvent("test"),
 				getGenericApplicationEventType("wildcardEvent"));
@@ -91,6 +91,16 @@ public void multicastConcreteWrongTypeGenericListener() {
 		multicastEvent(false, StringEventListener.class, new LongEvent(this, 123L), null);
 	}
 
+	@Test
+	public void multicastSmartGenericTypeGenericListener() {
+		multicastEvent(true, StringEventListener.class, new SmartGenericTestEvent<>(this, "test"), null);
+	}
+
+	@Test
+	public void multicastSmartGenericWrongTypeGenericListener() {
+		multicastEvent(false, StringEventListener.class, new SmartGenericTestEvent<>(this, 123L), null);
+	}
+
 	private void multicastEvent(boolean match, Class<?> listenerType,
 			ApplicationEvent event, ResolvableType eventType) {
 		@SuppressWarnings("unchecked")

spring-context/src/test/java/org/springframework/context/event/ApplicationListenerMethodAdapterTests.java

@@ -29,6 +29,7 @@
 import org.springframework.context.ApplicationEvent;
 import org.springframework.context.PayloadApplicationEvent;
 import org.springframework.core.ResolvableType;
+import org.springframework.core.ResolvableTypeProvider;
 import org.springframework.core.annotation.Order;
 import org.springframework.util.ReflectionUtils;
 
@@ -155,6 +156,42 @@ public void invokeListener() {
 		verify(this.sampleEvents, times(1)).handleGenericString(event);
 	}
 
+	@Test
+	public void invokeListenerWithGenericEvent() {
+		Method method = ReflectionUtils.findMethod(SampleEvents.class,
+				"handleGenericString", GenericTestEvent.class);
+		GenericTestEvent<String> event = new SmartGenericTestEvent<>(this, "test");
+		invokeListener(method, event);
+		verify(this.sampleEvents, times(1)).handleGenericString(event);
+	}
+
+	@Test
+	public void invokeListenerWithGenericPayload() {
+		Method method = ReflectionUtils.findMethod(SampleEvents.class,
+				"handleGenericStringPayload", EntityWrapper.class);
+		EntityWrapper<String> payload = new EntityWrapper<>("test");
+		invokeListener(method, new PayloadApplicationEvent<>(this, payload));
+		verify(this.sampleEvents, times(1)).handleGenericStringPayload(payload);
+	}
+
+	@Test
+	public void invokeListenerWithWrongGenericPayload() {
+		Method method = ReflectionUtils.findMethod(SampleEvents.class,
+				"handleGenericStringPayload", EntityWrapper.class);
+		EntityWrapper<Integer> payload = new EntityWrapper<>(123);
+		invokeListener(method, new PayloadApplicationEvent<>(this, payload));
+		verify(this.sampleEvents, times(0)).handleGenericStringPayload(any());
+	}
+
+	@Test
+	public void invokeListenerWithAnyGenericPayload() {
+		Method method = ReflectionUtils.findMethod(SampleEvents.class,
+				"handleGenericAnyPayload", EntityWrapper.class);
+		EntityWrapper<String> payload = new EntityWrapper<>("test");
+		invokeListener(method, new PayloadApplicationEvent<>(this, payload));
+		verify(this.sampleEvents, times(1)).handleGenericAnyPayload(payload);
+	}
+
 	@Test
 	public void invokeListenerRuntimeException() {
 		Method method = ReflectionUtils.findMethod(SampleEvents.class,
@@ -284,6 +321,16 @@ public void handleGenericString(GenericTestEvent<String> event) {
 		public void handleString(String payload) {
 		}
 
+		@EventListener
+		public void handleGenericStringPayload(EntityWrapper<String> event) {
+
+		}
+
+		@EventListener
+		public void handleGenericAnyPayload(EntityWrapper<?> event) {
+
+		}
+
 		@EventListener
 		public void tooManyParameters(String event, String whatIsThis) {
 		}
@@ -313,6 +360,19 @@ interface SimpleService {
 
 	}
 
+	private static class EntityWrapper<T> implements ResolvableTypeProvider {
+		private final T entity;
+
+		public EntityWrapper(T entity) {
+			this.entity = entity;
+		}
+
+		@Override
+		public ResolvableType getResolvableType() {
+			return ResolvableType.forClassWithGenerics(getClass(), this.entity.getClass());
+		}
+	}
+
 	static class InvalidProxyTestBean implements SimpleService {
 
 		@Override

spring-context/src/test/java/org/springframework/context/event/GenericApplicationListenerAdapterTests.java

@@ -66,6 +66,12 @@ public void genericListenerStrictTypeAndResolvableType() {
 		supportsEventType(true, StringEventListener.class, eventType);
 	}
 
+	@Test // or if the event provides its precise type
+	public void genericListenerStrictTypeAndResolvableTypeProvider() {
+		ResolvableType eventType = new SmartGenericTestEvent<>(this, "foo").getResolvableType();
+		supportsEventType(true, StringEventListener.class, eventType);
+	}
+
 	@Test // Demonstrates it works if we actually use the subtype
 	public void genericListenerStrictTypeEventSubType() {
 		StringEvent stringEvent = new StringEvent(this, "test");

spring-core/src/main/java/org/springframework/core/ResolvableType.java

@@ -67,13 +67,16 @@
  *
  * @author Phillip Webb
  * @author Juergen Hoeller
+ * @author Stephane Nicoll
  * @since 4.0
  * @see #forField(Field)
  * @see #forMethodParameter(Method, int)
  * @see #forMethodReturnType(Method)
  * @see #forConstructorParameter(Constructor, int)
  * @see #forClass(Class)
  * @see #forType(Type)
+ * @see #forInstance(Object)
+ * @see ResolvableTypeProvider
  */
 @SuppressWarnings("serial")
 public class ResolvableType implements Serializable {
@@ -984,6 +987,26 @@ public static ResolvableType forClassWithGenerics(Class<?> sourceClass, Resolvab
 		return forType(syntheticType, new TypeVariablesVariableResolver(variables, generics));
 	}
 
+	/**
+	 * Return a {@link ResolvableType} for the specified instance. The instance does not
+	 * convey generic information but if it implements {@link ResolvableTypeProvider} a
+	 * more precise {@link ResolvableType} can be used than the simple one based on
+	 * the {@link #forClass(Class) Class instance}.
+	 * @param instance the instance
+	 * @return a {@link ResolvableType} for the specified instance
+	 * @see ResolvableTypeProvider
+	 */
+	public static ResolvableType forInstance(Object instance) {
+		Assert.notNull(instance, "Instance must not be null");
+		if (instance instanceof ResolvableTypeProvider) {
+			ResolvableType type = ((ResolvableTypeProvider) instance).getResolvableType();
+			if (type != null) {
+				return type;
+			}
+		}
+		return ResolvableType.forClass(instance.getClass());
+	}
+
 	/**
 	 * Return a {@link ResolvableType} for the specified {@link Field}.
 	 * @param field the source field

spring-core/src/main/java/org/springframework/core/ResolvableTypeProvider.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2002-2015 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core;
+
+/**
+ * Any object can implement this interface to provide its actual {@link ResolvableType}.
+ * <p>
+ * Such information is very useful when figuring out if the instance matches a generic
+ * signature as Java does not convey the signature at runtime.
+ * <p>
+ * Users of this interface should be careful in complex hierarchy scenarios, especially
+ * when the generic type signature of the class changes in sub-classes. It is always
+ * possible to return {@code null} to fallback on a default behaviour.
+ *
+ * @author Stephane Nicoll
+ * @since 4.2
+ */
+public interface ResolvableTypeProvider {
+
+	/**
+	 * Return the {@link ResolvableType} describing this instance or {@code null} if some
+	 * sort of default should be applied instead.
+	 */
+	ResolvableType getResolvableType();
+
+}

spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java

@@ -133,6 +133,34 @@ public void forRawClassWithNull() throws Exception {
 		assertTrue(type.isAssignableFrom(String.class));
 	}
 
+	@Test
+	public void forInstanceMustNotBeNull() {
+		this.thrown.expect(IllegalArgumentException.class);
+		this.thrown.expectMessage("Instance must not be null");
+		ResolvableType.forInstance(null);
+	}
+
+	@Test
+	public void forInstanceNoProvider() {
+		ResolvableType type = ResolvableType.forInstance(new Object());
+		assertThat(type.getType(), equalTo(Object.class));
+		assertThat(type.resolve(), equalTo(Object.class));
+	}
+
+	@Test
+	public void forInstanceProvider() {
+		ResolvableType type = ResolvableType.forInstance(new MyGenericInterfaceType<String>(String.class));
+		assertThat(type.getRawClass(), equalTo(MyGenericInterfaceType.class));
+		assertThat(type.getGeneric().resolve(), equalTo(String.class));
+	}
+
+	@Test
+	public void forInstanceProviderNull() {
+		ResolvableType type = ResolvableType.forInstance(new MyGenericInterfaceType<String>(null));
+		assertThat(type.getType(), equalTo(MyGenericInterfaceType.class));
+		assertThat(type.resolve(), equalTo(MyGenericInterfaceType.class));
+	}
+
 	@Test
 	public void forField() throws Exception {
 		Field field = Fields.class.getField("charSequenceList");
@@ -1454,6 +1482,23 @@ public TypedConstructors(Map<String, Long> p) {
 	public interface MyInterfaceType<T> {
 	}
 
+	public class MyGenericInterfaceType<T> implements MyInterfaceType<T>, ResolvableTypeProvider {
+
+		private final Class<T> type;
+
+		public MyGenericInterfaceType(Class<T> type) {
+			this.type = type;
+		}
+
+		@Override
+		public ResolvableType getResolvableType() {
+			if (this.type == null) {
+				return null;
+			}
+			return ResolvableType.forClassWithGenerics(getClass(), this.type);
+		}
+	}
+
 
 	public class MySimpleInterfaceType implements MyInterfaceType<String> {
 	}