沿着哈勃望远，看清MyBatis整体架构

一、前言

MyBatis是目前非常流行的ORM框架，它的功能很强大，然而其实现却比较简单、优雅。本文主要讲述MyBatis的架构设计思路，并且讨论MyBatis的几个核心部件，然后结合一个select查询实例，深入代码，来探究MyBatis的实现。

二、MyBatis四层架构

MyBatis从上到下分为接口层、数据处理层、框架支撑层、引导层，如下：

接口层作用：接口层用于接收请求，调用sql语句。
接口层详细：Mybatis接口层提供两种数据库访问方式，Mybatis Statement ID访问数据库和Mapper接口访问数据库，底层都是一样的，都是新建SqlSession对象，并向其传入statementId和参数，最后使用SqlSession调动sql语句；

数据处理层作用：处理数据。
数据处理包括四个步骤：
(1) 参数映射（查询阶段，java类型的数据转换成jdbc类型的数据，通过 preparedStatement.setXXX() 来设值；返回阶段，resultset查询结果集中的 jdbcType 类型的数据转换成java类型数据）；
(2) sql语句动态生成；
(3) sql语句执行；
(4) 返回值处理（对于返回的结果集，支持结果集关系一对多和多对一的转换，并且有两种支持方式，一种为 嵌套查询语句的查询，还有一种是 嵌套结果集的查询。）

框架支撑层作用：在数据处理层下面，为数据处理提供技术支持。
技术性支持包括四个：缓存、事务、数据源与连接池、两种配置方式的支持（xml配置和注解+注解驱动）。其中，缓存包括一级缓存和二级缓存，用于select查询加速，update/delete/insert缓存即清空；事务保证一致性；连接池实现Collection连接复用；

引导层作用：位于最下面，用于引导整个mybatis启动与运行。
引导层包括两种方式：xml配置方式和Java api方式。

2.1 接口层

接口层提供MyBatis和数据库的交互两种方式：

a.使用传统的MyBatis提供的API，即statementId；

b. 使用Mapper接口

2.1.1 MyBatis使用Statement ID与数据库交互

MyBatis 提供了非常方便和简单的API，供用户实现对数据库的增删改查数据操作，以及对数据库连接信息和MyBatis 自身配置信息的维护操作，如下：

如上图所示，MyBatis使用API与数据库交互，分为两步骤：
（1）创建一个和数据库打交道的SqlSession对象
（2）根据Statement Id 和参数传递给SqlSession对象，使用 SqlSession对象完成和数据库的交互

SqlSession session = sqlSessionFactory.openSession();   // SqlSession对象
Blog blog =(Blog)session.selectOne("com.foo.bean.BlogMapper.selectByPrimaryKey",id); // statement Id

上述使用MyBatis 的方法，是创建一个和数据库打交道的SqlSession对象，然后根据Statement Id 和参数来操作数据库，这种方式固然很简单和实用，但是它不符合面向对象语言的概念和面向接口编程的编程习惯。由于面向接口的编程是面向对象的大趋势，MyBatis 为了适应这一趋势，增加了第二种使用MyBatis 支持Mapper接口调用方式。

2.1.2 Mybatis使用Mapper接口与数据库交互

Mybatis使用Mapper接口与数据库交互，符合面向对象面向接口的设计原则，步骤如下：

（1）MyBatis 将配置文件中的每一个 节点抽象为一个 Mapper 接口；

（2）Mapper接口中声明的方法和跟 节点中的 节点项对应；

（3） 节点的id值为Mapper 接口中的方法名称，parameterType 值表示Mapper 对应方法的入参类型，而resultMap 值则对应了Mapper 接口表示的返回值类型或者返回结果集的元素类型。

根据MyBatis 的配置规范配置好后，底层实际运行步骤是：

（1）实例化Mapper接口实现类：通过 SqlSession.getMapper(XXXMapper.class) 方法，MyBatis底层源码会根据相应的接口声明的方法信息，通过动态代理机制生成一个 Mapper 实例；

