最新MyBatis源码分析之核心处理层，java面试总结架构师中间件

写在最后

为了这次面试，也收集了很多的面试题！

以下是部分面试题截图

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

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.

}

}

}

复制代码

从上面的源码可以看出，build()方法很简单，只是调用了一下重载的build()方法，具体细节可以看注释。接下来我们开始分析XMLConfigBuilder的parse()方法以及Configuration对象。MyBatis在初始化的时候，会将MyBatis的配置信息全部加载到内存中，使用Configuration对象实例来存储。Configuration对象的结构和xml配置文件几乎相同，也就是说XML文件中的properties（属性）、setting（设置）、typeAliases（类型别名）和typeHandlers（类型处理器）等配置标签在Configuration对象中都有对应的属性来封装它们。也就是说，初始化配置文件信息的本质就是创建Configuration对象，将解析的XML数据封装到Configuration内部属性中。

/**

• 解析 XML 成 Configuration 对象。

• @return Configuration 对象

*/

public Configuration parse() {

// 若已解析，抛出 BuilderException 异常

if (parsed) {

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

}

// 标记已解析

parsed = true;

///parser是XPathParser解析器对象，读取节点内数据，是MyBatis配置文件中的顶层标签

// 解析 XML configuration 节点

parseConfiguration(parser.evalNode(“/configuration”));

return configuration;

}

/**

• 解析 XML

• 具体 MyBatis 有哪些 XML 标签，参见 《XML 映射配置文件》http://www.mybatis.org/mybatis-3/zh/configuration.html

• @param root 根节点

*/

private void parseConfiguration(XNode root) {

try {

//issue #117 read properties first

// 解析 标签

propertiesElement(root.evalNode(“properties”));

// 解析 标签

Properties settings = settingsAsProperties(root.evalNode(“settings”));

// 加载自定义的 VFS 实现类

loadCustomVfs(settings);

// 解析 标签

typeAliasesElement(root.evalNode(“typeAliases”));

// 解析 标签

pluginElement(root.evalNode(“plugins”));

// 解析 标签

objectFactoryElement(root.evalNode(“objectFactory”));

// 解析 标签

objectWrapperFactoryElement(root.evalNode(“objectWrapperFactory”));

// 解析 标签

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

// 解析 标签

mapperElement(root.evalNode(“mappers”));

} catch (Exception e) {

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

}

}

复制代码

从源码中可以看到，程序是通过parseConfiguration()实现了对mybatis-config.xml配置文件中的每个节点进行解析的，每个节点的解析过程都封装成了一个单独的方法，代码清爽简洁。

程序在解析节点时，会创建XMLMapperBuilder对象加载映射文件，如果映射配置文件配置的是相应的Mapper接口，也会加载相应的Mapper接口，解析其中的注解并向MapperRegistry完成注册。在解析标签的时，程序也会完成对SQL的解析，并将解析后的SQL节点信息封装成MappedStatement对象（描述一条SQL语句）,然后存入Configuration对象中的一个HashMap类型的属性mappedStatements中，map的key即是$namespace.${id}（全限定类名 + 方法名），value对应的MappedStatement对象。

在解析SQL节点中，有两个难点，一个是解析动态SQL，另一个是解析节点，此处只讲整体解析流程，这两个知识点后面以面试题形式单独文章分析。

/**

• MappedStatement 映射

• KEY：${namespace}.${id}

*/

protected final Map<String, MappedStatement> mappedStatements = new StrictMap<>(“Mapped Statements collection”);

复制代码

MappedStatement包含了SQL节点的很多属性，其中比较重要的字段如下：

/**

• 映射的语句，每个 、、、 对应一个 MappedStatement 对象

• @author Clinton Begin

*/

public final class MappedStatement {

/**

• 节点中的id属性（包括命名空间前缀）

*/

private String resource;

/**

• SqlSource 对象，对应一条SQL语句

*/

private SqlSource sqlSource;

/**

• SQL 语句类型（INSERT、UPDATE、DELETE、SELECT或FLUSH）

*/

private SqlCommandType sqlCommandType;

// 其他字段

··· ···

}

复制代码

解析标签的细节这里不一一介绍，感兴趣可以阅读《MyBatis技术内幕》。以上，便是MyBatis加载解析配置文件的整体流程。

1.2 执行SQL流程

===========

初始化完成以后，程序就可以准备接收参数执行SQL了，在分析MyBatis执行SQL流程之前，需要先介绍两个接口：SqlSession接口和Executor接口。

1. SqlSession SqlSession是一个接口，它有两个实现类：DefaultSqlSession（默认）和SqlSessionManager（弃用，不做介绍）。SqlSession是MyBatis中用于和数据库交互的顶层类，通常将它与ThreadLocal绑定，因为在控制事务时需要保证一个事务里的数据库操作都是在一个链接里执行的，一个会话使用一个SqlSession，并且在使用完毕后需要close。

