mybatis查询语句的背后之参数解析

 转载请注明出处。。。

一、前言

通过前面我们也知道，通过getmapper方式来进行查询，最后会通过mappermehod类，对接口中传来的参数也会在这个类里面进行一个解析，随后就传到对应位置，与sql里面的参数进行一个匹配，最后获取结果。对于mybatis通常传参(这里忽略掉rowbounds和resulthandler两种类型)有几种方式。

1、javabean类型参数

2、非javabean类型参数

注意，本文是基于mybatis3.5.0版本进行分析。

1、参数的存储

2、对sql语句中参数的赋值

下面将围绕这这两方面进行

二、参数的存储

先看下面一段代码

 1     @test
 2     public void testselectordinaryparam() throws exception{
 3         sqlsession sqlsession = mybatisutil.getsessionfactory().opensession();
 4         usermapper mapper = sqlsession.getmapper(usermapper.class);
 5         list<user> userlist = mapper.selectbyordinaryparam("张三1号");
 6         system.out.println(userlist);
 7         sqlsession.close();
 8     }
 9     list<user> selectbyordinaryparam(string username);  // mapper接口
10     <select id="selectbyordinaryparam" resultmap="baseresultmap">
11         select
12         <include refid="base_column_list"/>
13         from user
14         where username = #{username,jdbctype=varchar}
15     </select>

 或许有的人会奇怪，这个mapper接口没有带@param注解，怎么能在mapper配置文件中直接带上参数名呢，不是会报错吗，

在mybatis里面，对单个参数而言，直接使用参数名是没问题的，如果是多个参数就不能这样了，下面我们来了解下，mybatis的解析过程，请看下面代码，位于mappermehod类的内部类methodsignature构造函数中

 1 public methodsignature(configuration configuration, class<?> mapperinterface, method method) {
 2       type resolvedreturntype = typeparameterresolver.resolvereturntype(method, mapperinterface);
 3       if (resolvedreturntype instanceof class<?>) {
 4         this.returntype = (class<?>) resolvedreturntype;
 5       } else if (resolvedreturntype instanceof parameterizedtype) {
 6         this.returntype = (class<?>) ((parameterizedtype) resolvedreturntype).getrawtype();
 7       } else {
 8         this.returntype = method.getreturntype();
 9       }
10       this.returnsvoid = void.class.equals(this.returntype);
11       this.returnsmany = configuration.getobjectfactory().iscollection(this.returntype) || this.returntype.isarray();
12       this.returnscursor = cursor.class.equals(this.returntype);
13       this.returnsoptional = optional.class.equals(this.returntype);
14       this.mapkey = getmapkey(method);
15       this.returnsmap = this.mapkey != null;
16       this.rowboundsindex = getuniqueparamindex(method, rowbounds.class);
17       this.resulthandlerindex = getuniqueparamindex(method, resulthandler.class);
18      // 参数解析类
19       this.paramnameresolver = new paramnameresolver(configuration, method);
20     }

 参数的存储解析皆由paramnameresolver类来进行操作，先看下该类的构造函数

 1 /**
 2  * config 全局的配置文件中心
 3  * method 实际执行的方法，也就是mapper接口中的抽象方法
 4  * 
 5  */
 6 public paramnameresolver(configuration config, method method) {
 7     // 获取method中的所有参数类型
 8     final class<?>[] paramtypes = method.getparametertypes();
 9     // 获取参数中含有的注解，主要是为了@param注解做准备
10     final annotation[][] paramannotations = method.getparameterannotations();
11     final sortedmap<integer, string> map = new treemap<>();
12     // 这里实际上获取的值就是参数的个数。也就是二维数组的行长度
13     int paramcount = paramannotations.length;
14     // get names from @param annotations
15     for (int paramindex = 0; paramindex < paramcount; paramindex++) {
16       // 排除rowbounds和resulthandler两种类型的参数
17       if (isspecialparameter(paramtypes[paramindex])) {
18         // skip special parameters
19         continue;
20       }
21       string name = null;
22       // 如果参数中含有@param注解，则只用@param注解的值作为参数名
23       for (annotation annotation : paramannotations[paramindex]) {
24         if (annotation instanceof param) {
25           hasparamannotation = true;
26           name = ((param) annotation).value();
27           break;
28         }
29       }
30       // 即参数没有@param注解
31       if (name == null) {
32         // 参数实际名称，其实这个值默认就是true，具体可以查看configuration类中的该属性值，当然也可以在配置文件进行配置关闭
33         // 如果jdk处于1.8版本，且编译时带上了-parameters 参数，那么获取的就是实际的参数名，如methoda(string username)
34         // 获取的就是username,否则获取的就是args0  后面的数字就是参数所在位置
35         if (config.isuseactualparamname()) {
36           name = getactualparamname(method, paramindex);
37         }
38         // 如果以上条件都不满足，则将参数名配置为 0,1,2../
39         if (name == null) {
40           // use the parameter index as the name ("0", "1", ...)
41           // gcode issue #71
42           name = string.valueof(map.size());
43         }
44       }
45       map.put(paramindex, name);
46     }
47     names = collections.unmodifiablesortedmap(map);
48   }

 这个构造函数的作用就是对参数名称进行一个封装，得到一个  “参数位置-->参数名称 “ 的一个map结构，这样做的目的是为了替换参数值，我们也清楚，实际传过来的参数就是一个一个object数组结构，我们也可以将它理解为map结构。即 index --> 参数值，此就和之前的 map结构有了对应，也就最终可以得到一个 参数名称  --->  参数值 的一个对应关系。

 1 public object execute(sqlsession sqlsession, object[] args) {
 2     object result;
 3     switch (command.gettype()) {
 4       // 其它情况忽略掉
 5       case select:
 6         // 这里参数中含有resulthandler，暂不做讨论
 7         if (method.returnsvoid() && method.hasresulthandler()) {
 8           executewithresulthandler(sqlsession, args);
 9           result = null;
10         } else if (method.returnsmany()) {// 1、 返回结果为集合类型或数组类型，这种情况适用于大多数情况
11           result = executeformany(sqlsession, args);
12         } else if (method.returnsmap()) {// 返回结果为map类型
13           result = executeformap(sqlsession, args);
14         } else if (method.returnscursor()) {
15           result = executeforcursor(sqlsession, args);
16         } else {// 2、返回结果javabean类型，或普通的基础类型及其包装类等  
17           object param = method.convertargstosqlcommandparam(args);
18           result = sqlsession.selectone(command.getname(), param);
19           // 对java8中的optional进行了支持
20           if (method.returnsoptional() &&
21               (result == null || !method.getreturntype().equals(result.getclass()))) {
22             result = optional.ofnullable(result);
23           }
24         }
25         break;
26       default:
27         throw new bindingexception("unknown execution method for: " + command.getname());
28     }
29     if (result == null && method.getreturntype().isprimitive() && !method.returnsvoid()) {
30       throw new bindingexception("mapper method '" + command.getname()
31           + " attempted to return null from a method with a primitive return type (" + method.getreturntype() + ").");
32     }
33     return result;
34   }

 

