【深入理解MyBatis】- 08Mybatis 类型封装TypeParameterResolver

最新推荐文章于 2023-02-16 10:18:27 发布
最新推荐文章于 2023-02-16 10:18:27 发布
阅读量346 收藏
点赞数
分类专栏： 深入理解MyBatis
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/107804184
版权

基本使用

TypeParameterResolver能做什么？

  • 获取字段的类型，如String name;中的String
  • 获取方法返回值类型，如Double simpleSelect();中的Double
  • 获取方法入参类型，如void simpleSelectVoid(Integer param);中的Integer

基本使用例子

import static org.junit.Assert.assertEquals;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Type;

import org.junit.Test;

public class MyTypeParameterResolverTest {
	
	static class Person {
		private String name;
		
		String test(Integer n) {
			return name;
		}
	}
	
	@Test
	public void testReturn_String() throws Exception {
		Class<?> clazz = Person.class;
		Method method = clazz.getDeclaredMethod("test", Integer.class);
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(String.class, result);
	}
	
	@Test
	public void testParam_Integer() throws Exception {
		Class<?> clazz = Person.class;
		Method method = clazz.getDeclaredMethod("test", Integer.class);
		Type[] result = TypeParameterResolver.resolveParamTypes(method, clazz);
		assertEquals(Integer.class, result[0]);
	}
	
	@Test
	public void testField_String() throws Exception {
		Class<?> clazz = Person.class;
		Field field = clazz.getDeclaredField("name");
		Type result = TypeParameterResolver.resolveFieldType(field, clazz);
		assertEquals(String.class, result);
	}
}

获取复杂类型参数

包括java type

  • ParameterizedType
  • TypeVariable
  • GenericArrayType
  • WildcardType

使用如下

public class TypeParameterResolverTest {
	@Test
	public void testReturn_Lv0SimpleClass() throws Exception {
		// Double simpleSelect();
		Class<?> clazz = Level0Mapper.class;
		Method method = clazz.getMethod("simpleSelect");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(Double.class, result);
	}

	@Test
	public void testReturn_SimpleVoid() throws Exception {
		// void simpleSelectVoid(Integer param);
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("simpleSelectVoid", Integer.class);
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(void.class, result);
	}

	@Test
	public void testReturn_SimplePrimitive() throws Exception {
		// double simpleSelectPrimitive(int param);
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("simpleSelectPrimitive", int.class);
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(double.class, result);
	}

	@Test
	public void testReturn_SimpleClass() throws Exception {
		// Double simpleSelect();
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("simpleSelect");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(Double.class, result);
	}

