60-Mybatis源码分析

1. 架构设计&测试代码#

1.1 Mybatis 四层架构#

• 【API接口层】提供 API 增加、删除、修改、查询等接口，通过 API 接口对数据库进行操作；
• 【数据处理层】主要负责 SQL 的查询、解析、执行以及结果映射的处理，主要作用解析 SQL 根据调用请求完成一次数据库操作；
• 【框架支撑层】负责通用基础服务支撑,包含事务管理、连接池管理、缓存管理等共用组件的封装，为上层提供基础服务支撑；
• 【引导层】引导层是配置和启动 MyBatis 配置信息的方式。

1.2 主要组件及其相互关系#

组件	说明
SqlSession	是 Mybatis 对外暴露的核心 API，提供了对数据库的 CRUD 操作接口。
Executor	执行器，由 SqlSession 调用，负责数据库操作以及 Mybatis 两级缓存的维护。
StatementHandler	封装了 JDBC Statement 操作，负责对 Statement 的操作，例如 PrepareStatement 参数的设置以及结果集的处理。
ParameterHandler	是 StatementHandler 内部一个组件，主要负责对 ParameterStatement 参数的设置。
ResultSetHandler	是 StatementHandler 内部一个组件，主要负责对 ResultSet 结果集的处理，封装成目标对象返回。
TypeHandler	用于 Java 类型与 JDBC 类型之间的数据转换，ParameterHandler 和 ResultSetHandler 会分别使用到它的类型转换功能。
MappedStatement	是对 Mapper 配置文件或 Mapper 接口方法上通过注解声明 SQL 的封装。
Configuration	Mybatis 所有配置都统一由 Configuration 进行管理，内部由具体对象分别管理各自的小功能模块。

1.3 源码结构#

1.4 编写测试代码#

（1）SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    
    <!--第一部分：数据源配置-->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理 -->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver" />
                <property name="url" value="jdbc:mysql:///mybatis?characterEncoding=UTF-8" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>

   <!--第二部分：引入映射配置文件-->
    <mappers>
      <mapper resource="mapper/UserMapper.xml"></mapper>
    </mappers>
    
</configuration>

（2）UserMapper.xml

<?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="user">
 
  <select id="findUserById" parameterType="int" resultType="com.itheima.pojo.User">
        SELECT id, username FROM user WHERE id = #{id}
  </select>
  
</mapper>

（3）User.java

package com.itheima.pojo;

import lombok.Data;

@Data
public class User {

    private Integer id;

    private String username;

}

（4）编写测试类

public class MybatisTest {

  @Test
  public void test() throws IOException {
    InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();

    User user = sqlSession.selectOne("user.findUserById", user1);
    System.out.println(user);
    sqlSession.close();
  }

}

2. 源码剖析-初始化_如何解析的全局配置文件？#

全局配置文件可配置参数：https://mybatis.org/mybatis-3/zh/configuration.html

（1）Configuration

public class Configuration {

  protected Environment environment;

  // 允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为false。默认为false
  protected boolean safeRowBoundsEnabled;
  // 允许在嵌套语句中使用分页（ResultHandler）。如果允许使用则设置为false
  protected boolean safeResultHandlerEnabled = true;
  // 是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN
  // 到经典 Java 属性名 aColumn 的类似映射。默认false
  protected boolean mapUnderscoreToCamelCase;
  // 当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载。默认值false (true in ≤3.4.1)
  protected boolean aggressiveLazyLoading;
  // 是否允许单一语句返回多结果集（需要兼容驱动）。
  protected boolean multipleResultSetsEnabled = true;
  // 允许 JDBC 支持自动生成主键，需要驱动兼容。这就是insert时获取mysql自增主键/oracle sequence的开关。
  // 注：一般来说,这是希望的结果,应该默认值为true比较合适。
  protected boolean useGeneratedKeys;
  // 使用列标签代替列名,一般来说,这是希望的结果
  protected boolean useColumnLabel = true;
  // 是否启用缓存
  protected boolean cacheEnabled = true;
  // 指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，
  // 这对于有 Map.keySet() 依赖或 null 值初始化的时候是有用的。
  protected boolean callSettersOnNulls;
  // 允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的工程必须采用Java 8编译，
  // 并且加上-parameters选项。（从3.4.1开始）
  protected boolean useActualParamName = true;
  //当返回行的所有列都是空时，MyBatis默认返回null。 当开启这个设置时，MyBatis会返回一个空实例。
  // 请注意，它也适用于嵌套的结果集 (i.e. collectioin and association)。（从3.4.2开始）
  // 注：这里应该拆分为两个参数比较合适, 一个用于结果集，一个用于单记录。
  // 通常来说，我们会希望结果集不是null，单记录仍然是null
  protected boolean returnInstanceForEmptyRow;

  protected boolean shrinkWhitespacesInSql;

  // 指定 MyBatis 增加到日志名称的前缀。
  protected String logPrefix;
  // 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。一般建议指定为slf4j或log4j
  protected Class<? extends Log> logImpl;
  // 指定VFS的实现, VFS是mybatis提供的用于访问AS内资源的一个简便接口
  protected Class<? extends VFS> vfsImpl;
  protected Class<?> defaultSqlProviderType;
  // MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。
  // 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。
  // 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。
  protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;
  // 当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。 某些驱动需要指定列的 JDBC 类型，
  // 多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。
  protected JdbcType jdbcTypeForNull = JdbcType.OTHER;
  // 指定对象的哪个方法触发一次延迟加载。
  protected Set<String> lazyLoadTriggerMethods = new HashSet<>(Arrays.asList("equals", "clone", "hashCode", "toString"));
  // 设置超时时间，它决定驱动等待数据库响应的秒数。默认不超时
  protected Integer defaultStatementTimeout;
  // 为驱动的结果集设置默认获取数量。
  protected Integer defaultFetchSize;
  // SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）；
  // BATCH 执行器将重用语句并执行批量更新。
  protected ResultSetType defaultResultSetType;

  // 默认执行器类型
  protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
  // 指定 MyBatis 应如何自动映射列到字段或属性。
  // NONE 表示取消自动映射；
  // PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。
  // FULL 会自动映射任意复杂的结果集（无论是否嵌套）。
  protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;
  // 指定发现自动映射目标未知列（或者未知属性类型）的行为。这个值应该设置为WARNING比较合适
  protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE;
  // settings下的properties属性
  protected Properties variables = new Properties();
  // 默认的反射器工厂,用于操作属性、构造器方便
  protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
  // 对象工厂, 所有的类resultMap类都需要依赖于对象工厂来实例化
  protected ObjectFactory objectFactory = new DefaultObjectFactory();
  // 对象包装器工厂,主要用来在创建非原生对象,比如增加了某些监控或者特殊属性的代理类
  protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();
  // 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态
  protected boolean lazyLoadingEnabled = false;
  // 指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。MyBatis 3.3+使用JAVASSIST
  protected ProxyFactory proxyFactory = new JavassistProxyFactory();
  // MyBatis 可以根据不同的数据库厂商执行不同的语句，这种多厂商的支持是基于映射语句中的 databaseId 属性。
  protected String databaseId;

  protected Class<?> configurationFactory;

  protected final MapperRegistry mapperRegistry = new MapperRegistry(this);

  // mybatis插件列表
  protected final InterceptorChain interceptorChain = new InterceptorChain();
  protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry(this);

  // 类型注册器, 用于在执行sql语句的出入参映射以及mybatis-config文件里的各种配置
  // 比如<transactionManager type="JDBC"/><dataSource type="POOLED">时使用简写
  protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
  protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();

  protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
      .conflictMessageProducer((savedValue, targetValue) ->
          ". please check " + savedValue.getResource() + " and " + targetValue.getResource());
  protected final Map<String, Cache> caches = new StrictMap<>("Caches collection");
  protected final Map<String, ResultMap> resultMaps = new StrictMap<>("Result Maps collection");
  protected final Map<String, ParameterMap> parameterMaps = new StrictMap<>("Parameter Maps collection");
  protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<>("Key Generators collection");

  protected final Set<String> loadedResources = new HashSet<>();
  protected final Map<String, XNode> sqlFragments = new StrictMap<>("XML fragments parsed from previous mappers");

  protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<>();
  protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<>();
  protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<>();
  protected final Collection<MethodResolver> incompleteMethods = new LinkedList<>();

  /*
   * A map holds cache-ref relationship. The key is the namespace that
   * references a cache bound to another namespace and the value is the
   * namespace which the actual cache is bound to.
   */
  protected final Map<String, String> cacheRefMap = new HashMap<>();

  public Configuration(Environment environment) {
    this();
    this.environment = environment;
  }

  ...

（2）入口：SqlSessionFactoryBuilder#build

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
  try {
    // [使用构建者模式] XMLConfigBuilder 用来解析XML配置文件
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    // parser.parse() 使用XPATH解析XML配置文件，将配置文件封装为Configuration对象
    // 返回DefaultSqlSessionFactory对象，该对象拥有Configuration对象（封装配置文件信息）
    return build(parser.parse());
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  } finally {
    ErrorContext.instance().reset();
    try {
      inputStream.close();
    } catch (IOException e) {
      // Intentionally ignore. Prefer previous error.
    }
  }
}

创建 XMLConfigBuilder 对象，这个类是 BaseBuilder 的子类，BaseBuilder 类图如下：

看到这些子类基本上都是以 Builder 结尾，这里使用的是 Builder 建造者设计模式。

2.1 XMLConfigBuilder#构造参数#

XMLConfigBuilder 用来解析 XML 配置文件

XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
// ||
// ||
// \/
public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
  this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
  ...
}

Mybatis 对应解析包 org.apache.ibatis.parsing：

（4）XPathParser 基于 Java XPath 解析器，用于解析 MyBatis 中的配置文件（核心配置文件、SQL 映射文件）。

a. XpathParser#构造函数#

使用 XPath 语法解析 XML 的解析器。

public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver) {
    commonConstructor(validation, variables, entityResolver);
    // 解析XML文档为Document对象
    this.document = createDocument(new InputSource(inputStream));
}

XPathParser#createDocument 解析全局配置文件，封装为 Document 对象（封装一些子节点，使用 XPath 语法解析获取）。

