mybatis源码(六)mybatis动态sql的解析过程上篇
mybaits支持动态sql的使用。常见的动态sql标签：<where></where>标签、<if></if>、<choose|when|otherwise>、<foreach>、<trim>、<set>
1.组件介绍
1.1 SqlSource ：用于描述MyBatis中的SQL资源信息。是个接口，只有一个方法
public interface SqlSource {
BoundSql getBoundSql(Object parameterObject);
}
由以下几个实现类 这4种SqlSource实现类的作用如下。
● ProviderSqlSource: 用于描述通过@Select、@SelectProvider等注解配置的SQL资源信息。
● DynamicSqlSource: 用于描述Mapper XML文件中配置的SQL资源信息，这些SQL通常包含动态SQL配置或者${}参数占位符，需要在Mapper调用时才能确定具体的SQL语句。
● RawSqlSource: 用于描述Mapper XML文件中配置的SQL资源信息，与DynamicSqlSource不同的是，这些SQL语句在解析XML配置的时候就能确定，即不包含动态SQL相关配置。
● StaticSqlSource: 用于描述ProviderSqlSource、DynamicSqlSource及RawSq|Source解析后得到的静态SQL资源。
配置sql信息的两种方式：1.注解的方式：@SELECT @INSERT @Delete等 2.通过xml配置文件的方式
1.2 BoundSql : BoundSql是对动态SQL解析生成的SQL语句和参数映射信息的封装.是个class类
源码如下：
public class BoundSql {
// Mapper配置解析后的sql语句
private final String sql;
// Mapper参数映射信息
private final List<ParameterMapping> parameterMappings;
// Mapper参数对象
private final Object parameterObject;
// 额外参数信息，包括<bind>标签绑定的参数，内置参数
private final Map<String, Object> additionalParameters;
// 参数对象对应的MetaObject对象
private final MetaObject metaParameters;
public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) {
this.sql = sql;
this.parameterMappings = parameterMappings;
this.parameterObject = parameterObject;
this.additionalParameters = new HashMap<String, Object>();
this.metaParameters = configuration.newMetaObject(additionalParameters);
}
public String getSql() {
return sql;
}
public List<ParameterMapping> getParameterMappings() {
return parameterMappings;
}
public Object getParameterObject() {
return parameterObject;
}
public boolean hasAdditionalParameter(String name) {
String paramName = new PropertyTokenizer(name).getName();
return additionalParameters.containsKey(paramName);
}
public void setAdditionalParameter(String name, Object value) {
metaParameters.setValue(name, value);
}
public Object getAdditionalParameter(String name) {
return metaParameters.getValue(name);
}
}
1.3 LanguageDriver ： 用于解析SQL配置，将SQL 配置信息转换为SqlSource对象
LanguageDriver 接口中一共有3个方法，其中createParameterHandler()方法用于创建ParameterHandler对象，另外还有两个重载的createSqlSource()方法，这两个重载的方法用于创建Sq|Source对象。有两个实现类：
XMLanguageDriver ： 为XML语言驱动，为MyBatis提供了通过XML标签(我们常用的<if>、<where>等标签)结合OGNL表达式语法实现动态SQL的功能。
a.java注解也可使用动态sql，但是sql语句中要加入<script></script>标签括起来
b.java注解方式演示动态sql代码
@Data public class UserEntity { private Long id; private String name; private Date createTime; private String password; private String phone; private String nickName; } public interface UserMapper { List<UserEntity> getUserByEntity(UserEntity user); List<UserEntity> getUserInfo(UserEntity user); List<UserEntity> getUserByPhones(@Param("phones") List<String> phones); @Select("<script>" + "select * from user " + "<where> " + " <if test="name != null"> " + " AND name = #{name} " + " </if> " + " <if test="phone != null"> " + " AND phone = #{phone} " + " </if> " + "</where>" + "</script>") UserEntity getUserByPhoneAndName(@Param("phone") String phone, @Param("name") String name); List<UserEntity> getUserByNames(@Param("names") List<String> names); UserEntity getUserByName(@Param("userName") String userName); }
RawLanguageDriver ： 表示仅支持静态SQL配置，不支持动态SQL功能
c.MyBatis从3.2版本开始支持可插拔脚本语言，这允许我们插入一种脚本语言驱动，并基于这种语言来编写动态SQL语句。例如，我们可以让MyBatis的Mapper配置支持Velocity (或者Freemaker)语法，并基于Velocity (或者Freemaker) 语法编写动态SQL。要实现自定义的脚本语言驱动，只需要实现LanguageDriver接口，创建自定义的SqlSource对象，然后对SqlSource对象进行解析，生成最终的BoundSq|对象即可。首先需要在项目中添加该模块的依赖.
<dependency>
<groupId>org.mybatis.scripting</groupId>
<artifactId>mybatis-velocity</artifactId>
<version>2.0-SNAPSHOT</version>
</dependency>
1.4SqlNode : 用于描述动态SQL中<if>、<where>等标签信息，LanguageDriver解析SQL配置时，会把<if>、<where> 等动态SQL标签转换为SqINode对象，封装在Sq|Source中。
SqlNode是一个接口，只有一个方法，源码如下：
public interface SqlNode {
boolean apply(DynamicContext context);
}
提供了10种动态sql的实现类：
● IfSqINode: 用于描述动态SQL中<if>标签的内容，XMLanguageDriver在解析Mapper SQL配置生成SqlSource时，会对动态SQL中的<if>标签进行解析，将<if>标签转换为lfSqlNode对象。
● ForEachSqlNode: 用于描述动态SQL配置中的<foreach>标签,<foreach>标签配置信息在Mapper解析时会转换为ForEachSqlNode对象。
● ChooseSqlINode: 用于描述动态SQL配置中的<choose>标签内容，Mapper解析时会把<choose>标签配置内容转换为ChooseSqINode对象。
● MixedSqlNode: 用于描述一组SqINode对象， 通常一个Mapper配置是由多个SqlNode对象组成的，这些SqlNode对象通过MixedSqlNode进行关联，组成一个完整的动态SQL配置。
● SetSqlNode: 用于描述动态SQL配置中的<set>标签，Mapper解析时会把<set>标签配置信息转换为SetSqINode对象。
● TrimSq|Node: 用于描述动态SQL中的<trim>标签，动态SQL解析时，会把<trim>标签内容转 换为TrimSqlNode对象。在MyBatis动态SQL使用时,<where>标签和
<set>标签实现的内容都可以使用<trim>标签来完成，因此WhereSqlNode和SetSqlNode类设计为TrimSqlNode类的子类，属于特殊的TrimSqlNode。
● StaticTextSqlNode: 用于描述动态SQL中的静态文本内容。
● TextSqlNode: 该类与StaticTextSqlNode类不同的是，当静态文本中包含${}占位符时，说明${}需要在Mapper调用时将${}替换为具体的参数值。因此，使用TextSqlNode类来描述。
● VarDecISqlNode: 用于描述动态SQL中的<bind>标签，动态SQL解析时，会把<bind>标签配置信息转换为VarDeclSqlNode对象。
● WhereSq|INode: 用于描述动态SQL中的<where>标签,动态SQL解析时，会把<where>标签内容转换为WhereSqINode对象。
用测试代码描述sqlNode的使用过程
@Data public class UserEntity { private Long id; private String name; private Date createTime; private String password; private String phone; private String nickName; } <sql id="userAllField"> id,create_time, name, password, phone, nick_name </sql> <select id="getUserInfo" resultType="com.blog4java.mybatis.example.entity.User"> select <include refid="userAllField"/> from user where 1 = 1 <choose> <when test="id != null"> AND id = #{id} </when> <when test="name != null"> AND name = #{name} </when> <otherwise> AND phone is not null </otherwise> </choose> </select> @Test public void testSqlNode() { // 构建SqlNode SqlNode sn1 = new StaticTextSqlNode("select * from user where 1=1"); SqlNode sn2 = new IfSqlNode(new StaticTextSqlNode(" AND id = #{id}"),"id != null"); SqlNode sn3 = new IfSqlNode(new StaticTextSqlNode(" AND name = #{name}"),"name != null"); SqlNode sn4 = new IfSqlNode(new StaticTextSqlNode(" AND phone = #{phone}"),"phone != null"); SqlNode mixedSqlNode = new MixedSqlNode(Arrays.asList(sn1, sn2, sn3, sn4)); // 创建参数对象 Map<String, Object> paramMap = new HashMap<>(); paramMap.put("id","1"); // 创建动态SQL解析上下文 DynamicContext context = new DynamicContext(sqlSession.getConfiguration(),paramMap); // 调用SqlNode的apply()方法解析动态SQL mixedSqlNode.apply(context); // 调用DynamicContext对象的getSql（）方法获取动态SQL解析后的SQL语句 System.out.println(context.getSql()); }
1.5 NodeHandler：这是一个接口，提供了8种实现类。每种处理器用于处理对应的sql的动态标签。例如IfHandler用于处理动态sql配置中的<if>标签。负责将<if>标签内容转换为ifSqlNode对象
八种实现类分别是：BindHandler、TrimHandler、WhereHandler、SetHandler、ForEachHandler、IfHandler、OtherwiseHandler、ChooseHandler
public class XMLScriptBuilder extends BaseBuilder { private final XNode context; private boolean isDynamic; private final Class<?> parameterType; private final Map<String, NodeHandler> nodeHandlerMap = new HashMap<String, NodeHandler>(); public XMLScriptBuilder(Configuration configuration, XNode context) { this(configuration, context, null); } public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> parameterType) { super(configuration); this.context = context; this.parameterType = parameterType; initNodeHandlerMap(); } private void initNodeHandlerMap() { nodeHandlerMap.put("trim", new TrimHandler()); nodeHandlerMap.put("where", new WhereHandler()); nodeHandlerMap.put("set", new SetHandler()); nodeHandlerMap.put("foreach", new ForEachHandler()); nodeHandlerMap.put("if", new IfHandler()); nodeHandlerMap.put("choose", new ChooseHandler()); nodeHandlerMap.put("when", new IfHandler()); nodeHandlerMap.put("otherwise", new OtherwiseHandler()); nodeHandlerMap.put("bind", new BindHandler()); } public SqlSource parseScriptNode() { // 调用parseDynamicTags（）方法將SQL配置转换为SqlNode对象 MixedSqlNode rootSqlNode = parseDynamicTags(context); SqlSource sqlSource = null; // 判断Mapper SQL配置中是否包含动态SQL元素，如果是创建DynamicSqlSource对象，否则创建RawSqlSource对象 if (isDynamic) { sqlSource = new DynamicSqlSource(configuration, rootSqlNode); } else { sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType); } return sqlSource; } protected MixedSqlNode parseDynamicTags(XNode node) { List<SqlNode> contents = new ArrayList<SqlNode>(); NodeList children = node.getNode().getChildNodes(); // 对XML子元素进行遍历 for (int i = 0; i < children.getLength(); i++) { XNode child = node.newXNode(children.item(i)); // 如果子元素为SQL文本内容，则使用TextSqlNode描述该节点 if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) { String data = child.getStringBody(""); TextSqlNode textSqlNode = new TextSqlNode(data); // 判断SQL文本中包含${}参数占位符，则为动态SQL if (textSqlNode.isDynamic()) { contents.add(textSqlNode); isDynamic = true; } else { // 如果SQL文本中不包含${}参数占位符，则不是动态SQL contents.add(new StaticTextSqlNode(data)); } } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // 如果子元素为<if>、<where>等标签，则使用对应的NodeHandler处理 String nodeName = child.getNode().getNodeName(); NodeHandler handler = nodeHandlerMap.get(nodeName); if (handler == null) { throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement."); } handler.handleNode(child, contents); isDynamic = true; } } return new MixedSqlNode(contents); } private interface NodeHandler { void handleNode(XNode nodeToHandle, List<SqlNode> targetContents); } private class BindHandler implements NodeHandler { public BindHandler() { // Prevent Synthetic Access } @Override public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { final String name = nodeToHandle.getStringAttribute("name"); final String expression = nodeToHandle.getStringAttribute("value"); final VarDeclSqlNode node = new VarDeclSqlNode(name, expression); targetContents.add(node); } } private class TrimHandler implements NodeHandler { public TrimHandler() { // Prevent Synthetic Access } @Override public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle); String prefix = nodeToHandle.getStringAttribute("prefix"); String prefixOverrides = nodeToHandle.getStringAttribute("prefixOverrides"); String suffix = nodeToHandle.getStringAttribute("suffix"); String suffixOverrides = nodeToHandle.getStringAttribute("suffixOverrides"); TrimSqlNode trim = new TrimSqlNode(configuration, mixedSqlNode, prefix, prefixOverrides, suffix, suffixOverrides); targetContents.add(trim); } } private class WhereHandler implements NodeHandler { public WhereHandler() { // Prevent Synthetic Access } @Override public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle); WhereSqlNode where = new WhereSqlNode(configuration, mixedSqlNode); targetContents.add(where); } } private class SetHandler implements NodeHandler { public SetHandler() { // Prevent Synthetic Access } @Override public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle); SetSqlNode set = new SetSqlNode(configuration, mixedSqlNode); targetContents.add(set); } } private class ForEachHandler implements NodeHandler { public ForEachHandler() { // Prevent Synthetic Access } @Override public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { // 首先调用parseDynamicTags（）方法解析<foreach>标签子元素 MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle); String collection = nodeToHandle.getStringAttribute("collection"); String item = nodeToHandle.getStringAttribute("item"); String index = nodeToHandle.getStringAttribute("index"); String open = nodeToHandle.getStringAttribute("open"); String close = nodeToHandle.getStringAttribute("close"); String separator = nodeToHandle.getStringAttribute("separator"); ForEachSqlNode forEachSqlNode = new ForEachSqlNode(configuration, mixedSqlNode, collection, index, item, open, close, separator); targetContents.add(forEachSqlNode); } } private class IfHandler implements NodeHandler { public IfHandler() { // Prevent Synthetic Access } @Override public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { // 继续调用parseDynamicTags（）方法解析<if>标签中的子节点 MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle); // 获取<if>标签test属性 String test = nodeToHandle.getStringAttribute("test"); // 创建IfSqlNode对象 IfSqlNode ifSqlNode = new IfSqlNode(mixedSqlNode, test); // 將IfSqlNode对象添加到List中 targetContents.add(ifSqlNode); } } private class OtherwiseHandler implements NodeHandler { public OtherwiseHandler() { // Prevent Synthetic Access } @Override public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle); targetContents.add(mixedSqlNode); } } private class ChooseHandler implements NodeHandler { public ChooseHandler() { // Prevent Synthetic Access } @Override public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { List<SqlNode> whenSqlNodes = new ArrayList<SqlNode>(); List<SqlNode> otherwiseSqlNodes = new ArrayList<SqlNode>(); handleWhenOtherwiseNodes(nodeToHandle, whenSqlNodes, otherwiseSqlNodes); SqlNode defaultSqlNode = getDefaultSqlNode(otherwiseSqlNodes); ChooseSqlNode chooseSqlNode = new ChooseSqlNode(whenSqlNodes, defaultSqlNode); targetContents.add(chooseSqlNode); } private void handleWhenOtherwiseNodes(XNode chooseSqlNode, List<SqlNode> ifSqlNodes, List<SqlNode> defaultSqlNodes) { List<XNode> children = chooseSqlNode.getChildren(); for (XNode child : children) { String nodeName = child.getNode().getNodeName(); NodeHandler handler = nodeHandlerMap.get(nodeName); if (handler instanceof IfHandler) { handler.handleNode(child, ifSqlNodes); } else if (handler instanceof OtherwiseHandler) { handler.handleNode(child, defaultSqlNodes); } } } private SqlNode getDefaultSqlNode(List<SqlNode> defaultSqlNodes) { SqlNode defaultSqlNode = null; if (defaultSqlNodes.size() == 1) { defaultSqlNode = defaultSqlNodes.get(0); } else if (defaultSqlNodes.size() > 1) { throw new BuilderException("Too many default (otherwise) elements in choose statement."); } return defaultSqlNode; } } }
1.6 GenericTokenParser：Token解析器，用于解析#{}参数，获取#{}参数占位符中内容
例如下面是一个可能的#{}参数占位符配置 :#{userld,javaType=long,jdbcType=NUMERIC,typeHandler=MyTypeHandler} 该参数占位符经过GenericTokenParser解析后，获取参数占位符内容，即 userld,javaType=long,jdbcType=NUMERIC,typeHandler=MyTypeHandler,该内容会经过ParameterMappingTokenHandler对象进行替换处理。
public class GenericTokenParser {
private final String openToken;
private final String closeToken;
private final TokenHandler handler;
public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
this.openToken = openToken;
this.closeToken = closeToken;
this.handler = handler;
}
public String parse(String text) {
if (text == null || text.isEmpty()) {
return "";
}
// 获取第一个openToken在SQL中的位置
int start = text.indexOf(openToken, 0);
// start为-1说明SQL中不存在任何参数占位符
if (start == -1) {
return text;
}
// 將SQL转换为char数组
char[] src = text.toCharArray();
// offset用于记录已解析的#{或者}的偏移量，避免重复解析
int offset = 0;
final StringBuilder builder = new StringBuilder();
// expression为参数占位符中的内容
StringBuilder expression = null;
// 遍历获取所有参数占位符的内容，然后调用TokenHandler的handleToken（）方法替换参数占位符
while (start > -1) {
if (start > 0 && src[start - 1] == '\') {
// this open token is escaped. remove the backslash and continue.
builder.append(src, offset, start - offset - 1).append(openToken);
offset = start + openToken.length();
} else {
// found open token. let's search close token.
if (expression == null) {
expression = new StringBuilder();
} else {
expression.setLength(0);
}
builder.append(src, offset, start - offset);
offset = start + openToken.length();
int end = text.indexOf(closeToken, offset);
while (end > -1) {
if (end > offset && src[end - 1] == '\') {
// this close token is escaped. remove the backslash and continue.
expression.append(src, offset, end - offset - 1).append(closeToken);
offset = end + closeToken.length();
end = text.indexOf(closeToken, offset);
} else {
expression.append(src, offset, end - offset);
offset = end + closeToken.length();
break;
}
}
if (end == -1) {
// close token was not found.
builder.append(src, start, src.length - start);
offset = src.length;
} else {
// 调用TokenHandler的handleToken（）方法替换参数占位符
builder.append(handler.handleToken(expression.toString()));
offset = end + closeToken.length();
}
}
start = text.indexOf(openToken, offset);
}
if (offset < src.length) {
builder.append(src, offset, src.length - offset);
}
return builder.toString();
}
}
如上面的代码所示，在GenericTokenParser的parse()方法中， 对SQL配置中的所有#{}参数占位符进行解析，获取参数占位符的内容，然后调用ParameterMappingTokenHandler的handleToken()方法对参
数占位符内容进行替换。参数占位符的替换过程 ->ParameterMappingTokenHandler的handleToken()方法
1.7 ParameterMappingTokenHandler：ParameterMappingTokenHandler为Mybatis参数映射处理器，用于处理SQL中的#{}参数占位符
public class SqlSourceBuilder extends BaseBuilder {
private static final String parameterProperties = "javaType,jdbcType,mode,numericScale,resultMap,typeHandler,jdbcTypeName";
public SqlSourceBuilder(Configuration configuration) {
super(configuration);
}
public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
// ParameterMappingTokenHandler为Mybatis参数映射处理器，用于处理SQL中的#{}参数占位符
ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
// Token解析器，用于解析#{}参数
GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
// 调用GenericTokenParser对象的parse（）方法將#{}参数占位符转换为?
String sql = parser.parse(originalSql);
return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}
private static class ParameterMappingTokenHandler extends BaseBuilder implements TokenHandler {
private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
private Class<?> parameterType;
private MetaObject metaParameters;
public ParameterMappingTokenHandler(Configuration configuration, Class<?> parameterType, Map<String, Object> additionalParameters) {
super(configuration);
this.parameterType = parameterType;
this.metaParameters = configuration.newMetaObject(additionalParameters);
}
public List<ParameterMapping> getParameterMappings() {
return parameterMappings;
}
@Override
public String handleToken(String content) {
parameterMappings.add(buildParameterMapping(content));
return "?";
}
private ParameterMapping buildParameterMapping(String content) {
// 將#{}占位符内容转换为Map对象
Map<String, String> propertiesMap = parseParameterMapping(content);
// property 对应的值为参数占位符名称，例如userId
String property = propertiesMap.get("property");
// 推断参数类型
Class<?> propertyType;
// 如果内置参数，或<bind>标签绑定的参数包含该属性，则参数类型为Getter方法返回值类型
if (metaParameters.hasGetter(property)) {
propertyType = metaParameters.getGetterType(property);
// 判读该参数类型是否注册了TypeHandler,如果注册了则使用参数类型
} else if (typeHandlerRegistry.hasTypeHandler(parameterType)) {
propertyType = parameterType;
// 如果指定了jdbcType属性，并且为CURSOR类型，则使用ResultSet类型
} else if (JdbcType.CURSOR.name().equals(propertiesMap.get("jdbcType"))) {
propertyType = java.sql.ResultSet.class;
// 如果参数类型为Map接口的子类型，则使用Object类型
} else if (property == null || Map.class.isAssignableFrom(parameterType)) {
propertyType = Object.class;
} else {
// 获取parameterType对应的MetaClass对象，方便获取参数类型的反射信息
MetaClass metaClass = MetaClass.forClass(parameterType, configuration.getReflectorFactory());
// 如果参数类型中包含该属性，则使用Getter方法返回类型
if (metaClass.hasGetter(property)) {
propertyType = metaClass.getGetterType(property);
} else {
propertyType = Object.class;
}
}
// 使用建造者模式构建ParameterMapping对象
ParameterMapping.Builder builder = new ParameterMapping.Builder(configuration, property, propertyType);
Class<?> javaType = propertyType;
String typeHandlerAlias = null;
for (Map.Entry<String, String> entry : propertiesMap.entrySet()) {
String name = entry.getKey();
String value = entry.getValue();
// 指定ParameterMapping对象的属性
if ("javaType".equals(name)) {
javaType = resolveClass(value);
builder.javaType(javaType);
} else if ("jdbcType".equals(name)) {
builder.jdbcType(resolveJdbcType(value));
} else if ("mode".equals(name)) {
builder.mode(resolveParameterMode(value));
} else if ("numericScale".equals(name)) {
builder.numericScale(Integer.valueOf(value));
} else if ("resultMap".equals(name)) {
builder.resultMapId(value);
} else if ("typeHandler".equals(name)) {
typeHandlerAlias = value;
} else if ("jdbcTypeName".equals(name)) {
builder.jdbcTypeName(value);
} else if ("property".equals(name)) {
// Do Nothing
} else if ("expression".equals(name)) {
throw new BuilderException("Expression based parameters are not supported yet");
} else {
throw new BuilderException("An invalid property '" + name + "' was found in mapping #{" + content + "}. Valid properties are " + parameterProperties);
}
}
if (typeHandlerAlias != null) {
builder.typeHandler(resolveTypeHandler(javaType, typeHandlerAlias));
}
// 返回ParameterMapping对象
return builder.build();
}
private Map<String, String> parseParameterMapping(String content) {
try {
return new ParameterExpression(content);
} catch (BuilderException ex) {
throw ex;
} catch (Exception ex) {
throw new BuilderException("Parsing error was found in mapping #{" + content + "}. Check syntax #{property|(expression), var1=value1, var2=value2, ...} ", ex);
}
}
}
}
从上面的代码可以看出，SQL配置中的所有#{}参数占位符内容都被替换成了"?" 字符，为什么要替换成一一个"?" 字符呢?
因为MyBatis默认情况下会使用PreparedStatement对象与数据库进行交互，因此#{}参数占位符内容被替换成了问号，然后调用PreparedStatement对象的setXXX()方法为参数占位符设置值。
除此之外，ParameterMappingTokenHandler的handleToken()方法中还做了另一件事情，就是调用buildParameterMapping()方法对占位符内容进行解析，将占位符内容转换为ParameterMapping对象。
ParameterMapping 对象用于描述MyBatis参数映射信息，便于后续根据参数映射信息获取对应的TypeHandler为PreparedStatement对象设置值。
buildParameterMapping()方法解析参数占位符生成ParameterMapping对象的过程也在上述代码中
如上面的代码所示，在ParameterMappingTokenHandler类的buildParameterMapping()方法中首先将参数占位符内容转换为Map对
象，例如参数占位符内容如下:#{userld,javaType=long,jdbcType=NUMERIC,typeHandler=MyTypeHandler}
将会转换成如下Map对象:
Map<String, String> map = new HashMap<>() ;
map .put ("property", "userId") ;
map .put ("javaType", "long") ;
map.put ("jdbcType", "NUMERIC") ;
map.put ("typeHandler", "MyTypeHandler") ;
然后通过一系列的逻辑判断参数的类型(javaType属性值)。最后通过建造者模式构建ParameterMapping对象。