Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright 2002-2010 the original author or authors.
3
   *
4
   * Licensed under the Apache License, Version 2.0 (the "License");
5
   * you may not use this file except in compliance with the License.
6
   * You may obtain a copy of the License at
7
   *
8
   *      http://www.apache.org/licenses/LICENSE-2.0
9
   *
10
  * Unless required by applicable law or agreed to in writing, software
11
  * distributed under the License is distributed on an "AS IS" BASIS,
12
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
  * See the License for the specific language governing permissions and
14
  * limitations under the License.
15
  */
16
 
17
 package org.springframework.core;
18
 
29
 import java.util.Map;
31
 
Helper class for resolving generic types against type variables.

Mainly intended for usage within the framework, resolving method parameter types even when they are declared generically.

Author(s):
Juergen Hoeller
Rob Harrop
Since:
2.5.2
See also:
GenericCollectionTypeResolver
JdkVersion
45
 
46
 public abstract class GenericTypeResolver {
Cache from Class to TypeVariable Map
48
 
49
 	private static final Map<Class, Reference<Map<TypeVariable, Type>>> typeVariableCache =
Determine the target type for the given parameter specification.

Parameters:
methodParam the method parameter specification
Returns:
the corresponding generic parameter type
57
 
58
 	public static Type getTargetType(MethodParameter methodParam) {
59
 		Assert.notNull(methodParam, "MethodParameter must not be null");
60
 		if (methodParam.getConstructor() != null) {
61
 			return methodParam.getConstructor().getGenericParameterTypes()[methodParam.getParameterIndex()];
62
 		}
63
 		else {
64
 			if (methodParam.getParameterIndex() >= 0) {
65
 				return methodParam.getMethod().getGenericParameterTypes()[methodParam.getParameterIndex()];
66
 			}
67
 			else {
68
 				return methodParam.getMethod().getGenericReturnType();
69
 			}
70
 		}
71
 	}
Determine the target type for the given generic parameter type.

Parameters:
methodParam the method parameter specification
clazz the class to resolve type variables against
Returns:
the corresponding generic parameter or return type
78
 
79
 	public static Class<?> resolveParameterType(MethodParameter methodParam, Class clazz) {
80
 		Type genericType = getTargetType(methodParam);
81
 		Assert.notNull(clazz, "Class must not be null");
82
 		Map<TypeVariable, Type> typeVariableMap = getTypeVariableMap(clazz);
83
 		Type rawType = getRawType(genericType, typeVariableMap);
84
 		Class result = (rawType instanceof Class ? (Class) rawType : methodParam.getParameterType());
85
 		methodParam.setParameterType(result);
86
 		methodParam.typeVariableMap = typeVariableMap;
87
 		return result;
88
 	}
Determine the target type for the generic return type of the given method.

Parameters:
method the method to introspect
clazz the class to resolve type variables against
Returns:
the corresponding generic parameter or return type
95
 
96
 	public static Class<?> resolveReturnType(Method method, Class clazz) {
97
 		Assert.notNull(method, "Method must not be null");
98
 		Type genericType = method.getGenericReturnType();
99
 		Assert.notNull(clazz, "Class must not be null");
100
		Map<TypeVariable, Type> typeVariableMap = getTypeVariableMap(clazz);
101
		Type rawType = getRawType(genericType, typeVariableMap);
102
		return (rawType instanceof Class ? (Class) rawType : method.getReturnType());
103
	}
Resolve the single type argument of the given generic interface against the given target class which is assumed to implement the generic interface and possibly declare a concrete type for its type variable.

Parameters:
clazz the target class to check against
genericIfc the generic interface to resolve the type argument from
Returns:
the resolved type of the argument, or null if not resolvable
113
	public static Class<?> resolveTypeArgument(Class clazz, Class genericIfc) {
114
		Class[] typeArgs = resolveTypeArguments(clazz, genericIfc);
115
		if (typeArgs == null) {
116
			return null;
117
		}
118
		if (typeArgs.length != 1) {
119
			throw new IllegalArgumentException("Expected 1 type argument on generic interface [" +
120
					genericIfc.getName() + "] but found " + typeArgs.length);
121
		}
122
		return typeArgs[0];
123
	}
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.

Parameters:
clazz the target class to check against
genericIfc the generic interface to resolve the type argument from
Returns:
the resolved type of each argument, with the array size matching the number of actual type arguments, or null if not resolvable
134
	public static Class[] resolveTypeArguments(Class clazz, Class genericIfc) {
135
		return doResolveTypeArguments(clazz, clazz, genericIfc);
136
	}
138
	private static Class[] doResolveTypeArguments(Class ownerClass, Class classToIntrospect, Class genericIfc) {
139
		while (classToIntrospect != null) {
140
			Type[] ifcs = classToIntrospect.getGenericInterfaces();
141
			for (Type ifc : ifcs) {
142
				if (ifc instanceof ParameterizedType) {
144
					Type rawType = paramIfc.getRawType();
145
					if (genericIfc.equals(rawType)) {
146
						Type[] typeArgs = paramIfc.getActualTypeArguments();
147
						Class[] result = new Class[typeArgs.length];
148
						for (int i = 0; i < typeArgs.length; i++) {
149
							Type arg = typeArgs[i];
150
							result[i] = extractClass(ownerClass, arg);
151
						}
152
						return result;
153
					}
154
					else if (genericIfc.isAssignableFrom((Class) rawType)) {
155
						return doResolveTypeArguments(ownerClass, (Class) rawType, genericIfc);
156
					}
157
				}
158
				else if (genericIfc.isAssignableFrom((Class) ifc)) {
159
					return doResolveTypeArguments(ownerClass, (Class) ifc, genericIfc);
160
				}
161
			}
162
			classToIntrospect = classToIntrospect.getSuperclass();
163
		}
164
		return null;
165
	}
Extract a class instance from given Type. 
170
	private static Class extractClass(Class ownerClass, Type arg) {
171
		if (arg instanceof TypeVariable) {
172
			TypeVariable tv = (TypeVariable) arg;
173
			arg = getTypeVariableMap(ownerClass).get(tv);
174
			if (arg == null) {
176
			}
177
			else {
178
				arg = extractClass(ownerClass, arg);
179
			}
180
		}
181
		else if (arg instanceof GenericArrayType) {
184
			Class<?> componentClass = extractClass(ownerClass, gt);
185
			arg = Array.newInstance(componentClass, 0).getClass();
186
		}
187
		return (arg instanceof Class ? (Class) arg : Object.class);
188
	}
Resolve the specified generic type against the given TypeVariable map.

Parameters:
genericType the generic type to resolve
typeVariableMap the TypeVariable Map to resolved against
Returns:
the type if it resolves to a Class, or Object.class otherwise
197
	static Class resolveType(Type genericType, Map<TypeVariable, Type> typeVariableMap) {
198
		Type rawType = getRawType(genericType, typeVariableMap);
199
		return (rawType instanceof Class ? (Class) rawType : Object.class);
200
	}
Determine the raw type for the given generic parameter type.

Parameters:
genericType the generic type to resolve
typeVariableMap the TypeVariable Map to resolved against
Returns:
the resolved raw type
208
	static Type getRawType(Type genericType, Map<TypeVariable, Type> typeVariableMap) {
209
		Type resolvedType = genericType;
210
		if (genericType instanceof TypeVariable) {
211
			TypeVariable tv = (TypeVariable) genericType;
212
			resolvedType = typeVariableMap.get(tv);
213
			if (resolvedType == null) {
214
				resolvedType = extractBoundForTypeVariable(tv);
215
			}
216
		}
217
		if (resolvedType instanceof ParameterizedType) {
218
			return ((ParameterizedType) resolvedType).getRawType();
219
		}
220
		else {
221
			return resolvedType;
222
		}
223
	}
Build a mapping of TypeVariable names to concrete java.lang.Class for the specified java.lang.Class. Searches all super types, enclosing types and interfaces. 
232
		Map<TypeVariable, Type> typeVariableMap = (ref != null ? ref.get() : null);
234
		if (typeVariableMap == null) {
235
			typeVariableMap = new HashMap<TypeVariable, Type>();
237
			// interfaces
240
			// super class
241
			Type genericType = clazz.getGenericSuperclass();
242
			Class type = clazz.getSuperclass();
243
			while (type != null && !Object.class.equals(type)) {
244
				if (genericType instanceof ParameterizedType) {
245
					ParameterizedType pt = (ParameterizedType) genericType;
247
				}
249
				genericType = type.getGenericSuperclass();
250
				type = type.getSuperclass();
251
			}
253
			// enclosing class
254
			type = clazz;
255
			while (type.isMemberClass()) {
256
				genericType = type.getGenericSuperclass();
257
				if (genericType instanceof ParameterizedType) {
258
					ParameterizedType pt = (ParameterizedType) genericType;
260
				}
261
				type = type.getEnclosingClass();
262
			}
264
			.put(clazz, new WeakReference<Map<TypeVariable, Type>>(typeVariableMap));
265
		}
267
		return typeVariableMap;
268
	}