private Document createDocument(InputSource inputSource) {
  // important: this must only be called AFTER common constructor
  try {
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    // 进行dtd或者Schema校验
    factory.setValidating(validation);

    factory.setNamespaceAware(false);
    // 设置忽略注释为true
    factory.setIgnoringComments(true);
    // 设置是否忽略元素内容中的空白
    factory.setIgnoringElementContentWhitespace(false);
    factory.setCoalescing(false);
    factory.setExpandEntityReferences(true);

    DocumentBuilder builder = factory.newDocumentBuilder();
    builder.setEntityResolver(entityResolver);
    builder.setErrorHandler(new ErrorHandler() {
      @Override
      public void error(SAXParseException exception) throws SAXException {
        throw exception;
      }

      @Override
      public void fatalError(SAXParseException exception) throws SAXException {
        throw exception;
      }

      @Override
      public void warning(SAXParseException exception) throws SAXException {
      }
    });
    // 通过DOM解析，获取Document对象
    return builder.parse(inputSource);
  } catch (Exception e) {
    throw new BuilderException("Error creating document instance.  Cause: " + e, e);
  }
}

b. XMLConfigBuilder#构造函数#

创建 Configuration 对象，同时初始化内置类的别名。

private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
  // 创建Configuration对象，并通过TypeAliasRegistry注册一些Mybatis内部相关类的别名
  super(new Configuration());
  ErrorContext.instance().resource("SQL Mapper Configuration");
  this.configuration.setVariables(props);
  this.parsed = false;
  this.environment = environment;
  this.parser = parser;
}

public Configuration() {
  // TypeAliasRegistry（类型别名注册器）
  typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
  typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);

  typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
  typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
  typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);

  typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
  typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
  typeAliasRegistry.registerAlias("LRU", LruCache.class);
  typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
  typeAliasRegistry.registerAlias("WEAK", WeakCache.class);

  typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);

  typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
  typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);

  typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
  typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
  typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
  typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
  typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
  typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
  typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);

  typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
  typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);

  languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
  languageRegistry.register(RawLanguageDriver.class);
}

2.2 XMLConfigBuilder#parse#

//使用 XPATH 解析 XML 配置文件，将配置文件封装为 Configuration 对象。
parser.parse();

解析 XML 配置文件

public Configuration parse() {
  if (parsed) {
    throw new BuilderException("Each XMLConfigBuilder can only be used once.");
  }
  parsed = true;
  // parser.evalNode("/configuration") 通过XPATH解析器，解析configuration根节点
  // 从configuration根节点开始解析，最终将解析出的内容封装到Configuration对象中
  parseConfiguration(parser.evalNode("/configuration"));
  return configuration;
}

a. XPathParser#evalNode#

XPath 解析器，专门用来通过 Xpath 语法解析 XML 返回 XNode 节点。

public XNode evalNode(String expression) {
  // 根据XPATH语法，获取指定节点
  return evalNode(document, expression);
}

public XNode evalNode(Object root, String expression) {
  Node node = (Node) evaluate(expression, root, XPathConstants.NODE);
  if (node == null) {
  return null;
  }
  return new XNode(this, node, variables);
}

b. XMLConfigBuilder#parseConfiguration(XNode)#

从 Configuration 根节点开始解析，最终将解析出的内容封装到 Configuration 对象中。

private void parseConfiguration(XNode root) {
    try {
      // 解析</properties>标签
      propertiesElement(root.evalNode("properties"));
      // 解析</settings>标签
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      // 解析</typeAliases>标签
      typeAliasesElement(root.evalNode("typeAliases"));
      // 解析</plugins>标签
      pluginElement(root.evalNode("plugins"));
      // 解析</objectFactory>标签
      objectFactoryElement(root.evalNode("objectFactory"));
      // 解析</objectWrapperFactory>标签
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      // 解析</reflectorFactory>标签
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      
      // 解析</environments>标签
      environmentsElement(root.evalNode("environments"));
      // 解析</databaseIdProvider>标签
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      // 解析</typeHandlers>标签
      typeHandlerElement(root.evalNode("typeHandlers"));
      // 解析</mappers>标签 加载映射文件流程主入口
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

回到 SqlSessionFactoryBuilder#build() 方法：

// 返回DefaultSqlSessionFactory对象，该对象拥有Configuration对象（封装配置文件信息）
return build(parser.parse());
// ||
// ||
// \/
public SqlSessionFactory build(Configuration config) {
  // 创建SqlSessionFactory接口的默认实现类
  return new DefaultSqlSessionFactory(config);
}

2.3 小结#

3. 源码剖析-初始化_如何解析的映射配置文件？#

【Q1】映射配置文件中标签和属性如何被解析封装的？

【Q2】SQL 占位符如何进行的替换？动态 SQL 如何进行的解析？

3.1 XMLConfigBuilder#mapperElement#

解析全局配置文件中的标签（注意 if-else 块中各自的最后一行代码）

/**
 * 解析<mappers>标签
 * @param parent  mappers标签对应的XNode对象
 * @throws Exception
 */
private void mapperElement(XNode parent) throws Exception {
  if (parent != null) {
    // 获取<mappers>标签的子标签
    for (XNode child : parent.getChildren()) {
      if ("package".equals(child.getName())) {          // <=== <package>子标签
        // 获取mapper接口和mapper映射文件对应的package包名
        String mapperPackage = child.getStringAttribute("name");
        // => 将包下所有的mapper接口以及它的代理对象存储到一个Map集合中，key为mapper接口类型，value为代理对象工厂
        configuration.addMappers(mapperPackage);
      } else {                                          // <=== <mapper>子标签
        // 获取<mapper>子标签的resource属性
        String resource = child.getStringAttribute("resource");
        // 获取<mapper>子标签的url属性
        String url = child.getStringAttribute("url");
        // 获取<mapper>子标签的class属性
        String mapperClass = child.getStringAttribute("class");
        // 它们是互斥的
        if (resource != null && url == null && mapperClass == null) {
          ErrorContext.instance().resource(resource);
          InputStream inputStream = Resources.getResourceAsStream(resource);
          // 专门用来解析mapper映射文件
          XMLMapperBuilder mapperParser = new XMLMapperBuilder(
            		inputStream, configuration, resource, configuration.getSqlFragments());
          // 通过XMLMapperBuilder解析mapper映射文件
          mapperParser.parse();
        } 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());
          // 通过XMLMapperBuilder解析mapper映射文件
          mapperParser.parse();
        } else if (resource == null && url == null && mapperClass != null) {
          Class<?> mapperInterface = Resources.classForName(mapperClass);
          // => 将指定mapper接口以及它的代理对象存储到一个Map集合中，key为mapper接口类型，value为代理对象工厂
          configuration.addMapper(mapperInterface);
        } else {
          throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
        }
      }
    }
  }
}

3.2 package 子标签#

a. Configuration#addMappers#

将包下所有的 mapper 接口以及它的代理对象存储到一个 Map 集合中，key 为 mapper 接口类型，value 为代理对象工厂。

public void addMappers(String packageName) {
    mapperRegistry.addMappers(packageName);
}

b. MapperRegistry#addMappers#

将 Mapper 接口添加到 MapperRegistry 中。

// 1
public void addMappers(String packageName) {
  addMappers(packageName, Object.class);
}

// 2
public void addMappers(String packageName, Class<?> superType) {
  ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
  // 根据package名称，加载该包下Mapper接口文件（不是映射文件）
  resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
  // 获取加载的Mapper接口
  Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
  for (Class<?> mapperClass : mapperSet) {
    // => 将Mapper接口添加到MapperRegistry中
    addMapper(mapperClass);
  }
}

// 3
public <T> void addMapper(Class<T> type) {
  if (type.isInterface()) {
    // 如果Map集合中已经有该mapper接口的映射，就不需要再存储了
    if (hasMapper(type)) {
      throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
    }
    boolean loadCompleted = false;
    try {
      // 将mapper接口以及它的代理对象存储到一个Map集合中，key为mapper接口类型，value为代理对象工厂
      knownMappers.put(type, new MapperProxyFactory<T>(type));
      // 用来解析注解方式的mapper接口
      MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
      // => 解析注解方式的mapper接口
      parser.parse();
      loadCompleted = true;
    } finally {
      if (!loadCompleted) {
        knownMappers.remove(type);
      }
    }
  }
}

c. MapperAnnotationBuilder#parse#

解析注解方式的 mapper 接口

public void parse() {
  // 获取mapper接口的全路径
  String resource = type.toString();
  // 是否解析过该mapper接口
  if (!configuration.isResourceLoaded(resource)) {
    // 先解析mapper映射文件
    loadXmlResource();
    // 设置解析标识
    configuration.addLoadedResource(resource);
    // Mapper构建者助手
    assistant.setCurrentNamespace(type.getName());
    // 解析CacheNamespace注解
    parseCache();
    // 解析CacheNamespaceRef注解
    parseCacheRef();
    Method[] methods = type.getMethods();
    for (Method method : methods) {
      try {
        if (!method.isBridge()) {
          // => 每个mapper接口中的方法，都解析成MappedStatement对象
          parseStatement(method);
        }
      } catch (IncompleteElementException e) {
        configuration.addIncompleteMethod(new MethodResolver(this, method));
      }
    }
  }
  // 去检查所有的incompleteMethods，如果可以解析了.那就移除
  parsePendingMethods();
}

d. MapperAnnotationBuilder#parseStatement#

每个 mapper 接口中的方法，都解析成 MappedStatement 对象。

