这篇文章的标题本来该延续之前几篇的传统，叫做“Mybatis源码之ParameterHandler”，但是这个名字不足以覆盖这篇文章的内容，读完你就会知道ParameterHandler在设置过程中仅有那么一丁点的部分。
根据我的理解，Mybatis参数设置过程分为参数解析处理、动态SQL转为静态SQL、预编译参数赋值几个步骤，其中动态SQL转为静态SQL的过程中会涉及预编译${}参数赋值和预编译参数的解析工作。本文将从一个简单的示例出发了解Mybatis参数设置的全部流程，文章会涉及一些常见的问题：
-
${}占位符的处理流程； -
#{}占位符的处理流程； -
ParameterHandler#setParameters的执行流程；
从Demo开始
这个demo是在原来的基础上进行了改造，不过也仅仅是mapper.xml部分，大家先有个简单的印象，方便后续文章进行分析。
-
CompanyMapper.xml
xml中仅有一个select查询语句，为了便于分析${}与#{}两种占位符的差别，我在一个
1<?xml version="1.0" encoding="UTF-8"?>
2<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3
4<mapper namespace="com.raysonxin.dao.CompanyDao">
5 <resultMap id="baseResultMap" type="com.raysonxin.dataobject.CompanyDO">
6 <id column="id" property="id"/>
7 <result column="name" property="name"/>
8 <result column="cpy_type" property="cpyType"/>
9 </resultMap>
10
11 <select id="selectById" resultMap="baseResultMap">
12 select id,name,cpy_type from company
13 <where>
14 <if test="id != null">
15 id = ${id} or id = #{id}
16 </if>
17 </where>
18 </select>
19</mapper>
-
CompanyDao.java
1public interface CompanyDao {
2 /**
3 * 根据id查询CompanyDO
4 *
5 * @param cmpId 主键id
6 * @return 查询结果
7 */
8 CompanyDO selectById(@Param("id") Integer cmpId);
9}
-
Program.java
1public class Program {
2 public static void main(String[] args) throws IOException {
3 // mybatis配置文件
4 String path = "mybatis-config.xml";
5 InputStream inputStream = Resources.getResourceAsStream(path);
6 // 获取 SqlSessionFactory
7 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
8 // 创建 SqlSession
9 try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
10 CompanyDao dao = sqlSession.getMapper(CompanyDao.class);
11 CompanyDO companyDO = dao.selectById(1);
12 System.out.println(companyDO);
13 }
14 }
15}
下图来自之前的文章《Mybatis源码之SQL执行过程》，经过前文的分析，我们知道Mapper接口的方法是通过动态代理的方式由代理类MapperProxy委托到SqlSession对应的接口执行的，MapperProxy#invoke才是Mapper方法的真正入口，而本文所要分析的参数设置过程也是从这里开始的（确切来讲是MapperProxy#invoke方法所调用的MapperMethod#execute方法）。
image.png
Mybatis的参数设置流程，与我们常规意义上调用方法的参数设置有些不同。因为我们调用Mapper接口的方法，其参数虽然在接口中有定义，但是实际是作用在SQL语句上，而SQL语句是通过占位符（${}与#{}）来预占参数的。
这里其实就可能存在一定的差异，Mapper接口方法所定义的参数名称、个数、类型、顺序等一定与SQL语句的要求匹配吗？如果匹配，那Mybatis是如何把我们给定的参数，按照预期为SQL语句设置参数的呢？带着这几个问题，我们开始Mybatis参数设置流程的分析！
参数解析
由于Mapper接口方法执行时调用的是MapperMethod，其执行依赖MappedStatement中SqlSource对参数的要求。因此，在方法执行之前，Mybatis需要先把Mapper接口参数名称解析为通用的、可被理解的方式；同时，引入一些特性支持开发人员的参数定制。
结合示例代码，我们使用的是select语句，也就是会执行SELECT命令，MapperMethod#execute仅贴出与SELECT有关的代码进行说明。
1 public Object execute(SqlSession sqlSession, Object[] args) {
2 Object result;
3 switch (command.getType()) {
4 //省略INSERT、UPDATE、DELTE、FLUSH……
5 //仅查看SELECT命令
6 case SELECT:
7 //无返回值或者具有ResultHandler
8 if (method.returnsVoid() && method.hasResultHandler()) {
9 executeWithResultHandler(sqlSession, args);
10 result = null;
11 }
12 //返回列表
13 else if (method.returnsMany()) {
14 result = executeForMany(sqlSession, args);
15 }
16 //返回Map
17 else if (method.returnsMap()) {
18 result = executeForMap(sqlSession, args);
19 }
20 //返回Cursor
21 else if (method.returnsCursor()) {
22 result = executeForCursor(sqlSession, args);
23 }
24 //返回单个结果
25 else {
26 //参数转换：把参数转为sql命令参数
27 Object param = method.convertArgsToSqlCommandParam(args);
28 //调用SqlSession#selectOne方法
29 result = sqlSession.selectOne(command.getName(), param);
30 if (method.returnsOptional() &&
31 (result == null || !method.getReturnType().equals(result.getClass()))) {
32 result = Optional.ofNullable(result);
33 }
34 }
35 break;
36 }
37 if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
38 throw new BindingException("Mapper method '" + command.getName()
39 + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
40 }
41 return result;
42 }
在SELECT命令最后一个else的代码块（第27行），调用了MethodSignature#convertArgsToSqlCommandParam方法，作用是把我们通过Mapper接口传入的参数转为SQL命令参数。先通过断点看下方法执行后的效果：
示例中我们给接口selectById传入的参数为id=1（但是参数名id其实是不存在的），经过这个方法的处理，我们得到了一个名为param的ParamMap对象，其中包含两个键值对：id=1,param1=1；接着就把param交给了SqlSession#selectOne方法去执行。先不要着急想为什么这么转换，我们先来了解下转换的过程（我已经贴心的为绘制了这一过程的时序图）。
跟着代码走，我们会一步步走到ParamNameResolver#getNamedParams，在此之前已经在MapperMethod构造方法中完成了ParamNameResolver的实例化，所以我们先看下ParamNameResolver的构造方法，然后再了解getNamedParams的实现过程。（同一个类，代码放在一起了，省略部分无关方法）。
1public class ParamNameResolver {
2 //通用参数名称前缀
3 private static final String GENERIC_NAME_PREFIX = "param";
4
5 /**
6 * <p>
7 * The key is the index and the value is the name of the parameter.
8
9 * The name is obtained from {@link Param} if specified. When {@link Param} is not specified,
10 * the parameter index is used. Note that this index could be different from the actual index
11 * when the method has special parameters (i.e. {@link RowBounds} or {@link ResultHandler}).
12 * </p>
13 * <ul>
14 * <li>aMethod(@Param("M") int a, @Param("N") int b) -> {{0, "M"}, {1, "N"}}</li>
15 * <li>aMethod(int a, int b) -> {{0, "0"}, {1, "1"}}</li>
16 * <li>aMethod(int a, RowBounds rb, int b) -> {{0, "0"}, {2, "1"}}</li>
17 * </ul>
18 */
19 private final SortedMap<Integer, String> names;
20
21 private boolean hasParamAnnotation;
22
23 public ParamNameResolver(Configuration config, Method method) {
24 // 获取方法的参数类型，示例中即Integer
25 final Class<?>[] paramTypes = method.getParameterTypes();
26 // 获取方法参数的@Param注解列表
27 final Annotation[][] paramAnnotations = method.getParameterAnnotations();
28 final SortedMap<Integer, String> map = new TreeMap<>();
29 int paramCount = paramAnnotations.length;
30 // get names from @Param annotations
31 // 从@Param中获取参数名称
32 for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
33 // 是否为特殊参数，特殊参数是指RowBounds、ResultHandler
34 if (isSpecialParameter(paramTypes[paramIndex])) {
35 // skip special parameters
36 continue;
37 }
38 String name = null;
39 // 按照参数顺序获取注解
40 for (Annotation annotation : paramAnnotations[paramIndex]) {
41 //判断是否为@Param注解
42 if (annotation instanceof Param) {
43 // 标记具有@Param注解
44 hasParamAnnotation = true;
45 // 获取@Param注解中的参数名称，示例中“cmpId”
46 name = ((Param) annotation).value();
47 // 获取到注解中的参数即停止
48 break;
49 }
50 }
51 // 到这里，说明从注解中未获取到参数名称
52 if (name == null) {
53 // @Param was not specified.
54 // 未定指定@Param，允许使用实际参数名称，我们示例中的id
55 if (config.isUseActualParamName()) {
56 // 获取方法中实际参数名称
57 name = getActualParamName(method, paramIndex);
58 }
59 // 走到这，就采用参数的索引顺序作为名称，如“0”、“1”。。。
60 if (name == null) {
61 // use the parameter index as the name ("0", "1", ...)
62 // gcode issue #71
63 name = String.valueOf(map.size());
64 }
65 }
66 // 以参数索引顺序为key、上述过程获取到的名称为value，存储到map
67 // 示例中：0->id
68 map.put(paramIndex, name);
69 }
70 names = Collections.unmodifiableSortedMap(map);
71 }
72
73 //……
74
75 /**
76 * <p>
77 * A single non-special parameter is returned without a name.
78 * Multiple parameters are named using the naming rule.
79 * In addition to the default names, this method also adds the generic names (param1, param2,
80 * ...).
81 * </p>
82 */
83 public Object getNamedParams(Object[] args) {
84 final int paramCount = names.size();
85 // args为null，或者paramCount=0，返回null
86 if (args == null || paramCount == 0) {
87 return null;
88 }
89 // 无@Param注解并且只有一个参数，直接返回args的第一个元素
90 else if (!hasParamAnnotation && paramCount == 1) {
91 return args[names.firstKey()];
92 }
93 // 使用@Param注解或有多个参数
94 else {
95 final Map<String, Object> param = new ParamMap<>();
96 int i = 0;
97 // 遍历names
98 for (Map.Entry<Integer, String> entry : names.entrySet()) {
99 // 以names的value为key，以args值为value，添加到param
100 param.put(entry.getValue(), args[entry.getKey()]);
101 // add generic param names (param1, param2, ...)
102 // 添加通用参数，如param1、param2.。。
103 final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
104 // ensure not to overwrite parameter named with @Param
105 // 防止重复，覆盖已有参数
106 if (!names.containsValue(genericParamName)) {
107 param.put(genericParamName, args[entry.getKey()]);
108 }
109 i++;
110 }
111 return param;
112 }
113 }
114}
ParamNameResolver构造方法完成了参数名称的获取，其中会跳过特殊类型参数，如RowBounds、ResultHandler，最终以k-v方式存储至SortedMap。参数名称获取过程遵循的优先级规则是：
-
首先，获取@Param注解中设置的参数名称，如示例中的id；
-
其次，使用接口方法定义中的参数名称，如示例中的cmpId；
-
最后，使用参数索引编号作为名称，如“0”、“1”……
getNamedParams方法是为了构造参数名称与参数值的映射关系，首先把构造方法中获取到的参数名称与参数值存储到map中，然后为增加通用参数名称与参数值的关系。这样，在接口方法签名中或@Param注解中的参数名称不与通用参数发生冲突的情况下，每个参数值都会对应两个key，即上面调试截图的形式。
虽然占用的篇幅较多，但是参数解析的过程还是比较简单的，Mybatis结合全局配置，通过反射技术、@Param注解等方式，把接口入参转为一个Map结构，下一步调用SqlSession相关接口完成执行。
动态SQL转为静态SQL【可选】
这里的动态SQL是指DynamicSqlSource，静态SQL是指StaticSqlSource。我对这两者的理解是：
-
DynamicSqlSource：SQL语句存在动态元素，需要在运行时通过参数值才能将其转换为结构确定的、可以直接赋值的SQL语句，也就是静态化的SQL；
-
StaticSqlSource：包含形如`select * from tb_test where id=?`这样的SQL以及参数映射列表，只需要把其中的`?`替换为指定参数即可执行。
通过《Mybatis源码之MappedStatement》这篇文章，我们可以知道，如果在SQL语句中使用了动态元素（如：if标签、${}占位符等）MappedStatement#SqlSource类型为DynamicSqlSource，否则为RawSqlSource。其中，RawSqlSource内部其实封装了一个StaticSqlSource，已经完成了静态化处理及SQL语句中参数的提取操作。示例中，我们的SQL语句使用where、if这类标签，显然是动态SQL。所以，我们接下来按照动态SQL的流程来分析。
主体流程
“参数解析”一节，代码调用到了SqlSession#selectOne方法，随着代码执行，我们可以走到一个关键的方法MappedStatement#getBoundSql，它用来获取一个BoundSql对象。先看一下这段代码的执行逻辑：
1 public BoundSql getBoundSql(Object parameterObject) {
2 // 通过SqlSource获取BoundSql对象
3 BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
4 // 获取BoundSql中的参数映射列表
5 List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
6 //如果parameterMappings为空，则使用xml中的参数映射配置。
7 if (parameterMappings == null || parameterMappings.isEmpty()) {
8 boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
9 }
10
11 // 一般用不到，省略了
12 return boundSql;
13 }
getBoundSql就是为了获取BoundSql对象，首先通过SqlSource获取，如果未获取到parameterMappings，则考虑使用Configuration（即xml配置文件）中的ParameterMap作为参数映射。我们主要分析通过SqlSource获取的过程：示例中是动态SQL，所以这里的sqlSource是DynamicSqlSource的实例。
1public class DynamicSqlSource implements SqlSource {
2
3 private final Configuration configuration;
4 private final SqlNode rootSqlNode;
5
6 public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) {
7 this.configuration = configuration;
8 this.rootSqlNode = rootSqlNode;
9 }
10//org.apache.ibatis.scripting.xmltags.DynamicSqlSource#getBoundSql
11 public BoundSql getBoundSql(Object parameterObject) {
12 // 创建动态上下文对象，它里面主要是我们的从第一节获取到的参数解析结果
13 DynamicContext context = new DynamicContext(configuration, parameterObject);
14 // 动态SQL内部的SqlNode是MixedSqlNode实例，由多种不同的SqlNode组成，apply会依次调用SqlNode的apply方法
15 rootSqlNode.apply(context);
16 SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
17 Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
18 // 动态sql的转换过程就在这里。
19 SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
20 // 创建BoundSql对象
21 BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
22 for (Map.Entry<String, Object> entry : context.getBindings().entrySet()) {
23 boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
24 }
25 return boundSql;
26 }
27}
-
DynamicContext对象存储了这个阶段所需要的参数信息、提供了解析后sql语句拼接的工具方法及并存储处理后的sql语句，它贯穿SqlSource解析的整个过程。
-
rootSqlNode是MixedSqlNode的实例，它内存通过contents字段存储了SQL语句所包含的SqlNode列表，通过apply方法依次调用各个SqlNode#apply方法，完成SqlNode中表达式的计算及结果输出。例如：通过计算
表达式的结果，决定 标签内的SQL是否满足执行条件。由于SqlNode的类型有多种，处理方式也不尽相同，具体类型需要具体分析。 SqlSourceBuilder顾名思义，就是用来做SqlSource构建的工具类，具体来说是StaticSqlSource的构建类。正是通过它完成了从动态到静态的处理过程，期间会提取出SQL语句中通过
#{}占位符预设的参数映射信息。
DynamicSqlSource#getBoundSql方法的执行过程就比较清晰了，整体分为两个步骤：根据输入参数把MixedSqlNode中各个子SqlNode静态化，然后解析SQL语句中的#{}占位符所定义的参数映射信息并以?替换，创建StaticSqlSource对象和BoundSql。先通过下图概括这个阶段的执行过程，其中黄色注释部分是需要具体展开的。
MixedSqlNode#apply
MixedSqlNode代码如下所示，contents存储SQL所包含的所有SqlNode，apply方法执行时，会依次把MixedSqlNode#contents中的SqlNode遍历并调用apply方法。
1// MixedSqlNode
2public class MixedSqlNode implements SqlNode {
3 private final List<SqlNode> contents;
4
5 public MixedSqlNode(List<SqlNode> contents) {
6 this.contents = contents;
7 }
8
9 @Override
10 public boolean apply(DynamicContext context) {
11 for (SqlNode sqlNode : contents) {
12 sqlNode.apply(context);
13 }
14 return true;
15 }
16}
示例中的contents如下图所示，有两个StaticTextSqlNode、一个IfSqlNode（它内部存储的也是一个MixedSqlNode，包含一个TextSqlNode）。
MixedSqlNode#apply方法的分析过程就比较容易理解，只需要依次看下StaticTextSqlNode、IfSqlNode、TextSqlNode对apply方法的实现过程即可。
-
StaticTextSqlNode：静态文本，没有动态元素和参数处理，仅仅是拼接sql语句；
1 //org.apache.ibatis.scripting.xmltags.StaticTextSqlNode#apply
2 public boolean apply(DynamicContext context) {
3 context.appendSql(text);
4 return true;
5 }
6
7 // org.apache.ibatis.scripting.xmltags.DynamicContext#appendSql
8 public void appendSql(String sql) {
9 sqlBuilder.append(sql);
10 sqlBuilder.append(" ");
11 }
-
IfSqlNode：涉及ONGL表达式的判断，当表达式成立时，再调用IfSqlNode中的SqlNode#apply方法。
1 //org.apache.ibatis.scripting.xmltags.IfSqlNode#apply
2 public boolean apply(DynamicContext context) {
3 //表达式成立继续执行。
4 if (evaluator.evaluateBoolean(test, context.getBindings())) {
5 contents.apply(context);
6 return true;
7 }
8 return false;
9 }
-
此时，SqlNode的类型是MixedSqlNode，跟上面的逻辑类似，所以会执行到TextSqlNode。
TextSqlNode#apply虽然代码只有两行，这个过程比较复杂一些，涉及到了占位符${}的解析过程，我们重点看下。代码如下：
1 // org.apache.ibatis.scripting.xmltags.TextSqlNode#apply
2 public boolean apply(DynamicContext context) {
3 // 创建${}占位符的解析器，其中GenericTokenParser是通用的，BindingTokenParser是对占位符的替换方式实现
4 GenericTokenParser parser = createParser(new BindingTokenParser(context, injectionFilter));
5 //解析${}，完成替换，把解析结果拼接到sql语句中
6 context.appendSql(parser.parse(text));
7 return true;
8 }
9
10 private GenericTokenParser createParser(TokenHandler handler) {
11 //创建GenericTokenParser，处理的目标是`${`和`}`开闭包含的内容
12 return new GenericTokenParser("${", "}", handler);
13 }
GenericTokenParser是一个通用的SQL语句占位符的解析类，会从头到尾依次匹配openToken（如：${、#{）和closeToken（如：}）中间包含的表达式。若匹配到表达式，就会通过TokenHandler接口对象，对匹配表达式进行处理。通过上述代码可以，当处理${}时使用的是BindingTokenParser。
示例中，GenericTokenParser#parse方法的入参text是（如上图TextSqlNode的内容）：
1id = ${id} or id = #{id}
GenericTokenParser的parse方法比较长，但是很简单，我们重点来看下当匹配到表达式的处理流程，即BindingTokenParser#handleToken方法：
1 private static class BindingTokenParser implements TokenHandler {
2 // 上下文对象，内容包含了参数及sql语句解析结果
3 private DynamicContext context;
4 private Pattern injectionFilter;
5
6 public BindingTokenParser(DynamicContext context, Pattern injectionFilter) {
7 this.context = context;
8 this.injectionFilter = injectionFilter;
9 }
10
11 @Override
12 // 入参content是GenericTokenParser匹配到的表达式，示例中为“id”
13 public String handleToken(String content) {
14 // 获取输入的参数对象。示例为ParamMap，包含："id"->1,"param1"->1
15 Object parameter = context.getBindings().get("_parameter");
16 if (parameter == null) {
17 context.getBindings().put("value", null);
18 } else if (SimpleTypeRegistry.isSimpleType(parameter.getClass())) {
19 context.getBindings().put("value", parameter);
20 }
21 //通过ongl获取表达式对应的值，这里获取的value=1。
22 Object value = OgnlCache.getValue(content, context.getBindings());
23 String srtValue = value == null ? "" : String.valueOf(value); // issue #274 return "" instead of "null"
24 //sql入侵检测
25 checkInjection(srtValue);
26 return srtValue;
27 }
28
29 private void checkInjection(String value) {
30 if (injectionFilter != null && !injectionFilter.matcher(value).matches()) {
31 throw new ScriptingException("Invalid input. Please conform to regex" + injectionFilter.pattern());
32 }
33 }
34 }
代码走下来，我们知道BindingTokenParser#handleToken方法是完成了对GenericTokenParser#parse匹配到表达式的替换，即：由id替换为参数对应的值1。所以，原来SQL语句前后变化如下：
1# GenericTokenParser#parse入参
2id = ${id} or id = #{id}
3
4# GenericTokenParser#parse输出结果
5id = 1 or id = #{id}
以上处理结果会保存在DynamicContext中，MixedSqlNode#apply也就执行完成了。MixedSqlNode#contents中的SqlNode列表也被处理为了一条比较简洁的SQL语句，如下：
1select id,name,cpy_type from company WHERE id = 1 or id = #{id}
SqlSourceBuilder#parse
刚刚有说到，SqlSourceBuilder#parse的作用是匹配SQL语句中的#{}占位符，并将匹配到的表达式解析为参数映射列表。我们通过代码了解下过程：
1 //org.apache.ibatis.builder.SqlSourceBuilder#parse
2 public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
3 ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
4 GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
5 String sql = parser.parse(originalSql);
6 return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
7 }
相信大家一眼就看出来了，SqlSourceBuilder#parse的处理过程与TextSqlNode#apply的过程如出一辙，区别就在于SqlSourceBuilder#parse处理的是#{}，而且使用了ParameterMappingTokenHandler这个TokenHandler实现类。所以，我们只需要了解ParameterMappingTokenHandler#handleToken处理过程即可：
1 public String handleToken(String content) {
2 parameterMappings.add(buildParameterMapping(content));
3 return "?";
4 }
handleToken通过buildParameterMapping方法创建了ParameterMapping（参数映射）并添加到parameterMappings参数映射列表中；同时返回了?用于替换原来GenericTokenParser匹配到的表达式。也就是我们常说的，#{}内的参数会被?替换。
buildParameterMapping方法比较长，也比较复杂，我现在也没有完全理解，其中的case也没有遇到过，等以后理解了再来补充。虽然未完全理解，但不影响我们对整个过程的把握。在我们的例子中，它会使用构造器ParameterMapping.Builder把表达式转为ParameterMapping，其中会寻找参数映射所需的TypeHandler，用于后续的参数处理。
动态SQL转为静态SQL这个过程就分析完了，其实主要就是两件事：一是ONGL通过输入参数把SqlNode中的SQL片段转为静态的SQL，二是解析处理SQL语句中的参数占位符${}和#{}，Mybatis对二者的处理有很大的不同。对于${}直接将表达式替换为对应的参数值，对于#{}提取参数信息转为ParameterMapping，并将原来的表示是替换为?。
预编译参数赋值
终于来到最后一个环节！获得BoundSql之后，回到Mybatis对SQL的执行流程，就会从CachingExecutor一直走到PreparedStatementHandler#parameterize方法，它会使用DefaultParameterHandler对预编译SQL执行参数赋值，它是ParameterHandler的默认实现。当方法运行到这里后，DefaultParameterHandler的关键字段情况如下图所示：
结合上图中boundSql等字段的信息，我们看下setParameters方法的执行流程：
1 public void setParameters(PreparedStatement ps) {
2 ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
3 // 通过BoundSql获取参数映射列表
4 List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
5 // 仅参数映射列表非空时处理
6 if (parameterMappings != null) {
7 // 遍历参数映射列表
8 for (int i = 0; i < parameterMappings.size(); i++) {
9 // 获取当前参数映射
10 ParameterMapping parameterMapping = parameterMappings.get(i);
11 // 仅参数类型不是OUT时处理，示例为IN
12 if (parameterMapping.getMode() != ParameterMode.OUT) {
13 Object value;
14 // 获取参数名称
15 String propertyName = parameterMapping.getProperty();
16 // 额外参数是否包含当前属性，当前是_parameter和_databaseId
17 if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
18 value = boundSql.getAdditionalParameter(propertyName);
19 } else if (parameterObject == null) {
20 value = null;
21 }
22 // 类型处理器是否包含参数类型，当前参数类型为ParamMap
23 else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
24 value = parameterObject;
25 } else {
26 // 创建MetaObject对象
27 MetaObject metaObject = configuration.newMetaObject(parameterObject);
28 // 获取属性对应的值
29 value = metaObject.getValue(propertyName);
30 }
31 // 获取参数映射的类型处理器。这里是UnknownTypeHandler
32 TypeHandler typeHandler = parameterMapping.getTypeHandler();
33 // 获取jdbcType
34 JdbcType jdbcType = parameterMapping.getJdbcType();
35 if (value == null && jdbcType == null) {
36 jdbcType = configuration.getJdbcTypeForNull();
37 }
38 try {
39 //通过类型处理器为ps参数赋值
40 typeHandler.setParameter(ps, i + 1, value, jdbcType);
41 } catch (TypeException e) {
42 throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
43 } catch (SQLException e) {
44 throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
45 }
46 }
47 }
48 }
49 }
setParameters方法的执行过程比较清晰：依次遍历参数映射列表，从parameterObject中获取参数对应的值，然后通过类型处理器为PreparedStatement指定索引位置的参数赋值，最终完成所有参数的赋值操作。
这里需要注意的是，在通过TypeHandler为PreparedStatement赋值时，Mybatis会通过类型处理器注册中心查找与当前参数匹配的TypeHandler。因为我们的ParameterMapping是通过对SQL语句中预编译占位符#{}的解析而得到的，这里并没有明确参数的确切类型，Mybatis为ParameterMapping默认了UnknownTypeHandler作为处理器，即把参数类型默认为Object。所以，在我们的示例中会首先通过UnknownTypeHandler，然后通过resolveTypeHandler找到正确的类型处理器IntegerTypeHandler为PreparedStatement完成赋值操作。
总结
Mybatis参数设置过程到这里就完成了，非常感谢你能耐心的读到这里！简单做个总结吧：Mybatis的参数设置过程其实不仅仅是参数设置那么简单，它涉及了Mybatis对入参的转换处理，MappedStatement对参数的要求，而且对不同的占位符采取了不同的处理方式，以满足我们多种情景的要求；最终通过DefaultParameterHandler完成了对预编译声明PreparedStatement的参数赋值。
我们的示例是比较简单的，仅仅包含了一个参数，而且未涉及
本文到这里就结束了，希望对您有用，如果觉得有用就点个赞吧，^_^！本人水平有限，如您发现有任何错误或不当之处，欢迎批评指正。也可以关注我的微信公众号：“兮一昂吧”。
原文始发于微信公众号（码路印记）：Mybatis源码之参数设置揭秘
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/23815.html
