Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add ResolvableTypeProvider

Browse Source 
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
This commit is contained in:
Stephane Nicoll
2015-06-03 15:30:47 +02:00
parent a7aaf313d7
commit b87816ed20
10 changed files with 217 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
spring-context/src/main/java/org/springframework/context/PayloadApplicationEvent.java
View File

@@ -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 @@ import org.springframework.util.Assert;
* @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 class PayloadApplicationEvent<T> extends ApplicationEvent {
this.payload = payload;
}
@Override
public ResolvableType getResolvableType() {
return ResolvableType.forClassWithGenerics(getClass(),
ResolvableType.forInstance(getPayload()));
}
/**
* Return the payload of the event.

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

@@ -124,10 +124,11 @@ public class ApplicationListenerMethodAdapter implements GenericApplicationListe
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 {

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

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

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

@@ -21,6 +21,7 @@ import java.io.IOException;
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 abstract class AbstractApplicationEventListenerTests {
}
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) {

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

@@ -75,7 +75,7 @@ public class ApplicationContextEventTests extends AbstractApplicationEventListen
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 class ApplicationContextEventTests extends AbstractApplicationEventListen
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")

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

@@ -29,6 +29,7 @@ import org.springframework.context.ApplicationContext;
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 class ApplicationListenerMethodAdapterTests extends AbstractApplicationEv
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 class ApplicationListenerMethodAdapterTests extends AbstractApplicationEv
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 @@ public class ApplicationListenerMethodAdapterTests extends AbstractApplicationEv
}
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

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

@@ -66,6 +66,12 @@ public class GenericApplicationListenerAdapterTests extends AbstractApplicationE
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");

23
spring-core/src/main/java/org/springframework/core/ResolvableType.java
View File

@@ -67,6 +67,7 @@ import org.springframework.util.StringUtils;
*
* @author Phillip Webb
* @author Juergen Hoeller
* @author Stephane Nicoll
* @since 4.0
* @see #forField(Field)
* @see #forMethodParameter(Method, int)
@@ -74,6 +75,8 @@ import org.springframework.util.StringUtils;
* @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 class ResolvableType implements Serializable {
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

40
spring-core/src/main/java/org/springframework/core/ResolvableTypeProvider.java Normal file
View File

@@ -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();
}

45
spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java
View File

@@ -133,6 +133,34 @@ public class ResolvableTypeTests {
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 class ResolvableTypeTests {
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> {
}