Mybatis 工作流程及其原理与解析

2022 年 9 月 22 日
湖南
本文字数：7928 字
阅读完需：约 26 分钟

Mybatis 简介：

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java 对象)映射成数据库中的记录。本文将通过 debug 的方式来了解其工作原理。

Mybatis 核心类：

SqlSessionFactory：每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为中心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或通过 Java 的方式构建出 SqlSessionFactory 的实例。SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，建议使用单例模式或者静态单例模式。一个 SqlSessionFactory 对应配置文件中的一个环境（environment），如果你要使用多个数据库就配置多个环境分别对应一个 SqlSessionFactory。

SqlSession：SqlSession 是一个接口，它有 2 个实现类，分别是 DefaultSqlSession(默认使用)以及 SqlSessionManager。SqlSession 通过内部存放的执行器（Executor）来对数据进行 CRUD。此外 SqlSession 不是线程安全的，因为每一次操作完数据库后都要调用 close 对其进行关闭，官方建议通过 try-finally 来保证总是关闭 SqlSession。

Executor：Executor（执行器）接口有两个实现类，其中 BaseExecutor 有三个继承类分别是 BatchExecutor（重用语句并执行批量更新），ReuseExecutor（重用预处理语句 prepared statements），SimpleExecutor（普通的执行器）。以上三个就是主要的 Executor。通过下图可以看到 Mybatis 在 Executor 的设计上面使用了装饰者模式，我们可以用 CachingExecutor 来装饰前面的三个执行器目的就是用来实现缓存。

MappedStatement：MappedStatement 就是用来存放我们 SQL 映射文件中的信息包括 sql 语句，输入参数，输出参数等等。一个 SQL 节点对应一个 MappedStatement 对象。

Mybatis 工作流程：

阅读全文有惊喜哦！！！

下面将通过 debug 方式对 Mybatis 进行一步步解析。首先贴出我的 mybatis-config.xml 文件以及 Mapper.xml 文件。

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

select * from user

User where id = #{id}

insert into User (username,birthday,sex,address)

values (#{name},#{birthday},#{sex},#{address})

update User set username = #{username},birthday = #{birthday},

sex = #{sex},address = #{address} where id = #{id}

delete from User where id = #{id}

select * from User where sex = #{param1}

and username like #{param2}

and address = #{parma3}

select count(*) from user where username like #{username}

username like #{pattern}

and sex = #{sex}

and address = #{address}

where id in

#{id}

第一步通过 SqlSessionFactoryBuilder 创建 SqlSessionFactory：

首先在 SqlSessionFactoryBuilder 的 build（）方法中可以看到 MyBatis 内部定义了一个类 XMLConfigBuilder 用来解析配置文件 mybatis-config.xml。针对配置文件中的每一个节点进行解析并将数据存放到 Configuration 这个对象中，紧接着使用带有 Configuration 的构造方法发返回一个 DefautSqlSessionFactory。

public SqlSessionFactory build(InputStream inputStream) {

return build(inputStream, null, null);

}

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {

try {

XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);

//解析 mybatis-config.xml

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.

}

//返回 SqlSessionFactory，默认使用的是实现类 DefaultSqlSessionFactory

public SqlSessionFactory build(Configuration config) {

return new DefaultSqlSessionFactory(config);

}

public Configuration parse() {

if (parsed) {

throw new BuilderException("Each XMLConfigBuilder can only be used once.");

}

parsed = true;

//获取根节点 configuration

parseConfiguration(parser.evalNode("/configuration"));

return configuration;

}

//开始解析 mybatis-config.xml,并把解析后的数据存放到 configuration 中

private void parseConfiguration(XNode root) {

try {

//保存 mybatis-config.xml 中的标签 setting,本例中开启全局缓存 cacheEnabled，设置默认执行器 defaultExecutorType=REUSE

Properties settings = settingsAsPropertiess(root.evalNode("settings"));

//issue #117 read properties first

//解析是否配置了外部 properties，例如本例中配置的 jdbc.propertis

propertiesElement(root.evalNode("properties"));

//查看是否配置了 VFS，默认没有，本例也没有使用

loadCustomVfs(settings);

//查看是否用了类型别名，减少完全限定名的冗余，本例中使用了别名 User 代替了 com.ctc.Model.User

typeAliasesElement(root.evalNode("typeAliases"));

//查看是否配置插件来拦截映射语句的执行，例如拦截 Executor 的 Update 方法，本例没有使用

pluginElement(root.evalNode("plugins"))

//查看是否配置了 ObjectFactory，默认情况下使用对象的无参构造方法或者是带有参数的构造方法，本例没有使用

objectFactoryElement(root.evalNode("objectFactory"));

//查看是否配置了 objectWrapperFatory,这个用来或者 ObjectWapper，可以访问：对象，Collection，Map 属性。本例没有使用

objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));

//查看是否配置了 reflectorFactory,mybatis 的反射工具，提供了很多反射方法。本例没有使用

reflectorFactoryElement(root.evalNode("reflectorFactory"));

//放入参数到 configuration 对象中

settingsElement(settings);

// read it after objectFactory and objectWrapperFactory issue #631

//查看数据库环境配置

environmentsElement(root.evalNode("environments"));

//查看是否使用多种数据库，本例没有使用

databaseIdProviderElement(root.evalNode("databaseIdProvider"));

//查看是否配置了新的类型处理器，如果跟处理的类型跟默认的一致就会覆盖。本例没有使用

typeHandlerElement(root.evalNode("typeHandlers"));

//查看是否配置 SQL 映射文件,有四种配置方式，resource，url，class 以及自动扫包 package。本例使用 package

mapperElement(root.evalNode("mappers"));

} catch (Exception e) {

throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);

}