Extracts the bound Type for a given java.lang.reflect.TypeVariable. 
274
		Type[] bounds = typeVariable.getBounds();
275
		if (bounds.length == 0) {
276
			return Object.class;
277
		}
278
		Type bound = bounds[0];
279
		if (bound instanceof TypeVariable) {
281
		}
282
		return bound;
283
	}
285
	private static void extractTypeVariablesFromGenericInterfaces(Type[] genericInterfaces, Map<TypeVariable, Type> typeVariableMap) {
286
		for (Type genericInterface : genericInterfaces) {
287
			if (genericInterface instanceof ParameterizedType) {
288
				ParameterizedType pt = (ParameterizedType) genericInterface;
290
				if (pt.getRawType() instanceof Class) {
292
							((Class) pt.getRawType()).getGenericInterfaces(), typeVariableMap);
293
				}
294
			}
295
			else if (genericInterface instanceof Class) {
297
						((Class) genericInterface).getGenericInterfaces(), typeVariableMap);
298
			}
299
		}
300
	}
Read the TypeVariables from the supplied java.lang.reflect.ParameterizedType and add mappings corresponding to the TypeVariable name -> concrete type to the supplied java.util.Map.

Consider this case: 

 public interface Foo {
  ..
 }

 public class FooImpl implements Foo<String, Integer> {
  ..
 }