void parseStatement(Method method) {
  // 获取Mapper接口的形参类型
  Class<?> parameterTypeClass = getParameterType(method);
  // 解析Lang注解
  LanguageDriver languageDriver = getLanguageDriver(method);
  // 
  SqlSource sqlSource = getSqlSourceFromAnnotations(method, parameterTypeClass, languageDriver);
  if (sqlSource != null) {
    Options options = method.getAnnotation(Options.class);
    // 组装mappedStatementId
    final String mappedStatementId = type.getName() + "." + method.getName();
    Integer fetchSize = null;
    Integer timeout = null;
    StatementType statementType = StatementType.PREPARED;
    ResultSetType resultSetType = null;
    // 获取该mapper接口中的方法是CRUD操作的哪一种
    SqlCommandType sqlCommandType = getSqlCommandType(method);
    // 是否是SELECT操作
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    boolean flushCache = !isSelect;
    boolean useCache = isSelect;

    // 主键生成器，用于主键返回
    KeyGenerator keyGenerator;
    String keyProperty = null;
    String keyColumn = null;
    if (SqlCommandType.INSERT.equals(sqlCommandType) || SqlCommandType.UPDATE.equals(sqlCommandType)) {
      // first check for SelectKey annotation - that overrides everything else
      SelectKey selectKey = method.getAnnotation(SelectKey.class);
      if (selectKey != null) {
        keyGenerator = handleSelectKeyAnnotation(selectKey, mappedStatementId, getParameterType(method), languageDriver);
        keyProperty = selectKey.keyProperty();
      } else if (options == null) {
        keyGenerator = configuration.isUseGeneratedKeys() ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
      } else {
        keyGenerator = options.useGeneratedKeys() ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
        keyProperty = options.keyProperty();
        keyColumn = options.keyColumn();
      }
    } else {
      keyGenerator = NoKeyGenerator.INSTANCE;
    }

    if (options != null) {
      if (FlushCachePolicy.TRUE.equals(options.flushCache())) {
        flushCache = true;
      } else if (FlushCachePolicy.FALSE.equals(options.flushCache())) {
        flushCache = false;
      }
      useCache = options.useCache();
      fetchSize = options.fetchSize() > -1 || options.fetchSize() == Integer.MIN_VALUE ? options.fetchSize() : null;
      timeout = options.timeout() > -1 ? options.timeout() : null;
      statementType = options.statementType();
      resultSetType = options.resultSetType();
    }

    // 处理ResultMap注解
    String resultMapId = null;
    ResultMap resultMapAnnotation = method.getAnnotation(ResultMap.class);
    if (resultMapAnnotation != null) {
      String[] resultMaps = resultMapAnnotation.value();
      StringBuilder sb = new StringBuilder();
      for (String resultMap : resultMaps) {
        if (sb.length() > 0) {
          sb.append(",");
        }
        sb.append(resultMap);
      }
      resultMapId = sb.toString();
    } else if (isSelect) {
      resultMapId = parseResultMap(method);
    }

    // 通过Mapper构建助手，创建一个MappedStatement对象，封装信息
    assistant.addMappedStatement(
        mappedStatementId,
        sqlSource,
        statementType,
        sqlCommandType,
        fetchSize,
        timeout,
        // ParameterMapID
        null,
        parameterTypeClass,
        resultMapId,
        getReturnType(method),
        resultSetType,
        flushCache,
        useCache,
        false,
        keyGenerator,
        keyProperty,
        keyColumn,
        // DatabaseID
        null,
        languageDriver,
        // ResultSets
        options != null ? nullOrEmpty(options.resultSets()) : null);
  }
}

e. MapperBuilderAssistant#addMappedStatement#

通过 Mapper 构建助手，创建一个 MappedStatement 对象，封装信息。

public MappedStatement addMappedStatement(
    String id,
    SqlSource sqlSource,
    StatementType statementType,
    SqlCommandType sqlCommandType,
    Integer fetchSize,
    Integer timeout,
    String parameterMap,
    Class<?> parameterType,
    String resultMap,
    Class<?> resultType,
    ResultSetType resultSetType,
    boolean flushCache,
    boolean useCache,
    boolean resultOrdered,
    KeyGenerator keyGenerator,
    String keyProperty,
    String keyColumn,
    String databaseId,
    LanguageDriver lang,
    String resultSets) {

  if (unresolvedCacheRef) {
    throw new IncompleteElementException("Cache-ref not yet resolved");
  }

  id = applyCurrentNamespace(id, false);
  boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

  //利用构建者模式，去创建MappedStatement.Builder,用于创建MappedStatement对象
  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.Builder，构建一个MappedStatement
  MappedStatement statement = statementBuilder.build();
  // 将MappedStatement对象存储到Configuration中的Map集合中，key为statement的id，value为MappedStatement对象
  configuration.addMappedStatement(statement);
  return statement;
}

3.3 mapper 子标签#

a. XMLMapperBuilder#构造函数#

专门用来解析 mapper 映射文件

public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
  this(new XPathParser(inputStream, true, configuration.getVariables(), new XMLMapperEntityResolver()),
        configuration, resource, sqlFragments);
}

a-1. XPathParser#构造函数#

用来使用 XPath 语法解析 XML 的解析器

public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver) {
  commonConstructor(validation, variables, entityResolver);
  // 解析XML文档为Document对象
  this.document = createDocument(new InputSource(inputStream));
}

XPathParser#createDocument：创建 Mapper 映射文件对应的 Document 对象

private Document createDocument(InputSource inputSource) {
  // important: this must only be called AFTER common constructor
  try {
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    // 进行dtd或者Schema校验
    factory.setValidating(validation);

    factory.setNamespaceAware(false);
    // 设置忽略注释为true
    factory.setIgnoringComments(true);
    // 设置是否忽略元素内容中的空白
    factory.setIgnoringElementContentWhitespace(false);
    factory.setCoalescing(false);
    factory.setExpandEntityReferences(true);

    DocumentBuilder builder = factory.newDocumentBuilder();
    builder.setEntityResolver(entityResolver);
    builder.setErrorHandler(new ErrorHandler() {
      @Override
      public void error(SAXParseException exception) throws SAXException {
        throw exception;
      }

      @Override
      public void fatalError(SAXParseException exception) throws SAXException {
        throw exception;
      }

      @Override
      public void warning(SAXParseException exception) throws SAXException {
      }
    });
    // 通过DOM解析，获取Document对象
    return builder.parse(inputSource);
  } catch (Exception e) {
    throw new BuilderException("Error creating document instance.  Cause: " + e, e);
  }
}

a-2. XMLMapperBuilder#构造函数#

private XMLMapperBuilder(XPathParser parser, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
  super(configuration);
  this.builderAssistant = new MapperBuilderAssistant(configuration, resource);
  this.parser = parser;
  this.sqlFragments = sqlFragments;
  this.resource = resource;
}

MapperBuilderAssistant#构造函数：用于构建 MappedStatement 对象

public MapperBuilderAssistant(Configuration configuration, String resource) {
  super(configuration);
  ErrorContext.instance().resource(resource);
  this.resource = resource;
}

b. XMLMapperBuilder#parse#

通过 XMLMapperBuilder 解析 mapper 映射文件

public void parse() {
 // mapper映射文件是否已经加载过
 if (!configuration.isResourceLoaded(resource)) {
   // => 从映射文件中的<mapper>根标签开始解析，直到完整的解析完毕
   configurationElement(parser.evalNode("/mapper"));
   // 标记已经解析
   configuration.addLoadedResource(resource);
   bindMapperForNamespace();
 }

 parsePendingResultMaps();
 parsePendingCacheRefs();
 parsePendingStatements();
}

b-1. XMLMapperBuilder#configurationElement#

从映射文件中的根标签开始解析，直到完整的解析完毕。

/**
 * 解析映射文件
 * @param context 映射文件根节点<mapper>对应的XNode
 */
private void configurationElement(XNode context) {
  try {
    // 获取<mapper>标签的namespace值，也就是命名空间
    String namespace = context.getStringAttribute("namespace");
    // 命名空间不能为空
    if (namespace == null || namespace.equals("")) {
      throw new BuilderException("Mapper's namespace cannot be empty");
    }
    
    // 设置当前的命名空间为namespace的值
    builderAssistant.setCurrentNamespace(namespace);
    // 解析<cache-ref>子标签
    cacheRefElement(context.evalNode("cache-ref"));
    // 解析<cache>子标签
    cacheElement(context.evalNode("cache"));
    
    // 解析<parameterMap>子标签
    parameterMapElement(context.evalNodes("/mapper/parameterMap"));
    // 解析<resultMap>子标签
    resultMapElements(context.evalNodes("/mapper/resultMap"));
    // 解析<sql>子标签，也就是SQL片段
    sqlElement(context.evalNodes("/mapper/sql"));
    // => 解析<select>\<insert>\<update>\<delete>子标签
    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);
  }
}

b-2. XMLMapperBuilder#buildStatementFromContext#

// 1、构建MappedStatement
private void buildStatementFromContext(List<XNode> list) {
  if (configuration.getDatabaseId() != null) {
    buildStatementFromContext(list, configuration.getDatabaseId());
  }
  // => 构建MappedStatement
  buildStatementFromContext(list, null);
}

// 2、专门用来解析MappedStatement
private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
  for (XNode context : list) {
    // => MappedStatement解析器
    final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
    try {
      // => 解析select等4个标签，创建MappedStatement对象
      statementParser.parseStatementNode();
    } catch (IncompleteElementException e) {
      configuration.addIncompleteStatement(statementParser);
    }
  }
}

b-3. XMLStatementBuilder#构造函数#

public XMLStatementBuilder(Configuration configuration, MapperBuilderAssistant builderAssistant, XNode context, String databaseId) {
  super(configuration);
  this.builderAssistant = builderAssistant;
  this.context = context;
  this.requiredDatabaseId = databaseId;
}

b-4. XMLStatementBuilder#parseStatementNode#

/**
 * 解析<select>\<insert>\<update>\<delete>子标签
 */
public void parseStatementNode() {
  // 获取statement的id属性（特别关键的值）
  String id = context.getStringAttribute("id");
  String databaseId = context.getStringAttribute("databaseId");

  if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
    return;
  }

  Integer fetchSize = context.getIntAttribute("fetchSize");
  Integer timeout = context.getIntAttribute("timeout");
  String parameterMap = context.getStringAttribute("parameterMap");
  // 获取入参类型
  String parameterType = context.getStringAttribute("parameterType");
  // 别名处理，获取入参对应的Java类型
  Class<?> parameterTypeClass = resolveClass(parameterType);
  // 获取ResultMap
  String resultMap = context.getStringAttribute("resultMap");
  // 获取结果映射类型
  String resultType = context.getStringAttribute("resultType");
  String lang = context.getStringAttribute("lang");
  LanguageDriver langDriver = getLanguageDriver(lang);
  
  // 别名处理，获取返回值对应的Java类型
  Class<?> resultTypeClass = resolveClass(resultType);
  String resultSetType = context.getStringAttribute("resultSetType");
  
  // 设置默认StatementType为Prepared，该参数指定了后面的JDBC处理时，采用哪种Statement
  StatementType statementType = StatementType.valueOf(
                                    context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
  ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);

  String nodeName = context.getNode().getNodeName();
  // 解析SQL命令类型是什么？确定操作是CRUD中的哪一种
  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
  // <include>标签解析
  XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
  includeParser.applyIncludes(context.getNode());

  // Parse selectKey after includes and remove them.
  // 解析<selectKey>标签
  processSelectKeyNodes(id, parameterTypeClass, langDriver);
  
  // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
  // 创建SqlSource，解析SQL，封装SQL语句（未参数绑定）和入参信息
  SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
 
  String resultSets = context.getStringAttribute("resultSets");
  String keyProperty = context.getStringAttribute("keyProperty");
  String keyColumn = context.getStringAttribute("keyColumn");
  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;
  }

  // => 通过构建者助手，创建MappedStatement对象
  builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
      fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
      resultSetTypeEnum, flushCache, useCache, resultOrdered, 
      keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}

b-5. MapperBuilderAssistant#addMappedStatement#

通过构建者助手，创建 MappedStatement 对象。

