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

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright 2002-2009 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
 
28
 import java.util.Map;
30
 
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
44
 
45
 public abstract class GenericTypeResolver {
Cache from Class to TypeVariable Map
47
 
48
 	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
56
 
57
 	public static Type getTargetType(MethodParameter methodParam) {
58
 		Assert.notNull(methodParam, "MethodParameter must not be null");
59
 		if (methodParam.getConstructor() != null) {
60
 			return methodParam.getConstructor().getGenericParameterTypes()[methodParam.getParameterIndex()];
61
 		}
62
 		else {
63
 			if (methodParam.getParameterIndex() >= 0) {
64
 				return methodParam.getMethod().getGenericParameterTypes()[methodParam.getParameterIndex()];
65
 			}
66
 			else {
67
 				return methodParam.getMethod().getGenericReturnType();
68
 			}
69
 		}
70
 	}
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
77
 
78
 	public static Class<?> resolveParameterType(MethodParameter methodParam, Class clazz) {
79
 		Type genericType = getTargetType(methodParam);
80
 		Assert.notNull(clazz, "Class must not be null");
81
 		Map<TypeVariable, Type> typeVariableMap = getTypeVariableMap(clazz);
82
 		Type rawType = getRawType(genericType, typeVariableMap);
83
 		Class result = (rawType instanceof Class ? (Class) rawType : methodParam.getParameterType());
84
 		methodParam.setParameterType(result);
85
 		methodParam.typeVariableMap = typeVariableMap;
86
 		return result;
87
 	}
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
94
 
95
 	public static Class<?> resolveReturnType(Method method, Class clazz) {
96
 		Assert.notNull(method, "Method must not be null");
97
 		Type genericType = method.getGenericReturnType();
98
 		Assert.notNull(clazz, "Class must not be null");
99
 		Map<TypeVariable, Type> typeVariableMap = getTypeVariableMap(clazz);
100
		Type rawType = getRawType(genericType, typeVariableMap);
101
		return (rawType instanceof Class ? (Class) rawType : method.getReturnType());
102
	}
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
112
	public static Class<?> resolveTypeArgument(Class clazz, Class genericIfc) {
113
		Class[] typeArgs = resolveTypeArguments(clazz, genericIfc);
114
		if (typeArgs == null) {
115
			return null;
116
		}
117
		if (typeArgs.length != 1) {
118
			throw new IllegalArgumentException("Expected 1 type argument on generic interface [" +
119
					genericIfc.getName() + "] but found " + typeArgs.length);
120
		}
121
		return typeArgs[0];
122
	}
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
133
	public static Class[] resolveTypeArguments(Class clazz, Class genericIfc) {
134
		return doResolveTypeArguments(clazz, clazz, genericIfc);
135
	}
137
	private static Class[] doResolveTypeArguments(Class ownerClass, Class classToIntrospect, Class genericIfc) {
138
		while (classToIntrospect != null) {
139
			Type[] ifcs = classToIntrospect.getGenericInterfaces();
140
			for (Type ifc : ifcs) {
141
				if (ifc instanceof ParameterizedType) {
143
					Type rawType = paramIfc.getRawType();
144
					if (genericIfc.equals(rawType)) {
145
						Type[] typeArgs = paramIfc.getActualTypeArguments();
146
						Class[] result = new Class[typeArgs.length];
147
						for (int i = 0; i < typeArgs.length; i++) {
148
							Type arg = typeArgs[i];
149
							if (arg instanceof TypeVariable) {
150
								arg = getTypeVariableMap(ownerClass).get((TypeVariable) arg);
151
							}
152
							result[i] = (arg instanceof Class ? (Class) arg : Object.class);
153
						}
154
						return result;
155
					}
156
					else if (genericIfc.isAssignableFrom((Class) rawType)) {
157
						return doResolveTypeArguments(ownerClass, (Class) rawType, genericIfc);
158
					}
159
				}
160
				else if (genericIfc.isAssignableFrom((Class) ifc)) {
161
					return doResolveTypeArguments(ownerClass, (Class) ifc, genericIfc);
162
				}
163
			}
164
			classToIntrospect = classToIntrospect.getSuperclass();
165
		}
166
		return null;
167
	}
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
176
	static Class resolveType(Type genericType, Map<TypeVariable, Type> typeVariableMap) {
177
		Type rawType = getRawType(genericType, typeVariableMap);
178
		return (rawType instanceof Class ? (Class) rawType : Object.class);
179
	}
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
187
	static Type getRawType(Type genericType, Map<TypeVariable, Type> typeVariableMap) {
188
		Type resolvedType = genericType;
189
		if (genericType instanceof TypeVariable) {
190
			TypeVariable tv = (TypeVariable) genericType;
191
			resolvedType = typeVariableMap.get(tv);
192
			if (resolvedType == null) {
193
				resolvedType = extractBoundForTypeVariable(tv);
194
			}
195
		}
196
		if (resolvedType instanceof ParameterizedType) {
197
			return ((ParameterizedType) resolvedType).getRawType();
198
		}
199
		else {
200
			return resolvedType;
201
		}
202
	}
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. 
211
		Map<TypeVariable, Type> typeVariableMap = (ref != null ? ref.get() : null);
213
		if (typeVariableMap == null) {
214
			typeVariableMap = new HashMap<TypeVariable, Type>();
216
			// interfaces
219
			// super class
220
			Type genericType = clazz.getGenericSuperclass();
221
			Class type = clazz.getSuperclass();
222
			while (type != null && !Object.class.equals(type)) {
223
				if (genericType instanceof ParameterizedType) {
224
					ParameterizedType pt = (ParameterizedType) genericType;
226
				}
228
				genericType = type.getGenericSuperclass();
229
				type = type.getSuperclass();
230
			}
232
			// enclosing class
233
			type = clazz;
234
			while (type.isMemberClass()) {
235
				genericType = type.getGenericSuperclass();
236
				if (genericType instanceof ParameterizedType) {
237
					ParameterizedType pt = (ParameterizedType) genericType;
239
				}
240
				type = type.getEnclosingClass();
241
			}
243
			.put(clazz, new WeakReference<Map<TypeVariable, Type>>(typeVariableMap));
244
		}
246
		return typeVariableMap;
247
	}