（2）方法名和参数列表作为方法签名（方法的唯一标识），确定statement id，底层还是使用SqlSession调用sql语句：我们使用Mapper 接口的某一个方法时，MyBatis 会根据这个方法的方法名和参数类型，确定Statement Id，底层还是使用SqlSession.select("statementId",parameterObject);或者SqlSession.update("statementId",parameterObject); 等等来实现对数据库的操作；

MyBatis 引用Mapper 接口这种调用方式两个原因：

(1) 为了满足面向接口编程的需要；
(2) 使得用户在接口上可以使用注解来配置SQL语句，这样就可以脱离XML配置文件，实现“0配置”。

小结：
Mybatis接口层提供两个数据库访问方式，Mybatis Statement ID和Mapper接口，底层都是一样的，使用mapper也是通过方法名和参数列表作为方法签名，确定statement id，使用SqlSesson调用sql语句；
接口层在整个Mybatis四层第一层，其作用是：接收请求，开始调用sql语句。

2.2 数据处理层

数据处理层可以说是MyBatis 的核心，从大的方面上讲，它要完成两四个功能：

a. 通过传入参数构建动态SQL语句；（参数映射+动态SQL语句生成）

b. SQL语句的执行以及封装查询结果集成List。（SQL执行+结果处理）

2.2.1 参数映射

参数映射指的是对于 java数据类型和jdbc数据类型之间的转换：

这里有包括两个过程：

第一，查询阶段，java类型的数据转换成jdbc类型的数据，通过 preparedStatement.setXXX() 来设值；

第二，返回阶段，resultset查询结果集中的 jdbcType 类型的数据转换成java类型数据。

2.2.2 动态SQL语句生成

动态语句生成可以说是MyBatis框架非常优雅的一个设计，MyBatis 通过传入的参数值，使用 Ognl 来动态地构造SQL语句，使得MyBatis 有很强的灵活性和扩展性。

2.2.3 SQL语句的执行

动态SQL语句生成之后，MyBatis 执行SQL语句。

2.2.4 结果处理

Mybatis执行完成SQL语句后，可能将返回的结果集转换成List 列表。

MyBatis 在对结果集的处理中，支持结果集关系一对多和多对一的转换，并且有两种支持方式，一种为 嵌套查询语句的查询，还有一种是 嵌套结果集的查询。

面试官：谈一谈你对mybatis关联查询(Mapper接口的嵌套语句查询和嵌套结果查询)的理解？

2.3 框架支撑层

2.3.1 事务管理机制

事务管理机制对于ORM框架而言是不可缺少的一部分，事务管理机制的质量也是考量一个ORM框架是否优秀的一个标准。

2.3.2 连接池管理机制

由于创建一个数据库连接所占用的资源比较大， 对于数据吞吐量大和访问量非常大的应用而言，连接池的设计就显得非常重要。

2.3.3 缓存机制

为了提高数据利用率和减小服务器和数据库的压力，MyBatis 会对于一些查询提供会话级别的数据缓存，会将对某一次查询，放置到SqlSession 中，在允许的时间间隔内，对于完全相同的查询，MyBatis 会直接将缓存结果返回给用户，而不用再到数据库中查找。

2.3.4 SQL语句的配置方式

当接口层MyBatis使用Statement ID与数据库时，框架支撑层只能使用XML配置方式；当接口层MyBatis使用Mapper接口与数据库交互时，框架支撑层可以使用XML配置方式，也可以使用注解配置方式，推荐使用注解配置方式，符合面向对象的思想，后期引入通用mapper，单表查询不再需要在mapper.xml中写sql语句。

传统的MyBatis 配置SQL 语句方式就是使用XML文件进行配置的，但是这种方式不能很好地支持面向接口编程的理念，为了支持面向接口的编程，MyBatis 引入了Mapper接口的概念，面向接口的引入，对使用注解来配置SQL 语句成为可能，用户只需要在接口上添加必要的注解即可（一般是就是@Mapper注解），不用再去配置XML文件了。