public MappedStatement addMappedStatement(
    String id,
    SqlSource sqlSource,
    StatementType statementType,
    SqlCommandType sqlCommandType,
    Integer fetchSize,
    Integer timeout,
    String parameterMap,
    Class<?> parameterType,
    String resultMap,
    Class<?> resultType,
    ResultSetType resultSetType,
    boolean flushCache,
    boolean useCache,
    boolean resultOrdered,
    KeyGenerator keyGenerator,
    String keyProperty,
    String keyColumn,
    String databaseId,
    LanguageDriver lang,
    String resultSets) {

  if (unresolvedCacheRef) {
    throw new IncompleteElementException("Cache-ref not yet resolved");
  }

  id = applyCurrentNamespace(id, false);
  boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

  // => 利用构建者模式，去创建MappedStatement.Builder，用于创建MappedStatement对象
  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.Builder，构建一个MappedStatement
  MappedStatement statement = statementBuilder.build();
  // 将MappedStatement对象存储到Configuration中的Map集合中，key为statement的id，value为MappedStatement对象
  configuration.addMappedStatement(statement);
  return statement;
}

b-6. MappedStatement.Builder#构造函数#

利用构建者模式来创建MappedStatement.Builder，用于创建 MappedStatement 对象。

public Builder(Configuration configuration, String id, SqlSource sqlSource, SqlCommandType sqlCommandType) {
  mappedStatement.configuration = configuration;
  mappedStatement.id = id;
  mappedStatement.sqlSource = sqlSource;
  mappedStatement.statementType = StatementType.PREPARED;
  mappedStatement.resultSetType = ResultSetType.DEFAULT;
  mappedStatement.parameterMap = new ParameterMap.Builder(configuration, "defaultParameterMap", null, new ArrayList<>()).build();
  mappedStatement.resultMaps = new ArrayList<>();
  mappedStatement.sqlCommandType = sqlCommandType;
  mappedStatement.keyGenerator = configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType) 
    																			? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
  String logId = id;
  if (configuration.getLogPrefix() != null) {
    logId = configuration.getLogPrefix() + id;
  }
  mappedStatement.statementLog = LogFactory.getLog(logId);
  mappedStatement.lang = configuration.getDefaultScriptingLanguageInstance();
}

b-7. MappedStatement#build#

通过 MappedStatement.Builder，构建一个 MappedStatement。

public MappedStatement build() {
      assert mappedStatement.configuration != null;
      assert mappedStatement.id != null;
      assert mappedStatement.sqlSource != null;
      assert mappedStatement.lang != null;
      mappedStatement.resultMaps = Collections.unmodifiableList(mappedStatement.resultMaps);
      return mappedStatement;
}

4. 源码剖析-SqlSource创建流程#

【问题】SQL 占位符如何进行的替换？动态 SQL 如何进行的解析？

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG WHERE state = #{ACTIVE}
  <choose>
    <when test="title != null">
      AND title like #{title}
    </when>
    <when test="author != null and author.name != null">
      AND author_name like #{author.name}
    </when>
    <otherwise>
      AND featured = 1
    </otherwise>
  </choose>
</select>

相关类及对象：

• XMLLanguageDriver
• XMLScriptBuilder
• SqlSource 接口
• SqlSourceBuilder
• DynamicSqlSource 主要是封装动态 SQL 标签解析之后的 SQL 语句和带有 ${} 的 SQL 语句
• RawSqlSource 主要封装带有 #{} 的SQL语句
• StaticSqlSource 是 BoundSql 中要存储 SQL 语句的一个载体，上面两个 SqlSource 的 SQL 语句，最终都会存储到该 SqlSource 实现类。

4.1 XMLLanguageDriver#createSqlSource#

创建 SqlSource、解析 SQL、封装 SQL 语句（未参数绑定）和入参信息。

@Override
public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
  // => 初始化了动态SQL标签处理器
  XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
  // => 解析动态SQL
  return builder.parseScriptNode();
}

a. XMLScriptBuilder#构造函数#

初始化了动态 SQL 标签处理器

public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> parameterType) {
  super(configuration);
  this.context = context;
  this.parameterType = parameterType;
  // 初始化动态SQL中的节点处理器集合
  initNodeHandlerMap();
}

XMLScriptBuilder#initNodeHandlerMap：初始化动态 SQL 中的节点处理器集合

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());
}

b. XMLScriptBuilder#parseScriptNode#

解析动态 SQL

public SqlSource parseScriptNode() {
  // => 解析select\insert\ update\delete标签中的SQL语句，最终将解析到的SqlNode封装到MixedSqlNode中的List集合中。
  MixedSqlNode rootSqlNode = parseDynamicTags(context);
  SqlSource sqlSource = null;
  if (isDynamic) {
      // => 如果SQL中包含${}和动态SQL语句，则将SqlNode封装到DynamicSqlSource
      sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
  } else {
      // => 如果SQL中包含#{}，则将SqlNode封装到RawSqlSource中，并指定parameterType
      sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
  }
  return sqlSource;
}

4.2 XMLScriptBuilder#parseDynamicTags#

解析 select\insert\ update\delete 标签中的 SQL 语句，最终将解析到的 SqlNode 封装到 MixedSqlNode 中的 List 集合中。

• 将带有 ${} 的 SQL 信息封装到 TextSqlNode
• 将带有 #{} 的 SQL 信息封装到 StaticTextSqlNode
• 将动态 SQL 标签中的 SQL 信息分别封装到不同的 SqlNode 中

protected MixedSqlNode parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<>();
    //获取<select>\<insert>等4个标签的子节点，子节点包括元素节点和文本节点
    NodeList children = node.getNode().getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
        XNode child = node.newXNode(children.item(i));
        // 处理文本节点
        if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE
                || child.getNode().getNodeType() == Node.TEXT_NODE) {
            String data = child.getStringBody("");
            // 将文本内容封装到SqlNode中
            TextSqlNode textSqlNode = new TextSqlNode(data);
            // SQL语句中带有${}的话，就表示是dynamic的
            if (textSqlNode.isDynamic()) {
                contents.add(textSqlNode);
                isDynamic = true;
            } else {
                // SQL语句中（除了${}和下面的动态SQL标签），就表示是static的
                // StaticTextSqlNode的apply只是进行字符串的追加操作
                contents.add(new StaticTextSqlNode(data));
            }
            
            //处理元素节点
        } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
            String nodeName = child.getNode().getNodeName();
            // 动态SQL标签处理器
            // 思考，此处使用了哪种设计模式？--- 策略模式
            NodeHandler handler = nodeHandlerMap.get(nodeName);
            if (handler == null) {
                throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
            }
            handler.handleNode(child, contents);
            // 动态SQL标签是dynamic的
            isDynamic = true;
        }
    }
    return new MixedSqlNode(contents);
}

4.3 DynamicSqlSource#构造函数#

如果 SQL 中包含 ${} 和动态 SQL 语句，则将 SqlNode 封装到 DynamicSqlSource。

public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) {
  this.configuration = configuration;
  this.rootSqlNode = rootSqlNode;
}

4.4 RawSqlSource#构造函数#

如果 SQL 中包含 #{}，则将 SqlNode 封装到 RawSqlSource 中，并指定 parameterType。

private final SqlSource sqlSource;

public RawSqlSource(Configuration configuration, SqlNode rootSqlNode, Class<?> parameterType) {
    // 先调用 getSql(configuration, rootSqlNode)获取sql，再走下面的构造函数
    this(configuration, getSql(configuration, rootSqlNode), parameterType);
}

private static String getSql(Configuration configuration, SqlNode rootSqlNode) {
    DynamicContext context = new DynamicContext(configuration, null);
    rootSqlNode.apply(context);
    return context.getSql();
}

public RawSqlSource(Configuration configuration, String sql, Class<?> parameterType) {
    // 解析SQL语句
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    // 获取入参类型
    Class<?> clazz = parameterType == null ? Object.class : parameterType;
    // => 开始解析
    sqlSource = sqlSourceParser.parse(sql, clazz, new HashMap<String, Object>());
}

SqlSourceBuilder#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);
  // => 将解析之后的SQL信息，封装到StaticSqlSource对象中（SQL字符串是带有?号的字符串，?相关的参数信息，封装到ParameterMapping集合中）
  return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}

a. ParameterMappingTokenHandler#构造函数#

public ParameterMappingTokenHandler(Configuration configuration, Class<?> parameterType, Map<String, Object> additionalParameters) {
    super(configuration);
    this.parameterType = parameterType;
    this.metaParameters = configuration.newMetaObject(additionalParameters);
}

b. GenericTokenParser#构造函数#

创建分词解析器，指定待分析的 openToken 和 closeToken，并指定处理器。

public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
    this.openToken = openToken;
    this.closeToken = closeToken;
    this.handler = handler;
}

c. GenericTokenParser#parse#

解析 SQL 语句，处理 openToken 和 closeToken 中的内容。

/**
 * 解析${}和#{}
 * @param text
 * @return
 */
public String parse(String text) {
  if (text == null || text.isEmpty()) {
    return "";
  }
  // search open token
  int start = text.indexOf(openToken, 0);
  if (start == -1) {
    return text;
  }
  char[] src = text.toCharArray();
  int offset = 0;
  final StringBuilder builder = new StringBuilder();
  StringBuilder expression = null;
  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 {
        // => 进入
        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();
}

ParameterMappingTokenHandler#handleToken：

@Override
public String handleToken(String content) {
    parameterMappings.add(buildParameterMapping(content));
    return "?";
}

ParameterMappingTokenHandler#buildParameterMapping：创建 ParameterMapping 对象

private ParameterMapping buildParameterMapping(String content) {
    Map<String, String> propertiesMap = parseParameterMapping(content);
    String property = propertiesMap.get("property");
    Class<?> propertyType;
    if (metaParameters.hasGetter(property)) { // issue #448 get type from additional params
        propertyType = metaParameters.getGetterType(property);
    } else if (typeHandlerRegistry.hasTypeHandler(parameterType)) {
        propertyType = parameterType;
    } else if (JdbcType.CURSOR.name().equals(propertiesMap.get("jdbcType"))) {
        propertyType = java.sql.ResultSet.class;
    } else if (property == null || Map.class.isAssignableFrom(parameterType)) {
        propertyType = Object.class;
    } else {
        MetaClass metaClass = MetaClass.forClass(parameterType, configuration.getReflectorFactory());
        if (metaClass.hasGetter(property)) {
            propertyType = metaClass.getGetterType(property);
        } else {
            propertyType = Object.class;
        }
    }
    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();
        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));
    }
    return builder.build();
}

d. StaticSqlSource#构造函数#

将解析之后的 SQL 信息，封装到 StaticSqlSource。

private final String sql;
private final List<ParameterMapping> parameterMappings;
private final Configuration configuration;

public StaticSqlSource(Configuration configuration, String sql) {
  this(configuration, sql, null);
}