Extracts the bound Type for a given java.lang.reflect.TypeVariable. 
253
		Type[] bounds = typeVariable.getBounds();
254
		if (bounds.length == 0) {
255
			return Object.class;
256
		}
257
		Type bound = bounds[0];
258
		if (bound instanceof TypeVariable) {
260
		}
261
		return bound;
262
	}
264
	private static void extractTypeVariablesFromGenericInterfaces(Type[] genericInterfaces, Map<TypeVariable, Type> typeVariableMap) {
265
		for (Type genericInterface : genericInterfaces) {
266
			if (genericInterface instanceof ParameterizedType) {
267
				ParameterizedType pt = (ParameterizedType) genericInterface;
269
				if (pt.getRawType() instanceof Class) {
271
							((Class) pt.getRawType()).getGenericInterfaces(), typeVariableMap);
272
				}
273
			}
274
			else if (genericInterface instanceof Class) {
276
						((Class) genericInterface).getGenericInterfaces(), typeVariableMap);
277
			}
278
		}
279
	}
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}. 
297
	private static void populateTypeMapFromParameterizedType(ParameterizedType type, Map<TypeVariable, Type> typeVariableMap) {
298
		if (type.getRawType() instanceof Class) {
299
			Type[] actualTypeArguments = type.getActualTypeArguments();
300
			TypeVariable[] typeVariables = ((Class) type.getRawType()).getTypeParameters();
301
			for (int i = 0; i < actualTypeArguments.length; i++) {
302
				Type actualTypeArgument = actualTypeArguments[i];
303
				TypeVariable variable = typeVariables[i];
304
				if (actualTypeArgument instanceof Class) {
305
					typeVariableMap.put(variable, actualTypeArgument);
306
				}
307
				else if (actualTypeArgument instanceof GenericArrayType) {
308
					typeVariableMap.put(variable, actualTypeArgument);
309
				}
310
				else if (actualTypeArgument instanceof ParameterizedType) {
311
					typeVariableMap.put(variable, actualTypeArgument);
312
				}
313
				else if (actualTypeArgument instanceof TypeVariable) {
314
					// We have a type that is parameterized at instantiation time
315
					// the nearest match on the bridge method will be the bounded type.
316
					TypeVariable typeVariableArgument = (TypeVariable) actualTypeArgument;
317
					Type resolvedType = typeVariableMap.get(typeVariableArgument);
318
					if (resolvedType == null) {
319
						resolvedType = extractBoundForTypeVariable(typeVariableArgument);
320
					}
321
					typeVariableMap.put(variable, resolvedType);
322
				}
323
			}
324
		}
325
	}
New to GrepCode? Check out our FAQ X