For 'FooImpl' the following mappings would be added to the java.util.Map: {S=java.lang.String, T=java.lang.Integer}. 
318
	private static void populateTypeMapFromParameterizedType(ParameterizedType type, Map<TypeVariable, Type> typeVariableMap) {
319
		if (type.getRawType() instanceof Class) {
320
			Type[] actualTypeArguments = type.getActualTypeArguments();
321
			TypeVariable[] typeVariables = ((Class) type.getRawType()).getTypeParameters();
322
			for (int i = 0; i < actualTypeArguments.length; i++) {
323
				Type actualTypeArgument = actualTypeArguments[i];
324
				TypeVariable variable = typeVariables[i];
325
				if (actualTypeArgument instanceof Class) {
326
					typeVariableMap.put(variable, actualTypeArgument);
327
				}
328
				else if (actualTypeArgument instanceof GenericArrayType) {
329
					typeVariableMap.put(variable, actualTypeArgument);
330
				}
331
				else if (actualTypeArgument instanceof ParameterizedType) {
332
					typeVariableMap.put(variable, actualTypeArgument);
333
				}
334
				else if (actualTypeArgument instanceof TypeVariable) {
335
					// We have a type that is parameterized at instantiation time
336
					// the nearest match on the bridge method will be the bounded type.
337
					TypeVariable typeVariableArgument = (TypeVariable) actualTypeArgument;
338
					Type resolvedType = typeVariableMap.get(typeVariableArgument);
339
					if (resolvedType == null) {
340
						resolvedType = extractBoundForTypeVariable(typeVariableArgument);
341
					}
342
					typeVariableMap.put(variable, resolvedType);
343
				}
344
			}
345
		}
346
	}
New to GrepCode? Check out our FAQ X