Spring中，@Service @Controller注解 + @ComponentScan扫描注解，等效于 xml配置
Mybatis中，@Mapper注解 + @MapperScan扫描注解，等效于 xml配置
总之，注解+扫描 等效于 xml配置。

2.4 引导层

引导层是配置和启动MyBatis 配置信息的方式。

MyBatis 提供两种方式来引导MyBatis ：基于XML配置文件的方式和基于Java API 的方式。

三、MyBatis的主要构件及其相互关系

从MyBatis代码实现的角度来看，MyBatis的主要的核心部件有以下几个：

组件名称	作用
SqlSession(接口层)	作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能
Executor(数据处理层-动态SQL语句生成)	MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护
StatementHandler(数据处理层-动态SQL语句生成)	封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合。
ParameterHandler(数据处理层-参数映射）	负责对用户传递的参数转换成JDBC Statement 所需要的参数
ResultSetHandler(数据处理层-结果处理与映射）	负责将JDBC返回的ResultSet结果集对象转换成List类型的集合
TypeHandler(数据处理层-参数映射)	负责java数据类型和jdbc数据类型之间的映射和转换
MappedStatement(接口层)	MappedStatement维护了一条节点的封装
SqlSource(数据处理层-SQL解析)	负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
BoundSql(数据处理层-动态SQL语句生成)	表示动态生成的SQL语句以及相应的参数信息
Configuration(全家配置)	MyBatis所有的配置信息都维持在Configuration对象之中。

注：这里只是列出了我个人认为属于核心的部件，请读者不要先入为主，认为MyBatis就只有这些部件哦！每个人对MyBatis的理解不同，分析出的结果自然会有所不同，欢迎读者提出质疑和不同的意见，我们共同探讨。它们的关系如下图所示：

mybatis和jdbc是两个不同的东西

(1) mybatis是服务端程序的一个ORM框架，对象关系映射框架，上图中只解释mybatis十个组件，不解释jdbc的组件。

(2) jdbc是java database connection，java数据库连接工具，只用于java语句，但是可以连接不同数据库，一般是mysql。

mybatis在服务端程序的下面，jdbc在数据库的上面，所以上图中，mybatis在上面，jdbc在下面。

四、从MyBatis一次select 查询语句来分析MyBatis的架构设计

4.1 从宏观的角度看

4.1.1 数据库数据准备

   --创建一个员工基本信息表
    create  table "EMPLOYEES"(
        "EMPLOYEE_ID" NUMBER(6) not null,
       "FIRST_NAME" VARCHAR2(20),
       "LAST_NAME" VARCHAR2(25) not null,
       "EMAIL" VARCHAR2(25) not null unique,
       "SALARY" NUMBER(8,2),
        constraint "EMP_EMP_ID_PK" primary key ("EMPLOYEE_ID")
    );
    comment on table EMPLOYEES is '员工信息表';
    comment on column EMPLOYEES.EMPLOYEE_ID is '员工id';
    comment on column EMPLOYEES.FIRST_NAME is 'first name';
    comment on column EMPLOYEES.LAST_NAME is 'last name';
    comment on column EMPLOYEES.EMAIL is 'email address';
    comment on column EMPLOYEES.SALARY is 'salary';
    
    --添加数据
	insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY)
	values (100, 'Steven', 'King', 'SKING', 24000.00);
	
	insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY)
	values (101, 'Neena', 'Kochhar', 'NKOCHHAR', 17000.00);
	
	insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY)
	values (102, 'Lex', 'De Haan', 'LDEHAAN', 17000.00);
	
	insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY)
	values (103, 'Alexander', 'Hunold', 'AHUNOLD', 9000.00);
	
	insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY)
	values (104, 'Bruce', 'Ernst', 'BERNST', 6000.00);
	
	insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY)
	values (105, 'David', 'Austin', 'DAUSTIN', 4800.00);
	
	insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY)
	values (106, 'Valli', 'Pataballa', 'VPATABAL', 4800.00);
	
	insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY)
	values (107, 'Diana', 'Lorentz', 'DLORENTZ', 4200.00);    

4.1.2 Mybatis配置文件

