浩哥解析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：

   private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();

　　上面的集合中键值的类型分别为Class类型与MapperProxyFactory类型，MapperProxyFactory是映射器代理工厂，通过这个工厂类可以获取到对应的映射器代理类MapperProxy，这里只需要保存一个映射器的代理工厂，根据工厂就可以获取到对应的映射器。

　　相应的，注册器中必然定义了添加映射器和获取映射器的方法来对外提供服务（供外部调取）。这里就是addMapper()方法与getMapper()方法，在该注册器中还有一种根据包名来注册映射器的方法addMappers()方法。因为该方法最后会调用addMapper()方法来完成具体的注册功能，所以我们直接从addMappers()说起。

2.1.1 addMappers()

　　addMappers()方法是将给定包名下的所有映射器注册到注册器中。其源码：

   public <T> void addMapper(Class<T> type) {
     //mapper必须是接口！才会添加
     if (type.isInterface()) {
       if (hasMapper(type)) {
         //如果重复添加了，报错
         throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
       }
       boolean loadCompleted = false;
       try {
         knownMappers.put(type, new MapperProxyFactory<T>(type));
         // It's important that the type is added before the parser is run
         // otherwise the binding may automatically be attempted by the
         // mapper parser. If the type is already known, it won't try.
         MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
         parser.parse();
         loadCompleted = true;
       } finally {
         //如果加载过程中出现异常需要再将这个mapper从mybatis中删除,这种方式比较丑陋吧，难道是不得已而为之？
         if (!loadCompleted) {
           knownMappers.remove(type);
         }
       }
     }
   }

   /**
    * @since 3.2.2
    */
   public void addMappers(String packageName, Class<?> superType) {
     //查找包下所有是superType的类
     ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
     resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
     Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
     for (Class<?> mapperClass : mapperSet) {
       addMapper(mapperClass);
     }
   }

   /**
    * @since 3.2.2
    */
   //查找包下所有类
   public void addMappers(String packageName) {
     addMappers(packageName, Object.class);
   }

　　其实这三个方法均可对外实现添加映射器的功能，分别应对不同的情况，其中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():

   @SuppressWarnings("unchecked")
   //返回代理类
   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.");
     }
     try {
       return mapperProxyFactory.newInstance(sqlSession);
     } catch (Exception e) {
       throw new BindingException("Error getting mapper instance. Cause: " + e, e);
     }
   }

　　该方法很简单，从集合中获取指定接口类型的映射器代理工厂，然后使用这个代理工厂创建映射器代理实例并返回，那么我们就可以获取到映射器的代理实例。

2.2 MapperProxyFactory：映射器代理工厂

　　这个类很简单，直接上全码：

 package org.apache.ibatis.binding;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import org.apache.ibatis.session.SqlSession;
 /**
  * 映射器代理工厂
  */
 public class MapperProxyFactory<T> {

   private final Class<T> mapperInterface;
   private Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();

   public MapperProxyFactory(Class<T> mapperInterface) {
     this.mapperInterface = mapperInterface;
   }

   public Class<T> getMapperInterface() {
     return mapperInterface;
   }

   public Map<Method, MapperMethod> getMethodCache() {
     return methodCache;
   }

   @SuppressWarnings("unchecked")
   protected T newInstance(MapperProxy<T> mapperProxy) {
     //用JDK自带的动态代理生成映射器
     return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
   }

   public T newInstance(SqlSession sqlSession) {
     final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
     return newInstance(mapperProxy);
   }

 }

　　明显是工厂模式，工厂模式的目的就是为了获取目标类的实例，很明显这个类就是为了在MapperRegisty中的addMapper(Class<T> type)方法的第4步中进行调用而设。

　　该类内部先调用MapperProxy的构造器生成MapperProxy映射器代理实例，然后以之使用JDK自带的动态代理来生成映射器代理实例（代理的实现在下一节中）。

　　在这个代理工厂中定义了一个缓存集合，其实为了调用MapperProxy的构造器而设，这个缓存集合用于保存当前映射器中的映射方法的。

　　映射方法单独定义，是因为这里并不存在一个真正的类和方法供调用，只是通过反射和代理的原理来实现的假的调用，映射方法是调用的最小单位（独立个体），将映射方法定义之后，它就成为一个实实在在的存在，我们可以将调用过的方法保存到对应的映射器的缓存中，以供下次调用，避免每次调用相同的方法的时候都需要重新进行方法的生成。很明显，方法的生成比较复杂，会消耗一定的时间，将其保存在缓存集合中备用，可以极大的解决这种时耗问题。

