上一篇文章分析了mybatis对mybatis-config.xml文件的整体解析流程，这篇文章将分析mybatis主配置文件中<mappers/>标签的解析过程，即XMLConfigBuilder的parseConfiguration方法中调用的mapperElement方法原理

mapperElement方法

<mappers/>标签内可以通过<mapper/>标签注册单个mapper，也可以通过<package/>标签将指定package下所有interfaces都注册成为mappers。<mapper/>标签可以通过resource，url或者class属性中的任一方式指定ORM映射，详细说明见官网介绍

mapperElement方法的整体思路就是通过传入的XNode参数遍历mappers标签下的所有package或者mapper标签，逐个进行解析。

对于package标签以及使用<mapper class="xxx.aaa"/>的mapper标签，mybatis仅仅是将package name或者mapperInterface添加到configuration中，留待后续才处理；而对于通过<mapper resource="xxx/aMapper.xml"/>或者<mapper url="file:///var/xxx/aMapper.xml"/>定位mapper.xml文件的mapper标签，在将resource或者url转成输入流后构造出XMLMapperBuilder对象，通过XMLMapperBuilder对象的parse方法进行解析

// 解析mappers标签
private void mapperElement(XNode parent) throws Exception {
  if (parent != null) {
    //遍历mappers下的所有mapper
    for (XNode child : parent.getChildren()) {
        
      // 将<package>标签中name属性指定的package下所有interfaces都注册为mappers
      if ("package".equals(child.getName())) {
        String mapperPackage = child.getStringAttribute("name");
        configuration.addMappers(mapperPackage);
        
        //单个mapper标签解析
      } else {
        //只能指定三个属性中的其中一个
        String resource = child.getStringAttribute("resource");
        String url = child.getStringAttribute("url");
        String mapperClass = child.getStringAttribute("class");
        
        //通过classpath的相对路径定位mapper.xml文件
        if (resource != null && url == null && mapperClass == null) {
          ErrorContext.instance().resource(resource);
          InputStream inputStream = Resources.getResourceAsStream(resource);
          // 构造mapperParser对象去解析mapper.xml文件
          XMLMapperBuilder mapperParser =
            new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
          //开始解析mapper.xml文件，主要关注#{}和${}解析的区别
          mapperParser.parse();

          //通过url全限定路径定位mapper.xml文件
          //跟上一分支几乎无差别
        } else if (resource == null && url != null && mapperClass == null) {
          ErrorContext.instance().resource(url);
          InputStream inputStream = Resources.getUrlAsStream(url);
          XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
          mapperParser.parse();

          // 使用mapper interface classes
        } else if (resource == null && url == null && mapperClass != null) {
          Class<?> mapperInterface = Resources.classForName(mapperClass);
          configuration.addMapper(mapperInterface);
        } else {
          // 如果超过两个属性被赋值则抛异常
          throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
        }
      }
    }
  }
}

接着分析很关键的parse方法

parse方法

首先判断节点是不是被加载过了，没加载过的才进入if分支进行解析。通过configurationElement方法解析mapper文件，解析过后相应的resource标记为已加载，下一次就不会重复解析。然后调用bindMapperForNamespace方法将namespace与对应的Class进行绑定。执行完if分支后调用3个方法重新解析之前没解析成功的节点？

public void parse() {
  if (!configuration.isResourceLoaded(resource)) {
    // 解析mapper文件
    configurationElement(parser.evalNode("/mapper"));
    //解析过后添加到configuration
    configuration.addLoadedResource(resource);
    //绑定Namespace里面的Class对象
    bindMapperForNamespace();
  }
  //重新解析之前解析不了的节点
  parsePendingResultMaps();
  parsePendingCacheRefs();
  parsePendingStatements();
}

先接着看configurationElement方法

configurationElement方法

这个方法的作用就是解析mapper.xml文件里的各子标签节点，mapper.xml文件有9种子标签（其中parameterMap在官网中标注为已弃用），具体见官网