这里主要分析1情况。对于2情况也就是接下来要说的参数赋值情况，不过要先介绍下method.convertargstosqlcommandparam这代码带来的一个结果是怎么样的

 1 public object convertargstosqlcommandparam(object[] args) {
 2       return paramnameresolver.getnamedparams(args);
 3     }
 4 
 5 public object getnamedparams(object[] args) {
 6     final int paramcount = names.size();
 7     if (args == null || paramcount == 0) {
 8       return null;
 9     } else if (!hasparamannotation && paramcount == 1) {// 1
10       return args[names.firstkey()];
11     } else {
12       final map<string, object> param = new parammap<>();
13       int i = 0;
14       for (map.entry<integer, string> entry : names.entryset()) {
15         param.put(entry.getvalue(), args[entry.getkey()]);
16         // add generic param names (param1, param2, ...)
17         final string genericparamname = generic_name_prefix + string.valueof(i + 1);
18         // ensure not to overwrite parameter named with @param
19         if (!names.containsvalue(genericparamname)) {
20           param.put(genericparamname, args[entry.getkey()]);
21         }
22         i++;
23       }
24       return param;
25     }
26   }

 

可以很清楚的知道最后又调用了paramnameresolver类的getnamedpaams方法，这个方法的主要作用就是，将原来的参数位置 -->  参数名称  映射关系转为  参数名称 --->参数值 ，并且新加一个参数名和参数值得一个对应关系。即

param1  ->参数值1

param2 -->参数值2 

当然如果只有一个参数，如代码中的1部分，若参数没有@param注解，且只有一个参数，则不会加入上述的一个对象关系，这也就是前面说的，对于单个参数，可以直接在sql中写参数名就ok的原因。下面回到前面

 1 private <e> object executeformany(sqlsession sqlsession, object[] args) {
 2     list<e> result;
 3     // 获取对应的一个映射关系，param类型有可能为map或null或参数实际类型
 4     object param = method.convertargstosqlcommandparam(args);
 5     if (method.hasrowbounds()) {
 6       rowbounds rowbounds = method.extractrowbounds(args);
 7       result = sqlsession.<e>selectlist(command.getname(), param, rowbounds);
 8     } else {
 9       result = sqlsession.<e>selectlist(command.getname(), param);
10     }
11     // 如果返回结果类型和method的返回结果类型不一致，则进行转换数据结构
12     // 其实就是result返回结果不是list类型，而是其他集合类型或数组类型
13     if (!method.getreturntype().isassignablefrom(result.getclass())) {
14       if (method.getreturntype().isarray()) {// 为数组结果
15         return converttoarray(result);
16       } else {// 其他集合类型
17         return converttodeclaredcollection(sqlsession.getconfiguration(), result);
18       }
19     }
20     return result;
21   }

 

代码也不复杂，就是将得到的参数对应关系传入，最终获取结果，根据实际需求进行结果转换。

3、对sql语句中参数的赋值

 其实前面一篇博客中也有涉及到。参数赋值的位置在defaultparameterhandler类里面，可以查看前面一篇博客，这里不做过多介绍，传送门  

 

 

---------------------------------------------------------------------------------------------------------------------------------------分界线--------------------------------------------------------------------------------------------------------

若有不足或错误之处，还望指正，谢谢！