Mybatis源码分析（四）：mapper.xml增删查改的节点解析和动态SQL的实现

概述

• 我们通常在mapper.xml中定义增删查改select|insert|update|delete的相关SQL，在对应的select|insert|update|delete节点中支持通过if，（choose, when, otherwise），（trim, where, set），foreach等内嵌节点来实现动态SQL定义，动态SQL的使用方法可以参考：动态 SQL
  
• 对于增删查改，在对应的select|insert|update|delete节点中，通过id属性来映射mapper接口的对应方法，其中mapper接口是通过父节点mapper的namespace来定义映射的。
• 由上篇文章：Mybatis源码分析（三）：mapper.xml的解析及namespace与Mapper接口的映射
  的分析可知，mapper.xml主要是通过builder包的xml子包的XMLMapperBuilder来解析，对应增删查改select|insert|update|delete节点的解析主要是在buildStatementFromContext方法中定义的。

增删查改节点解析：XMLStatementBuilder

• buildStatementFromContext方法的定义如下：其中参数list为select|insert|update|delete对应的类型为XNode的节点集合。

  private void buildStatementFromContext(List<XNode> list) {
      if (configuration.getDatabaseId() != null) {
        buildStatementFromContext(list, configuration.getDatabaseId());
      }
      buildStatementFromContext(list, null);
  }
  
  private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
      // list为mapper.xml文件中SQL操作（select|insert|update|delete）节点列表
      for (XNode context : list) {
      
        // 增删查改节点的解析器
        final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
        try {
          // 解析mapper.xml文件中的相关SQL操作标签，
          // 并存放到configuration的mappedStatements集合中
          statementParser.parseStatementNode();
        } catch (IncompleteElementException e) {
          // 如果存在解析异常，则放到incompleteStatements中
          configuration.addIncompleteStatement(statementParser);
        }
      }
  }
  

• 在内部增删查改节点的解析主要是通过builder包的xml子包的XMLStatementBuilder来完成的，具体在XMLStatementBuilder的parseStatementNode方法中定义解析逻辑：

  public void parseStatementNode() {
      // mapper接口的方法名
      String id = context.getStringAttribute("id"); 
      
      // fetchSize,parameterMap,parameterType,resultType,resultMap相关属性的解析
      ...
  
      // flushCache,useCache缓存相关的属性的解析
      ...
  
      // include节点解析，主要用于include相关的SQL片段，如需要select的列
      ...
      
      // 解析SQL，使用SqlSource存放
      SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
  
      // keyGenerator相关
      ...
      
      // 构造当前增删查改节点对应的MappedStatement对象
      builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
          fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
          resultSetTypeEnum, flushCache, useCache, resultOrdered, 
          keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  }
  

• 在parseStatementNode中，在解析好select|insert|update|delete节点相关的属性之后，最后通过builder包的MapperBuilderAssistant来创建对应的MappedStatement对象，然后保存该MappedStatement对象到Configuration的mappedStatements集合中。其中SqlSource是用来保存SQL节点的类，包括动态SQL节点。

  public MappedStatement addMappedStatement(...参数列表) {
  
      if (unresolvedCacheRef) {
        throw new IncompleteElementException("Cache-ref not yet resolved");
      }
  
      id = applyCurrentNamespace(id, false);
      boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
  
      // MappedStatement构建器，组装select|insert|update|delete节点的属性值，构造SQL对应的MappedStatement对象
      // 然后将该mappedStatement对象实例保存到Configuration的mappedStatements集合
      MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
          .resource(resource)
          .fetchSize(fetchSize)
          .timeout(timeout)
          .statementType(statementType)
          .keyGenerator(keyGenerator)
          .keyProperty(keyProperty)
          .keyColumn(keyColumn)
          .databaseId(databaseId)
          .lang(lang)
          .resultOrdered(resultOrdered)
          .resultSets(resultSets)
          .resultMaps(getStatementResultMaps(resultMap, resultType, id))
          .resultSetType(resultSetType)
          .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
          .useCache(valueOrDefault(useCache, isSelect))
          .cache(currentCache);
  
      ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
      if (statementParameterMap != null) {
        statementBuilder.parameterMap(statementParameterMap);
      }
  
      MappedStatement statement = statementBuilder.build();
  
      // 添加到configuration的mappedStatements集合中缓存起来
      configuration.addMappedStatement(statement);
      return statement;
  }
  

• Configuration的addMappedStatement方法实现：

  public void addMappedStatement(MappedStatement ms) {
      // id对应mapper接口的方法名
      mappedStatements.put(ms.getId(), ms);
  }
  

动态SQL实现

• 由以上分析可知，增删查改select|insert|update|delete对应的每个SQL节点对应一个mapping包的SqlSource类对象实例。SqlSource接口的定义如下：在应用代码调用mapper节点的方法时，在内部通过对应的MappedStatement调用其所关联的SqlSource的getBoundSql方法，获取需要执行的SQL语句。

  // 保存在mapper.xml或者使用注解定义的mybatis风格的sql语句
  public interface SqlSource {
    BoundSql getBoundSql(Object parameterObject);
  }
  