// 解析mapper文件里面的节点
// 拿到里面配置的配置项 最终封装成一个MapperedStatemanet
private void configurationElement(XNode context) {
  try {
    //mapper文件对应的interface  
    String namespace = context.getStringAttribute("namespace");
    if (namespace == null || namespace.equals("")) {
      throw new BuilderException("Mapper's namespace cannot be empty");
    }
    builderAssistant.setCurrentNamespace(namespace);

    //逐一解析mapper里的各子标签,前四个先不看,后续再分析
    cacheRefElement(context.evalNode("cache-ref"));
    cacheElement(context.evalNode("cache"));
    parameterMapElement(context.evalNodes("/mapper/parameterMap"));
    resultMapElements(context.evalNodes("/mapper/resultMap"));
    // mapper文件里的<sql/>标签解析
    sqlElement(context.evalNodes("/mapper/sql"));
    // 解析sql statement
    buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
  } catch (Exception e) {
    throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
  }
}

sqlElement方法

从sqlElement(List<XNode> list)方法会进到sqlElement(List<XNode> list, String requiredDatabaseId)方法

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper  namespace="com.xxx">
    ...
  <sql id="..." databaseId="..." lang="...">
    ...
  </sql>
</mapper>

private void sqlElement(List<XNode> list, String requiredDatabaseId) {
  for (XNode context : list) {
    //看能否取到databaseid
    String databaseId = context.getStringAttribute("databaseId");
    String id = context.getStringAttribute("id");
    id = builderAssistant.applyCurrentNamespace(id, false);
    //还不懂干啥用的
    if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) {
        // 将id和context节点放入map中
      sqlFragments.put(id, context);
    }
  }
}

发现sql标签的解析过程仅仅是将sql标签里的id和sql标签节点context实例放入一个map中，可能是为了后续解析sql语句中的include时根据id取出对应context，再换上sql标签里的内容。这个地方后续再研究。

buildStatementFromContext方法

接着看解析sql语句的buildStatementFromContext方法。这个方法会调用同名方法buildStatementFromContext(List<XNode> list, String requiredDatabaseId)，在该方法内遍历所有sql语句节点，通过XMLStatementBuilder对象进行解析，暂时解析失败的加入到一个集合中，等所有节点都遍历过后再重新解析一次

private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
  for (XNode context : list) {
    final XMLStatementBuilder statementParser = 
        new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
    try {
      //解析四种节点:select, update, insert, delete
      statementParser.parseStatementNode();
    } catch (IncompleteElementException e) {
      //此sql语句暂时无法成功解析时先保存起来，等其他sql语句解析完后再重新解析
      configuration.addIncompleteStatement(statementParser);
    }
  }
}

接着看statementParser的parseStatementNode方法，这个方法就是用来解析sql语句节点的各属性值，完成<include/>替换，静态sql解析（#{} 解析）

public void parseStatementNode() {
  String id = context.getStringAttribute("id");
  String databaseId = context.getStringAttribute("databaseId");
  if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
    return;
  }

  String nodeName = context.getNode().getNodeName();

  //command type统一转成大写格式
  SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
  boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
  //是否刷新缓存 默认值:增删改刷新 查询不刷新
  boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
  //是否使用二级缓存 默认值:查询使用 增删改不使用
  boolean useCache = context.getBooleanAttribute("useCache", isSelect);
  // ?
  boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

  // Include Fragments before parsing
  XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
  //替换Includes标签为对应的sql标签里面的值
  includeParser.applyIncludes(context.getNode());

  // 参数类型解析
  String parameterType = context.getStringAttribute("parameterType");
  //根据parameterType的alias从typeAliasRegistry中取出对应Class对象
  Class<?> parameterTypeClass = resolveClass(parameterType);

  //解析配置的自定义脚本语言驱动 mybatis plus
  String lang = context.getStringAttribute("lang");
  LanguageDriver langDriver = getLanguageDriver(lang);

  // Parse selectKey after includes and remove them.
  //解析selectKey
  processSelectKeyNodes(id, parameterTypeClass, langDriver);

  // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
  //设置主键生成器
  KeyGenerator keyGenerator;
  String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
  keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
  if (configuration.hasKeyGenerator(keyStatementId)) {
    keyGenerator = configuration.getKeyGenerator(keyStatementId);
  } else {
    keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
        configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
        ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
  }

  // 解析Sql：根据sql文本来解析，如果没有动态sql语句且只有#{}的时候，直接静态解析使用?占位；当有 ${} 不解析
  // 调用实现类XMLLanguageDriver的createSqlSource方法
  SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);

  StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
  Integer fetchSize = context.getIntAttribute("fetchSize");
  Integer timeout = context.getIntAttribute("timeout");
  String parameterMap = context.getStringAttribute("parameterMap");
  String resultType = context.getStringAttribute("resultType");
  Class<?> resultTypeClass = resolveClass(resultType);
  String resultMap = context.getStringAttribute("resultMap");
  String resultSetType = context.getStringAttribute("resultSetType");
  ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
  if (resultSetTypeEnum == null) {
    resultSetTypeEnum = configuration.getDefaultResultSetType();
  }
  String keyProperty = context.getStringAttribute("keyProperty");
  String keyColumn = context.getStringAttribute("keyColumn");
  String resultSets = context.getStringAttribute("resultSets");

  //将上面解析出来的对象放入MappedStatement
  // 通过MappedStatement可以拿到所有属性参数
  builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
      fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
      resultSetTypeEnum, flushCache, useCache, resultOrdered,
      keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}