配置文件一般命名为mybatisConfig.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">
      <transactionManager type="JDBC" />
      <dataSource type="POOLED">
	 <property name="driver" value="oracle.jdbc.driver.OracleDriver" />  
         <property name="url" value="jdbc:oracle:thin:@localhost:1521:xe" />  
         <property name="username" value="louis" />  
         <property name="password" value="123456" />
      </dataSource>
    </environment>
  </environments>
    <mappers>
       <mapper  resource="com/louis/mybatis/domain/EmployeesMapper.xml"/>
    </mappers>
</configuration>

mapper的识别两种方式：
mybatisConfig.xml中配置 或者 @Mapper注解+@MapperScan注解

4.1.3 参数映射

POJO+XxxMapper.java+XxxMapper.xml

package com.louis.mybatis.model;
 
import java.math.BigDecimal;
 
public class Employee {
     
    private Integer employeeId;
 
    private String firstName;
 
    private String lastName;
 
    private String email;
 
    private BigDecimal salary;
 
    public Integer getEmployeeId() {
     
        return employeeId;
    }
 
    public void setEmployeeId(Integer employeeId) {
     
        this.employeeId = employeeId;
    }
 
    public String getFirstName() {
     
        return firstName;
    }
 
    public void setFirstName(String firstName) {
     
        this.firstName = firstName;
    }
 
    public String getLastName() {
     
        return lastName;
    }
 
    public void setLastName(String lastName) {
     
        this.lastName = lastName;
    }
 
    public String getEmail() {
     
        return email;
    }
 
    public void setEmail(String email) {
     
        this.email = email;
    }
 
    public BigDecimal getSalary() {
     
        return salary;
    }
 