public class DefaultSqlSession implements SqlSession {

private final Configuration configuration;

private final Executor executor;

··· ···

}

复制代码

SqlSession中的两个最重要的参数，configuration与初始化时的相同，Executor为执行器。

1. Executor Executor也是一个接口，其中定义了数据库操作的基本方法，常用的实现类有三个：BatchExecutor（重用语句并执行批量更新）、ReuseExecutor（重用预处理语句preparedStatement）、SimpleExecutor（普通的执行器，默认）。

介绍完SqlSession和Executor，接下来通过传统方式来分析SQL执行流程。首先，看到以下代码，便是触发SQL执行的语句。

SqlSession sqlSession = factory.openSession();

List list = sqlSession.selectList(“com.silver.mapper.UserMapper.getUserByName”);

复制代码

1.2.1 获取SqlSession

==================

我们通过factory工厂对象的openSession()方法获取到SqlSession，打开openSession()方法，代码如下：

// 6. 进入openSession方法

@Override

public SqlSession openSession() {

//getDefaultExecutorType()传递的是SimpleExecutor

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

}

// 7. 进入openSessionFromDataSource。

// ExecutorType 为Executor的类型，TransactionIsolationLevel为事务隔离级别，autoCommit是否开启事务

// openSession的多个重载方法可以指定获得的SeqSession的Executor类型和事务的处理

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

Transaction tx = null;

try {

// 获得 Environment 对象

final Environment environment = configuration.getEnvironment();

// 创建 Transaction 对象

final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);

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

// 创建 Executor 对象

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

// 创建 DefaultSqlSession 对象

return new DefaultSqlSession(configuration, executor, autoCommit);

} catch (Exception e) {

// 如果发生异常，则关闭 Transaction 对象

closeTransaction(tx); // may have fetched a connection so lets call close()

throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);

} finally {

ErrorContext.instance().reset();

}

}

复制代码

1.2.2 执行SqlSession接口

====================

获取到SqlSession过后，接下来就是执行SqlSession中的接口，也就是传统方式代码的第二行，参数为全限定类名+方法名，接收到参数后，会从Configuration对象的Mapped Statement容器中取到对应的MappedStatement对象，然后交由Executor来执行。selectList()重载方法源码如下：

//8.进入selectList方法，多个重载方法

@Override

public List selectList(String statement) {

return this.selectList(statement, null);

}

@Override

public List selectList(String statement, Object parameter) {

return this.selectList(statement, parameter, RowBounds.DEFAULT);

}

@Override

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

try {

// 根据传入的全限定类名+方法名从映射的Map中获得 MappedStatement 对象

MappedStatement ms = configuration.getMappedStatement(statement);

// 调用Executor中的方法来处理

// RowBounds用来处理分页逻辑

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

}

}

复制代码

1.2.3 执行Executor接口

==================

继续上面的源码，进入executor.query()方法。

//此方法在SimpleExecutor的父类BaseExecutor中实现

@Override

public List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {

//根据传入的参数动态获得SQL语句，最后返回用BoundSql对象表示

BoundSql boundSql = ms.getBoundSql(parameter);

//为本次查询创建缓存的Key

CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);

// 查询

return query(ms, parameter, rowBounds, resultHandler, key, boundSql);

}

@SuppressWarnings(“unchecked”)

@Override

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

// 已经关闭，则抛出 ExecutorException 异常

if (closed) {

throw new ExecutorException(“Executor was closed.”);

}

// 清空本地缓存，如果 queryStack 为零，并且要求清空本地缓存。

if (queryStack == 0 && ms.isFlushCacheRequired()) {

clearLocalCache();

}

List list;

try {

// queryStack + 1

queryStack++;

// 从一级缓存中，获取查询结果

list = resultHandler == null ? (List) localCache.getObject(key) : null;

// 获取到，则进行处理

if (list != null) {

handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);

// 获得不到，则从数据库中查询

} else {

list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);

}

} finally {

// queryStack - 1

queryStack–;

}

if (queryStack == 0) {

// 执行延迟加载

for (DeferredLoad deferredLoad : deferredLoads) {

deferredLoad.load();

}

// issue #601

// 清空 deferredLoads

deferredLoads.clear();

// 如果缓存级别是 LocalCacheScope.STATEMENT ，则进行清理

if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {

// issue #482

clearLocalCache();

}

}

return list;

}

// 从数据库中读取操作

private List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {

List list;

// 在缓存中，添加占位对象。此处的占位符，和延迟加载有关，可见 DeferredLoad#canLoad() 方法

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;

}

// SimpleExecutor中实现父类的doQuery()抽象方法

@Override

