5、MyBatis-parameterType 入参封装 Map 流程

public MyUser selectMyUserIdAndAge(Integer id, @Param("user") MyUser user);

public class MapperProxy<T> implements InvocationHandler, Serializable { private static final long serialVersionUID = -6424540398559729838L;
private final SqlSession sqlSession;
private final Class<T> mapperInterface;
private final Map<Method, MapperMethod> methodCache; public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
this.sqlSession = sqlSession;
this.mapperInterface = mapperInterface;
this.methodCache = methodCache;
} @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
// 代理以后，并不是所有 Mapper 的方法调用时都会调用这个 invoke 方法，如果这个方法是 Object 中通用的方法（toString、hashCode等）则无需执行
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (isDefaultMethod(method)) {
// 如果这个方法的权限修饰符是 public 并且是由接口提供，则执行 invokeDefaultMethod 方法，这里是由代理对象提供
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
// 去缓存中找 MapperMethod
final MapperMethod mapperMethod = cachedMapperMethod(method);
// 执行
return mapperMethod.execute(sqlSession, args);
} private MapperMethod cachedMapperMethod(Method method) {
return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
} private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
throws Throwable {
final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
.getDeclaredConstructor(Class.class, int.class);
if (!constructor.isAccessible()) {
constructor.setAccessible(true);
}
final Class<?> declaringClass = method.getDeclaringClass();
return constructor
.newInstance(declaringClass,
MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
| MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
.unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
} /**
* Backport of java.lang.reflect.Method#isDefault()
*/
private boolean isDefaultMethod(Method method) {
return (method.getModifiers() & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC && method.getDeclaringClass().isInterface();
}
}

public class MapperMethod { private final SqlCommand command;
private final MethodSignature method; public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
this.command = new SqlCommand(config, mapperInterface, method);
this.method = new MethodSignature(config, mapperInterface, method);
} public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
// 4种情况，insert|update|delete|select，分别调用 SqlSession 的 4 大类方法
switch (command.getType()) {
case INSERT: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
case UPDATE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
}
case DELETE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
case SELECT:
if (method.returnsVoid() && method.hasResultHandler()) {
// 如果有结果处理器
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) {
// 如果结果有多条记录
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) {
// 如果结果是map
result = executeForMap(sqlSession, args);
} else if (method.returnsCursor()) {
// 如果结果是游标
result = executeForCursor(sqlSession, args);
} else {
// 否则就是一条记录
// 装配参数
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
if (method.returnsOptional() && (result == null || !method.getReturnType().equals(result.getClass()))) {
result = Optional.ofNullable(result);
}
}
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + command.getName());
}
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
throw new BindingException("Mapper method '" + command.getName() + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
}
return result;
}
...
}

public class ParamNameResolver { private static final String GENERIC_NAME_PREFIX = "param"; private final SortedMap<Integer, String> names; private boolean hasParamAnnotation; public ParamNameResolver(Configuration config, Method method) {
// 获取参数列表中每个参数的类型
final Class<?>[] paramTypes = method.getParameterTypes();
// 获取每个标了 @Param 注解的参数的值,赋值给 name
final Annotation[][] paramAnnotations = method.getParameterAnnotations();
// 记录参数索引与参数名称的关系
final SortedMap<Integer, String> map = new TreeMap<>();
int paramCount = paramAnnotations.length; // 遍历参数保存至 map：（key：参数索引，value：name的值）
for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
// 是否为特殊参数：RowBounds或ResultHandler
if (isSpecialParameter(paramTypes[paramIndex])) {
continue;
}
String name = null;
// 标注了 @Param 注解：name的值为注解的值
for (Annotation annotation : paramAnnotations[paramIndex]) {
if (annotation instanceof Param) {
hasParamAnnotation = true;
name = ((Param) annotation).value();
break;
}
}
// 没有标 @Param 注解
if (name == null) {
if (config.isUseActualParamName()) {
// 全局配置：useActualParamName（jdk1.8）：name为参数名
name = getActualParamName(method, paramIndex);
}
if (name == null) {
// name为map.size()：相当于当前元素的索引，0，1，2，3...
name = String.valueOf(map.size());
}
}
map.put(paramIndex, name);
}
names = Collections.unmodifiableSortedMap(map);
} private String getActualParamName(Method method, int paramIndex) {
return ParamNameUtil.getParamNames(method).get(paramIndex);
} private static boolean isSpecialParameter(Class<?> clazz) {
return RowBounds.class.isAssignableFrom(clazz) || ResultHandler.class.isAssignableFrom(clazz);
} public String[] getNames() {
return names.values().toArray(new String[0]);
} public Object getNamedParams(Object[] args) {
final int paramCount = names.size();
if (args == null || paramCount == 0) {
// 没有参数
return null;
} else if (!hasParamAnnotation && paramCount == 1) {
// 未使用@Param注解且参数列表只有一个,即 args[0] 参数的值
return args[names.firstKey()];
} else {
// 为参数创建 param+ 索引的格式作为默认参数名称 如：param1 下标从1开始
final Map<String, Object> param = new ParamMap<>();
int i = 0;
// 遍历names集合；{0=arg0, 1=user}
for (Map.Entry<Integer, String> entry : names.entrySet()) {
// names集合的 value 作为 key; names 集合的 key 作为取值的参考args[0]
// {arg0:args[0],user=args[1]}
param.put(entry.getValue(), args[entry.getKey()]);
final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
if (!names.containsValue(genericParamName)) {
// 额外的将每一个参数也保存到 param 中，使用新的key：param1...paramN,有 @Param 注解可以 #{指定的key}，或者#{param1}
param.put(genericParamName, args[entry.getKey()]);
}
i++;
}
return param;
}
}
}