    public void setSalary(BigDecimal salary) {
     
        this.salary = salary;
    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.louis.mybatis.dao.EmployeesMapper" >
 
  <resultMap id="BaseResultMap" type="com.louis.mybatis.model.Employee" >
    <id column="EMPLOYEE_ID" property="employeeId" jdbcType="DECIMAL" />
    <result column="FIRST_NAME" property="firstName" jdbcType="VARCHAR" />
    <result column="LAST_NAME" property="lastName" jdbcType="VARCHAR" />
    <result column="EMAIL" property="email" jdbcType="VARCHAR" />
    <result column="SALARY" property="salary" jdbcType="DECIMAL" />
  </resultMap>
  
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select 
    	EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY
    	from LOUIS.EMPLOYEES
    	where EMPLOYEE_ID = #{employeeId,jdbcType=DECIMAL}
  </select>
</mapper>

XxxMapper.xml中用来写sql语句，使用通用mapper之后，单表查询不用在写XxxMapper.xml中写sql语句了。

4.1.4 相关依赖

pom.xml中，导入mybatis和jdbc依赖，如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
 
  <groupId>batis</groupId>
  <artifactId>batis</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>
 
  <name>batis</name>
  <url>http://maven.apache.org</url>
 
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
 
    <dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.7</version>
	</dependency>
    
	<dependency>
		<groupId>com.oracle</groupId>
		<artifactId>ojdbc14</artifactId>
		<version>10.2.0.4.0</version>
	</dependency>
    
  </dependencies>
</project>

4.1.5 客户端代码

package com.louis.mybatis.test;
 
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 
import com.louis.mybatis.model.Employee;
 
/**
 * SqlSession 简单查询演示类
 * @author louluan
 */
public class SelectDemo {
     
 
	public static void main(String[] args) throws Exception {
     
		/*
		 * 1.加载mybatis的配置文件，初始化mybatis，创建出SqlSessionFactory，是创建SqlSession的工厂
		 * 这里只是为了演示的需要，SqlSessionFactory临时创建出来，在实际的使用中，SqlSessionFactory只需要创建一次，当作单例来使用
		 */
		InputStream inputStream = Resources.getResourceAsStream("mybatisConfig.xml");
		SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
		SqlSessionFactory factory = builder.build(inputStream);
		
		//2. 从SqlSession工厂 SqlSessionFactory中创建一个SqlSession，进行数据库操作
		SqlSession sqlSession = factory.openSession();
	
		//3.使用SqlSession查询
		Map<String,Object> params = new HashMap<String,Object>();
		
		params.put("min_salary",10000);
		//a.查询工资低于10000的员工
		List<Employee> result = sqlSession.selectList("com.louis.mybatis.dao.EmployeesMapper.selectByMinSalary",params);
		//b.未传最低工资，查所有员工
		List<Employee> result1 = sqlSession.selectList("com.louis.mybatis.dao.EmployeesMapper.selectByMinSalary");
		System.out.println("薪资低于10000的员工数："+result.size());
		//~output :   查询到的数据总数：5  
		System.out.println("所有员工数: "+result1.size());
		//~output :  所有员工数: 8
	}
 
}

从4.1.1到4.1.5，表设计、mybatisConfig.xml（mapper的两种方式，xml中配置或者@Mapper+@MapperScan）、POJO+XxxMapper.java+XxxMapper.xml(使用通用mapper,单表操作不用写sql语句)、依赖导入（mybatis依赖和jdbc依赖）、客户端代码（从配置文件得到InputStream，然后SqlSessionFactoryBuilder、然后SqlSessionFactory、然后SqlSession、传入statementid和参数，执行sql语句，拿到结果集）

4.2 从源码的角度看mybatis查询

这里介绍SqlSession的整个工作过程

4.2.1 开启一个数据库访问会话

我们所说的开启一个数据库访问会话，代码实现就是创建SqlSession对象，如下：

SqlSession sqlSession = factory.openSession();

MyBatis封装了对数据库的访问，把对数据库的会话和事务控制放到了SqlSession对象中。

如上图所示，SqlSession中两个内容：事务控制+数据查询。事务控制就是commit和rollback，数据查询就是 select update insert delete。

4.2.2 SqlSession组件

SqlSession对象调用selectList方法，传递一个配置Sql语句的StatementId和参数，然后返回结果，代码如下：

List<Employee> result = sqlSession.selectList("com.louis.mybatis.dao.EmployeesMapper.selectByMinSalary",params);

上述的"com.louis.mybatis.dao.EmployeesMapper.selectByMinSalary"，是配置在EmployeesMapper.xml 的Statement ID，params 是传递的查询参数。

注意：这里是statementId就是 类名+方法名

让我们来看一下sqlSession.selectList()方法的定义：

  public <E> List<E> selectList(String statement, Object parameter) {
     
    return this.selectList(statement, parameter, RowBounds.DEFAULT);
  }
 
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
     
    try {
     
      //1.根据Statement Id，在mybatis配置对象Configuration中查找和配置文件相对应的MappedStatement	
      MappedStatement ms = configuration.getMappedStatement(statement);
      //2. 将查询任务委托给MyBatis 的执行器 Executor
      List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
      return result;
    } catch (Exception e) {
     
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
     
      ErrorContext.instance().reset();
    }
  }

MyBatis在初始化的时候，会将MyBatis的配置信息全部加载到内存中，使用org.apache.ibatis.session.Configuration实例来维护。使用者可以使用sqlSession.getConfiguration()方法来获取。MyBatis的配置文件中配置信息的组织格式和内存中对象的组织格式几乎完全对应的。上述例子中的

  <select id="selectByMinSalary" resultMap="BaseResultMap" parameterType="java.util.Map" >
    select 
    	EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY
    	from LOUIS.EMPLOYEES
    	<if test="min_salary != null">
    		where SALARY < #{min_salary,jdbcType=DECIMAL}
    	</if>
  </select>

加载到内存中会生成一个对应的MappedStatement对象，然后会以key=“com.louis.mybatis.dao.EmployeesMapper.selectByMinSalary” ，value为MappedStatement对象的形式维护到Configuration的一个Map中。当以后需要使用的时候，只需要通过Id值来获取就可以了。

从上述的代码中我们可以看到SqlSession的职能是：SqlSession根据Statement ID, 在mybatis配置对象Configuration中获取到对应的MappedStatement对象，然后调用mybatis执行器Executor来执行具体的操作，代码如下：