　　即使是在一般的项目中也会存在很多的映射器，这些映射器都要注册到注册器中，注册器集合中的每个映射器中都保存着一个独有的映射器代理工厂实例，而不是映射器实例，映射器实例只在需要的时候使用代理工厂进行创建，所以我们可以这么来看，MapperProxyFactory会存在多个实例，针对每个映射器有一个实例，这个实例就作为值保存在注册器中，而下一节中的MapperProxy被MapperProxyFactory调用来生成代理实例，同样也是与映射器接口一一对应的存在（即存在多个实例，只不过这个实例只会在需要的时候进行创建，不需要的时候是不存在的）。

2.3 MapperProxy：映射器代理

　　映射器代理类是MapperProxyFactory对应的目标类：

 package org.apache.ibatis.binding;
 import java.io.Serializable;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.util.Map;
 import org.apache.ibatis.reflection.ExceptionUtil;
 import org.apache.ibatis.session.SqlSession;
 /**
  * 映射器代理，代理模式
  *
  */
 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 {
     //代理以后，所有Mapper的方法调用时，都会调用这个invoke方法
     //并不是任何一个方法都需要执行调用代理对象进行执行，如果这个方法是Object中通用的方法（toString、hashCode等）无需执行
     if (Object.class.equals(method.getDeclaringClass())) {
       try {
         return method.invoke(this, args);
       } catch (Throwable t) {
         throw ExceptionUtil.unwrapThrowable(t);
       }
     }
     //这里优化了，去缓存中找MapperMethod
     final MapperMethod mapperMethod = cachedMapperMethod(method);
     //执行
     return mapperMethod.execute(sqlSession, args);
   }

   //去缓存中找MapperMethod
   private MapperMethod cachedMapperMethod(Method method) {
     MapperMethod mapperMethod = methodCache.get(method);
     if (mapperMethod == null) {
       //找不到才去new
       mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
       methodCache.put(method, mapperMethod);
     }
     return mapperMethod;
   }

 }

　　该类中的三个参数：

　　　　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 字段

   private final SqlCommand command;
   private final MethodSignature method;

　　这两个字段类型都是以MapperMethod中的静态内部类的方式定义的，分别表示sql命令与接口中的方法。

　　这两个字段都是final修饰，表示不可变，即一旦赋值，就永远是该值。

2.4.2 构造器

   public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
     this.command = new SqlCommand(config, mapperInterface, method);
     this.method = new MethodSignature(config, method);
   }

　　使用构造器对上面的两个字段进行赋值，这个赋值是永久的。

2.4.3 核心方法：execute()

   //执行
   public Object execute(SqlSession sqlSession, Object[] args) {
     Object result;
     //可以看到执行时就是4种情况，insert|update|delete|select，分别调用SqlSession的4大类方法
     if (SqlCommandType.INSERT == command.getType()) {
       Object param = method.convertArgsToSqlCommandParam(args);
       result = rowCountResult(sqlSession.insert(command.getName(), param));
     } else if (SqlCommandType.UPDATE == command.getType()) {
       Object param = method.convertArgsToSqlCommandParam(args);
       result = rowCountResult(sqlSession.update(command.getName(), param));
     } else if (SqlCommandType.DELETE == command.getType()) {
       Object param = method.convertArgsToSqlCommandParam(args);
       result = rowCountResult(sqlSession.delete(command.getName(), param));
     } else if (SqlCommandType.SELECT == command.getType()) {
       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 {
         //否则就是一条记录
         Object param = method.convertArgsToSqlCommandParam(args);
         result = sqlSession.selectOne(command.getName(), param);
       }
     } else {
       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;
   }

　　这里可以很明显的看出，在这个执行方法中封装了对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脚本来实现查询级的分页，再不会有大量查询数据占据内存。

　　下面将上面四种情况对应的方法源码贴出：

   //结果处理器
   private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
     MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
     if (void.class.equals(ms.getResultMaps().get(0).getType())) {
       throw new BindingException("method " + command.getName()
           + " needs either a @ResultMap annotation, a @ResultType annotation,"
           + " or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
     }
     Object param = method.convertArgsToSqlCommandParam(args);
     if (method.hasRowBounds()) {
       RowBounds rowBounds = method.extractRowBounds(args);
       sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
     } else {
       sqlSession.select(command.getName(), param, method.extractResultHandler(args));
     }
   }

   //多条记录
   private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
     List<E> result;
     Object param = method.convertArgsToSqlCommandParam(args);
     //代入RowBounds
     if (method.hasRowBounds()) {
       RowBounds rowBounds = method.extractRowBounds(args);
       result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
     } else {
       result = sqlSession.<E>selectList(command.getName(), param);
     }
     // issue #510 Collections & arrays support
     if (!method.getReturnType().isAssignableFrom(result.getClass())) {
       if (method.getReturnType().isArray()) {
         return convertToArray(result);
       } else {
         return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
       }
     }
     return result;
   }

   private <E> Object convertToDeclaredCollection(Configuration config, List<E> list) {
     Object collection = config.getObjectFactory().create(method.getReturnType());
     MetaObject metaObject = config.newMetaObject(collection);
     metaObject.addAll(list);
     return collection;
   }

   @SuppressWarnings("unchecked")
   private <E> E[] convertToArray(List<E> list) {
     E[] array = (E[]) Array.newInstance(method.getReturnType().getComponentType(), list.size());
     array = list.toArray(array);
     return array;
   }

   private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) {
     Map<K, V> result;
     Object param = method.convertArgsToSqlCommandParam(args);
     if (method.hasRowBounds()) {
       RowBounds rowBounds = method.extractRowBounds(args);
       result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey(), rowBounds);
     } else {
       result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey());
     }
     return result;
   }