第二步通过 SqlSessionFactory 创建 SqlSession：

@Override

public SqlSession openSession() {

return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);

}

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {

Transaction tx = null;

try {

//拿到前文从 mybatis 中解析到的数据库环境配置

final Environment environment = configuration.getEnvironment();

final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);

//拿到 jdbc 的事务管理器，有两种一种是 jbc,一种的 managed。本例使用的是 JdbcTransaction

tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);

//从 mybatis 配置文件可以看到本例使用了 REUSE，因此返回的是 ReuseExecutor 并把事务传入对象中

final Executor executor = configuration.newExecutor(tx, execType);

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

}

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) interceptorChain.pluginAll(executor);

return executor;

}

//返回一个 SqlSession，默认使用 DefaultSqlSession

public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {

this.configuration = configuration;

this.executor = executor;

this.dirty = false;

this.autoCommit = autoCommit;

}

第三步通过 SqlSession 拿到 Mapper 对象的代理：

@Override

public T getMapper(Class type) {

return configuration.getMapper(type, this);

}

public T getMapper(Class type, SqlSession sqlSession) {

//前文解析 Mybatis-config.xml 的时候，在解析标签 mapper 就是用 configuration 对象的 mapperRegistry 存放数据

return mapperRegistry.getMapper(type, sqlSession);

}

@SuppressWarnings("unchecked")

public T getMapper(Class type, SqlSession sqlSession) {

//knownMapper 是一个 HashMap 在存放 mapperRegistry 的过程中，以每个 Mapper 对象的类型为 Key, MapperProxyFactory 为 value 保存。

//例如本例中保存的就是 Key:com.ctc.mapper.UserMapper,value 就是保存了 key 的 MapperProxyFactory 对象

final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) knownMappers.get(type);

if (mapperProxyFactory == null) {

throw new BindingException("Type " + type + " is not known to the MapperRegistry.");

}

try {

return mapperProxyFactory.newInstance(sqlSession);

} catch (Exception e) {

throw new BindingException("Error getting mapper instance. Cause: " + e, e);

}