public StaticSqlSource(Configuration configuration, String sql, List<ParameterMapping> parameterMappings) {
  this.sql = sql;
  this.parameterMappings = parameterMappings;
  this.configuration = configuration;
}

5. 源码剖析-揭秘SqlSession执行主流程#

Executor 接口

组件	说明
BaseExecutor	基础执行器，是一个抽象类，这种通过抽象的实现接口的方式是「适配器设计模式」之「接口适配」的体现，是 Executor 的默认实现，实现了大部分 Executor 接口定义的功能（包括一级缓存、延迟加载、回滚、关闭等功能），降低了接口实现的难度；
SimpleExecutor	简单执行器，每执行一条 sql，都会打开一个 Statement，执行完成后关闭；
ReuseExecutor	重用执行器，相较于 SimpleExecutor 多了 Statement 的缓存功能，其内部维护一个 Map<String, Statement>，每次编译完成的 Statement 都会进行缓存，不会关闭（因为每一个 SqlSession 都有一个新的 Executor 对象，所以我们缓存在 ReuseExecutor 上的 Statement 作用域是同一个 SqlSession）；
BatchExecutor	批量执行器，基于 JDBC 的 addBatch、executeBatch 功能，并且在当前 sql 和上一条 sql 完全一样的时候，重用 Statement，在调用 doFlushStatements 的时候，将数据刷新到数据库；
CachingExecutor	缓存执行器，装饰器模式，在开启缓存的时候。会在上面 3 种执行器的外面再包上 CachingExecutor。即：先从缓存中查询结果，如果存在，就返回；如果不存在，再委托给 Executor#delegate 去数据库中取，delegate 可以是上面任何一个执行器。

5.1 DefaultSqlSession#selectList#

@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
        // 根据传入的statementId，获取MappedStatement对象
        MappedStatement ms = configuration.getMappedStatement(statement);
        // 调用执行器的查询方法
        // RowBounds是用来逻辑分页（按照条件将数据从数据库查询到内存中，在内存中进行分页）
        // => wrapCollection(parameter)是用来装饰集合或者数组参数
        return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

5.2 CachingExecutor#query#

Configuration 中 cacheEnabled 属性值默认为 true

// ====== 第一步 ======
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, 
                         ResultHandler resultHandler) throws SQLException {
  // 获取绑定的SQL语句，比如“SELECT * FROM user WHERE id = ? ” 
  BoundSql boundSql = ms.getBoundSql(parameterObject);
  // 生成缓存Key
  CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
  return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

// ====== 第二步 ======
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, 
                         ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  // 获取二级缓存
  Cache cache = ms.getCache();
  if (cache != null) {
    // 当为select语句时，flushCache默认为false，表示任何时候语句被调用，都不会去清空本地缓存和二级缓存
    // 当为insert、update、delete语句时，useCache默认为true，表示会将本条语句的结果进行二级缓存
    // 刷新二级缓存 （存在缓存且flushCache为true时）
    flushCacheIfRequired(ms);
    if (ms.isUseCache() && resultHandler == null) {
      ensureNoOutParams(ms, boundSql);
      // 从二级缓存中查询数据
      @SuppressWarnings("unchecked")
      List<E> list = (List<E>) tcm.getObject(cache, key);
      // 如果二级缓存中没有查询到数据，则查询数据库
      if (list == null) {
        // => 委托给 BaseExecutor 执行
        list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
        tcm.putObject(cache, key, list);
      }
      return list;
    }
  }
  // 委托给BaseExecutor执行
  return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

5.3 BaseExecutor#query#

二级缓存设置开启且缓存中没有或者未开启二级缓存，则从一级缓存中查找结果集。

@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, 
                         ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
  if (closed) {
    throw new ExecutorException("Executor was closed.");
  }
  if (queryStack == 0 && ms.isFlushCacheRequired()) {
    clearLocalCache();
  }
  List<E> list;
  try {
    queryStack++;
    // 从一级缓存中获取数据
    list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
    if (list != null) {
      handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
    } else {
      // 如果一级缓存没有数据，则从数据库查询数据
      list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }
  } finally {
    queryStack--;
  }
  if (queryStack == 0) {
    for (DeferredLoad deferredLoad : deferredLoads) {
      deferredLoad.load();
    }
    deferredLoads.clear();
    if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
      clearLocalCache();
    }
  }
  return list;
}

5.4 BaseExecutor#queryFromDatabase#

如果一级缓存没有数据，则从数据库查询数据。

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  List<E> list;
  localCache.putObject(key, EXECUTION_PLACEHOLDER);
  try {
    // 执行查询
    list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
  } finally {
    //移除一级缓存中原有值
    localCache.removeObject(key);
  }
  //往一级缓存中存值
  localCache.putObject(key, list);
  if (ms.getStatementType() == StatementType.CALLABLE) {
    localOutputParameterCache.putObject(key, parameter);
  }
  return list;
}

5.5 SimpleExecutor#doQuery#

StatementHandler 概述：

组件	简要说明	详细说明
RoutingStatementHandler	StatementHandler 的默认实现，由 RoutingStatementHandler 负责根据 StatementType 创建对应的 StatementHandler（保存到属性 delegate 中）来处理调用。	路由语句处理器，直接实现了 StatementHandler 接口，作用如其名称，确确实实只是起到了路由功能，并把上面介绍到的三个语句处理器实例作为自身的委托对象而已，所以执行器在构建语句处理器时，都是直接 new 了 RoutingStatementHandler 实例。
BaseStatementHandler	是 StatementHandler 接口的另一个实现类。本身是一个抽象类，用于简化 StatementHandler 接口实现的难度，，它主要有 3 个实现类（如下）。	基础语句处理器（抽象类），它基本把语句处理器接口的核心部分都实现了，包括配置绑定、执行器绑定、映射器绑定、参数处理器构建、结果集处理器构建、语句超时设置、语句关闭等，并另外定义了新的方法 instantiateStatement 供不同子类实现以便获取不同类型的语句连接，属于适配器设计模式体现。子类可以普通执行 SQL 语句，也可以做预编译执行，还可以执行存储过程等。
SimpleStatementHandler	管理 Statement 对象并向数据库中推送不需要预编译的 SQL 语句	普通语句处理器，继承 BaseStatementHandler 抽象类，对应 java.sql.Statement 对象的处理，处理普通的不带动态参数运行的 SQL，即执行简单拼接的字符串语句，同时由于 Statement 的特性，SimpleStatementHandler 每次执行都需要编译 SQL （注意：我们知道 SQL 的执行是需要编译和解析的）。
PreparedStatementHandler	管理 Statement 对象并向数据中推送需要预编译的 SQL 语句	预编译语句处理器，继承 BaseStatementHandler 抽象类，对应 java.sql.PrepareStatement 对象的处理，相比上面的普通语句处理器，它支持可变参数 SQL 执行，由于 PrepareStatement 的特性，它会进行预编译，在缓存中一旦发现有预编译的命令，会直接解析执行，所以减少了再次编译环节，能够有效提高系统性能，并预防 SQL 注入攻击（所以是系统默认也是我们推荐的语句处理器）。
CallableStatementHandler	管理 Statement 对象并调用数据库中的存储过程	存储过程处理器，继承 BaseStatementHandler 抽象类，对应 java.sql.CallableStatement 对象的处理，很明了，它是用来调用存储过程的，增加了存储过程的函数调用以及输出/输入参数的处理支持。

继续走源码：

@Override
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler,
        BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
        // 获取Configuration对象
        Configuration configuration = ms.getConfiguration();
        // 创建RoutingStatementHandler，用来处理Statement
        // => a. RoutingStatementHandler类中初始化delegate类（SimpleStatementHandler、PreparedStatementHandler）
        StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
        // => b. 子流程1：设置参数
        stmt = prepareStatement(handler, ms.getStatementLog());
        // => c. 子流程2：执行SQL语句（已经设置过参数），并且映射结果集
        return handler.query(stmt, resultHandler);
    } finally {
        closeStatement(stmt);
    }
}

a. Configuration#newStatementHandler#

创建 StatementHandler，用来执行 MappedStatement 对象。

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement,
    Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  // => 创建路由功能的StatementHandler，根据MappedStatement中的StatementType创建对应的 StatementHandler
  StatementHandler statementHandler = new RoutingStatementHandler(
    																				executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
  statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
  return statementHandler;
}

RoutingStatementHandler#构造函数：创建路由功能的 StatementHandler，根据 MappedStatement 中的 StatementType 创建对应的 StatementHandler。

public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, 
                               RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {

    switch (ms.getStatementType()) {
      case STATEMENT:
        delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case PREPARED:
        delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case CALLABLE:
        delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      default:
        throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
    }

}

b. SimpleExecutor#prepareStatement#

设置参数

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  // => 1. 获取连接
  Connection connection = getConnection(statementLog);
  // => 2. 创建Statement（PreparedStatement、Statement、CallableStatement）
  stmt = handler.prepare(connection, transaction.getTimeout());
  // => 3. SQL参数设置
  handler.parameterize(stmt);
  return stmt;
}

b-1. BaseExecutor#getConnection#

获取数据库连接

protected Connection getConnection(Log statementLog) throws SQLException {
    Connection connection = transaction.getConnection();
    if (statementLog.isDebugEnabled()) {
      return ConnectionLogger.newInstance(connection, statementLog, queryStack);
    } else {
      return connection;
    }
}

b-2. BaseStatementHandler#prepare#

创建 Statement（PreparedStatement、Statement、CallableStatement）

@Override
public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
  ErrorContext.instance().sql(boundSql.getSql());
  Statement statement = null;
  try {
    // => 实例化Statement，比如PreparedStatement
    statement = instantiateStatement(connection);
    // 设置查询超时时间
    setStatementTimeout(statement, transactionTimeout);
    setFetchSize(statement);
    return statement;
  } catch (SQLException e) {
    closeStatement(statement);
    throw e;
  } catch (Exception e) {
    closeStatement(statement);
    throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
  }
}

PreparedStatementHandler#instantiateStatement：实例化 PreparedStatement

@Override
protected Statement instantiateStatement(Connection connection) throws SQLException {
  // 获取带有占位符的SQL语句
  String sql = boundSql.getSql();
  // 处理带有主键返回的SQL
  if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
    String[] keyColumnNames = mappedStatement.getKeyColumns();
    if (keyColumnNames == null) {
      return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
    } else {
      return connection.prepareStatement(sql, keyColumnNames);
    }
  } else if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
    return connection.prepareStatement(sql);
  } else {
    return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
  }
}

b-3. PreparedStatementHandler#parameterize#

SQL 参数设置，参数映射流程会详细分解。