createSqlSource方法调用的是实现类XMLLanguageDriver#createSqlSource方法

public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
  XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
  // 针对动态sql和静态sql区分性地创建了sqlSource
  return builder.parseScriptNode();
}

在createSqlSource方法里又创建了XMLScriptBuilder对象，执行了parseScriptNode方法，分别对动态sql和静态sql进行处理。对于动态sql（即使用了${}）只构造SqlSource，不进行解析；对于静态sql，会进行解析工作

public SqlSource parseScriptNode() {
  //# $
  MixedSqlNode rootSqlNode = parseDynamicTags(context);
  SqlSource sqlSource;
  if (isDynamic) {
    // 动态sql
    // 仅仅是构造了相应的sqlSource，不进行解析工作
    sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
  } else {
    // 静态文本sql
    // 构造静态sql的sqlSource，并且将sql语句中的#{}替换为了?
    sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
  }
  return sqlSource;
}

静态sql通过SqlSourceBuilder对象进行解析

public RawSqlSource(Configuration configuration, String sql, Class<?> parameterType) {
  SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
  Class<?> clazz = parameterType == null ? Object.class : parameterType;
  sqlSource = sqlSourceParser.parse(sql, clazz, new HashMap<>());
}

GenericTokenParser对象在sql解析中会多次出现，后续再仔细分析其工作流程。针对#{}符号注册了GenericTokenParser对象，调用parse方法进行解析。

// 静态sql解析，实现对#{}的处理
public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
  ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
  GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
  // 开始解析
  String sql = parser.parse(originalSql);
  return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}

这里要关注上面parse方法中构造的TokenHandler对象的handleToken方法，源码如下所示，它会返回 ? 占位符

//全局扫描#{id} 字符串之后  会把里面所有 #{} 调用handleToken 替换为?
@Override
public String handleToken(String content) {
  parameterMappings.add(buildParameterMapping(content));
  return "?";
}

然后在TokenParser的parse方法内找出所有#{}，再调用TokenHandler的handleToken方法将#{}替换为 ? 占位符

//## org/apache/ibatis/parsing/GenericTokenParser.java
public String parse(String text) {
  if (text == null || text.isEmpty()) {
    return "";
  }
  // search open token
  // 所谓open token在这里就是 ${ 或者 #{，close token就是 }
  int start = text.indexOf(openToken);
  if (start == -1) {
    return text;
  }
  char[] src = text.toCharArray();
  int offset = 0;
  final StringBuilder builder = new StringBuilder();
  StringBuilder expression = null;
  //遍历里面所有的#{} select ?  ,#{id1} ${}
  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);
          break;
        }
      }
      if (end == -1) {
        // close token was not found.
        builder.append(src, start, src.length - start);
        offset = src.length;
      } else {

        // 调用SqlSourceBuilder静态内部类的ParameterMappingTokenHandler的handleToken方法
        // 扫描#{id} 字符串之后  会把里面所有 #{} 调用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();
}

小结

解析mybatis主配置文件中的<mappers>标签后就能够定位所有mapper文件或者相关interface，然后在mapperElement方法内遍历解析所有mapper，解析单个mapper时，通过configurationElement方法解析mapper文件里的各属性，sql语句的解析由parseStatementNode方法完成，在XMLLanguageDriver#createSqlSource方法里根据sql语句是动态还是静态的分别创建不同的SqlSource实现类。对于动态Sql（${}），仅仅创建SqlSource实例；对于静态sql，在创建SqlSource实例的同时，还将#{}替换为占位符 ? （原生JDBC的PreparedStatement 的sql格式）