 //1.根据Statement Id，在mybatis 配置对象Configuration中查找和配置文件相对应的MappedStatement，Configuration里面是key,value,这里根据key得到value
MappedStatement ms = configuration.getMappedStatement(statement);
//2. 将查询任务委托给MyBatis 的执行器 Executor执行
List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);

SqlSession的使命完成，看Executor的表演。

4.2.3 Executor执行器

MyBatis执行器Executor根据SqlSession传递的参数执行query()方法，如下：

/**
* BaseExecutor 类部分代码
*
*/
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
     
	  
	// 1.根据具体传入的参数，动态地生成需要执行的SQL语句，用BoundSql对象表示  
    BoundSql boundSql = ms.getBoundSql(parameter);
    // 2.为当前的查询创建一个缓存Key
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }
 
  @SuppressWarnings("unchecked")
  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 {
     
    	// 3.缓存中没有值，直接从数据库中读取数据  
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
     
      queryStack--;
    }
    if (queryStack == 0) {
     
      for (DeferredLoad deferredLoad : deferredLoads) {
     
        deferredLoad.load();
      }
      deferredLoads.clear(); // issue #601
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
     
        clearLocalCache(); // issue #482
      }
    }
    return list;
  }
 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 {
     
      //4. 执行查询，返回List 结果，然后将查询的结果放入缓存之中
      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;
  }

进一步深入，doQuery()方法是怎么执行的？

/**
*
*SimpleExecutor类的doQuery()方法实现
*
*/
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
     
    Statement stmt = null;
    try {
     
      Configuration configuration = ms.getConfiguration();
      //5. 根据既有的参数，创建StatementHandler对象来执行查询操作
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      //6. 创建java.Sql.Statement对象，传递给StatementHandler对象
      stmt = prepareStatement(handler, ms.getStatementLog());
      //7. 调用StatementHandler.query()方法，返回List结果集
      return handler.<E>query(stmt, resultHandler);
    } finally {
     
      closeStatement(stmt);
    }
  }

上述的Executor.query()方法几经转折，最后会创建一个StatementHandler对象，然后将必要的参数传递给StatementHandler，使用StatementHandler来完成对数据库的查询，最终返回List结果集。

从上面的代码中我们可以看出，Executor的功能和作用是：

(1、根据传递的参数，完成SQL语句的动态解析，生成BoundSql对象，供StatementHandler使用

// 1.根据具体传入的参数，动态地生成需要执行的SQL语句，用BoundSql对象表示  
BoundSql boundSql = ms.getBoundSql(parameter); 

(2、为查询创建缓存，以提高性能

// 2.为当前的查询创建一个缓存Key
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
// 这个query()中同时用到了动态生成的boundSql和缓存key
return query(ms, parameter, rowBounds, resultHandler, key, boundSql); 

(3、缓存中没有值，直接从数据库中读取数据

  if (list != null) {
     
    handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
  } else {
     
	// 3.缓存中没有值，直接从数据库中读取数据  
    list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
  }

（4、 执行查询，返回List 结果，然后将查询的结果放入缓存之中

try {
     
  //4. 执行查询，返回List 结果，然后将查询的结果放入缓存之中
  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、具体doQuery()查询中，创建JDBC的Statement连接对象，传递给StatementHandler对象，返回List查询结果

  //5. 根据既有的参数，创建StatementHandler对象来执行查询操作
  StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
  //6. 创建java.Sql.Statement对象，传递给StatementHandler对象
  stmt = prepareStatement(handler, ms.getStatementLog());
  //7. 调用StatementHandler.query()方法，返回List结果集
  // StatementHandler作为调用者，Statement作为实参
  return handler.<E>query(stmt, resultHandler);

好了，Executor的任务完成了，看StatementHandler和Statement的表演，核心就是：

  // StatementHandler作为调用者，Statement作为实参
  return handler.<E>query(stmt, resultHandler);

4.2.4 StatementHandler与Statement

StatementHandler对象负责设置Statement对象中的查询参数、处理JDBC返回的resultSet，将resultSet加工为List集合并返回，doQuery() 方法的实现，如下(接着上面的Executor第六步和第七步)：

/**
*
*SimpleExecutor类的doQuery()方法实现
*
*/
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
      
Statement stmt = null; 
try {
      
   Configuration configuration = ms.getConfiguration(); 
   StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); 
   // 1.准备Statement对象，并设置Statement对象的参数 
   stmt = prepareStatement(handler, ms.getStatementLog()); 
   // 2. StatementHandler执行query()方法，返回List结果 
   return handler.<E>query(stmt, resultHandler); 
   } finally {
      
   closeStatement(stmt); 
   } 
 }
 
  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
     
    Statement stmt;
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection);
    //对创建的Statement对象设置参数，即设置SQL 语句中 ? 设置为指定的参数
    handler.parameterize(stmt);
    return stmt;
  }

