浩哥解析MyBatis源码——binding绑定模块之MapperRegisty
Posted 唯一浩哥
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了浩哥解析MyBatis源码——binding绑定模块之MapperRegisty相关的知识，希望对你有一定的参考价值。
原创作品，可以转载，但是请标注出处地址：http://www.cnblogs.com/V1haoge/p/6758456.html
1、回顾
之前解析了解析模块parsing，其实所谓的解析模块就是为了解析SQL脚本中的参数，根据给定的开始标记与结束标记来进行参数的定位获取，然后由标记处理器进行参数处理，再然后将处理过后的参数再组装回SQL脚本中。
如此一来，解析的目的就是为了处理参数。
这一篇看看binding绑定模块。
2、binding模块
binding模块位于org.apache.ibatis.binding包下，这个模块有四个类，这四个类是层层调用的关系，对外的是MapperRegistry，映射器注册器。它会被Configuration类直接调用，用于将用户自定义的映射器全部注册到注册器中，而这个注册器显而易见会保存在Configuration实例中备用（具体详情后述）。
其实看到这个名称，我们就会想起之前解析的类型别名注册器与类型处理器注册器，其实他们之间的目的差不多，就是注册的内容不同罢了，映射器注册器注册的是MyBatis使用者自定义的各种映射器。
2.1 MapperRegistry：映射器注册器
首先在注册器中会定义一个集合用于保存注册内容，这里是有HashMap：
1 private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();
上面的集合中键值的类型分别为Class类型与MapperProxyFactory类型，MapperProxyFactory是映射器代理工厂，通过这个工厂类可以获取到对应的映射器代理类MapperProxy，这里只需要保存一个映射器的代理工厂，根据工厂就可以获取到对应的映射器。
相应的，注册器中必然定义了添加映射器和获取映射器的方法来对外提供服务（供外部调取）。这里就是addMapper()方法与getMapper()方法，在该注册器中还有一种根据包名来注册映射器的方法addMappers()方法。因为该方法最后会调用addMapper()方法来完成具体的注册功能，所以我们直接从addMappers()说起。
2.1.1 addMappers()
addMappers()方法是将给定包名下的所有映射器注册到注册器中。其源码：
1 public <T> void addMapper(Class<T> type) { 2 //mapper必须是接口！才会添加 3 if (type.isInterface()) { 4 if (hasMapper(type)) { 5 //如果重复添加了，报错 6 throw new BindingException("Type " + type + " is already known to the MapperRegistry."); 7 } 8 boolean loadCompleted = false; 9 try { 10 knownMappers.put(type, new MapperProxyFactory<T>(type)); 11 // It\'s important that the type is added before the parser is run 12 // otherwise the binding may automatically be attempted by the 13 // mapper parser. If the type is already known, it won\'t try. 14 MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type); 15 parser.parse(); 16 loadCompleted = true; 17 } finally { 18 //如果加载过程中出现异常需要再将这个mapper从mybatis中删除,这种方式比较丑陋吧，难道是不得已而为之？ 19 if (!loadCompleted) { 20 knownMappers.remove(type); 21 } 22 } 23 } 24 } 25 26 /** 27 * @since 3.2.2 28 */ 29 public void addMappers(String packageName, Class<?> superType) { 30 //查找包下所有是superType的类 31 ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>(); 32 resolverUtil.find(new ResolverUtil.IsA(superType), packageName); 33 Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses(); 34 for (Class<?> mapperClass : mapperSet) { 35 addMapper(mapperClass); 36 } 37 } 38 39 /** 40 * @since 3.2.2 41 */ 42 //查找包下所有类 43 public void addMappers(String packageName) { 44 addMappers(packageName, Object.class); 45 }
其实这三个方法均可对外实现添加映射器的功能，分别应对不同的情况，其中addMappers(String packkageName)方法用于仅指定包名的情况下，扫描包下的每个映射器进行注册；addMappers(String packageName, Class<?> superType)方法在之前的方法的前提下加了一个限制，必须指定超类，将包下满足以superType为超类的映射器注册到注册器中；addMapper(Class<T> type)方法指的是将指定的类型的映射器添加到注册器中。
按照介绍的顺序排序为方法1、方法2、方法3，其中方法1通过调用方法2实现功能，方法2通过调用方法3实现功能，可见方法3为添加映射器的核心方法。
方法1调用方法2的时候添加了一个参数Object.class，表示所有的Java类都可以被注册（因为Java类均是Object的子类）
方法2调用方法3的之前进行了扫描（使用ResolverUtil工具类完成包扫描），获取满足条件的所有类的set集合，然后在循环调用核心方法实现每个映射器的添加。
我们来看看核心方法addMapper(Class<T> type)：
1、验证要添加的映射器的类型是否是接口，如果不是接口则结束添加，如果是接口则执行下一步
2、验证注册器集合中是否已存在该注册器（即重复注册验证），如果已存在则抛出绑定异常，否则执行下一步
3、定义一个boolean值，默认为false
4、执行HashMap集合的put方法，将该映射器注册到注册器中：以该接口类型为键，以以接口类型为参数调用MapperProxyFactory的构造器创建的映射器代理工厂为值
5、然后对使用注解方式实现的映射器进行注册（一般不使用）
6、设置第三步的boolean值为true，表示注册完成
7、在finally语句块中对注册失败的类型进行清除
整个步骤很是简单，重点就在第4步：在注册器的集合中保存的是一个根据接口类型创建的映射器代理工厂实例，这个内容下一节解析
2.1.2 getMapper()
既然我们将映射器注册到了注册器中，当然是为了供外方使用的，要供外方使用，就必须提供获取方法getMapper():
1 @SuppressWarnings("unchecked") 2 //返回代理类 3 public <T> T getMapper(Class<T> type, SqlSession sqlSession) { 4 final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type); 5 if (mapperProxyFactory == null) { 6 throw new BindingException("Type " + type + " is not known to the MapperRegistry."); 7 } 8 try { 9 return mapperProxyFactory.newInstance(sqlSession); 10 } catch (Exception e) { 11 throw new BindingException("Error getting mapper instance. Cause: " + e, e); 12 } 13 }
该方法很简单，从集合中获取指定接口类型的映射器代理工厂，然后使用这个代理工厂创建映射器代理实例并返回，那么我们就可以获取到映射器的代理实例。
2.2 MapperProxyFactory：映射器代理工厂
这个类很简单，直接上全码：
1 package org.apache.ibatis.binding; 2 import java.lang.reflect.Method; 3 import java.lang.reflect.Proxy; 4 import java.util.Map; 5 import java.util.concurrent.ConcurrentHashMap; 6 import org.apache.ibatis.session.SqlSession; 7 /** 8 * 映射器代理工厂 9 */ 10 public class MapperProxyFactory<T> { 11 12 private final Class<T> mapperInterface; 13 private Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>(); 14 15 public MapperProxyFactory(Class<T> mapperInterface) { 16 this.mapperInterface = mapperInterface; 17 } 18 19 public Class<T> getMapperInterface() { 20 return mapperInterface; 21 } 22 23 public Map<Method, MapperMethod> getMethodCache() { 24 return methodCache; 25 } 26 27 @SuppressWarnings("unchecked") 28 protected T newInstance(MapperProxy<T> mapperProxy) { 29 //用JDK自带的动态代理生成映射器 30 return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy); 31 } 32 33 public T newInstance(SqlSession sqlSession) { 34 final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache); 35 return newInstance(mapperProxy); 36 } 37 38 }
明显是工厂模式，工厂模式的目的就是为了获取目标类的实例，很明显这个类就是为了在MapperRegisty中的addMapper(Class<T> type)方法的第4步中进行调用而设。
该类内部先调用MapperProxy的构造器生成MapperProxy映射器代理实例，然后以之使用JDK自带的动态代理来生成映射器代理实例（代理的实现在下一节中）。
在这个代理工厂中定义了一个缓存集合，其实为了调用MapperProxy的构造器而设，这个缓存集合用于保存当前映射器中的映射方法的。
映射方法单独定义，是因为这里并不存在一个真正的类和方法供调用，只是通过反射和代理的原理来实现的假的调用，映射方法是调用的最小单位（独立个体），将映射方法定义之后，它就成为一个实实在在的存在，我们可以将调用过的方法保存到对应的映射器的缓存中，以供下次调用，避免每次调用相同的方法的时候都需要重新进行方法的生成。很明显，方法的生成比较复杂，会消耗一定的时间，将其保存在缓存集合中备用，可以极大的解决这种时耗问题。
即使是在一般的项目中也会存在很多的映射器，这些映射器都要注册到注册器中，注册器集合中的每个映射器中都保存着一个独有的映射器代理工厂实例，而不是映射器实例，映射器实例只在需要的时候使用代理工厂进行创建，所以我们可以这么来看，MapperProxyFactory会存在多个实例，针对每个映射器有一个实例，这个实例就作为值保存在注册器中，而下一节中的MapperProxy被MapperProxyFactory调用来生成代理实例，同样也是与映射器接口一一对应的存在（即存在多个实例，只不过这个实例只会在需要的时候进行创建，不需要的时候是不存在的）。
2.3 MapperProxy：映射器代理
映射器代理类是MapperProxyFactory对应的目标类：
1 package org.apache.ibatis.binding; 2 import java.io.Serializable; 3 import java.lang.reflect.InvocationHandler; 4 import java.lang.reflect.Method; 5 import java.util.Map; 6 import org.apache.ibatis.reflection.ExceptionUtil; 7 import org.apache.ibatis.session.SqlSession; 8 /** 9 * 映射器代理，代理模式 10 * 11 */ 12 public class MapperProxy<T> implements InvocationHandler, Serializable { 13 14 private static final long serialVersionUID = -6424540398559729838L; 15 private final SqlSession sqlSession; 16 private final Class<T> mapperInterface; 17 private final Map<Method, MapperMethod> methodCache; 18 19 public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) { 20 this.sqlSession = sqlSession; 21 this.mapperInterface = mapperInterface; 22 this.methodCache = methodCache; 23 } 24 25 @Override 26 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 27 //代理以后，所有Mapper的方法调用时，都会调用这个invoke方法 28 //并不是任何一个方法都需要执行调用代理对象进行执行，如果这个方法是Object中通用的方法（toString、hashCode等）无需执行 29 if (Object.class.equals(method.getDeclaringClass())) { 30 try { 31 return method.invoke(this, args); 32 } catch (Throwable t) { 33 throw ExceptionUtil.unwrapThrowable(t); 34 } 35 } 36 //这里优化了，去缓存中找MapperMethod 37 final MapperMethod mapperMethod = cachedMapperMethod(method); 38 //执行 39 return mapperMethod.execute(sqlSession, args); 40 } 41 42 //去缓存中找MapperMethod 43 private MapperMethod cachedMapperMethod(Method method) { 44 MapperMethod mapperMethod = methodCache.get(method); 45 if (mapperMethod == null) { 46 //找不到才去new 47 mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()); 48 methodCache.put(method, mapperMethod); 49 } 50 return mapperMethod; 51 } 52 53 }
该类中的三个参数：
sqlSession：session会话
mapperInterface：映射器接口
methodCache：方法缓存
以上三个参数需要在构造器中进行赋值，首先session会话用于指明操作的来源，映射器接口指明操作的目标，方法缓存则用于保存具体的操作方法实例。在每个映射器代理中都存在以上三个参数，也就是说我们一旦我们使用过某个操作，那么这个操作过程中产生的代理实例将会一直存在，且具体操作方法会保存在这个代理实例的方法缓存中备用。
MapperProxy是使用JDK动态代理实现的代理功能，其重点就在invoke()方法中，首先过滤掉Object类的方法，然后从先从缓存中获取指定的方法，如果缓存中不存在则新建一个MapperMethod实例并将其保存在缓存中，如果缓存中存在这个指定的方法实例，则直接获取执行。
这里使用缓存进行流程优化，极大的提升了MyBatis的执行速率。
2.4 MapperMethod：映射器方法
映射器方法是最底层的被调用者，同时也是binding模块中最复杂的内容。它是MyBatis中对SqlSession会话操作的封装，那么这意味着什么呢？意味着这个类可以看做是整个MyBatis中数据库操作的枢纽，所有的数据库操作都需要经过它来得以实现。
我们单独使用MyBatis时，有时会直接操作SqlSession会话进行数据库操作，但是在SSM整合之后，这个数据库操作却是自动完成的，那么Sqlsession就需要被自动执行，那么组织执行它的就是这里的MapperMethod。
SqlSession会作为参数在从MapperRegisty中getMapper()中一直传递到MapperMethod中的execute()方法中，然后在这个方法中进行执行。
下面我们来解读MapperMethod的源码：
2.4.1 字段
1 private final SqlCommand command; 2 private final MethodSignature method;
这两个字段类型都是以MapperMethod中的静态内部类的方式定义的，分别表示sql命令与接口中的方法。
这两个字段都是final修饰，表示不可变，即一旦赋值，就永远是该值。
2.4.2 构造器
1 public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) { 2 this.command = new SqlCommand(config, mapperInterface, method); 3 this.method = new MethodSignature(config, method); 4 }
使用构造器对上面的两个字段进行赋值，这个赋值是永久的。
2.4.3 核心方法：execute()
1 //执行 2 public Object execute(SqlSession sqlSession, Object[] args) { 3 Object result; 4 //可以看到执行时就是4种情况，insert|update|delete|select，分别调用SqlSession的4大类方法 5 if (SqlCommandType.INSERT == command.getType()) { 6 Object param = method.convertArgsToSqlCommandParam(args); 7 result = rowCountResult(sqlSession.insert(command.getName(), param)); 8 } else if (SqlCommandType.UPDATE == command.getType()) { 9 Object param = method.convertArgsToSqlCommandParam(args); 10 result = rowCountResult(sqlSession.update(command.getName(), param)); 11 } else if (SqlCommandType.DELETE == command.getType()) { 12 Object param = method.convertArgsToSqlCommandParam(args); 13 result = rowCountResult(sqlSession.delete(command.getName(), param)); 14 } else if (SqlCommandType.SELECT == command.getType()) { 15 if (method.returnsVoid() && method.hasResultHandler()) { 16 //如果有结果处理器 17 executeWithResultHandler(sqlSession, args); 18 result = null; 19 } else if (method.returnsMany()) { 20 //如果结果有多条记录 21 result = executeForMany(sqlSession, args); 22 } else if (method.returnsMap()) { 23 //如果结果是map 24 result = executeForMap(sqlSession, args); 25 } else { 26 //否则就是一条记录 27 Object param = method.convertArgsToSqlCommandParam(args); 28 result = sqlSession.selectOne(command.getName(), param); 29 } 30 } else { 31 throw new BindingException("Unknown execution method for: " + command.getName()); 32 } 33 if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) { 34 throw new BindingException("Mapper method \'" + command.getName() 35 + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ")."); 36 } 37 return result; 38 }
这里可以很明显的看出，在这个执行方法中封装了对SqlSession的操作，而且将所有的数据库操作分类为增删改查四大类型，分别通过调用SqlSession的4大类方法来完成功能。
param表示的是SQL执行参数，可以通过静态内部类MethodSignature的convertArgsToSqlCommandParam()方法获取。
对SqlSession的增、删、改操作使用了rowCountResult()方法进行封装，这个方法对SQL操作的返回值类型进行验证检查，保证返回数据的安全。
针对SqlSession的查询操作较为复杂，分为多种情况：
1、针对拥有结果处理器的情况：执行executeWithResultHandler(SqlSession sqlSession, Object[] args)方法
这种有结果处理器的情况，就不需要本方法进行结果处理，自然有指定的结果处理器来进行处理，所以其result返回值设置为null。
2、针对返回多条记录的情况：执行executeForMany(SqlSession sqlSession, Object[] args)方法
内部调用SqlSession的selectList(String statement, Object parameter, RowBounds rowBounds)方法
针对Collections以及arrays进行支持，以解决#510BUG
3、针对返回Map的情况：执行executeForMap(SqlSession sqlSession, Object[] args)方法
内部调用SqlSession的selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds)方法
4、针对返回一条记录的情况：执行SqlSession的selectOne(String statement, Object parameter)方法
针对前三种情况返回的都不是一条数据，在实际项目必然会出现需要分页的情况，MyBatis中为我们提供了RowBounds来进行分页设置，在需要进行分页的情况，直接将设置好的分页实例传到SqlSession中即可。只不过这种方式的分页属于内存分页，针对数据量小的情况比较适合，对于大数据量的查询分页并不适合，大型项目中的分页也不会使用这种方式来实现分页，而是采用之后会解析的分页插件来时限物理分页，即直接修改SQL脚本来实现查询级的分页，再不会有大量查询数据占据内存。
下面将上面四种情况对应的方法源码贴出：
1 //结果处理器 2 private void executeWithResultHandler(SqlSession sqlSession, Object[] args) { 3 MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName()); 4 if (void.class.equals(ms.getResultMaps().get(0).getType())) { 5 throw new BindingException("method " + command.getName() 6 + " needs either a @ResultMap annotation, a @ResultType annotation," 7 + " or a resultType attribute in XML so a ResultHandler can be used as a parameter."); 8 } 9 Object param = method.convertArgsToSqlCommandParam(args); 10 if (method.hasRowBounds()) { 11 RowBounds rowBounds = method.extractRowBounds(args); 12 sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args)); 13 } else { 14 sqlSession.select(command.getName(), param, method.extractResultHandler(args)); 15 } 16 } 17 18 //多条记录 19 private <E> Object executeForMany(SqlSession sqlSession, Object[] args) { 20 List<E> result; 21 Object param = method.convertArgsToSqlCommandParam(args); 22 //代入RowBounds 23 if (method.hasRowBounds()) { 24 RowBounds rowBounds = method.extractRowBounds(args); 25 result = sqlSession.<E>selectList(command.getName(), param, rowBounds); 26 } else { 27 result = sqlSession.<E>selectList(command.getName(), param); 28 } 29 // issue #510 Collections & arrays support 30 if (!method.getReturnType().isAssignableFrom(result.getClass())) { 31 if (method.getReturnType().isArray()) { 32 return convertToArray(result); 33 } else { 34 return convertToDeclaredCollection(sqlSession.getConfiguration(), result); 35 } 36 } 37 return result; 38 } 39 40 private <E> Object convertToDeclaredCollection(Configuration config, List<E> list) { 41 Object collection = config.getObjectFactory().create(method.getReturnType()); 42 MetaObject metaObject = config.newMetaObject(collection); 43 metaObject.addAll(list); 44 return collection; 45 } 46 47 @SuppressWarnings("unchecked") 48 private <E> E[] convertToArray(List<E> list) { 49 E[] array = (E[]) Array.newInstance(method.getReturnType().getComponentType(), list.size()); 50 array = list.toArray(array); 51 return array; 52 } 53 54 private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) { 55 Map<K, V> result; 56 Object param = method.convertArgsToSqlCommandParam(args); 57 if (method.hasRowBounds()) { 58 RowBounds rowBounds = method.extractRowBounds(args); 59 result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey(), rowBounds); 60 } else { 61 result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey()); 62 } 63 return result; 64 }
2.4.4 静态内部类：SqlCommand
1 //SQL命令，静态内部类 2 public static class SqlCommand { 3 4 private final String name; 5 private final SqlCommandType type; 6 7 public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) { 8 String statementName = mapperInterface.getName() + "." + method.getName(); 9 MappedStatement ms = null; 10 if (configuration.hasStatement(statementName)) { 11 ms = configuration.getMappedStatement(statementName); 12 } else if (!mapperInterface.equals(method.getDeclaringClass().getName())) { // issue #35 13 //如果不是这个mapper接口的方法，再去查父类 14 String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName(); 15 if (configuration.hasStatement(parentStatementName)) { 16 ms = configuration.getMappedStatement(parentStatementName); 17 } 18 } 19 if (ms == null) { 20 throw new BindingException("Invalid bound statement (not found): " + statementName); 21 } 22 name = ms.getId(); 23 type = ms.getSqlCommandType(); 24 if (type == SqlCommandType.UNKNOWN) { 25 throw new BindingException("Unknown execution method for: " + name); 26 } 27 } 28 29 public String getName() { 30 return name; 31 } 32 33 public SqlCommandType getType() { 34 return type; 35 } 36 }
这个内部类比较简单，是对SQL命令的封装，定义两个字段，name和type，前者表示SQL命令的名称，这个名称就是接口的全限定名+方法名称（中间以.连接），后者表示的是SQL命令的类型，无非增删改查四种。
内部类中有一个带参数的构造器用于对字段赋值，里面涉及到了MappedStatement类，这个类封装的是映射语句的信息，在构建Configuration实例时会创建一个Map集合用于存储所有的映射语句，而这些映射语句的解析存储是在构建映射器的时候完成的（MapperBuilderAssistant类中）。
MappedStatement中的id字段表示的是statementName，即本内部类中的name值，所以在第22行代码处直接将id赋值给name
2.4.5 静态内部类：MethodSignature
首先我们来看看字段定义：
1 private final boolean returnsMany;//是否返回多个多条记录 2 private final boolean returnsMap;//是否返回Map 3 private final boolean returnsVoid;//是否返回void 4 private final Class<?> returnType;//返回类型 5 private final String mapKey;//@mapKey注解指定的键值 6 private final Integer resultHandlerIndex;//结果处理器参数在方法参数列表中的位置下标 7 private final以上是关于浩哥解析MyBatis源码——binding绑定模块之MapperRegisty的主要内容，如果未能解决你的问题，请参考以下文章浩哥解析MyBatis源码——Type类型模块之类型处理器注册器（TypeHandlerRegistry）
UE4 Unlua源码解析9 - 静态绑定和动态绑定的实现原理