	@Test
	public void testReturn_SimpleList() throws Exception {
		// List<Double> simpleSelectList();
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("simpleSelectList");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof ParameterizedType);
		ParameterizedType paramType = (ParameterizedType) result;
		assertEquals(List.class, paramType.getRawType());
		assertEquals(1, paramType.getActualTypeArguments().length);
		assertEquals(Double.class, paramType.getActualTypeArguments()[0]);
	}

	@Test
	public void testReturn_SimpleMap() throws Exception {
		// Map<Integer, Double> simpleSelectMap();
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("simpleSelectMap");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof ParameterizedType);
		ParameterizedType paramType = (ParameterizedType) result;
		assertEquals(Map.class, paramType.getRawType());
		assertEquals(2, paramType.getActualTypeArguments().length);
		assertEquals(Integer.class, paramType.getActualTypeArguments()[0]);
		assertEquals(Double.class, paramType.getActualTypeArguments()[1]);
	}

	@Test
	public void testReturn_SimpleWildcard() throws Exception {
		// List<? extends String> simpleSelectWildcard();
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("simpleSelectWildcard");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof ParameterizedType);
		ParameterizedType paramType = (ParameterizedType) result;
		assertEquals(List.class, paramType.getRawType());
		assertEquals(1, paramType.getActualTypeArguments().length);
		assertTrue(paramType.getActualTypeArguments()[0] instanceof WildcardType);
		WildcardType wildcard = (WildcardType) paramType.getActualTypeArguments()[0];
		assertEquals(String.class, wildcard.getUpperBounds()[0]);
	}

	@Test
	public void testReturn_SimpleArray() throws Exception {
		// String[] simpleSelectArray();
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("simpleSelectArray");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof Class);
		Class<?> resultClass = (Class<?>) result;
		assertTrue(resultClass.isArray());
		assertEquals(String.class, resultClass.getComponentType());
	}

	@Test
	public void testReturn_SimpleArrayOfArray() throws Exception {
		// String[][] simpleSelectArrayOfArray();
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("simpleSelectArrayOfArray");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof Class);
		Class<?> resultClass = (Class<?>) result;
		assertTrue(resultClass.isArray());
		assertTrue(resultClass.getComponentType().isArray());
		assertEquals(String.class, resultClass.getComponentType().getComponentType());
	}

	@Test
	public void testReturn_SimpleTypeVar() throws Exception {
		// <K extends Calculator<?>> K simpleSelectTypeVar();
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("simpleSelectTypeVar");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(Object.class, result);
	}

	@Test
	public void testReturn_Lv1Class() throws Exception {
		// N select(N param);
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("select", Object.class);
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(String.class, result);
	}

	@Test
	public void testReturn_Lv2CustomClass() throws Exception {
		// Calculator<N> selectCalculator(Calculator<N> param);
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("selectCalculator", Calculator.class);
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof ParameterizedType);
		ParameterizedType paramType = (ParameterizedType) result;
		assertEquals(Calculator.class, paramType.getRawType());
		assertEquals(1, paramType.getActualTypeArguments().length);
		assertEquals(String.class, paramType.getActualTypeArguments()[0]);
	}

	@Test
	public void testReturn_Lv2CustomClassList() throws Exception {
		// List<Calculator<L>> selectCalculatorList();
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("selectCalculatorList");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof ParameterizedType);
		ParameterizedType paramTypeOuter = (ParameterizedType) result;
		assertEquals(List.class, paramTypeOuter.getRawType());
		assertEquals(1, paramTypeOuter.getActualTypeArguments().length);
		ParameterizedType paramTypeInner = (ParameterizedType) paramTypeOuter.getActualTypeArguments()[0];
		assertEquals(Calculator.class, paramTypeInner.getRawType());
		assertEquals(Date.class, paramTypeInner.getActualTypeArguments()[0]);
	}

	@Test
	public void testReturn_Lv0InnerClass() throws Exception {
		// N select(N param);
		Class<?> clazz = Level0InnerMapper.class;
		Method method = clazz.getMethod("select", Object.class);
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(Float.class, result);
	}

	@Test
	public void testReturn_Lv2Class() throws Exception {
		// N select(N param);
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("select", Object.class);
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(String.class, result);
	}

	@Test
	public void testReturn_Lv1List() throws Exception {
		// List<N> selectList(M param1, N param2);
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("selectList", Object.class, Object.class);
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof ParameterizedType);
		ParameterizedType type = (ParameterizedType) result;
		assertEquals(List.class, type.getRawType());
		assertEquals(1, type.getActualTypeArguments().length);
		assertEquals(String.class, type.getActualTypeArguments()[0]);
	}

	@Test
	public void testReturn_Lv1Array() throws Exception {
		// N[] selectArray(List<N>[] param);
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("selectArray", List[].class);
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof Class);
		Class<?> resultClass = (Class<?>) result;
		assertTrue(resultClass.isArray());
		assertEquals(String.class, resultClass.getComponentType());
	}

	@Test
	public void testReturn_Lv2ArrayOfArray() throws Exception {
		// N[][] selectArrayOfArray();
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("selectArrayOfArray");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof Class);
		Class<?> resultClass = (Class<?>) result;
		assertTrue(result instanceof Class);
		assertTrue(resultClass.isArray());
		assertTrue(resultClass.getComponentType().isArray());
		assertEquals(String.class, resultClass.getComponentType().getComponentType());
	}

	@Test
	public void testReturn_Lv2ArrayOfList() throws Exception {
		//  List<N>[] selectArrayOfList();
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("selectArrayOfList");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof GenericArrayType);
		GenericArrayType genericArrayType = (GenericArrayType) result;
		assertTrue(genericArrayType.getGenericComponentType() instanceof ParameterizedType);
		ParameterizedType paramType = (ParameterizedType) genericArrayType.getGenericComponentType();
		assertEquals(List.class, paramType.getRawType());
		assertEquals(String.class, paramType.getActualTypeArguments()[0]);
	}

	@Test
	public void testReturn_Lv2WildcardList() throws Exception {
		// List<? extends N> selectWildcardList();
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("selectWildcardList");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof ParameterizedType);
		ParameterizedType type = (ParameterizedType) result;
		assertEquals(List.class, type.getRawType());
		assertEquals(1, type.getActualTypeArguments().length);
		assertTrue(type.getActualTypeArguments()[0] instanceof WildcardType);
		WildcardType wildcard = (WildcardType) type.getActualTypeArguments()[0];
		assertEquals(0, wildcard.getLowerBounds().length);
		assertEquals(1, wildcard.getUpperBounds().length);
		assertEquals(String.class, wildcard.getUpperBounds()[0]);
	}

	@Test
	public void testReturn_LV2Map() throws Exception {
		// Map<N, M> selectMap();
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("selectMap");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertTrue(result instanceof ParameterizedType);
		ParameterizedType paramType = (ParameterizedType) result;
		assertEquals(Map.class, paramType.getRawType());
		assertEquals(2, paramType.getActualTypeArguments().length);
		assertEquals(String.class, paramType.getActualTypeArguments()[0]);
		assertEquals(Integer.class, paramType.getActualTypeArguments()[1]);
	}

	@Test
	public void testReturn_Subclass() throws Exception {
		Class<?> clazz = SubCalculator.class;
		Method method = clazz.getMethod("getId");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(String.class, result);
	}

	@Test
	public void testParam_Primitive() throws Exception {
		// double simpleSelectPrimitive(int param);
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("simpleSelectPrimitive", int.class);
		Type[] result = TypeParameterResolver.resolveParamTypes(method, clazz);
		assertEquals(1, result.length);
		assertEquals(int.class, result[0]);
	}

	@Test
	public void testParam_Simple() throws Exception {
		// void simpleSelectVoid(Integer param);
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("simpleSelectVoid", Integer.class);
		Type[] result = TypeParameterResolver.resolveParamTypes(method, clazz);
		assertEquals(1, result.length);
		assertEquals(Integer.class, result[0]);
	}

	@Test
	public void testParam_Lv1Single() throws Exception {
		// N select(N param);
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("select", Object.class);
		Type[] result = TypeParameterResolver.resolveParamTypes(method, clazz);
		assertEquals(1, result.length);
		assertEquals(String.class, result[0]);
	}

	@Test
	public void testParam_Lv2Single() throws Exception {
		// N select(N param);
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("select", Object.class);
		Type[] result = TypeParameterResolver.resolveParamTypes(method, clazz);
		assertEquals(1, result.length);
		assertEquals(String.class, result[0]);
	}

	@Test
	public void testParam_Lv2Multiple() throws Exception {
		// List<N> selectList(M param1, N param2);
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("selectList", Object.class, Object.class);
		Type[] result = TypeParameterResolver.resolveParamTypes(method, clazz);
		assertEquals(2, result.length);
		assertEquals(Integer.class, result[0]);
		assertEquals(String.class, result[1]);
	}

	@Test
	public void testParam_Lv2CustomClass() throws Exception {
		// Calculator<N> selectCalculator(Calculator<N> param);
		Class<?> clazz = Level2Mapper.class;
		Method method = clazz.getMethod("selectCalculator", Calculator.class);
		Type[] result = TypeParameterResolver.resolveParamTypes(method, clazz);
		assertEquals(1, result.length);
		assertTrue(result[0] instanceof ParameterizedType);
		ParameterizedType paramType = (ParameterizedType) result[0];
		assertEquals(Calculator.class, paramType.getRawType());
		assertEquals(1, paramType.getActualTypeArguments().length);
		assertEquals(String.class, paramType.getActualTypeArguments()[0]);
	}

	@Test
	public void testParam_Lv1Array() throws Exception {
		// String[] simpleSelectArray();
		Class<?> clazz = Level1Mapper.class;
		Method method = clazz.getMethod("selectArray", List[].class);
		Type[] result = TypeParameterResolver.resolveParamTypes(method, clazz);
		assertTrue(result[0] instanceof GenericArrayType);
		GenericArrayType genericArrayType = (GenericArrayType) result[0];
		assertTrue(genericArrayType.getGenericComponentType() instanceof ParameterizedType);
		ParameterizedType paramType = (ParameterizedType) genericArrayType.getGenericComponentType();
		assertEquals(List.class, paramType.getRawType());
		assertEquals(String.class, paramType.getActualTypeArguments()[0]);
	}

	@Test
	public void testParam_Subclass() throws Exception {
		Class<?> clazz = SubCalculator.class;
		Method method = clazz.getMethod("setId", Object.class);
		Type[] result = TypeParameterResolver.resolveParamTypes(method, clazz);
		assertEquals(String.class, result[0]);
	}

	@Test
	public void testReturn_Anonymous() throws Exception {
		Calculator<?> instance = new Calculator<Integer>();
		Class<?> clazz = instance.getClass();
		Method method = clazz.getMethod("getId");
		Type result = TypeParameterResolver.resolveReturnType(method, clazz);
		assertEquals(Object.class, result);
	}

	@Test
	public void testField_GenericField() throws Exception {
		Class<?> clazz = SubCalculator.class;
		Class<?> declaredClass = Calculator.class;
		Field field = declaredClass.getDeclaredField("fld");
		Type result = TypeParameterResolver.resolveFieldType(field, clazz);
		assertEquals(String.class, result);
	}

	@Test
	public void testReturnParam_WildcardWithUpperBounds() throws Exception {
		class Key {
		}
		@SuppressWarnings("unused")
		class KeyBean<S extends Key & Cloneable, T extends Key> {
			private S key1;
			private T key2;

			public S getKey1() {
				return key1;
			}

			public void setKey1(S key1) {
				this.key1 = key1;
			}

			public T getKey2() {
				return key2;
			}

			public void setKey2(T key2) {
				this.key2 = key2;
			}
		}
		Class<?> clazz = KeyBean.class;
		Method getter1 = clazz.getMethod("getKey1");
		assertEquals(Key.class, TypeParameterResolver.resolveReturnType(getter1, clazz));
		Method setter1 = clazz.getMethod("setKey1", Key.class);
		assertEquals(Key.class, TypeParameterResolver.resolveParamTypes(setter1, clazz)[0]);
		Method getter2 = clazz.getMethod("getKey2");
		assertEquals(Key.class, TypeParameterResolver.resolveReturnType(getter2, clazz));
		Method setter2 = clazz.getMethod("setKey2", Key.class);
		assertEquals(Key.class, TypeParameterResolver.resolveParamTypes(setter2, clazz)[0]);
	}
}

