手写一个迷你版的Mybatis框架

1. 前言

接触Mybatis框架有些时日了，但我仅仅处于“会使用它”的这个层面，并没有对它进行深入地理解。所以，现在抽时间想对它一探究竟。

2. Mybatis工作原理

Mybatis工作原理参考了此博文：
Mybatis工作原理

2.1 Mybatis架构

2.1.1 Mybatis框架的分层

Mybatis框架大致分为四层：引导层、接口层、数据处理层、框架支撑层。
如下图：

2.1.2 Mybatis框架的实现原理

Mybatis的底层还是采用了原生JDBC技术来实现对数据库的操作。只是通过 SqlSessionFactory，SqlSession，Executor，StatementHandler，ParameterHandler，ResultHandler和TypeHandler等几个处理器封装了这些过程。
几个组件的功能如下：

• Executor：执行器（update, query, flushStatements, commit, rollback, getTransaction, close, isClosed）
• ParameterHandler：参数处理器（getParameterObject, setParameters）
• ResultSetHandler：结果处理器（handleResultSets, handleOutputParameters）
• StatementHandler：sql查询处理器(prepare, parameterize, batch, update, query)

其中，StatementHandler通过ParameterHandler与ResultHandler分别进行参数预编译 与结果处理。而ParameterHandler与ResultHandler都使用TypeHandler进行映射。

2.2 Mybatis的核心运行流程

Mybatis的核心运行流程可分为三个阶段：

• 初始化阶段：读取XML配置文件和注解中的配置信息，创建配置对象，并完成各个模块的初始化工作
• 代理阶段：封装Mybatis的编程模型，使用Mapper接口开发的初始化工作
• 数据读写阶段：通过SqlSession完成SQL的解析、参数的映射、SQL的执行、结果的反射解析过程

3. 手写Mybatis

按照Mybatis的核心运行流程的三个阶段一步步编码，每完成一个阶段，就进行测试。

3.1 初始化阶段

读取XML配置文件和注解中的配置信息，创建配置对象，并完成各个模块的初始化工作

项目结构图：

1. MappedStatement
MappedStatement对象是对mapper文件中的每一个标签进行抽象

@Data
public class MappedStatement {
	// 命名空间
    private String namespace;
    // id
    private String resourceId;
    // 返回类型
    private String resultType;
    // sql语句
    private String sql;
}

2. Confifuration
mapper文件中包含多个标签，所有会有个对象来存储标签的集合

Confifuration是用来存储所有配置信息的，且此配置信息全局唯一

/**
 * 存储所有配置信息：
 *      数据库配置信息、mapper配置信息
 */
@Data
public class Configuration {
    // jdbc的驱动
    private String jdbcDriver;
    // jdbc的url
    private String jdbcUrl;
    // jdbc的username
    private String jdbcUsername;
    // jdbc的password
    private String jdbcPassword;

    /**
     * mapper文件中可能有多条SQL语句（MapperStatement对象）
     * Map：可实现快速访问
     */
    private Map mapperStatements = new HashMap<>();
}

3. SqlSessionFactory
我们在使用Mybatis时，会写如下代码：

在通过工厂模式进行实例化SqlSessionFactory时，会加载mybatis的核心配置文件mybatis-config.xml。所以，这里也仿照mybatis源码，新建个SqlSessionFactory类

public class SqlSessionFactory {

    private final Configuration configuration = new Configuration();

    public SqlSessionFactory() {
        loadDbInfo();
        loadMappersInfo();
    }
    ...
}

此类有两个作用：

1. 实例化过程中加载配置文件到Configuration对象
2. 生产SqlSession对象

loadDbInfo()

// 记录mapper.xml文件存放的位置
public static final String MAPPER_CONFIG_LOCATION = "mappers";
// 记录数据库连接信息文件存放的位置
public static final String DB_CONFIG_FILE = "db.properties";

// 加载数据库配置信息
private void loadDbInfo() {
    // 加载数据库信息配置文件
    InputStream dbIn = SqlSessionFactory.class.getClassLoader().getResourceAsStream(DB_CONFIG_FILE);
    Properties p = new Properties();
    try {
        // 将配置信息写入到Properties对象
        p.load(dbIn);
    } catch (IOException e) {
        e.printStackTrace();
    }

    // 将数据库配置信息写入到Configuration对象
    configuration.setJdbcDriver(p.get("jdbc.driver").toString());
    configuration.setJdbcUrl(p.get("jdbc.url").toString());
    configuration.setJdbcUsername(p.get("jdbc.username").toString());
    configuration.setJdbcPassword(p.get("jdbc.password").toString());
}

loadMappersInfo()

// 加载指定文件夹下的所有mapper.xml文件
private void loadMappersInfo() {
    URL resource = null;
    resource = SqlSessionFactory.class.getClassLoader().getResource(MAPPER_CONFIG_LOCATION);
    // 获取指定文件夹信息
    File mappers = new File(resource.getFile());
    if (mappers.isDirectory()) {
        File[] files = mappers.listFiles();
        // 遍历文件夹下所有的mapper.xml，并解析信息后，注入到Configuration对象中
        for (File file : files) {
            loadMapperInfo(file);
        }
    }
}

loadMapperInfo()
使用dom4j技术对mapper文件进行解析

