可能在刚学 Java 和 Mybatis 的小伙伴，会很好奇为什么明明是一个接口，但是居然可以调用，但是明明并没有声明它的实现类，并且它是怎么找到我们要执行的 SQL 呢。那么这一个包就能解开你的疑惑。
binding 包的主要作用是处理 Java 方法和映射文件中 SQL 语句之间绑定关系。也就是我们常常用到的 userMapper.getById() 方法，是怎么绑定到一条具体 SQL 语句的。
虽然binding 包下的类不多，但是每个都很经典，只要能理解透的话，你就会发现其实真想要手写一个简单的 ORM 框架也没有那么难。就让我们奔着这个目标继续学习下去吧。
类关系概览
图片来自 《通用源码指导书：Mybatis源码详解》—— 易哥
首先观察一下上图，看到这样的一个关系，MapperProxyFactory 用来创建 MapperProxy 而 MapperProxy 用来执行 MapperMethod。现在我们将这三个类对应到我们使用 Mybatis 时所写的。
// 这是一个简单的 Mapper 文件，除了没有那么多方法以外，基本上都差不多
@Mapper
public interface UserMapper {
User selectById(@Param("userId") Long userId);
List<User> selectListByName(@Param("name") String name);
}
我们把MapperProxyFactory 看作 UserMapper，而 MapperProxy 看作 UserMapper 的实现类，MapperMethod 则是 UserMapper 中的某一个方法。
MapperProxyFactory 通过 JDK 动态代理来实现 new 一个 UserMapper 的实现类。
看了这个图，我觉得你们心里应该有个底了，但是细心的读者可能会发现一个地方特别奇怪，为啥和上一张图有点不太一样，MapperProxy 下面不是不是 MapperMethod 吗，从哪里冒出来了一个 MapperMethodInvoker。图中的两个 MapperMehtodInvoker 中又分别包含了 MapperMethod 和 MethodHandle。
/*
由于在 JDK8 中又引入了默认方法，所以实际上 Java 映射文件中已经不是所有都是接口了。
默认方法是没有映射到具体的 SQL 的，所以也不能去找到它所指向的 SQL，而是直接通过反射去调用。
所以 Mybatis 抽象出了一个通用的接口 MapperMehtodInvoker，有两个实现类 PlainMethodInvoker、DefaultMethodInvoker 分别对应普通的接口方法 和默认方法。根据不同的方法类型来选用对应的实现。
*/
if (m.isDefault()) {
// 如果是一个默认方法
/*
通过判断是否存在特定的方法来区分版本，如果有 privateLookupInMethod 方法的话，说明是 JDK9 及以上版本，如果没有则是 JDK8。
可能有的小伙伴会疑惑，为什么不都选用同一种方法呢，是因为 JDK9 中就把对应的实现删除了吗？
其实并不是的，而是由于每个版本可能反射都做了一些优化，比如在 JDK8 中可能某一种反射的方式可能更加安全更加快，但是在 JDK9 中另一种方法更好，所以才会出现这种情况。
*/
if (privateLookupInMethod == null) {
// 如果当前 JDK 版本为 8
return new DefaultMethodInvoker(getMethodHandleJava8(method));
} else {
// 如果当前 JDK 版本为 9+
return new DefaultMethodInvoker(getMethodHandleJava9(method));
}
} else {
// 如果是一个接口的话，说明是一个映射方法，即我们常用的 getById 这种。
return new PlainMethodInvoker(
new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
}
类详解
终于到了最令人激动的环节了(不知道你们激不激动，反正我是挺激动的)。我们还是跟着之前的类关系图，从最外层的也就是 MapperRegistry 到内层的 MapperMethod 类，一个一个去分析。
MapperRegistry
在分析类关系的时候，我们已经提到了这个类，它保存了 Mybatis 中所有的 Mapper，从注册表中拿到了对应的 Mapper 我们就可以直接调用 Mapper 中的方法了。
核心成员变量
private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
关键的成员变量就是 knowMappers 这x 是一个 Map，可以通过 Class 获取对应的 MapperProxyFactory。
核心方法
作为一个保存 MapperProxyFactory 容器，最关键的两个功能就是两个：addMapper 和 getMapper。
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
// 如果找不到直接抛出异常
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
// 实例化对象
return mapperProxyFactory.newInstance(sqlSession);
}
public <T> void addMapper(Class<T> type) {
if (type.isInterface()) {
// 只添加 interface
if (hasMapper(type)) {
throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
}
// 是否加载完成的标志，
boolean loadCompleted = false;
try {
// 先把坑占好，防止循环加载
knownMappers.put(type, new MapperProxyFactory<>(type));
MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
// 加载并解析
parser.parse();
loadCompleted = true;
} finally {
// 如果由于报错没有加载完成，那么就要将预先生成好的 MapperProxyFactory 删掉
if (!loadCompleted) {
knownMappers.remove(type);
}
}
}
}
Mybatis 为什么会有循环加载示意图。
这里没有讲解析的细节是因为 MapperAnnotationBuilder 是 builder 包的内容，下一篇文章应该就会分析 builder 包，大家可以好好期待一下。
MapperProxyFactory
MapperProxyFactory 作为一个 Mapper 的’原型’，包含了 Mapper 中的方法。
核心成员变量
// 当前 MapperProxyFactory 代表的 Mapper 的类型
private final Class<T> mapperInterface;
// Java 映射文件中的方法及其对应的调用器
private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap<>();
核心方法
protected T newInstance(MapperProxy<T> mapperProxy) {
// JDK 动态代理生成代理对象
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {
mapperInterface }, mapperProxy);
}
public T newInstance(SqlSession sqlSession) {
// MapperProxy 实现了 InvocationHandler 所以只要调用被代理对象的任何方法，实际上都会进入到 invoke 方法中
final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}
其实最关键的就是 Proxy.newProxyInstance，可以说这句话就是 Mybatis 实现 Java 方法到执行 SQL 执行映射的底层。JDK 动态代理我就不在这里讲述了，相信聪明的小伙伴能找到不少相关的资料。
MapperProxy
MapperProxy 可以理解为 Java 映射接口的实现类。
核心成员变量
// 只允许以下作用域的方法能执行反射，利用二进制的每一位代表一种修饰符，可以节省空间
private static final int ALLOWED_MODES =
MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
| MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC;
// JDK8 中只有 Lookup(Class, int)
private static final Constructor<Lookup> lookupConstructor;
// 在 JDK9 中才有 privateLookupIn(Class, Lookup)
private static final Method privateLookupInMethod;
// 会话
private final SqlSession sqlSession;
// 被代理对象
private final Class<T> mapperInterface;
// Java 映射文件中的方法及其对应的调用器，对象是由 MapperProxyFactory 创建的，生成的每个代理对象都是其的引用
// 所以，所有的代理对象都共享这些内容
private final Map<Method, MapperMethodInvoker> methodCache;
核心方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (Object.class.equals(method.getDeclaringClass())) {
// 如果调用的时 Object 类中声明的方法，直接反射调用
return method.invoke(this, args);
} else {
return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
}
}
// 获取已经缓存好的 MapperMethodInvoker
private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
MapperMethodInvoker invoker = methodCache.get(method);
if (invoker != null) {
// 如果在缓存中找到了对应的 invoker 方法，那么则直接返回
return invoker;
}
// 如果没有缓存对应的 invoker 方法，则构建并缓存起来
return methodCache.computeIfAbsent(method, m -> {
if (m.isDefault()) {
// 如果是一个默认方法
if (privateLookupInMethod == null) {
// 当前版本为JDK 8
return new DefaultMethodInvoker(getMethodHandleJava8(method));
} else {
// 当前版本为JDK 9+
return new DefaultMethodInvoker(getMethodHandleJava9(method));
}
} else {
// 如果不是默认方法，说明是一个需要映射的方法，即我们常用的 userMapper.getById 这种。
return new PlainMethodInvoker(
new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
}
}
注：我在粘贴代码段的时候，除非 try catch 中有重要逻辑，否则都会将其删除掉。尽量减少代码数量，让小伙伴们能专注于重点的逻辑。
小伙伴们应该知道在 JDK8 中接口引入了默认方法，默认方法其实和普通类的方法一样，是不强制子类去实现它的。所以直接反射调用默认方法就好了，而非默认方法就不行，必须要自己去实现方法中的业务逻辑。
可以看到返回的是 MapperMethodInvoker 的两个实现类：DefaultMethodInvoker 和 PlainMethodInvoker，对应 invoke 方法实现如下。
// PlainMethodInvoker
public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession)
throws Throwable {
// 执行对应的 SQL
return mapperMethod.execute(sqlSession, args);
}
// DefaultMethodInvoker
public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession)
throws Throwable {
// 等同于 method.invoke()，但是比它的性能更高
return methodHandle.bindTo(proxy).invokeWithArguments(args);
}
MapperMethod
MapperMethod 对应的是一个映射方法。映射方法包含两个关键要素，一个是要执行的 SQL，一个是方法的签名。
核心成员变量
// SQL 信息
private final SqlCommand command;
// 方法签名
private final MethodSignature method;
核心方法
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
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()) {
// 如果没有返回值，并且请求参数中有 ResultHandler 才执行这个方法
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;
// 只是用来刷新缓存的语句，不映射任何一条 SQL
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + command.getName());
}
// 如果要求返回一个原生类型，但是 result 又是 null，那么就需要抛出异常，因为 null 转换为 int 或者其他基本类型会报空指针异常。
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
throw new BindingException();
}
return result;
}
可以看到说的是 execute 方法，实际上调用的还是 SqlSession 的方法，这是设计模式中的委派者模式。至于 SqlSession 里面的代码，我们会在后面的分析，一步一步慢慢来哟。
MapperMethod 的静态内部类 MethodSignature、SqlCommand、ParamMap
MethodSignature
MethodSignature 是方法的签名，在 Java 语言中签名就是方法的名称和方法的请求参数，而 Mybatis 中定义的这个签名和 Java 的有点区别。
核心成员变量
/* 返回值的相关信息 */
// 返回值类型为 Collection 或 Array
private final boolean returnsMany;
// 返回值类型为 Map
private final boolean returnsMap;
// 没有返回值
private final boolean returnsVoid;
// 返回值类型为 Cursor
private final boolean returnsCursor;
// 返回值类型为 Optional
private final boolean returnsOptional;
// 返回值类型
private final Class<?> returnType;
// mapKey的值
private final String mapKey;
/* 请求参数的相关信息 */
// 请求参数中 ResultHandler 的下标
private final Integer resultHandlerIndex;
// 请求参数中 RowBounds 的下标
private final Integer rowBoundsIndex;
// 请求参数名称解析器，解析后返回的是一个 ParamMap
private final ParamNameResolver paramNameResolver;
核心方法
public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) {
// 首先获取方法的返回值类型
Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
if (resolvedReturnType instanceof Class<?>) {
this.returnType = (Class<?>) resolvedReturnType;
} else if (resolvedReturnType instanceof ParameterizedType) {
this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType();
} else {
this.returnType = method.getReturnType();
}
// 是否返回的是 void
this.returnsVoid = void.class.equals(this.returnType);
// 是否返回的是集合或数组
this.returnsMany =
configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();
// 是否返回时游标
this.returnsCursor = Cursor.class.equals(this.returnType);
// 是否返回的是 optional
this.returnsOptional = Optional.class.equals(this.returnType);
// 得到 MapKey
this.mapKey = getMapKey(method);
// 如果存在 MapKey 说明返回值类型是 Map
this.returnsMap = this.mapKey != null;
// 得到请求参数类型为 RowBounds 的下标
this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
// 得到请求参数类型为 ResultHandler 的下标
this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
// 得到参数名称解析器
this.paramNameResolver = new ParamNameResolver(configuration, method);
}
这是MethodSignature 的构造方法，是用来初始化会初始化所有的成员变量。
SqlCommand
SqlCommand 记录了该映射方法所映射到的 SQL 的一些关键信息。SQL 的类型和 SQL 的唯一ID，通过 SQL 的类型可以决定使用什么方式处理执行结果，通过 SQL 的唯一ID可以找到需要执行的 SQL。
核心成员变量
// SQL 的名称，在整个项目中是唯一的，等同于 ID
private final String name;
// SQL 的类型，枚举类型
// UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH
private final SqlCommandType type;
核心方法
public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
final String methodName = method.getName();
final Class<?> declaringClass = method.getDeclaringClass();
// 解析 MappedStatement，实际上是从 Configuration 中获取的 MappedStatement
MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass,
configuration);
if (ms == null) {
if (method.getAnnotation(Flush.class) != null) {
name = null;
type = SqlCommandType.FLUSH;
} else {
throw new BindingException();
}
} else {
// SQL 指令的名称为 MappedStatement 的ID，是唯一的
name = ms.getId();
type = ms.getSqlCommandType();
if (type == SqlCommandType.UNKNOWN) {
throw new BindingException();
}
}
}
ParamMap
继承自HashMap<String, V> ，key 代表请求参数的名称，value 代表请求参数具体的值，只覆盖了 get 方法。
核心方法
public V get(Object key) {
if (!super.containsKey(key)) {
throw new BindingException(
"Parameter '" + key + "' not found. Available parameters are " + keySet());
}
return super.get(key);
}
如果找不到对应的名称，直接抛出异常。
总结：可以发现，这篇文章的代码是相当的多的，因为这个包是相当重要的包。其中的类也不多，所以基本上每行代码都是非常的重要，因此希望大家可以去把这个包中的内容都仔细的看一下。肯定能对以后的编码有所帮助。