null if not resolvable
- */
- public static Class resolveTypeArgument(Class clazz, Class genericIfc) {
- Class[] typeArgs = resolveTypeArguments(clazz, genericIfc);
- if (typeArgs == null) {
- return null;
- }
- if (typeArgs.length != 1) {
- throw new IllegalArgumentException("Expected 1 type argument on generic interface [" + genericIfc.getName()
- + "] but found " + typeArgs.length);
- }
- return typeArgs[0];
- }
-
- /**
- * Resolve the type arguments of the given generic interface against the given target class which is assumed to
- * implement the generic interface and possibly declare concrete types for its type variables.
- *
- * @param clazz the target class to check against
- * @param genericIfc the generic interface or superclass to resolve the type argument from
- * @return the resolved type of each argument, with the array size matching the number of actual type arguments, or
- * null if not resolvable
- */
- public static Class[] resolveTypeArguments(Class clazz, Class genericIfc) {
- return doResolveTypeArguments(clazz, clazz, genericIfc);
- }
-
- private static Class[] doResolveTypeArguments(Class ownerClass, Class classToIntrospect, Class genericIfc) {
- while (classToIntrospect != null) {
- if (genericIfc.isInterface()) {
- Type[] ifcs = classToIntrospect.getGenericInterfaces();
- for (Type ifc : ifcs) {
- Class[] result = doResolveTypeArguments(ownerClass, ifc, genericIfc);
- if (result != null) {
- return result;
- }
- }
- } else {
- Class[] result = doResolveTypeArguments(ownerClass, classToIntrospect.getGenericSuperclass(), genericIfc);
- if (result != null) {
- return result;
- }
- }
- classToIntrospect = classToIntrospect.getSuperclass();
- }
- return null;
- }
-
- private static Class[] doResolveTypeArguments(Class ownerClass, Type ifc, Class genericIfc) {
- if (ifc instanceof ParameterizedType) {
- ParameterizedType paramIfc = (ParameterizedType) ifc;
- Type rawType = paramIfc.getRawType();
- if (genericIfc.equals(rawType)) {
- Type[] typeArgs = paramIfc.getActualTypeArguments();
- Class[] result = new Class[typeArgs.length];
- for (int i = 0; i < typeArgs.length; i++) {
- Type arg = typeArgs[i];
- result[i] = extractClass(ownerClass, arg);
- }
- return result;
- } else if (genericIfc.isAssignableFrom((Class) rawType)) {
- return doResolveTypeArguments(ownerClass, (Class) rawType, genericIfc);
- }
- } else if (genericIfc.isAssignableFrom((Class) ifc)) {
- return doResolveTypeArguments(ownerClass, (Class) ifc, genericIfc);
- }
- return null;
- }
-
- /**
- * Extract a class instance from given Type.
- */
- private static Class extractClass(Class ownerClass, Type arg) {
- if (arg instanceof ParameterizedType) {
- return extractClass(ownerClass, ((ParameterizedType) arg).getRawType());
- } else if (arg instanceof GenericArrayType) {
- GenericArrayType gat = (GenericArrayType) arg;
- Type gt = gat.getGenericComponentType();
- Class componentClass = extractClass(ownerClass, gt);
- return Array.newInstance(componentClass, 0).getClass();
- } else if (arg instanceof TypeVariable) {
- TypeVariable tv = (TypeVariable) arg;
- arg = getTypeVariableMap(ownerClass).get(tv);
- if (arg == null) {
- arg = extractBoundForTypeVariable(tv);
- } else {
- arg = extractClass(ownerClass, arg);
- }
- }
- return (arg instanceof Class ? (Class) arg : Object.class);
- }
-
- /**
- * Resolve the specified generic type against the given TypeVariable map.
- *
- * @param genericType the generic type to resolve
- * @param typeVariableMap the TypeVariable Map to resolved against
- * @return the type if it resolves to a Class, or Object.class otherwise
- */
- static Class resolveType(Type genericType, MapType for a given {@link TypeVariable}.
- */
- static Type extractBoundForTypeVariable(TypeVariable typeVariable) {
- Type[] bounds = typeVariable.getBounds();
- if (bounds.length == 0) {
- return Object.class;
- }
- Type bound = bounds[0];
- if (bound instanceof TypeVariable) {
- bound = extractBoundForTypeVariable((TypeVariable) bound);
- }
- return bound;
- }
-
- private static void extractTypeVariablesFromGenericInterfaces(Type[] genericInterfaces,
- Map resolveType(Type type) {
- return GenericTypeResolver.resolveType(type, getTypeVariableMap());
+ return (Class) GenericTypeResolver.resolveType(type, getTypeVariableMap());
}
/*
diff --git a/spring-data-commons-parent/pom.xml b/spring-data-commons-parent/pom.xml
index fa6b9e521..08248e2bc 100644
--- a/spring-data-commons-parent/pom.xml
+++ b/spring-data-commons-parent/pom.xml
@@ -14,9 +14,9 @@
4.8.1
1.2.16
1.8.5
- 3.0.6.RELEASE
+ 3.0.7.RELEASE
4.0.0.RELEASE
- [${org.springframework.version.30}, ${org.springframework.version.40}]
+ [${org.springframework.version.30}, ${org.springframework.version.40})
1.2.1