• BoundSql的定义如下：其中sql属性就是实际执行的SQL语句。

  // SQL语句对象类，对于动态参数已经替换为了SQL标准的问号?，并已经记录好了参数的顺序信息
  public class BoundSql {
  	private final String sql; // SQL语句，带问号?的SQL语句
  	private final List<ParameterMapping> parameterMappings; // SQL参数名
  	private final Object parameterObject; // 参数名和参数值映射集合
  	private final Map<String, Object> additionalParameters;
  	private final MetaObject metaParameters;
  	
  	...
  
  }
  

• 在XMLStatementBuilder的parseStatementNode方法中，通过scripting包的xmltags子包的LanguageDriver的createSqlSource方法来创建对应的SqlSource对象，对应xml的实现类为XMLLanguageDriver。XMLLanguageDriver的createSqlSource方法实现如下：通过scripting包的xmltags子包的XMLScriptBuilder的parseScriptNode方法来解析该增删查改对应的xml节点。

  public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
      XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
      return builder.parseScriptNode();
  }
  

• XMLScriptBuilder的构造函数实现如下：

  public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> parameterType) {
      super(configuration);
      this.context = context;
      this.parameterType = parameterType;
      // 初始化子节点处理器
      initNodeHandlerMap();
   }
  
  
    // 初始化各子节点的处理器，并保存在nodeHandlerMap
  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());
  }
  

• XMLScriptBuilder的parseScriptNode方法，定义解析增删改查节点，同时判断是否为动态SQL，如果是则使用
  DynamicSqlSource来封装，否则使用RawSqlSource。

  public SqlSource parseScriptNode() {
      // 解析获取一个SqlNode节点结合，通过MixedSqlNode来封装
      // 在parseDynamicTags方法中，会根据节点信息，判断是否为动态SQL，为isDynamic设值
      MixedSqlNode rootSqlNode = parseDynamicTags(context);
      SqlSource sqlSource = null;
      if (isDynamic) {
        // 动态SQL，即包含if，foreach等节点的
        sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
      } else {
        // 普通静态SQL，不包含if，foreach等节点的，但可以存在使用#{}设置的动态参数
        sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
      }
      return sqlSource;
  }
  

• 动态SQL对应的DynamicSqlSource的定义如下：由parseScriptNode方法可知，rootSqlNode的类型为MixedSqlNode，MixedSqlNode包含了if，foreach等节点的集合，如if节点对应scripting包的xmltags子包的IfSqlNode。

  // 动态SQL，即包含动态参数的SQL
  public class DynamicSqlSource implements SqlSource {
  
    private final Configuration configuration;
    private final SqlNode rootSqlNode;
  
    ...
    
  }
  
  public class MixedSqlNode implements SqlNode {
    private final List<SqlNode> contents;
  
    // 包含sql节点集合，如trim，where，if等
    public MixedSqlNode(List<SqlNode> contents) {
      this.contents = contents;
    }
    
    ...
  
  }
  
  public class IfSqlNode implements SqlNode {
    private final ExpressionEvaluator evaluator;
    private final String test;
    private final SqlNode contents;
    
    ...
  
  }
  

• 其中是否为动态SQL的判断：对于纯文本，则根据是否存在使用${}来定义的动态SQL语句参数；对于SQL内部存在xml节点，如if, foreach等，则默认属于动态SQL；对于纯文本中存在#{}定义的字符串参数，不使用动态SQL。具体在parseDynamicTags方法中定义。

  protected MixedSqlNode parseDynamicTags(XNode node) {
      List<SqlNode> contents = new ArrayList<SqlNode>();
      NodeList children = node.getNode().getChildNodes();
      for (int i = 0; i < children.getLength(); i++) {
        XNode child = node.newXNode(children.item(i));
  
        // 纯文本SQL，则判断是否存在"${"和"}"对，则说明为动态SQL
        if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
          String data = child.getStringBody("");
          TextSqlNode textSqlNode = new TextSqlNode(data);
          
          // 如果是纯文本，即select|insert|update|delete节点内部，不存在if, foreach等子节点时，
          // 存在"${"和"}"对，则说明为动态SQL
          if (textSqlNode.isDynamic()) {
            contents.add(textSqlNode);
            isDynamic = true;
          } else {
            contents.add(new StaticTextSqlNode(data));
          }
  
        // SQL内部包含xml节点，即if, foreach, choose等节点，则是动态SQL
        } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
          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);
  
          // 设置为true
          isDynamic = true;
        }
      }
      return new MixedSqlNode(contents);
  }
  

• $ 与 # 的区别为：$是将传入的数据直接显示生成sql语句，#是将传入的值当做字符串的形式。如下：

  select id,name,age from student where id =#{id}

  #：select id,name,age from student where id ='1'
  $：select id,name,age from student where id = 1