root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Revert "Support WildcardType resolution in GenericTypeResolver" 

This reverts commit f075120675.

See gh-22313
See gh-31690
This commit is contained in:
Sébastien Deleuze 2023-11-29 14:37:44 +01:00
parent 35fcbae8c6
commit 7cf124b696
2 changed files with 18 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
spring-core/src/main/java/org/springframework/core/GenericTypeResolver.java
View File

@ -39,7 +39,6 @@ import org.springframework.util.ConcurrentReferenceHashMap;
* @author Rob Harrop * @author Rob Harrop
* @author Sam Brannen * @author Sam Brannen
* @author Phillip Webb * @author Phillip Webb
* @author Sebastien Deleuze
* @since 2.5.2 * @since 2.5.2
*/ */
public final class GenericTypeResolver { public final class GenericTypeResolver {
@ -167,30 +166,29 @@ public final class GenericTypeResolver {
} }
else if (genericType instanceof ParameterizedType parameterizedType) { else if (genericType instanceof ParameterizedType parameterizedType) {
ResolvableType resolvedType = ResolvableType.forType(genericType); ResolvableType resolvedType = ResolvableType.forType(genericType);
Class<?>[] generics = new Class<?>[parameterizedType.getActualTypeArguments().length]; if (resolvedType.hasUnresolvableGenerics()) {
Type[] typeArguments = parameterizedType.getActualTypeArguments(); Class<?>[] generics = new Class<?>[parameterizedType.getActualTypeArguments().length];
ResolvableType contextType = ResolvableType.forClass(contextClass); Type[] typeArguments = parameterizedType.getActualTypeArguments();
for (int i = 0; i < typeArguments.length; i++) { ResolvableType contextType = ResolvableType.forClass(contextClass);
Type typeArgument = typeArguments[i]; for (int i = 0; i < typeArguments.length; i++) {
if (typeArgument instanceof TypeVariable<?> typeVariable) { Type typeArgument = typeArguments[i];
ResolvableType resolvedTypeArgument = resolveVariable(typeVariable, contextType); if (typeArgument instanceof TypeVariable<?> typeVariable) {
if (resolvedTypeArgument != ResolvableType.NONE) { ResolvableType resolvedTypeArgument = resolveVariable(typeVariable, contextType);
generics[i] = resolvedTypeArgument.resolve(); if (resolvedTypeArgument != ResolvableType.NONE) {
generics[i] = resolvedTypeArgument.resolve();
}
else {
generics[i] = ResolvableType.forType(typeArgument).resolve();
}
} }
else { else {
generics[i] = ResolvableType.forType(typeArgument).resolve(); generics[i] = ResolvableType.forType(typeArgument).resolve();
} }
} }
else if (typeArgument instanceof WildcardType wildcardType) { Class<?> rawClass = resolvedType.getRawClass();
generics[i] = resolveWildcard(wildcardType, contextType).resolve(); if (rawClass != null) {
return ResolvableType.forClassWithGenerics(rawClass, generics).getType();
} }
else {
generics[i] = ResolvableType.forType(typeArgument).resolve();
}
}
Class<?> rawClass = resolvedType.getRawClass();
if (rawClass != null) {
return ResolvableType.forClassWithGenerics(rawClass, generics).getType();
} }
} }
} }
@ -226,26 +224,6 @@ public final class GenericTypeResolver {
return ResolvableType.NONE; return ResolvableType.NONE;
} }
private static ResolvableType resolveWildcard(WildcardType wildcardType, ResolvableType contextType) {
for (Type bound : wildcardType.getUpperBounds()) {
if (bound instanceof TypeVariable<?> typeVariable) {
ResolvableType resolvedTypeArgument = resolveVariable(typeVariable, contextType);
if (resolvedTypeArgument != ResolvableType.NONE) {
return resolvedTypeArgument;
}
}
}
for (Type bound : wildcardType.getLowerBounds()) {
if (bound instanceof TypeVariable<?> typeVariable) {
ResolvableType resolvedTypeArgument = resolveVariable(typeVariable, contextType);
if (resolvedTypeArgument != ResolvableType.NONE) {
return resolvedTypeArgument;
}
}
}
return ResolvableType.forType(wildcardType);
}
/** /**
* Resolve the specified generic type against the given TypeVariable map. * Resolve the specified generic type against the given TypeVariable map.
* <p>Used by Spring Data. * <p>Used by Spring Data.

69
spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2022 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -194,58 +194,6 @@ class GenericTypeResolverTests {
assertThat(resolved).isEqualTo(E.class); assertThat(resolved).isEqualTo(E.class);
} }
@Test
void resolveWildcardTypeWithUpperBound() {
Method method = method(MySimpleSuperclassType.class, "upperBound", List.class);
Type resolved = resolveType(method.getGenericParameterTypes()[0], MySimpleSuperclassType.class);
ResolvableType resolvableType = ResolvableType.forType(resolved);
assertThat(resolvableType.hasUnresolvableGenerics()).isFalse();
assertThat(resolvableType.resolveGenerics()).containsExactly(String.class);
}
@Test
void resolveWildcardTypeWithUpperBoundWithResolvedType() {
Method method = method(MySimpleSuperclassType.class, "upperBoundWithResolvedType", List.class);
Type resolved = resolveType(method.getGenericParameterTypes()[0], MySimpleSuperclassType.class);
ResolvableType resolvableType = ResolvableType.forType(resolved);
assertThat(resolvableType.hasUnresolvableGenerics()).isFalse();
assertThat(resolvableType.resolveGenerics()).containsExactly(Integer.class);
}
@Test
void resolveWildcardTypeWithLowerBound() {
Method method = method(MySimpleSuperclassType.class, "lowerBound", List.class);
Type resolved = resolveType(method.getGenericParameterTypes()[0], MySimpleSuperclassType.class);
ResolvableType resolvableType = ResolvableType.forType(resolved);
assertThat(resolvableType.hasUnresolvableGenerics()).isFalse();
assertThat(resolvableType.resolveGenerics()).containsExactly(String.class);
}
@Test
void resolveWildcardTypeWithLowerBoundWithResolvedType() {
Method method = method(MySimpleSuperclassType.class, "lowerBoundWithResolvedType", List.class);
Type resolved = resolveType(method.getGenericParameterTypes()[0], MySimpleSuperclassType.class);
ResolvableType resolvableType = ResolvableType.forType(resolved);
assertThat(resolvableType.hasUnresolvableGenerics()).isFalse();
assertThat(resolvableType.resolveGenerics()).containsExactly(Integer.class);
}
@Test
void resolveWildcardTypeWithUnbounded() {
Method method = method(MySimpleSuperclassType.class, "unbounded", List.class);
Type resolved = resolveType(method.getGenericParameterTypes()[0], MySimpleSuperclassType.class);
ResolvableType resolvableType = ResolvableType.forType(resolved);
assertThat(resolvableType.hasUnresolvableGenerics()).isFalse();
assertThat(resolvableType.resolveGenerics()).containsExactly(Object.class);
}
@Test // gh-28904
void resolveGenericWithDifferentInterfaceOrder() {
Type f = First.class.getTypeParameters()[0];
assertThat(resolveType(f, FirstSecondService.class)).isEqualTo(Integer.class);
assertThat(resolveType(f, SecondFirstService.class)).isEqualTo(Integer.class);
}
private static Method method(Class<?> target, String methodName, Class<?>... parameterTypes) { private static Method method(Class<?> target, String methodName, Class<?>... parameterTypes) {
Method method = findMethod(target, methodName, parameterTypes); Method method = findMethod(target, methodName, parameterTypes);
assertThat(method).describedAs(target.getName() + "#" + methodName).isNotNull(); assertThat(method).describedAs(target.getName() + "#" + methodName).isNotNull();
@ -268,21 +216,6 @@ class GenericTypeResolverTests {
} }
public abstract class MySuperclassType<T> { public abstract class MySuperclassType<T> {
public void upperBound(List<? extends T> list) {
}
public void upperBoundWithResolvedType(List<? extends Integer> list) {
}
public void lowerBound(List<? extends T> list) {
}
public void lowerBoundWithResolvedType(List<? super Integer> list) {
}
public void unbounded(List<?> list) {
}
} }
public class MySimpleSuperclassType extends MySuperclassType<String> { public class MySimpleSuperclassType extends MySuperclassType<String> {