public T newInstance(SqlSession sqlSession) {

//生成一个 mapperProxy 对象，这个对象实现了 InvocationHandler, Serializable。就是 JDK 动态代理中的方法调用处理器

final MapperProxy mapperProxy = new MapperProxy(sqlSession, mapperInterface, methodCache);

return newInstance(mapperProxy);

}

public MapperProxy(SqlSession sqlSession, Class mapperInterface, Map methodCache) {

this.sqlSession = sqlSession;

this.mapperInterface = mapperInterface;

this.methodCache = methodCache;

}

@SuppressWarnings("unchecked")

protected T newInstance(MapperProxy mapperProxy) {

//通过 JDK 动态代理生成一个 Mapper 的代理，在本例中的就是 UserMapper 的代理类，它实现了 UserMapper 接口

return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);

}

第四步通过 MapperProxy 调用 Maper 中相应的方法：

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

//判断当前调用的 method 是不是 Object 中声明的方法，如果是的话直接执行。

if (Object.class.equals(method.getDeclaringClass())) {

try {

return method.invoke(this, args);

} catch (Throwable t) {

throw ExceptionUtil.unwrapThrowable(t);

}

final MapperMethod mapperMethod = cachedMapperMethod(method);

return mapperMethod.execute(sqlSession, args);

}

//把当前请求放入一个 HashMap 中，一旦下次还是同样的方法进来直接返回。

private MapperMethod cachedMapperMethod(Method method) {

MapperMethod mapperMethod = methodCache.get(method);

if (mapperMethod == null) {

mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());

methodCache.put(method, mapperMethod);

}

return mapperMethod;

}

public Object execute(SqlSession sqlSession, Object[] args) {

Object result;

switch (command.getType()) {

case INSERT: {

Object param = method.convertArgsToSqlCommandParam(args);

result = rowCountResult(sqlSession.insert(command.getName(), param));

break;

}

case UPDATE: {

Object param = method.convertArgsToSqlCommandParam(args);

result = rowCountResult(sqlSession.update(command.getName(), param));

break;

}

case DELETE: {

Object param = method.convertArgsToSqlCommandParam(args);

result = rowCountResult(sqlSession.delete(command.getName(), param));

break;

}

case SELECT:

if (method.returnsVoid() && method.hasResultHandler()) {

executeWithResultHandler(sqlSession, args);

result = null;

} else if (method.returnsMany()) {

result = executeForMany(sqlSession, args);

} else if (method.returnsMap()) {

result = executeForMap(sqlSession, args);

} else if (method.returnsCursor()) {

result = executeForCursor(sqlSession, args);

} else {

//本次案例会执行 selectOne

Object param = method.convertArgsToSqlCommandParam(args);

result = sqlSession.selectOne(command.getName(), param);

}

break;

case FLUSH:

result = sqlSession.flushStatements();

break;

default:

throw new BindingException("Unknown execution method for: " + command.getName());

}

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;

}

@Override

public <T> T selectOne(String statement, Object parameter) {

// Popular vote was to return null on 0 results and throw exception on too many.

List<T> list = this.<T>selectList(statement, parameter);

if (list.size() == 1) {

return list.get(0);

} else if (list.size() > 1) {

throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());

} else {

return null;

}

@Override

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {

try {

MappedStatement ms = configuration.getMappedStatement(statement);

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

}

//这边调用的是 CachingExecutor 类的 query,还记得前文解析 mybatis-config.xml 的时候我们指定了 REUSE 但是因为在配置文件中开启了缓存

//所以 ReuseExecutor 被 CachingExecotur 装饰，新增了缓存的判断，最后还是会调用 ReuseExecutor

@Override

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {

BoundSql boundSql = ms.getBoundSql(parameterObject);

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) {

flushCacheIfRequired(ms);

if (ms.isUseCache() && resultHandler == null) {

ensureNoOutParams(ms, parameterObject, boundSql);

@SuppressWarnings("unchecked")

List<E> list = (List<E>) tcm.getObject(cache, key);

if (list == null) {

//如果缓存中没有数据则查询数据库

list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);

//结果集放入缓存