源码分析

主要是针对以上四种type类型的封装，三种类型获取方法入口都为同一个resolveType(returnType, srcType, declaringClass)

  • 获取字段的类型入口：resolveFieldType
  • 获取方法返回值类型入口：resolveReturnType
  • 获取方法入参类型 入口：resolveParamTypes
public class TypeParameterResolver {

	public static Type resolveReturnType(Method method, Type srcType) {
		// Generic: 带有泛型化参数
		Type returnType = method.getGenericReturnType();
		// 方法对应的类或者接口定义，[只能是public方法]
		Class<?> declaringClass = method.getDeclaringClass();
		// returnType: 方法返回类型
		// srcType: 使用class的对象
		// declaringClass：对应接口的对象
		return resolveType(returnType, srcType, declaringClass);
	}

	public static Type resolveFieldType(Field field, Type srcType) {
		Type fieldType = field.getGenericType();
		Class<?> declaringClass = field.getDeclaringClass();

		return resolveType(fieldType, srcType, declaringClass);
	}

	public static Type[] resolveParamTypes(Method method, Type srcType) {
		Type[] paramTypes = method.getGenericParameterTypes();
		Class<?> declaringClass = method.getDeclaringClass();
		Type[] result = new Type[paramTypes.length];
		for (int i = 0; i < paramTypes.length; i++) {
			result[i] = resolveType(paramTypes[i], srcType, declaringClass);
		}
		return result;
	}