@Override
public void parameterize(Statement statement) throws SQLException {
  // 通过ParameterHandler处理参数
  parameterHandler.setParameters((PreparedStatement) statement);
}

c. PreparedStatementHandler#query#

执行 SQL 语句（已经设置过参数），并且映射结果集。

@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  PreparedStatement ps = (PreparedStatement) statement;
  // => 执行PreparedStatement，也就是执行SQL语句
  ps.execute();
  // => 处理结果集
  return resultSetHandler.handleResultSets(ps);
}

c-1. PreparedStatement#execute#

调用 JDBC 的 API 执行 Statement。

c-2. DefaultResultSetHandler#handleResultSets#

处理结果集 ，结果映射流程会详细分解。

@Override
public List<Object> handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

    // <select>标签的resultMap属性，可以指定多个值，多个值之间用逗号（,）分割
    final List<Object> multipleResults = new ArrayList<>();

    int resultSetCount = 0;
    // 这里是获取第一个结果集，将传统JDBC的ResultSet包装成一个包含结果列元信息的ResultSetWrapper对象
    ResultSetWrapper rsw = getFirstResultSet(stmt);

    // 这里是获取所有要映射的ResultMap（按照逗号分割出来的）
    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    // 要映射的ResultMap的数量
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    // 循环处理每个ResultMap，从第一个开始处理
    while (rsw != null && resultMapCount > resultSetCount) {
        // 得到结果映射信息
        ResultMap resultMap = resultMaps.get(resultSetCount);
        // 处理结果集
        // 从rsw结果集参数中获取查询结果，再根据resultMap映射信息，将查询结果映射到multipleResults中
        handleResultSet(rsw, resultMap, multipleResults, null);

        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
    }

    // 对应<select>标签的resultSets属性，一般不使用该属性
    String[] resultSets = mappedStatement.getResultSets();
    if (resultSets != null) {
        while (rsw != null && resultSetCount < resultSets.length) {
            ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
            if (parentMapping != null) {
                String nestedResultMapId = parentMapping.getNestedResultMapId();
                ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
                handleResultSet(rsw, resultMap, null, parentMapping);
            }
            rsw = getNextResultSet(stmt);
            cleanUpAfterHandlingResultSet();
            resultSetCount++;
        }
    }

    // 如果只有一个结果集合，则直接从多结果集中取出第一个
    return collapseSingleResultList(multipleResults);
}

5.6 小结#

执行 SqlSession：参数有两个（statementId 和参数对象）

1. 根据 statementId 去 Configuration 中的 MappedStatement 集合中查找对应的 MappedStatement 对象；
2. 取出 MappedStatement 中的 SQL 信息；
3. 取出 MappedStatement 中的 statementType，用来创建 Statement 对象；
   1. 取出 MappedStatement 中的 Configuration 对象，通过 Configuration 对象，获取 DataSource 对象，通过 DataSource 对象，创建 Connection，通过 Connection 创建 Statement 对象；
   2. 设置参数；
   3. 执行 Statement；
   4. 处理结果集。

6. 源码剖析-揭秘如何设置的参数？#

MyBatis 四大核心组件我们已经了解到了两种，一个是 Executor ，它是MyBatis 解析SQL请求首先会经过的第一道关卡，它的主要作用在于创建缓存，管理 StatementHandler 的调用，为 StatementHandler 提供 Configuration 环境等。

StatementHandler 组件最主要的作用在于创建 Statement 对象与数据库进行交流，还会使用 ParameterHandler 进行参数配置，使用 ResultSetHandler 把查询结果与实体类进行绑定。那么本节就来了解一下第三个组件 ParameterHandler。

6.1 ParameterHandler的创建#

ParameterHandler 相比于其他的组件就简单很多了，ParameterHandler 译为参数处理器，负责为 PreparedStatement 的 sql 语句参数动态赋值，这个接口很简单只有两个方法（如下），ParameterHandler 只有一个实现类 DefaultParameterHandler ， 它实现了这两个方法。

public interface ParameterHandler {

  // 用于读取参数
  Object getParameterObject();

  // 用于对 PreparedStatement 的参数赋值
  void setParameters(PreparedStatement ps) throws SQLException;

}

参数处理器对象是在创建 StatementHandler 对象的同时被创建的，由 Configuration 对象负责创建。

protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, 
                               RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  this.configuration = mappedStatement.getConfiguration();
  this.executor = executor;
  this.mappedStatement = mappedStatement;
  this.rowBounds = rowBounds;

  this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
  this.objectFactory = configuration.getObjectFactory();

  if (boundSql == null) {
    generateKeys(parameterObject);
    boundSql = mappedStatement.getBoundSql(parameterObject);
  }

  this.boundSql = boundSql;

  // 创建参数处理器
  this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
  // 创建结果映射器
  this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, 
                                                            parameterHandler, resultHandler, boundSql);
}

在创建 ParameterHandler 时，需要传入 SQL 的 mappedStatement 对象，读取的参数和 SQL 语句。

注意：一个 BoundSql 对象，就代表了一次 SQL 语句的实际执行，而 SqlSource 对象的责任，就是根据传入的参数对象，动态计算这个 BoundSql， 也就是 Mapper 文件中节点的计算，是由 SqlSource 完成的，SqlSource 最常用的实现类是 DynamicSqlSource。

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
  // 创建ParameterHandler
  ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
  parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
  return parameterHandler;
}

上面是 Configuration 创建 ParameterHandler 的过程，它实际上是交由 LanguageDriver 来创建具体的参数处理器，LanguageDriver 默认的实现类是 XMLLanguageDriver，由它调用 DefaultParameterHandler 中的构造方法完成 ParameterHandler 的创建工作。

public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
  return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
}

public DefaultParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
  this.mappedStatement = mappedStatement;
  this.configuration = mappedStatement.getConfiguration();
  // 获取 TypeHandlerRegistry 注册
  this.typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
  this.parameterObject = parameterObject;
  this.boundSql = boundSql;
}

6.2 PreparedStatementHandler#parameterize#

设置 PreparedStatement 的参数

@Override
public void parameterize(Statement statement) throws SQLException {
  // 通过 ParameterHandler 处理参数
  parameterHandler.setParameters((PreparedStatement) statement);
}

6.3 DefaultParameterHandler#setParameters#

@Override
public void setParameters(PreparedStatement ps) {
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    // 获取要设置的参数映射信息
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
        for (int i = 0; i < parameterMappings.size(); i++) {
            ParameterMapping parameterMapping = parameterMappings.get(i);
            // 只处理入参
            if (parameterMapping.getMode() != ParameterMode.OUT) {
                Object value;
                // 获取属性名称（#{}中的属性名）
                String propertyName = parameterMapping.getProperty();
                if (boundSql.hasAdditionalParameter(propertyName)) {
                    value = boundSql.getAdditionalParameter(propertyName);
                } else if (parameterObject == null) {
                    value = null;
                } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                    value = parameterObject;
                } else {
                    MetaObject metaObject = configuration.newMetaObject(parameterObject);
                    value = metaObject.getValue(propertyName);
                }
                // 获取每个参数的类型处理器，去设置入参和获取返回值
                TypeHandler typeHandler = parameterMapping.getTypeHandler();
                // 获取每个参数的JdbcType
                JdbcType jdbcType = parameterMapping.getJdbcType();
                if (value == null && jdbcType == null) {
                    jdbcType = configuration.getJdbcTypeForNull();
                }
                try {
                    // => 给PreparedStatement设置参数
                    typeHandler.setParameter(ps, i + 1, value, jdbcType);
                } catch (TypeException e) {
                    throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                } catch (SQLException e) {
                    throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                }
            }
        }
    }
}

6.4 BaseTypeHandler#setParameter#

给 PreparedStatement 设置参数

@Override
public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
    if (parameter == null) {
        if (jdbcType == null) {
            throw new TypeException(
                    "JDBC requires that the JdbcType must be specified for all nullable parameters.");
        }
        try {
            ps.setNull(i, jdbcType.TYPE_CODE);
        } catch (SQLException e) {
            throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . "
                + "Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. "
                + "Cause: " + e, e);
        }
    } else {
        try {
            // => 通过PreparedStatement的API去设置非空参数
            setNonNullParameter(ps, i, parameter, jdbcType);
        } catch (Exception e) {
            throw new TypeException("Error setting non null for parameter #" + i + " with JdbcType " + jdbcType
                + " . "
                + "Try setting a different JdbcType for this parameter or a different configuration property. "
                + "Cause: " + e, e);
        }
    }
}

6.5 xxxTypeHandler#setNonNullParameter#

通过 PreparedStatement 的 API 去设置非空参数，例如：ArrayTypeHandler。

@Override
public void setNonNullParameter(PreparedStatement ps, int i, Object parameter, JdbcType jdbcType) throws SQLException {
    ps.setArray(i, (Array) parameter);
}

7. 源码剖析-结果集映射流程#

如下均为 DefaultResultSetHandler 下的方法

7.1 handleResultSets#

从 rsw 结果集参数中获取查询结果，再根据 resultMap 映射信息，将查询结果映射到 multipleResults 中。

@Override
public List<Object> handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

    // <select>标签的resultMap属性，可以指定多个值，多个值之间用逗号（,）分割
    final List<Object> multipleResults = new ArrayList<>();

    int resultSetCount = 0;
    // 这里是获取第一个结果集，将传统JDBC的ResultSet包装成一个包含结果列元信息的ResultSetWrapper对象
    ResultSetWrapper rsw = getFirstResultSet(stmt);

    // 这里是获取所有要映射的ResultMap（按照逗号分割出来的）
    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    // 要映射的ResultMap的数量
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    // 循环处理每个ResultMap，从第一个开始处理
    while (rsw != null && resultMapCount > resultSetCount) {
        // 得到结果映射信息
        ResultMap resultMap = resultMaps.get(resultSetCount);
        // 处理结果集
        // => 从rsw结果集参数中获取查询结果，再根据resultMap映射信息，将查询结果映射到multipleResults中
        handleResultSet(rsw, resultMap, multipleResults, null);

        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
    }

    // 对应<select>标签的resultSets属性，一般不使用该属性
    String[] resultSets = mappedStatement.getResultSets();
    if (resultSets != null) {
        while (rsw != null && resultSetCount < resultSets.length) {
            ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
            if (parentMapping != null) {
                String nestedResultMapId = parentMapping.getNestedResultMapId();
                ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
                handleResultSet(rsw, resultMap, null, parentMapping);
            }
            rsw = getNextResultSet(stmt);
            cleanUpAfterHandlingResultSet();
            resultSetCount++;
        }
    }

    // 如果只有一个结果集合，则直接从多结果集中取出第一个
    return collapseSingleResultList(multipleResults);
}

7.2 handleRowValues#

处理行数据，其实就是完成结果映射。