2.4.4 静态内部类：SqlCommand

   //SQL命令，静态内部类
   public static class SqlCommand {

     private final String name;
     private final SqlCommandType type;

     public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
       String statementName = mapperInterface.getName() + "." + method.getName();
       MappedStatement ms = null;
       if (configuration.hasStatement(statementName)) {
         ms = configuration.getMappedStatement(statementName);
       } else if (!mapperInterface.equals(method.getDeclaringClass().getName())) { // issue #35
         //如果不是这个mapper接口的方法，再去查父类
         String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName();
         if (configuration.hasStatement(parentStatementName)) {
           ms = configuration.getMappedStatement(parentStatementName);
         }
       }
       if (ms == null) {
         throw new BindingException("Invalid bound statement (not found): " + statementName);
       }
       name = ms.getId();
       type = ms.getSqlCommandType();
       if (type == SqlCommandType.UNKNOWN) {
         throw new BindingException("Unknown execution method for: " + name);
       }
     }

     public String getName() {
       return name;
     }

     public SqlCommandType getType() {
       return type;
     }
   }

　　这个内部类比较简单，是对SQL命令的封装，定义两个字段，name和type，前者表示SQL命令的名称，这个名称就是接口的全限定名+方法名称（中间以.连接），后者表示的是SQL命令的类型，无非增删改查四种。

　　内部类中有一个带参数的构造器用于对字段赋值，里面涉及到了MappedStatement类，这个类封装的是映射语句的信息，在构建Configuration实例时会创建一个Map集合用于存储所有的映射语句，而这些映射语句的解析存储是在构建映射器的时候完成的（MapperBuilderAssistant类中）。

　　MappedStatement中的id字段表示的是statementName，即本内部类中的name值，所以在第22行代码处直接将id赋值给name

2.4.5 静态内部类：MethodSignature

　　首先我们来看看字段定义：

     private final boolean returnsMany;//是否返回多个多条记录
     private final boolean returnsMap;//是否返回Map
     private final boolean returnsVoid;//是否返回void
     private final Class<?> returnType;//返回类型
     private final String mapKey;//@mapKey注解指定的键值
     private final Integer resultHandlerIndex;//结果处理器参数在方法参数列表中的位置下标
     private final Integer rowBoundsIndex;//分页配置参数在方法参数列表中的位置下标
     private final SortedMap<Integer, String> params;//参数集合
     private final boolean hasNamedParameters;//指定方法是否存在的参数注解

　　这些字段的含义正如源码中注释所述。

　　然后是带参构造器：

     public MethodSignature(Configuration configuration, Method method) {
       this.returnType = method.getReturnType();
       this.returnsVoid = void.class.equals(this.returnType);
       this.returnsMany = (configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray());
       this.mapKey = getMapKey(method);
       this.returnsMap = (this.mapKey != null);
       this.hasNamedParameters = hasNamedParams(method);
       //以下重复循环2遍调用getUniqueParamIndex，是不是降低效率了
       //记下RowBounds是第几个参数
       this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
       //记下ResultHandler是第几个参数
       this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
       this.params = Collections.unmodifiableSortedMap(getParams(method, this.hasNamedParameters));
     }

　　构造器的参数分别为Configuration与Method，我们的字段的值部分是需要从这两个参数中获取的。

　　　　返回类型returnType从Method中获取

　　　　hasNamedParameters表示是否存在注解方式定义的参数

　　　　获取Method中RowBounds类型参数与ResultHandler类型参数的位置