	// type: 方法返回类型
	// srcType: 使用class的对象
	// declaringClass：对应接口的对象
	private static Type resolveType(Type type, Type srcType, Class<?> declaringClass) {
		// 泛型方法 T test();中的T
		if (type instanceof TypeVariable) {
			return resolveTypeVar((TypeVariable<?>) type, srcType, declaringClass);
		}
		// 方法 List<String> test();
		else if (type instanceof ParameterizedType) {
			return resolveParameterizedType((ParameterizedType) type, srcType, declaringClass);
		}
		// 方法 List<String>[] test();
		else if (type instanceof GenericArrayType) {
			return resolveGenericArrayType((GenericArrayType) type, srcType, declaringClass);
		}
		// 基本类型double，数组等String[][];
		else {
			return type;
		}
	}

	// List<String>[]
	private static Type resolveGenericArrayType(GenericArrayType genericArrayType, Type srcType,
			Class<?> declaringClass) {
		// List<String>[] -> List<String>
		Type componentType = genericArrayType.getGenericComponentType();
		Type resolvedComponentType = null;
		// N[]
		if (componentType instanceof TypeVariable) {
			resolvedComponentType = resolveTypeVar((TypeVariable<?>) componentType, srcType, declaringClass);
		}
		// N[][]
		else if (componentType instanceof GenericArrayType) {
			resolvedComponentType = resolveGenericArrayType((GenericArrayType) componentType, srcType, declaringClass);
		}
		// List<N>[]
		else if (componentType instanceof ParameterizedType) {
			resolvedComponentType = resolveParameterizedType((ParameterizedType) componentType, srcType,
					declaringClass);
		}
		if (resolvedComponentType instanceof Class) {
			return Array.newInstance((Class<?>) resolvedComponentType, 0).getClass();
		} else {
			return new GenericArrayTypeImpl(resolvedComponentType);
		}
	}