// 加载指定的mapper.xml文件
private void loadMapperInfo(File file) {
    // 1.获取解析器
    SAXReader reader = new SAXReader();
    // 2.通过read()方法读取一个文件，转换成document对象
    Document document = null;
    try {
        document = reader.read(file);
    } catch (DocumentException e) {
        e.printStackTrace();
    }

    // 获取根节点：
    Element root = document.getRootElement();
    // 获取命令空间namespace属性
    String namespace = root.attribute("namespace").getData().toString();

    // 获取子节点select列表：
    List selects = root.elements("select");

    // 遍历select节点列表，将信息记录到MapperStatement对象，并注入到Configuration对象中
    for (Element element : selects) {
        MappedStatement mapperStatement = new MappedStatement();
        // 获取id属性
        String id = element.attribute("id").getData().toString();
        // 获取resultType属性
        String resultType = element.attribute("resultType").getData().toString();
        // 获取SQL语句信息
        String sql = element.getData().toString();
        String resourceId = namespace + "." + id;

        mapperStatement.setNamespace(namespace);
        mapperStatement.setResourceId(id);
        mapperStatement.setResultType(resultType);
        mapperStatement.setSql(sql);

        configuration.getMappedStatements().put(resourceId, mapperStatement);
    }
}
 
  
4. SqlSession
 SqlSessionFactory类的第二个作用：生产SqlSession
 
  
什么是SqlSession？简单理解：使用mybatis访问数据库时，与数据库的每一次连接都SqlSession。并且SqlSession中要保存Configuration的引用，因为此对象中有数据库连接信息，这样连接数据库时就可以获取连接信息
 
  
/**
*mybatis暴露给外部的接口，实现增删改查
*/
public interface SqlSession {
     T selectOne(String statement, Object parameter);
     List selectList(String statement, Object parameter);
     T getMapper(Class type);
}
 
  
5. DefaultSqlSession
 DefaultSqlSession是SqlSession接口的实现类。
 
  
public class DefaultSqlSession implements SqlSession {

    private final Configuration configuration;

    public DefaultSqlSession(Configuration configuration) {
        super();
        this.configuration = configuration;
    }
    ...
    // 接口中的方法暂不实现
}
 
  
DefaultSqlSession中的Configuration引用是由外界传入的。
 
  
openSession()
 在SqlSessionFactory类中，添加此方法，用于生产SqlSession对象
 
  
// 生产SqlSession对象
public SqlSession openSession() {
   return new DefaultSqlSession(configuration);
}
 
  
初始化阶段：读取XML配置文件和数据库配置文件中的信息加载到Configuration对象中去
 
  
第一阶段测试：
 
  
public class Test {

    public static void main(String[] args) {
        SqlSessionFactory factory = new SqlSessionFactory();
        SqlSession sqlSession = factory.openSession();
        System.out.println(sqlSession);
    }
}
 
  

 Debug时，可以看到Configuration对象中有值，并且和配置文件中的信息一致。
 
  
3.2 代理阶段
 
  
封装Mybatis的编程模型，使用Mapper接口开发的初始化工作
 
  
话说 SqlSession
 
  
SqlSession意味着创建数据库会话，代表了一次与数据库的连接
 
  
SqlSession是Mybatis对外提供数据访问的主要API
 SqlSession的作用就是对外提供数据访问的主要API，为什么这么说呢？
 
  
下面给出两个mybatis入门的代码示例：
 可到Mybats官网查看：mybatis入门
 使用mapper接口（推荐）：
 
  
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sqlSessionFactory.openSession();

UserMapper mapper = session.getMapper(UserMapper.class);
User user = mapper.selectById(2l);
System.out.println(user);
 
  
使用SqlSession：
 全限定名= namespace + mapper文件中标签的Id。
 此种编程方式是Mybatis的前身ibatis的编程方式
 
  
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sqlSessionFactory.openSession();

User user = session.selectOne("com.zzc.mapper.UserMapper.selectById", 1);
System.out.println(user);
 
  
读者可以测试一番，两者结果是一致的。
 
  
SqlSession的功能都是基于Excutor来实现的
 查看源码的SqlSession查询接口的嵌套关系。如下图：
 
 由此可知，SqlSession中的方法最终调用了Executor中的方法
 
  
那么为什么不直接在SqlSession的方法中直接完成对数据库的操作，而要交给Executor呢？这里采用了面向对象的单一职责原则：SqlSession只对外提供服务，内部由Executor完成。
 
  
1. Executor
 此接口定义了数据库基本的操作方法
 
  
public interface Executor {
    // 查询接口
     List query(MappedStatement ms, Object parameter);
}
 
  
2. DefaultExecutor
 DefaultExecutor实现了Executor接口
 
  
public class DefaultExecutor implements Executor {
    private final Configuration configuration;

    public DefaultExecutor(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public  List query(MappedStatement ms, Object parameter) {
    	System.out.println(ms.getSql());
    	return null;
    }
}
 
  
DefaultExecutor也要操作数据库，所以需要Configuration对象
 
  
3.DefaultSqlSession
 在此类中添加Executor属性并初始化
 
  
/**
 * 1.对外提供数据访问的api
 * 2.对内将请求转发给Executor
 */
public class DefaultSqlSession implements SqlSession {

    private final Configuration configuration;
    private Executor executor;

    public DefaultSqlSession(Configuration configuration) {
        super();
        this.configuration = configuration;
        this.executor = new DefaultExecutor(configuration);
    }
}
 
  
重写此类的方法
 selectList()
 
  
@Override
public  List selectList(String statement, Object parameter) {
    MappedStatement ms = configuration.getMappedStatements().get(statement);
    return executor.query(ms, parameter);
}
 
  
selectOne()
 
  
@Override
public  T selectOne(String statement, Object parameter) {
    List