public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler,
        RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    // 是否有内置嵌套的结果映射
    if (resultMap.hasNestedResultMaps()) {
        ensureNoRowBounds();
        checkResultHandler();
        // 嵌套结果映射
        handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {
        // => 简单结果映射
        handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
}

7.3 handleRowValuesForSimpleResultMap#

简单结果映射

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap,
        ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
    // 获取结果集信息
    ResultSet resultSet = rsw.getResultSet();
    // 使用rowBounds的分页信息，进行逻辑分页（也就是在内存中分页）
    skipRows(resultSet, rowBounds);
    while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
        // 通过<resultMap>标签的子标签<discriminator>对结果映射进行鉴别
        ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
        // => 将查询结果封装到POJO中
        Object rowValue = getRowValue(rsw, discriminatedResultMap, null);
        // 处理对象嵌套的映射关系
        storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
    }
}

7.4 getRowValue#

将查询结果封装到 POJO 中

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
    // 延迟加载的映射信息
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
    // => a. 创建要映射的PO类对象
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
        final MetaObject metaObject = configuration.newMetaObject(rowValue);
        boolean foundValues = this.useConstructorMappings;
        // 是否应用自动映射，也就是通过resultType进行映射
        if (shouldApplyAutomaticMappings(resultMap, false)) {
            // => b. 根据columnName和type属性名映射赋值
            foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
        }
        // 根据我们配置ResultMap的column和property映射赋值
        // => c. 如果映射存在nestedQueryId，会调用getNestedQueryMappingValue方法获取返回值
        foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
        foundValues = lazyLoader.size() > 0 || foundValues;
        rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
    }
    return rowValue;
}

a. createResultObject#

创建映射结果对象

private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader,
        String columnPrefix) throws SQLException {
    this.useConstructorMappings = false; // reset previous mapping result
    final List<Class<?>> constructorArgTypes = new ArrayList<>();
    final List<Object> constructorArgs = new ArrayList<>();
    // => 创建结果映射的PO类对象
    Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);
    if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
        // 获取要映射的PO类的属性信息
        final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
        for (ResultMapping propertyMapping : propertyMappings) {
            // 延迟加载处理
            if (propertyMapping.getNestedQueryId() != null && propertyMapping.isLazy()) {
                // 通过动态代理工厂，创建延迟加载的代理对象
                resultObject = configuration.getProxyFactory().createProxy(resultObject, lazyLoader, configuration,
                        objectFactory, constructorArgTypes, constructorArgs);
                break;
            }
        }
    }
    this.useConstructorMappings = resultObject != null && !constructorArgTypes.isEmpty();
    return resultObject;
}

private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, List<Class<?>> constructorArgTypes,
        List<Object> constructorArgs, String columnPrefix) throws SQLException {
    final Class<?> resultType = resultMap.getType();
    final MetaClass metaType = MetaClass.forClass(resultType, reflectorFactory);
    final List<ResultMapping> constructorMappings = resultMap.getConstructorResultMappings();
    if (hasTypeHandlerForResultObject(rsw, resultType)) {
        return createPrimitiveResultObject(rsw, resultMap, columnPrefix);
    } else if (!constructorMappings.isEmpty()) {
        return createParameterizedResultObject(rsw, resultType, constructorMappings, constructorArgTypes,
                constructorArgs, columnPrefix);
    } else if (resultType.isInterface() || metaType.hasDefaultConstructor()) {
        // 对象工厂创建对象
        return objectFactory.create(resultType);
    } else if (shouldApplyAutomaticMappings(resultMap, false)) {
        return createByConstructorSignature(rsw, resultType, constructorArgTypes, constructorArgs, columnPrefix);
    }
    throw new ExecutorException("Do not know how to create an instance of " + resultType);
}

b. applyAutomaticMappings#

根据 columnName 和 type 属性名映射赋值。

private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject,
        String columnPrefix) throws SQLException {
    List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
    boolean foundValues = false;
    if (!autoMapping.isEmpty()) {
        for (UnMappedColumnAutoMapping mapping : autoMapping) {
            final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
            if (value != null) {
                foundValues = true;
            }
            if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
                // gcode issue #377, call setter on nulls (value is not 'found')
                metaObject.setValue(mapping.property, value);
            }
        }
    }
    return foundValues;
}

c. applyPropertyMappings#

根据我们配置 ResultMap 的 column 和 property 映射赋值，如果映射存在 nestedQueryId，会调用 getNestedQueryMappingValue 方法获取返回值。

private boolean applyPropertyMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject,
        ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {
    final List<String> mappedColumnNames = rsw.getMappedColumnNames(resultMap, columnPrefix);
    boolean foundValues = false;
    final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
    for (ResultMapping propertyMapping : propertyMappings) {
        String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
        if (propertyMapping.getNestedResultMapId() != null) {
            // the user added a column attribute to a nested result map, ignore it
            column = null;
        }
        if (propertyMapping.isCompositeResult()
                || (column != null && mappedColumnNames.contains(column.toUpperCase(Locale.ENGLISH)))
                || propertyMapping.getResultSet() != null) {
            Object value = getPropertyMappingValue(rsw.getResultSet(), metaObject, propertyMapping, lazyLoader,
                    columnPrefix);
            // issue #541 make property optional
            final String property = propertyMapping.getProperty();
            if (property == null) {
                continue;
            } else if (value == DEFERRED) {
                foundValues = true;
                continue;
            }
            if (value != null) {
                foundValues = true;
            }
            if (value != null || (configuration.isCallSettersOnNulls()
                    && !metaObject.getSetterType(property).isPrimitive())) {
                metaObject.setValue(property, value);
            }
        }
    }
    return foundValues;
}

8. 源码剖析-获取Mapper代理对象流程#

8.1 DefaultSqlSession#getMapper#

从 Configuration 对象中，根据 Mapper 接口，获取 Mapper 代理对象。

@Override
public <T> T getMapper(Class<T> type) {
    // 从Configuration对象中，根据Mapper接口获取Mapper代理对象
    return configuration.<T>getMapper(type, this);
}

8.2 Configuration#getMapper#

获取 Mapper 代理对象

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
}

8.3 MapperRegistry#getMapper#

通过代理对象工厂，获取代理对象。

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  // 根据Mapper接口的类型，从Map集合中获取Mapper代理对象工厂
  final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
  if (mapperProxyFactory == null) {
    throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
  }
  try {
    // => 通过MapperProxyFactory生产MapperProxy，通过MapperProxy产生Mapper代理对象
    return mapperProxyFactory.newInstance(sqlSession);
  } catch (Exception e) {
    throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  }
}

8.4 MapperProxyFactory#newInstance#

调用JDK的动态代理方式，创建Mapper代理

// 1
protected T newInstance(MapperProxy<T> mapperProxy) {
  // 使用JDK动态代理方式，生成代理对象
  return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}

// 2
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  // 根据Mapper接口的类型，从Map集合中获取Mapper代理对象工厂
  final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
  if (mapperProxyFactory == null) {
    throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
  }
  try {
    // 通过MapperProxyFactory生产MapperProxy，通过MapperProxy产生Mapper代理对象
    return mapperProxyFactory.newInstance(sqlSession);
  } catch (Exception e) {
    throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  }
}

8.5 MapperProxy#invoke#

在动态代理返回了实例后，我们就可以直接调用 mapper 类中的方法了，但代理对象调用方法，执行是在 MapperProxy 中的 invoke 方法，该类实现 InvocationHandler 接口，并重写 invoke() 方法。

// 通过JDK动态代理生成并获取代理对象       
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 代理对象对象调用方法，底层执行invoke方法       
List<User> allUser = userMapper.findAllUser();

问题：invoke 方法执行逻辑是什么？

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
        // 如果是 Object 定义的方法，直接调用
        if (Object.class.equals(method.getDeclaringClass())) {
            return method.invoke(this, args);

        } else if (isDefaultMethod(method)) {
            return invokeDefaultMethod(proxy, method, args);
        }
    } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
    }
    // 获得 MapperMethod 对象
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    // !!! MapperMethod最终调用了执行的方法
    return mapperMethod.execute(sqlSession, args);
}

8.6 MapperMethod#execute#

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    // 判断mapper中的方法类型，最终调用的还是SqlSession中的方法
    switch (command.getType()) {
        case INSERT: {
            // 转换参数
            Object param = method.convertArgsToSqlCommandParam(args);
            // 执行 INSERT 操作
            // 转换 rowCount
            result = rowCountResult(sqlSession.insert(command.getName(), param));
            break;
        }
        case UPDATE: {
            // 转换参数
            Object param = method.convertArgsToSqlCommandParam(args);
            // 转换 rowCount
            result = rowCountResult(sqlSession.update(command.getName(), param));
            break;
        }
        case DELETE: {
            // 转换参数
            Object param = method.convertArgsToSqlCommandParam(args);
            // 转换 rowCount
            result = rowCountResult(sqlSession.delete(command.getName(), param));
            break;
        }
        case SELECT:
            // 无返回，并且有 ResultHandler 方法参数，则将查询的结果，提交给 ResultHandler 进行处理
            if (method.returnsVoid() && method.hasResultHandler()) {
                executeWithResultHandler(sqlSession, args);
                result = null;
            // 执行查询，返回列表
            } else if (method.returnsMany()) {
                result = executeForMany(sqlSession, args);
            // 执行查询，返回 Map
            } else if (method.returnsMap()) {
                result = executeForMap(sqlSession, args);
            // 执行查询，返回 Cursor
            } else if (method.returnsCursor()) {
                result = executeForCursor(sqlSession, args);
            // 执行查询，返回单个对象
            } else {
                // 转换参数
                Object param = method.convertArgsToSqlCommandParam(args);
                // 查询单条
                result = sqlSession.selectOne(command.getName(), param);
                if (method.returnsOptional() &&
                        (result == null || !method.getReturnType().equals(result.getClass()))) {
                    result = Optional.ofNullable(result);
                }
            }
            break;
        case FLUSH:
            result = sqlSession.flushStatements();
            break;
        default:
            throw new BindingException("Unknown execution method for: " + command.getName());
    }
    // 返回结果为 null ，并且返回类型为基本类型，则抛出 BindingException 异常
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
        throw new BindingException("Mapper method '" + command.getName()
                + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    // 返回结果
    return result;
}

9. 源码剖析-插件机制#

9.1 插件概述#

什么是 Mybatis 插件？有什么作用？

一般开源框架都会提供扩展点，让开发者自行扩展，从而完成逻辑的增强。

基于插件机制可以实现了很多有用的功能，比如说分页，字段加密，监控等功能，这种通用的功能，就如同 AOP 一样，横切在数据操作上。而通过 Mybatis 插件可以实现对框架的扩展，来实现自定义功能，并且对于用户是无感知的。