	// Map<String, String> -> parameterizedType -> getActualTypeArguments ->
	// [String, String]
	// Map<String, String> -> parameterizedType -> getRawType -> Map
	private static ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type srcType,
			Class<?> declaringClass) {
		Class<?> rawType = (Class<?>) parameterizedType.getRawType();
		Type[] typeArgs = parameterizedType.getActualTypeArguments();
		Type[] args = new Type[typeArgs.length];
		for (int i = 0; i < typeArgs.length; i++) {
			// 方法 T test();中的T
			if (typeArgs[i] instanceof TypeVariable) {
				args[i] = resolveTypeVar((TypeVariable<?>) typeArgs[i], srcType, declaringClass);
			}
			// 方法 List<String> test();
			else if (typeArgs[i] instanceof ParameterizedType) {
				args[i] = resolveParameterizedType((ParameterizedType) typeArgs[i], srcType, declaringClass);
			}

			// 泛型限定 List<? extends String> test(); --> upperBounds 上界
			// 泛型限定 List<? supper String> test(); --> lowerBounds 下界
			else if (typeArgs[i] instanceof WildcardType) {
				args[i] = resolveWildcardType((WildcardType) typeArgs[i], srcType, declaringClass);
			} else {
				args[i] = typeArgs[i];
			}
		}
		return new ParameterizedTypeImpl(rawType, null, args);
	}

	private static Type resolveWildcardType(WildcardType wildcardType, Type srcType, Class<?> declaringClass) {
		Type[] lowerBounds = resolveWildcardTypeBounds(wildcardType.getLowerBounds(), srcType, declaringClass);
		Type[] upperBounds = resolveWildcardTypeBounds(wildcardType.getUpperBounds(), srcType, declaringClass);
		return new WildcardTypeImpl(lowerBounds, upperBounds);
	}

	// 泛型限定 List<? extends String> test(); --> upperBounds 上界
	// 泛型限定 List<? supper String> test(); --> lowerBounds 下界
	private static Type[] resolveWildcardTypeBounds(Type[] bounds, Type srcType, Class<?> declaringClass) {
		Type[] result = new Type[bounds.length];
		for (int i = 0; i < bounds.length; i++) {
			if (bounds[i] instanceof TypeVariable) {
				result[i] = resolveTypeVar((TypeVariable<?>) bounds[i], srcType, declaringClass);
			} else if (bounds[i] instanceof ParameterizedType) {
				result[i] = resolveParameterizedType((ParameterizedType) bounds[i], srcType, declaringClass);
			} else if (bounds[i] instanceof WildcardType) {
				result[i] = resolveWildcardType((WildcardType) bounds[i], srcType, declaringClass);
			} else {
				result[i] = bounds[i];
			}
		}
		return result;
	}

	// typeVar：方法 T test();中的T
	// srcType: 使用class的对象
	// declaringClass：对应接口的对象
	private static Type resolveTypeVar(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass) {
		Type result = null;
		Class<?> clazz = null;
		if (srcType instanceof Class) {
			clazz = (Class<?>) srcType;
		} else if (srcType instanceof ParameterizedType) {
			ParameterizedType parameterizedType = (ParameterizedType) srcType;
			clazz = (Class<?>) parameterizedType.getRawType();
		} else {
			throw new IllegalArgumentException(
					"The 2nd arg must be Class or ParameterizedType, but was: " + srcType.getClass());
		}

		if (clazz == declaringClass) {
			Type[] bounds = typeVar.getBounds();
			if (bounds.length > 0) {
				return bounds[0];
			}
			return Object.class;
		}

		// 继承的父类class，保留泛型信息
		Type superclass = clazz.getGenericSuperclass();
		result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superclass);
		if (result != null) {
			return result;
		}

		// 继承的父类interfaces，保留泛型信息
		Type[] superInterfaces = clazz.getGenericInterfaces();
		for (Type superInterface : superInterfaces) {
			result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superInterface);
			if (result != null) {
				return result;
			}
		}
		return Object.class;
	}

	// typeVar: N
	// superclass: org.apache.ibatis.reflection.typeparam.Level0Mapper<E, F,
	// java.lang.String>
	// srcType：interface org.apache.ibatis.reflection.typeparam.Level1Mapper
	// declaringClass: interface org.apache.ibatis.reflection.typeparam.Level0Mapper
	// clazz：interface org.apache.ibatis.reflection.typeparam.Level1Mapper
	// superclass：org.apache.ibatis.reflection.typeparam.Level0Mapper<E, F,
	// java.lang.String>
	private static Type scanSuperTypes(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass, Class<?> clazz,
			Type superclass) {
		Type result = null;
		if (superclass instanceof ParameterizedType) {
			ParameterizedType parentAsType = (ParameterizedType) superclass;
			Class<?> parentAsClass = (Class<?>) parentAsType.getRawType();
			// 对应泛型参数对比：[L, M, N]->[E, F, class java.lang.String]
			// N -> class java.lang.String
			if (declaringClass == parentAsClass) {
				Type[] typeArgs = parentAsType.getActualTypeArguments();
				TypeVariable<?>[] declaredTypeVars = declaringClass.getTypeParameters();
				for (int i = 0; i < declaredTypeVars.length; i++) {
					if (declaredTypeVars[i] == typeVar) {
						if (typeArgs[i] instanceof TypeVariable) {
							TypeVariable<?>[] typeParams = clazz.getTypeParameters();
							for (int j = 0; j < typeParams.length; j++) {
								if (typeParams[j] == typeArgs[i]) {
									if (srcType instanceof ParameterizedType) {
										result = ((ParameterizedType) srcType).getActualTypeArguments()[j];
									}
									break;
								}
							}
						} else {
							result = typeArgs[i];
						}
					}
				}
			} else if (declaringClass.isAssignableFrom(parentAsClass)) {
				result = resolveTypeVar(typeVar, parentAsType, declaringClass);
			}
		} else if (superclass instanceof Class) {
			if (declaringClass.isAssignableFrom((Class<?>) superclass)) {
				result = resolveTypeVar(typeVar, superclass, declaringClass);
			}
		}
		return result;
	}

	private TypeParameterResolver() {
		super();
	}

	static class ParameterizedTypeImpl implements ParameterizedType {
		private Class<?> rawType;

		private Type ownerType;

		private Type[] actualTypeArguments;

		public ParameterizedTypeImpl(Class<?> rawType, Type ownerType, Type[] actualTypeArguments) {
			super();
			this.rawType = rawType;
			this.ownerType = ownerType;
			this.actualTypeArguments = actualTypeArguments;
		}

		@Override
		public Type[] getActualTypeArguments() {
			return actualTypeArguments;
		}

		@Override
		public Type getOwnerType() {
			return ownerType;
		}

		@Override
		public Type getRawType() {
			return rawType;
		}

		@Override
		public String toString() {
			return "ParameterizedTypeImpl [rawType=" + rawType + ", ownerType=" + ownerType + ", actualTypeArguments="
					+ Arrays.toString(actualTypeArguments) + "]";
		}
	}

	static class WildcardTypeImpl implements WildcardType {
		private Type[] lowerBounds;

		private Type[] upperBounds;

		private WildcardTypeImpl(Type[] lowerBounds, Type[] upperBounds) {
			super();
			this.lowerBounds = lowerBounds;
			this.upperBounds = upperBounds;
		}

		@Override
		public Type[] getLowerBounds() {
			return lowerBounds;
		}

		@Override
		public Type[] getUpperBounds() {
			return upperBounds;
		}
	}

	static class GenericArrayTypeImpl implements GenericArrayType {
		private Type genericComponentType;

		private GenericArrayTypeImpl(Type genericComponentType) {
			super();
			this.genericComponentType = genericComponentType;
		}

		@Override
		public Type getGenericComponentType() {
			return genericComponentType;
		}
	}
}
dengjili
关注
专栏目录
【Mybatis源码】反射 – TypeParameterResolver
Mointor
11-08 308
主要介绍Mybatis中使用反射机制封装的类型参数解析器，主要用作字段、方法参数、方法返回值类型的解析
【三】MyBatis-Spring最全源码详解之SQL执行流程
人工智障训练师的博客
03-16 928
前面两篇系列文章已经详细介绍了Mapper接口的扫描过程和对应bean的创建过程。本文重点介绍mybatis执行SQL的过程。 DaoService的selectByName方法，拿到的personMapper对象已经是上文介绍的那个superMapperProxy对象。执行personMapper.selectByName(personName)方法，其实就是执行的superMapperPro...
mybatis源码学习------TypeParameterResolver
我是兴锅的博客
08-14 686
TypeParameterResolver简介 TypeParameterResolver是反射包下的一个工具类，用于解析方法的参数、返回类型和类中定义的字段的类型。 在阅读本片文章之前最好还是先了解一下java.lang.reflcet包下的Type接口及其子接口和实现，关于Type接口的介绍请移步 TypeParameterResolver类中的resolveFieldType方法、resolveReturnType方法和resolveParamTypes方法分别用于解析字段的类型、解析方法返回的类型以
Mybatis 源码学习(3)-反射工具（TypeParameterResolver）
teaandnoodle的专栏
11-11 441
TypeParameterResolver 是用来解析类中字段、方法参数、方法返回值的工具类，它通过自身的静态方法，利用反射处理对应的类型，并转化为实际的 Type 类型。而 Type 类型是 java 程序中所有数据类型的基类，它包含原始类型，参数化类型，类型变量，数组类型和通配符泛型几种类型。 Type Type 是所有类型的父接口，它的继承关系如下： Class：原始类型，Java 中的每...
【MyBatis】源码学习 01 - 泛型解析器 TypeParameterResolver
最新发布
MichelleChung的星球
02-16 548
6.10 泛型解析器 TypeParameterResolver 学习笔记。
mybatis基础支持层-反射模块：TypeParameterResolver
c_zyer的博客
08-20 287
一、Type 首先了解一些基础类型的含义，Type有哪些实现类和子接口：Class,ParameterizedType,GenericArrayType,TypeVariable,WildcardType public interface Type { /** * Returns a string describing this type, including information * about any type parameters. * * @im
MyBatis源码解析--基础支持层（3）
jacobbbbbbbb的博客
06-11 135
MetaObject 提供了对象的属性值的获取与设置等方法，是对BaseWrapper操作的进一步增强 public class MetaObject { //原始的java对象 private final Object originalObject; //对对象的包装，抽象了对象的属性信息，他定义了一系列查询对象属性信息的方法，以及更新属性的方法； private final ObjectWrapper objectWrapper; private final ObjectFa
Mybatis的反射
qq_33640789的博客
11-12 1432
  我们都知道Mybatis是ORM框架，主要是实现数据库字段和Java对象的映射，其中用到的就是反射。Mybatis的反射是一个特别强大的模块。   Mybatis的反射这里主要介绍ObjectFactory，Reflector，ReflectorFactory，ObjectWrapper，MetaObject 一：ObjectFactory   ObjectFactory主要提供了create方法，通过mapper.xml里面的对象路径反射生成对象。DefaultObjectFactory继承了Obje
Mybatis（七）：源码分析-Mapper接口动态代理对象的方法调用
weixin_40074110的博客
06-28 775
从官网Demo代码来入手：https://mybatis.org/mybatis-3/zh/getting-started.html Mapper接口的代理对象(映射器)的方法调用 动态代理生成的代理对象，调用的代理对象的任何方法都是执行调用管理器MapperProxy.invoke()方法。 // 从 SqlSessionFactory 中获取 SqlSession try (SqlSession session = sqlSessionFactory.openSession()) {
MyBatis源码解析之Mapper方法调用过程
weixin_42575542的博客
12-07 668
MyBatis源码解析之Mapped方法调用过程分析过程 在此声明，此文章是对江荣波老师的《MyBatis3源码深度解析》的总结，尊重原作者。 分析过程 这里我们介绍Mapper方法的执行过程以及Mapper接口与Mapper SQL配置是如何关联的。 首先我们需要调用SqlSession对象的getMapper()获取一个动态代理对象MapperProxy，然后通过代理对象调用方法即可。 // MapperRegistry类，根据Mapper接口Class对象获取Mapper动态代理对象 @Su
MyBatis 技术内幕 - 基础支持层 - 反射器模块 - TypeParameterResolver
走在命运的左岸
09-29 218
MyBatis 技术内幕 - 基础支持层 - 反射器模块 - TypeParameterResolver 概述 mybatis : 3.4.6 jdk : 1.8 总结 TypeParameterResolver 功能：解析类中属性、成员方法的入参、成员方法的返回值的数据类型 ...
Mybatis TypeParameterResolver
weixin_35753291的博客
01-04 130
Mybatis TypeParameterResolver 是 Mybatis 中用来解析类型参数的解析器。 Mybatis 使用 TypeHandler 来将数据库中的数据映射到 Java 类型的对象上，而 TypeParameterResolver 负责帮助 Mybatis 解析出 TypeHandler 所需要的 Java 类型的参数。 例如，如果你定义了一个 TypeHandler，并且希...
Mybatis原码学习（四）TypeParameterResolver
云乐
06-01 466
得先申明下，这篇文章应该不会有借鉴价值，我也只能是斗胆总结下。 为什么呢，因为这是我目前为止遇到问题最大的一部分，绕过去绕过来，可能是自己对泛型、类型学习都还不够，理解得很吃力很吃力。 代码部分来自博客：https://www.jianshu.com/p/73bb429b9a01 我实在懒得打注释了，解释就用文章的方式吧。 在开始介绍TypeParmeterResolver之前，得了解一下Type的知识： Type是所有类型的父接口，它有四个子接口和一个实现类。 下面来看这些子接口和子类所代表的类型。 C
Mybatis技术内幕（2.3.7）：反射模块-TypeParameterResolver
weixin_34116110的博客
04-02 231
基于Mybatis-3.5.0版本 Type 接口   为什么要单独拿一篇文章来讲呢？因为里面涉及到的java-Type接口的内容之前没有接触和了解过。我相信在座的很多小伙伴也一定不知道其中的奥秘哦~   你知道Class对象还有一个父接口吗？ 以下内容均摘录自 徐郡明 《Mybatis技术内幕》 先简单介绍一下Type接口的基础知识。Type是所有类型的父接口，它有四个子接口和一个实现类...
MyBatis构架设计学习------反射工具箱------TypeParameterResolver
豢龙先生
03-03 176
上一篇：MyBatis构架设计学习------反射工具箱------Reflector&ReflectorFactory
mybatis之TypeParameterResolver工具类
HAD_HAD的博客
03-03 247
TypeParameterResolver 它是一个工具类，提供了一系列静态 方法来解析指定类中的宇段、方法返回值或方法参数的类型。 TypeParameterResolver 中各个静 态方法之间的调用关系大致如图 2-11 所示，为保持清晰，其中递归调用没有表现出来，在后面 的代码分析过程中会进行强调。 public class TypeParameterResolver { /** * @return The field type as {@link Type}. If it
MyBatis源码实现之反射工具箱TypeParameterResolver
瘦子没有夏天
04-22 1143
反射工具箱之TypeParameterResolver Type 在开始介绍TypeParameterResolver 之前，先简单介绍一下Type接口的基础知识。Type 是 所有类型的父接口，它有四个子接口和一个实现类，如图2-10 所示。 下面来看这些子接口和子类所代表的类型。 Class 比较常见，它表示的是原始类型。Class 类的对象表示NM 中的一个类或接口， 每个Java 类在...
Guava中的TypeToken，解决泛型运行时类型擦除的问题
Learning
06-14 3381
关于对于Type的理解 泛型是一种类型 关于Type，是一个标示接口，该标示接口描述的意义是代表所有的类型 public interface Type { } Type的分类 Class<T> ParameterizedType 泛型 ...... 泛型的结构 public Person<T> { } public interface ParameterizedType extends Type
深入理解MyBatis-Guice：从入门到实践
"MyBatis-Guice3.2参考文档是MyBatis社区提供的一份教程，旨在帮助用户理解并使用MyBatis与Guice的集成，以便更有效地进行数据库操作和依赖注入。这份文档涵盖了从入门到核心组件的详细内容，包括安装、快速设置、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值