以上我们可以总结StatementHandler对象主要完成两个工作：

(1. 设置参数：对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包含 若干个? 占位符，我们其后再对占位符进行设值，StatementHandler通过parameterize(statement)方法对Statement进行设值；

(2. 查询：StatementHandler通过List query(Statement statement, ResultHandler resultHandler)方法来完成执行Statement，和将Statement对象返回的resultSet封装成List。

StatementHandler 的两个作用：设置参数、查询。

4.2.4.1 设置参数

设置参数：StatementHandler 的parameterize(statement) 方法的实现

/**
*   StatementHandler 类的parameterize(statement) 方法实现 
*/
public void parameterize(Statement statement) throws SQLException {
     
	//使用ParameterHandler对象来完成对Statement的设值  
    parameterHandler.setParameters((PreparedStatement) statement);
  }

  /**
   * 
   *ParameterHandler类的setParameters(PreparedStatement ps) 实现
   * 对某一个Statement进行设置参数
   */
  public void setParameters(PreparedStatement ps) throws SQLException {
     
    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)) {
      // issue #448 ask first for additional params
            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);
          }
          
          // 每一个Mapping都有一个TypeHandler，根据TypeHandler来对preparedStatement进行设置参数
          TypeHandler typeHandler = parameterMapping.getTypeHandler();
          JdbcType jdbcType = parameterMapping.getJdbcType();
          if (value == null && jdbcType == null) jdbcType = configuration.getJdbcTypeForNull();
          // 设置参数，这里将java类型变为jdbc类型
          typeHandler.setParameter(ps, i + 1, value, jdbcType);
        }
      }
    }
  }

从上述的代码可以看到,StatementHandler 的parameterize(Statement) 方法调用了 ParameterHandler的setParameters(statement) 方法，这个方法根据我们输入的参数，对statement对象的 ? 占位符处进行赋值，如下：

typeHandler.setParameter(ps, i + 1, value, jdbcType);

解释一下setParameter方法：根据boundSql动态Sql得到一个parameterMappings，然后遍历这个list，对于每一个parameterMapping，从parameterMapping得到propertyName，从propertyName得到value，然后，从parameterMapping得到typeHandler，从parameterMapping得到jdbcType ，最后使用 typeHandler.setParameter(ps, i + 1, value, jdbcType);

4.2.4.2 查询

查询：StatementHandler 的List query(Statement statement, ResultHandler resultHandler)方法的实现

  /**
   * PreParedStatement类的query方法实现
   */
  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
     
	// 1.调用preparedStatemnt.execute()方法，然后将resultSet交给ResultSetHandler处理  
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    //2. 使用ResultHandler来处理ResultSet
    return resultSetHandler.<E> handleResultSets(ps);
  }

StatementHandler将查询的业务交给ResultSetHandler来完成，下面的主角成为ResultSetHandler了

