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 Integer rowBoundsIndex;//分页配置参数在方法参数列表中的位置下标
8     private final SortedMap<Integer, String> params;//参数集合
9     private final boolean hasNamedParameters;//指定方法是否存在的参数注解

  这些字段的意义正使源码中注释所陈述。

  然后是带参构造器:

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

  构造器的参数分别吗Configuration与Method,我们的字段的值部分是用从立片个参数中得的。

    返回路returnType从Method中取

    hasNamedParameters表示是否留存注解方式定义之参数

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

  下面是基本措施:convertArgsToSqlCommandParam(Object[] args):

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

  这个里面类是针对映射器接口中之法子的包裹,其主干职能就是是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集合中:

 1     //得到所有参数
 2     private SortedMap<Integer, String> getParams(Method method, boolean hasNamedParameters) {
 3       //用一个TreeMap,这样就保证还是按参数的先后顺序
 4       final SortedMap<Integer, String> params = new TreeMap<Integer, String>();
 5       final Class<?>[] argTypes = method.getParameterTypes();
 6       for (int i = 0; i < argTypes.length; i++) {
 7         //是否不是RowBounds/ResultHandler类型的参数
 8         if (!RowBounds.class.isAssignableFrom(argTypes[i]) && !ResultHandler.class.isAssignableFrom(argTypes[i])) {
 9           //参数名字默认为0,1,2,这就是为什么xml里面可以用#{1}这样的写法来表示参数了
10           String paramName = String.valueOf(params.size());
11           if (hasNamedParameters) {
12             //还可以用注解@Param来重命名参数
13             paramName = getParamNameFromAnnotation(method, i, paramName);
14           }
15           params.put(i, paramName);
16         }
17       }
18       return params;
19     }
20 
21     private String getParamNameFromAnnotation(Method method, int i, String paramName) {
22       final Object[] paramAnnos = method.getParameterAnnotations()[i];
23       for (Object paramAnno : paramAnnos) {
24         if (paramAnno instanceof Param) {
25           paramName = ((Param) paramAnno).value();
26         }
27       }
28       return paramName;
29     }

  这个方式主要额目的就是取得指定方法Method中之享有排除RowBounds类型和ResultHandler类型的参数的参数,并将其再排序,将依次保存至Map集合中,Map集合总保存的情节恐怕吗:[(0,”0″),(1,”1″),(3,”2″),(4,”3″),(5,”4″),(6,”5″)]的体裁,第一单数字(键)表示的是欠参数在章程列表中之本原职务(包含RowBounds类型和ResultHandler类型的参数),第二单数字(值字符串形式)表示的是拖欠参数在消除RowBounds类型和ResultHandler类型的参数后重排的相继,先后顺序与之前同一。

  暂时就解析到此,这同样篇用binding模块进行了分析,重点就是MapperMethod类,这是一个枢纽类,是操作数据库的画龙点睛一圈。

网站地图xml地图