　　下面是核心方法：convertArgsToSqlCommandParam(Object[] args)：

    public Object convertArgsToSqlCommandParam(Object[] args) {
       final int paramCount = params.size();
       if (args == null || paramCount == 0) {
         //如果没参数
         return null;
       } else if (!hasNamedParameters && paramCount == 1) {
         //如果只有一个参数
         return args[params.keySet().iterator().next().intValue()];
       } else {
         //否则，返回一个ParamMap，修改参数名，参数名就是其位置
         final Map<String, Object> param = new ParamMap<Object>();
         int i = 0;
         for (Map.Entry<Integer, String> entry : params.entrySet()) {
           //1.先加一个#{0},#{1},#{2}...参数
           param.put(entry.getValue(), args[entry.getKey().intValue()]);
           // issue #71, add param names as param1, param2...but ensure backward compatibility
           final String genericParamName = "param" + String.valueOf(i + 1);
           if (!param.containsKey(genericParamName)) {
             //2.再加一个#{param1},#{param2}...参数
             //你可以传递多个参数给一个映射器方法。如果你这样做了,
             //默认情况下它们将会以它们在参数列表中的位置来命名,比如:#{param1},#{param2}等。
             //如果你想改变参数的名称(只在多参数情况下) ,那么你可以在参数上使用@Param(“paramName”)注解。
             param.put(genericParamName, args[entry.getKey()]);
           }
           i++;
         }
         return param;
       }
     }

　　这个内部类是对映射器接口中的方法的封装，其核心功能就是convertArgsToSqlCommandParam(Object[] args)方法，用于将方法中的参数转换成为SQL脚本命令中的参数形式，其实就是将参数位置作为键，具体的参数作为值保存到一个Map集合中，这样在SQL脚本命令中用键#{1}通过集合就能得到具体的参数。

　　之后会介绍，在params集合中保存的键值对分别为未排除RowBounds类型和ResultHandler类型的参数时各参数的位置下标与排除之后按原参数先后顺序重新编号的新位置下标，而params的size大小其实是排除RowBounds类型和ResultHandler类型的参数之后参数的数量大小。

　　上面的源码第14行，以params中的值（即新位置下标）为键，以通过原位置下标从方法的参数数组中获取的具体参数为值保存在param集合中。之后再以paramn（n为从1开始的数值）为键，以通过原位置下标从方法的参数数组中获取的具体参数为值保存在param集合中，这么一来，在param中就保存这两份参数。

　　此处为了向老版本兼容，故在map中保存着两份参数，一份是老版的与#{0}为键的参数另一种为以#{param1}为键的参数。

　　下面介绍params集合字段，这个集合用于保存方法中所有的参数，这是一个Map集合，通过getParams()方法来获取方法中所有的参数，并将参数保存到Map集合中：

     //得到所有参数
     private SortedMap<Integer, String> getParams(Method method, boolean hasNamedParameters) {
       //用一个TreeMap,这样就保证还是按参数的先后顺序
       final SortedMap<Integer, String> params = new TreeMap<Integer, String>();
       final Class<?>[] argTypes = method.getParameterTypes();
       for (int i = 0; i < argTypes.length; i++) {
         //是否不是RowBounds/ResultHandler类型的参数
         if (!RowBounds.class.isAssignableFrom(argTypes[i]) && !ResultHandler.class.isAssignableFrom(argTypes[i])) {
           //参数名字默认为0,1,2，这就是为什么xml里面可以用#{1}这样的写法来表示参数了
           String paramName = String.valueOf(params.size());
           if (hasNamedParameters) {
             //还可以用注解@Param来重命名参数
             paramName = getParamNameFromAnnotation(method, i, paramName);
           }
           params.put(i, paramName);
         }
       }
       return params;
     }

     private String getParamNameFromAnnotation(Method method, int i, String paramName) {
       final Object[] paramAnnos = method.getParameterAnnotations()[i];
       for (Object paramAnno : paramAnnos) {
         if (paramAnno instanceof Param) {
           paramName = ((Param) paramAnno).value();
         }
       }
       return paramName;
     }

　　这个方法主要额目的就是获取指定方法Method中的所有排除RowBounds类型和ResultHandler类型的参数的参数，并将其重新排序，将顺序保存到Map集合中，Map集合总保存的内容可能为：[(0,"0"),(1,"1"),(3,"2"),(4,"3"),(5,"4"),(6,"5")]的样式，第一个数字（键）表示的是该参数在方法列表中的原位置（包含RowBounds类型和ResultHandler类型的参数），第二个数字（值字符串形式）表示的是该参数在排除RowBounds类型和ResultHandler类型的参数之后重排的顺序，先后顺序与之前一致。

　　暂时就解析到这里，这一篇将binding模块进行了解析，重点就是MapperMethod类，这是一个枢纽类，是操作数据库的必要一环。