/**  
* DefaultResultSetHandler类的handleResultSets()方法实现
*
*/
public List<Object> handleResultSets(Statement stmt) throws SQLException {
     
    final List<Object> multipleResults = new ArrayList<Object>();
 
    int resultSetCount = 0;
    ResultSetWrapper rsw = getFirstResultSet(stmt);
 
    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    
    while (rsw != null && resultMapCount > resultSetCount) {
     
      ResultMap resultMap = resultMaps.get(resultSetCount);
      
      //将resultSet
      handleResultSet(rsw, resultMap, multipleResults, null);
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }
 
    String[] resultSets = mappedStatement.getResulSets();
    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);
  }

从上述代码我们可以看出，StatementHandler 的List query(Statement statement, ResultHandler resultHandler)方法的实现，是调用了ResultSetHandler的handleResultSets(Statement) 方法。ResultSetHandler的handleResultSets(Statement) 方法会将Statement语句执行后生成的resultSet 结果集转换成List 结果集。

4.2.5 小结

第一个主角SqlSession

SqlSession根据Statement ID, 在mybatis配置对象Configuration中获取到对应的MappedStatement对象，然后调用mybatis执行器来执行具体的操作。

  //1.根据Statement Id，在mybatis 配置对象Configuration中查找和配置文件相对应的MappedStatement，Configuration里面是key,value,这里根据key得到value
  MappedStatement ms = configuration.getMappedStatement(statement);
  //2. 将查询任务委托给MyBatis 的执行器 Executor执行
  List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);

SqlSession的使命完成，看Executor的表演。

第二个主角Executor

Executor的功能和作用是：

(1、根据传递的参数，完成SQL语句的动态解析，生成BoundSql对象，供StatementHandler使用

// 1.根据具体传入的参数，动态地生成需要执行的SQL语句，用BoundSql对象表示  
BoundSql boundSql = ms.getBoundSql(parameter); 

(2、为查询创建缓存，以提高性能

// 2.为当前的查询创建一个缓存Key
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
// 这个query()中同时用到了动态生成的boundSql和缓存key
return query(ms, parameter, rowBounds, resultHandler, key, boundSql); 

(3、缓存中没有值，直接从数据库中读取数据

  if (list != null) {
     
    handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
  } else {
     
	// 3.缓存中没有值，直接从数据库中读取数据  
    list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
  }

(4、 执行查询，返回List 结果，然后将查询的结果放入缓存之中

try {
     
  //4. 执行查询，返回List 结果，然后将查询的结果放入缓存之中
  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、具体doQuery()查询中，创建JDBC的Statement连接对象，传递给StatementHandler对象，返回List查询结果

  //5. 根据既有的参数，创建StatementHandler对象来执行查询操作
  StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
  //6. 创建java.Sql.Statement对象，传递给StatementHandler对象
  stmt = prepareStatement(handler, ms.getStatementLog());
  //7. 调用StatementHandler.query()方法，返回List结果集
  return handler.<E>query(stmt, resultHandler);

第三个主角StatementHandler、第四个主角ParameterHandlder、第五个主角TypeHandler和第六个主角ResultSetHandler

以上我们可以总结StatementHandler对象主要完成两个工作：

(1. 设置参数：对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包含 若干个? 占位符，我们其后再对占位符进行设值，StatementHandler通过parameterize(statement)方法对Statement进行设值；

typeHandler.setParameter(ps, i + 1, value, jdbcType);

解释一下setParameter方法：根据boundSql动态Sql得到一个parameterMappings，然后遍历这个list，对于每一个parameterMapping，从parameterMapping得到propertyName，从propertyName 得到value，然后，从parameterMapping得到typeHandler，从parameterMapping得到jdbcType ，最后使用 typeHandler.setParameter(ps, i + 1, value, jdbcType);

(2.查询：StatementHandler通过List query(Statement statement, ResultHandler resultHandler)方法来完成执行Statement，和将Statement对象返回的resultSet封装成List。

StatementHandler将查询的业务交给ResultSetHandler来完成，对于ResultSetHandler，返回的时候应该也是要用到TypeHandler类将jdbc类型转换为java类型，但是没找到，DefaultResultSetHandler类中搜索getTypeHandler()就好了。

五、尾声

《沿着哈勃望远，看清MyBatis整体架构》，完成了。

天天打码，天天进步！！！