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

Remove references to ClassTypeInformation from TypeInformation.

Browse Source 
Closes #2703
This commit is contained in:
Mark Paluch
2022-10-06 16:20:22 +02:00
parent 1ff6e39ec2
commit b55f098b43
9 changed files with 43 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
src/main/java/org/springframework/data/util/ClassTypeInformation.java
View File

@@ -33,18 +33,18 @@ import org.springframework.util.ConcurrentLruCache;
* @author Christoph Strobl
* @deprecated since 3.0 to go package protected at some point. Refer to {@link TypeInformation} only.
*/
@Deprecated
@Deprecated(since = "3.0", forRemoval = true)
@SuppressWarnings({ "rawtypes", "unchecked" })
public class ClassTypeInformation<S> extends TypeDiscoverer<S> {
private static final ConcurrentLruCache<ResolvableType, ClassTypeInformation<?>> cache = new ConcurrentLruCache<>(64,
ClassTypeInformation::new);
@Deprecated public static final ClassTypeInformation<Collection> COLLECTION;
@Deprecated public static final ClassTypeInformation<List> LIST;
@Deprecated public static final ClassTypeInformation<Set> SET;
@Deprecated public static final ClassTypeInformation<Map> MAP;
@Deprecated public static final ClassTypeInformation<Object> OBJECT;
public static final ClassTypeInformation<Collection> COLLECTION;
public static final ClassTypeInformation<List> LIST;
public static final ClassTypeInformation<Set> SET;
public static final ClassTypeInformation<Map> MAP;
public static final ClassTypeInformation<Object> OBJECT;
static {
@@ -62,11 +62,6 @@ public class ClassTypeInformation<S> extends TypeDiscoverer<S> {
this.type = (Class<S>) type.resolve(Object.class);
}
private ClassTypeInformation(Class<S> type) {
super(ResolvableType.forClass(type));
this.type = type;
}
/**
* @param <S>
* @param type
@@ -75,10 +70,10 @@ public class ClassTypeInformation<S> extends TypeDiscoverer<S> {
*/
@Deprecated
public static <S> ClassTypeInformation<S> from(Class<S> type) {
return cti(ResolvableType.forClass(type));
return from(ResolvableType.forClass(type));
}
static <S> ClassTypeInformation<S> cti(ResolvableType type) {
static <S> ClassTypeInformation<S> from(ResolvableType type) {
Assert.notNull(type, "Type must not be null");
@@ -104,8 +99,7 @@ public class ClassTypeInformation<S> extends TypeDiscoverer<S> {
*/
static TypeInformation<?> fromReturnTypeOf(Method method, @Nullable Class<?> actualType) {
var type = actualType == null
? ResolvableType.forMethodReturnType(method)
var type = actualType == null ? ResolvableType.forMethodReturnType(method)
: ResolvableType.forMethodReturnType(method, actualType);
return TypeInformation.of(type);

27
src/main/java/org/springframework/data/util/TypeDiscoverer.java
View File

@@ -47,9 +47,7 @@ import org.springframework.util.ReflectionUtils;
* @author Jürgen Diez
* @author Alessandro Nistico
* @author Johannes Englmeier
* @deprecated since 3.0 to go package protected at some point. Prefer to refer to {@link TypeInformation} instead.
*/
@Deprecated
class TypeDiscoverer<S> implements TypeInformation<S> {
private static final ConcurrentLruCache<ResolvableType, TypeInformation<?>> CACHE = new ConcurrentLruCache<>(64,
@@ -124,8 +122,7 @@ class TypeDiscoverer<S> implements TypeInformation<S> {
return type.isArray() //
|| Iterable.class.equals(type) //
|| Collection.class.isAssignableFrom(type) //
|| Streamable.class.isAssignableFrom(type)
|| CustomCollections.isCollection(type);
|| Streamable.class.isAssignableFrom(type) || CustomCollections.isCollection(type);
}
@Nullable
@@ -195,7 +192,7 @@ class TypeDiscoverer<S> implements TypeInformation<S> {
}
@Override
public ClassTypeInformation<?> getRawTypeInformation() {
public TypeInformation<?> getRawTypeInformation() {
return new ClassTypeInformation<>(ResolvableType.forRawClass(resolvableType.toClass()));
}
@@ -257,13 +254,10 @@ class TypeDiscoverer<S> implements TypeInformation<S> {
return TypeInformation.of(resolvableSuperType);
}
var noGenericsResolvable = !Arrays.stream(resolvableSuperType.resolveGenerics())
.filter(it -> it != null)
.findAny()
var noGenericsResolvable = !Arrays.stream(resolvableSuperType.resolveGenerics()).filter(it -> it != null).findAny()
.isPresent();
return noGenericsResolvable
? new ClassTypeInformation<>(ResolvableType.forRawClass(superType))
return noGenericsResolvable ? new ClassTypeInformation<>(ResolvableType.forRawClass(superType))
: TypeInformation.of(resolvableSuperType);
}
@@ -299,8 +293,7 @@ class TypeDiscoverer<S> implements TypeInformation<S> {
}
return Arrays.stream(resolvableType.getGenerics())
.<TypeInformation<?>> map(it -> it.resolve(Object.class) == null ? null : TypeInformation.of(it))
.toList();
.<TypeInformation<?>> map(it -> it.resolve(Object.class) == null ? null : TypeInformation.of(it)).toList();
}
@Override
@@ -308,8 +301,8 @@ class TypeDiscoverer<S> implements TypeInformation<S> {
public TypeInformation<? extends S> specialize(TypeInformation<?> type) {
if (this.getTypeArguments().size() == type.getTypeArguments().size()) {
return (TypeInformation<? extends S>) TypeInformation.of(
ResolvableType.forClassWithGenerics(type.getType(), this.resolvableType.getGenerics()));
return (TypeInformation<? extends S>) TypeInformation
.of(ResolvableType.forClassWithGenerics(type.getType(), this.resolvableType.getGenerics()));
}
return TypeInformation.of((Class<S>) type.getType());
@@ -380,10 +373,8 @@ class TypeDiscoverer<S> implements TypeInformation<S> {
var rawType = getType();
var field = ReflectionUtils.findField(rawType, fieldname);
return field != null
? Optional.of(TypeInformation.of(ResolvableType.forField(field, resolvableType)))
: Optional.ofNullable(BeanUtils.getPropertyDescriptor(rawType, fieldname))
.map(it -> from(it, rawType))
return field != null ? Optional.of(TypeInformation.of(ResolvableType.forField(field, resolvableType)))
: Optional.ofNullable(BeanUtils.getPropertyDescriptor(rawType, fieldname)).map(it -> from(it, rawType))
.map(TypeInformation::of);
}

52
src/main/java/org/springframework/data/util/TypeInformation.java
View File

@@ -42,15 +42,11 @@ import org.springframework.util.Assert;
@SuppressWarnings({ "deprecation", "rawtypes" })
public interface TypeInformation<S> {
public static final TypeInformation<Collection> COLLECTION = ClassTypeInformation.COLLECTION;
public static final TypeInformation<List> LIST = ClassTypeInformation.LIST;
public static final TypeInformation<Set> SET = ClassTypeInformation.SET;
public static final TypeInformation<Map> MAP = ClassTypeInformation.MAP;
public static final TypeInformation<Object> OBJECT = ClassTypeInformation.OBJECT;
static TypeInformation<?> orObject(@Nullable ResolvableType type) {
return type == null ? ClassTypeInformation.OBJECT : of(type);
}
TypeInformation<Collection> COLLECTION = ClassTypeInformation.COLLECTION;
TypeInformation<List> LIST = ClassTypeInformation.LIST;
TypeInformation<Set> SET = ClassTypeInformation.SET;
TypeInformation<Map> MAP = ClassTypeInformation.MAP;
TypeInformation<Object> OBJECT = ClassTypeInformation.OBJECT;
/**
* Creates a new {@link TypeInformation} from the given {@link ResolvableType}.
@@ -63,11 +59,8 @@ public interface TypeInformation<S> {
Assert.notNull(type, "Type must not be null");
return type.hasGenerics()
|| (type.isArray() && type.getComponentType().hasGenerics()) //
|| (type.getType() instanceof TypeVariable)
? TypeDiscoverer.td(type)
: ClassTypeInformation.cti(type);
return type.hasGenerics() || (type.isArray() && type.getComponentType().hasGenerics()) //
|| (type.getType() instanceof TypeVariable) ? TypeDiscoverer.td(type) : ClassTypeInformation.from(type);
}
/**
@@ -108,8 +101,7 @@ public interface TypeInformation<S> {
*/
public static TypeInformation<?> fromReturnTypeOf(Method method, @Nullable Class<?> type) {
ResolvableType intermediate = type == null
? ResolvableType.forMethodReturnType(method)
ResolvableType intermediate = type == null ? ResolvableType.forMethodReturnType(method)
: ResolvableType.forMethodReturnType(method, type);
return TypeInformation.of(intermediate);
@@ -161,8 +153,7 @@ public interface TypeInformation<S> {
return typeInformation;
}
throw new IllegalArgumentException(
String.format("Could not find required property %s on %s", property, getType()));
throw new IllegalArgumentException(String.format("Could not find required property %s on %s", property, getType()));
}
/**
@@ -259,12 +250,11 @@ public interface TypeInformation<S> {
}
/**
* Returns a {@link ClassTypeInformation} to represent the {@link TypeInformation} of the raw type of the current
* instance.
* Returns a {@link TypeInformation} to represent the {@link TypeInformation} of the raw type of the current instance.
*
* @return
*/
ClassTypeInformation<?> getRawTypeInformation();
TypeInformation<?> getRawTypeInformation();
/**
* Transparently returns the {@link java.util.Map} value type if the type is a {@link java.util.Map}, returns the
@@ -338,8 +328,7 @@ public interface TypeInformation<S> {
if (result == null) {
throw new IllegalArgumentException(String.format(
"Can't retrieve super type information for %s; Does current type really implement the given one",
superType));
"Can't retrieve super type information for %s; Does current type really implement the given one", superType));
}
return result;
@@ -362,21 +351,6 @@ public interface TypeInformation<S> {
*/
List<TypeInformation<?>> getTypeArguments();
/**
* Specializes the given (raw) {@link ClassTypeInformation} using the context of the current potentially parameterized
* type, basically turning the given raw type into a parameterized one. Will return the given type as is if no
* generics are involved.
*
* @param type must not be {@literal null}.
* @return will never be {@literal null}.
* @deprecated since 3.0. Use {@link #specialize(TypeInformation)} instead, i.e. switch the given parameter's type to
* {@link TypeInformation} in the first place.
*/
@Deprecated
default TypeInformation<? extends S> specialize(ClassTypeInformation<?> type) {
return specialize((TypeInformation<?>) type);
}
/**
* Specializes the given (raw) {@link TypeInformation} using the context of the current potentially parameterized
* type, basically turning the given raw type into a parameterized one. Will return the given type as is if no
@@ -391,7 +365,7 @@ public interface TypeInformation<S> {
}
/**
* Returns whether the current type is a sub type of the given one, i.e. whether it's assignable but not the same one.
* Returns whether the current type is a subtype of the given one, i.e. whether it's assignable but not the same one.
*
* @param type must not be {@literal null}.
* @return