Mybatis 插件本质上来说就是一个拦截器，它体现了 JDK 动态代理和责任链设计模式的综合运用。

Mybatis 中针对四大组件提供了扩展机制，这四个组件分别是：

Mybatis 中所允许拦截的方法如下：

• Executor【SQL 执行器】【update,query,commit,rollback】
• StatementHandler【SQL 语法构建器对象】【prepare,parameterize,batch,update,query等】
• ParameterHandler【参数处理器】【getParameterObject,setParameters等】
• ResultSetHandler【结果集处理器】【handleResultSets,handleOuputParameters等】

能干什么？

• 分页功能：Mybatis 的分页默认是基于内存分页的（查出所有再截取），数据量大的情况下效率较低，不过使用 Mybatis 插件可以改变该行为，只需要拦截 StatementHandler 类的 prepare 方法，改变要执行的 SQL 语句为分页语句即可。
• 性能监控：对于 SQL 语句执行的性能监控，可以通过拦截 Executor 类的 update、query 等方法，用日志记录每个方法执行的时间。

9.2 如何自定义插件#

在使用之前，我们先来看看Mybatis提供的插件相关的类，过一遍它们分别提供了哪些功能，最后我们自己定义一个插件。

前面已经知道 Mybatis 插件是可以对 Mybatis 中四大组件对象的方法进行拦截，那拦截器拦截哪个类的哪个方法如何知道，就由下面这个注解提供拦截信息。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Intercepts {  
  Signature[] value();
}

由于一个拦截器可以同时拦截多个对象的多个方法，所以就使用了 Signture 数组，该注解定义了拦截的完整信息。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({})
public @interface Signature {
  // 拦截的类
  Class<?> type();
  // 拦截的方法
  String method();
  // 拦截方法的参数    
  Class<?>[] args();
} 

已经知道了该拦截哪些对象的哪些方法，拦截后要干什么就需要实现 Intercetor#intercept 方法，在这个方法里面实现拦截后的处理逻辑。

public interface Interceptor {
  /**
   * 真正方法被拦截执行的逻辑
   *
   * @param invocation 主要目的是将多个参数进行封装
   */
  Object intercept(Invocation invocation) throws Throwable;
    
  // 生成目标对象的代理对象
  default Object plugin(Object target) {
    return Plugin.wrap(target, this);
  }
  
  // 可以拦截器设置一些属性
  default void setProperties(Properties properties) {
    // NOP
  }
}

案例：把 Mybatis 所有执行的 SQL 都记录下来

步骤：

1. 创建 Interceptor 的实现类，重写方法；
2. 使用 @Intercepts 注解完成插件签名，说明插件的拦截四大对象之一的哪一个对象的哪一个方法
3. 将写好的插件注册到全局配置文件中

① 创建 Interceptor 的实现类

public class MyPlugin implements Interceptor {

  private final Logger logger = LoggerFactory.getLogger(this.getClass());

  /** 这里是每次执行操作的时候，都会进行这个拦截器的方法内 */
  @Override
  public Object intercept(Invocation invocation) throws Throwable {
    StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
    BoundSql boundSql = statementHandler.getBoundSql();
    String sql = boundSql.getSql();
    logger.info("mybatis intercept sql: {}", sql);
    return invocation.proceed(); // 执行原方法 
  } 

  /**
  * 包装目标对象 为目标对象创建代理对象
  * @Param  要拦截的对象
  * @Return 代理对象
  */
  @Override 
  public Object plugin(Object target) {
    System.out.println("将要包装的目标对象：" + target); 
    return Plugin.wrap(target, this);
  }

  /** 插件初始化的时候调用，也只调用一次，插件配置的属性从这里设置进来 */
  @Override
  public void setProperties(Properties properties) {
  	System.out.println("插件配置的初始化参数：" + properties );
  }
}

② 使用 @Intercepts 注解完成插件签名来说明插件的拦截四大对象之一的哪一个对象的哪一个方法

@Intercepts({ @Signature(type = StatementHandler.class, 
                         method = "prepare", 
                         args = { Connection.class, Integer.class}) })
public class SQLStatsInterceptor implements Interceptor {

③ 将写好的插件注册到全局配置文件中

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <plugins>
        <plugin interceptor="com.itheima.interceptor.MyPlugin">
            <property name="dialect" value="mysql" />
        </plugin>
    </plugins>
</configuration>

【核心思想】就是使用 JDK 动态代理的方式，对这四个对象进行包装增强。具体的做法是，创建一个类实现 Mybatis 的拦截器接口，并且加入到拦截器链中，在创建核心对象的时候，不直接返回，而是遍历拦截器链，把每一个拦截器都作用于核心对象中。这么一来，Mybatis 创建的核心对象其实都是代理对象，都是被包装过的。

9.3 源码分析#

插件对象是如何实例化的？ 插件的实例对象如何添加到拦截器链中的？ 组件对象的代理对象是如何产生的？

a. 插件配置信息的加载#

我们定义好了一个拦截器，那我们怎么告诉Mybatis呢？Mybatis所有的配置都定义在配置文件中。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <plugins>
        <plugin interceptor="com.itheima.interceptor.MyPlugin">
            <property name="dialect" value="mysql" />
        </plugin>
    </plugins>
</configuration>

对应的解析代码如下（XMLConfigBuilder#pluginElement）：

private void pluginElement(XNode parent) throws Exception {
  if (parent != null) {
    for (XNode child : parent.getChildren()) {
      // 获取拦截器
      String interceptor = child.getStringAttribute("interceptor");
      // 获取配置的Properties属性
      Properties properties = child.getChildrenAsProperties();
      // 根据配置文件中配置的插件类的全限定名 进行反射初始化
      Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).getDeclaredConstructor().newInstance();
      // 将属性添加到Intercepetor对象
      interceptorInstance.setProperties(properties);
      // 添加到配置类的InterceptorChain属性，InterceptorChain类维护了一个List<Interceptor>
      configuration.addInterceptor(interceptorInstance);
    }
  }
}

主要做了以下工作：

1. 遍历解析 plugins 标签下每个 plugin 标签
2. 根据解析的类信息创建 Interceptor 对象
3. 调用 setProperties 方法设置属性
4. 将拦截器添加到 Configuration 类的 IntercrptorChain 拦截器链中

对应时序图如下：

b. 代理对象的生成#

Executor 代理对象（Configuration#newExecutor）

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
  executorType = executorType == null ? defaultExecutorType : executorType;
  executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
  Executor executor;
  if (ExecutorType.BATCH == executorType) {
    executor = new BatchExecutor(this, transaction);
  } else if (ExecutorType.REUSE == executorType) {
    executor = new ReuseExecutor(this, transaction);
  } else {
    executor = new SimpleExecutor(this, transaction);
  }
  if (cacheEnabled) {
    executor = new CachingExecutor(executor);
  }
  // 生成Executor代理对象逻辑
  executor = (Executor) interceptorChain.pluginAll(executor);
  return executor;
}

ParameterHandler 代理对象（Configuration#newParameterHandler）

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
    // 生成ParameterHandler代理对象逻辑 
    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
    return parameterHandler;
}

ResultSetHandler 代理对象（Configuration#newResultSetHandler）

public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, 
                                            ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) {
    ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, 
                                                                      resultHandler, boundSql, rowBounds);
    // 生成ResultSetHandler代理对象逻辑
    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
    return resultSetHandler;
}

StatementHandler 代理对象（Configuration#newStatementHandler）

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, 
                                            RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    // 生成StatementHandler代理对象逻辑
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
}

通过查看源码会发现，所有代理对象的生成都是通过 InterceptorChain#pluginAll 方法来创建的，进一步查看 pluginAll 方法：

public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
        target = interceptor.plugin(target);
    }
    return target;
}

InterceptorChain#pluginAll 内部通过遍历 Interceptor#plugin 方法来创建代理对象，并将生成的代理对象又赋值给 target，如果存在多个拦截器的话，生成的代理对象会被另一个代理对象所代理，从而形成一个代理链，执行的时候，依次执行所有拦截器的拦截逻辑代码，再跟进去。

default Object plugin(Object target) {
    return Plugin.wrap(target, this);
}

Interceptor#plugin 方法最终将目标对象和当前的拦截器交给 Plugin.wrap 方法来创建代理对象。该方法是默认方法，是 Mybatis 框架提供的一个典型 plugin 方法的实现。

public static Object wrap(Object target, Interceptor interceptor) {
    // 1.解析该拦截器所拦截的所有接口及对应拦截接口的方法
    Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
    Class<?> type = target.getClass();
    // 2.获取目标对象实现的所有被拦截的接口
    Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
    // 3.目标对象有实现被拦截的接口，生成代理对象并返回
    if (interfaces.length > 0) {
        // 通过JDK动态代理的方式实现
      return Proxy.newProxyInstance(
          type.getClassLoader(),
          interfaces,
          new Plugin(target, interceptor, signatureMap));
    }
    // 目标对象没有实现被拦截的接口，直接返回原对象
    return target;

}

最终我们看到其实是通过 JDK 提供的 Proxy.newProxyInstance 方法来生成代理对象。以上代理对象生成过程的时序图如下。

c. 拦截逻辑的执行#

通过上面的分析，我们知道Mybatis框架中执行Executor、ParameterHandler、ResultSetHandler和StatementHandler中的方法时真正执行的是代理对象对应的方法。而且该代理对象是通过JDK动态代理生成的，所以执行方法时实际上是调用InvocationHandler#invoke方法（Plugin类实现InvocationHandler接口）,下面是Plugin#invoke方法

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    Set<Method> methods = signatureMap.get(method.getDeclaringClass());
    if (methods != null && methods.contains(method)) {
      return interceptor.intercept(new Invocation(target, method, args));
    }
    return method.invoke(target, args);
  } catch (Exception e) {
    throw ExceptionUtil.unwrapThrowable(e);
  }
}

一个对象被代理很多次

问题：同一个组件对象的同一个方法是否可以被多个拦截器进行拦截？

答案是肯定的，所以我们配置在最前面的拦截器最先被代理，但是执行的时候却是最外层的（最后配置的）先执行。

举例说明。假如依次定义了三个插件：plugin1、plugin2、plugin3，那么 List 中就会按顺序存储：plugin1、plugin2、plugin3。而解析的时候是遍历 list，所以解析的时候也是按照“plugin1、plugin2、plugin3”的顺序。但是执行的时候就要反过来了，执行的时候是按照“plugin3、plugin2、plugin1”的顺序进行执行。

当 Executor 的某个方法被调用的时候，插件逻辑会先行执行。执行顺序由外而内，比如上图的执行顺序为 plugin3 → plugin2 → Plugin1 → Executor。