public List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {

Statement stmt = null;

try {

Configuration configuration = ms.getConfiguration();

// 传入参数创建StatementHanlder对象来执行查询

StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);

// 创建jdbc中的statement对象

stmt = prepareStatement(handler, ms.getStatementLog());

// 执行 StatementHandler ，进行读操作

return handler.query(stmt, resultHandler);

} finally {

// 关闭 StatementHandler 对象

closeStatement(stmt);

}

}

// 初始化 StatementHandler 对象

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {

Statement stmt;

// 获得 Connection 对象

Connection connection = getConnection(statementLog);

// 创建 Statement 或 PrepareStatement 对象

stmt = handler.prepare(connection, transaction.getTimeout());

// 设置 SQL 上的参数，例如 PrepareStatement 对象上的占位符

handler.parameterize(stmt);

return stmt;

}

复制代码

Executor.query()方法几经转折，最后会创建一个StatementHandler对象，然后将必要的参数传递给StatementHandler，使用StatementHandler来完成对数据库的查询，最终返回List结果集。从以上代码可以看出，Executor的功能和作用是：

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

2. 为查询创建缓存，以提高性能；

3. 创建JDBC的Statement连接对象，床底给StatementHandler对象，返回List查询结果。

1.2.4 StatementHandler接口

========================

StatementHandler接口主要完成两个工作：

1. 对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包含若干个？占位符。后面介绍如何对占位符设值，StatementHandler通过parameterize()方法对Statement进行设值；

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

进入到StatementHandler的parameterize(statement)方法的实现：

@Override

public void parameterize(Statement statement) throws SQLException {

//使用ParameterHandler对象来完成对Statement的设值

parameterHandler.setParameters((PreparedStatement) statement);

}

@SuppressWarnings(“Duplicates”)

@Override

public void setParameters(PreparedStatement ps) {

ErrorContext.instance().activity(“setting parameters”).object(mappedStatement.getParameterMap().getId());

// 遍历 ParameterMapping 数组

List parameterMappings = boundSql.getParameterMappings();

if (parameterMappings != null) {

for (int i = 0; i < parameterMappings.size(); i++) {

// 获得 ParameterMapping 对象

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

}

// 获得 typeHandler、jdbcType 属性

TypeHandler typeHandler = parameterMapping.getTypeHandler();

JdbcType jdbcType = parameterMapping.getJdbcType();

if (value == null && jdbcType == null) {

jdbcType = configuration.getJdbcTypeForNull();

}

// 设置 ? 占位符的参数

try {

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

} catch (TypeException | SQLException e) {

throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);

}

}

}

}

}

复制代码

从以上代码可以看出，StatementHandler的parameterize(Statement) 方法调用了ParameterHandlerጱsetParameters(statement) 方法，ParameterHandlerጱsetParameters(Statement)根据我们输入的参数，对statement对象的? 占位符进行赋值。进入到StatementHandler 的List query(Statement statement, ResultHandler resultHandler)方法的实现：

@Override

public List query(Statement statement, ResultHandler resultHandler) throws SQLException {

PreparedStatement ps = (PreparedStatement) statement;

// 1、执行查询

ps.execute();

// 2、交由ResultHandler处理返回结果

return resultSetHandler.handleResultSets(ps);

结尾

这不止是一份面试清单，更是一种”被期望的责任“，因为有无数个待面试者，希望从这篇文章中，找出通往期望公司的”钥匙“，所以上面每道选题都是结合我自身的经验于千万个面试题中经过艰辛的两周，一个题一个题筛选出来再次对好答案和格式做出来的，面试的答案也是再三斟酌，深怕误人子弟是小，影响他人仕途才是大过，也希望您能把这篇文章分享给更多的朋友，让他帮助更多的人，帮助他人，快乐自己，最后，感谢您的阅读。

由于细节内容实在太多啦，在这里我花了两周的时间把这些答案整理成一份文档了，在这里只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

resultHandler)方法的实现：

@Override

public List query(Statement statement, ResultHandler resultHandler) throws SQLException {

PreparedStatement ps = (PreparedStatement) statement;

// 1、执行查询

ps.execute();

// 2、交由ResultHandler处理返回结果

return resultSetHandler.handleResultSets(ps);

结尾

[外链图片转存中…(img-irbAvt5E-1715644241135)]

这不止是一份面试清单，更是一种”被期望的责任“，因为有无数个待面试者，希望从这篇文章中，找出通往期望公司的”钥匙“，所以上面每道选题都是结合我自身的经验于千万个面试题中经过艰辛的两周，一个题一个题筛选出来再次对好答案和格式做出来的，面试的答案也是再三斟酌，深怕误人子弟是小，影响他人仕途才是大过，也希望您能把这篇文章分享给更多的朋友，让他帮助更多的人，帮助他人，快乐自己，最后，感谢您的阅读。

由于细节内容实在太多啦，在这里我花了两周的时间把这些答案整理成一份文档了，在这里只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取