MyBatis 工作原理

概览

我把MyBatis的工作原理分为以下几个方面或方面：

1. 读取MyBatis核心配置文件的文件流
2. 解析文件流获取SessionFactory对象
3. 获取SqlSession对象
4. 整合参数执行数据库操作(增删改查）
5. 事务提交
6. 关闭会话

一.创建SqlSessionFactory对象

我Google了一下不通过Spring注入使用MyBatis操作数据库的方式
How do I create an SqlSessionFactory object in MyBatis? | Kode Java

Kode Java:

public static void main(String[] args) throws IOException {
       // A resource file for MyBatis configuration.
        Reader reader = 
        Resources.getResourceAsReader("configuration.xml");

        // Creates an SqlSessionFactoryBuilder. This builder need only 
        // create one time during the application life time.
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        // Creates an instance of SqlSessionFactory. This object can be 
        // used to initiate an SqlSession for querying information from 
        // the mapped query.
        SqlSessionFactory factory = builder.build(reader);
        System.out.println("factory = " + factory);
}

改造：

public static void main(String[] args) throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        // 从SqlSessionFactory对象中获取 SqlSession对象
        sqlSession = factory.openSession();     
        sqlSession.close();     
}

二.工作原理

1.核心代码

通过上述步骤一的代码，可以改造出一个MyBatis与数据库之间的操作的过程，如下：
实体类：

public class UserInfo implements Serializable {
    //主键id
    private Integer id;
    //号码
    private String phone;
    //密码
    private String password;

    private static final long serialVersionUID = 1L;
    //忽略getter、setter、toString方法
  
}

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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/boatmate?serverTimezone=UTC" />
                <property name="username" value="root" />
                <property name="password" value="1+1==Two" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserInfoMapper.xml" />
    </mappers>  
</configuration>

UserInfo 对应mapper文件：

<?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="UserInfo">
    <!-- 添加用户 -->
    <insert id="addUser" useGeneratedKeys="true" keyProperty="id"
        parameterType="com.xuyj.mybatiswork.model.UserInfo">
        INSERT INTO user_info (phone, password)
        VALUES (#{phone},
        #{password})
    </insert>
</mapper>

操作代码:

public static void main(String[] args) {

        UserInfo user = new UserInfo();
        user.setPhone("15252478436");
        user.setPassword("12345678");

        String resource = "mybatis-config.xml";
        InputStream inputStream;
        SqlSession sqlSession = null;
        try {
            //读取文件流
            inputStream = Resources.getResourceAsStream(resource);
            //将MyBatis配置文件流转换成SessionFactory对象
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
            // 获取 SqlSession对象
            sqlSession = factory.openSession();
            // 执行操作
            sqlSession.insert("addUser", user);
            // 提交操作
            sqlSession.commit();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            // 关闭SqlSession
            if (sqlSession != null) {
                sqlSession.close();

            }
        }

    }

2.分析代码

2.1 获取配置文件的文件流

 inputStream = Resources.getResourceAsStream(resource);

MyBatis提供了一个文件资源加载类，通过传入路径获取文件流

2.2 获取SqlSessionFactory

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);

这个Builder模式会通过XMLConfigBuilder对象对文件流进行解析，构造Configuration对象，然后交给build()方法构造DefaultSqlSessionFactory对象并返回。
具体代码：

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      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.
      }
    }
  }
  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

2.4 获取SqlSession对象

具体代码

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      // 根据Configuration的Environment属性来创建事务工厂
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      // 从事务工厂中创建事务，默认等级为null，autoCommit=false
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
       // 创建执行器
       Executor executor = this.configuration.newExecutor(tx, execType);
        // 根据执行器创建返回对象 SqlSession
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

2.3 通过SqlSession对象，对数据库操作

通过SqlSessionFactory获取到DefaultSqlSession对象，之后的操作基本就类似其他持久层框架，这边就只分析插入操作。
具体代码：

 @Override
  public int update(String statement, Object parameter) {
    try {
      dirty = true;
      MappedStatement ms = configuration.getMappedStatement(statement);
     //通过执行器进行数据库操作
      return executor.update(ms, wrapCollection(parameter));
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

MappedStatement是一个sql映射对象。里面封装的数据就是mapper.xml的键值信息。

2.4 SimpleExecutor 对象执行sql语句

具体代码

 @Override
  public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
     // 创建StatementHandler对象，从而创建Statement对象
      StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
        // 将sql语句和参数绑定并生成SQL指令
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.update(stmt);
    } finally {
      closeStatement(stmt);
    }
  }

• 通过prepareStatement()方法,研究MyBatis是如何将sql拼接合成的：

 private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    Connection connection = getConnection(statementLog);
    // 准备Statement
    Statement stmt = handler.prepare(connection);
    // 设置SQL查询中的参数值
    handler.parameterize(stmt);
    return stmt;
  }

• 查看parameterize()

 public void parameterize(Statement statement) throws SQLException {
    this.parameterHandler.setParameters((PreparedStatement)statement);
}

在这一步中，先把Statement转换成PreparedStatement对象，可以看出这里是MyBatis对JDBC的一个封装。

• handler.update()

 @Override
  public int update(Statement statement) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    //执行语句
    ps.execute();
   //获取返回值
    int rows = ps.getUpdateCount();
    Object parameterObject = boundSql.getParameterObject();
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
    keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
    return rows;
  }

2.5 事务提交

也是对JDBC的一层封装

 @Override
  public void commit(boolean force) {
    try {
    // 是否提交（判断是提交还是回滚）
      executor.commit(isCommitOrRollbackRequired(force));
      dirty = false;
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error committing transaction.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

最后调用的也是JDBCTransation的commit()

public void commit() throws SQLException {
    if (this.connection != null && !this.connection.getAutoCommit()) {
        if (log.isDebugEnabled()) {
            log.debug("Committing JDBC Connection [" + this.connection + "]");
        }
        // 提交连接
        this.connection.commit();
    }
}