mybatis 源码分析（三）Executor 详解

最新推荐文章于 2024-10-11 17:30:36 发布
最新推荐文章于 2024-10-11 17:30:36 发布
阅读量147 收藏
点赞数
文章标签： java 数据库
原文链接：http://www.cnblogs.com/sanzao/p/11394969.html
版权

本文将主要介绍 Executor 的整体结构和各子类的功能，并对比效率；

一、Executor 主体结构

1. 类结构

executor 的类结构如图所示：

其各自的功能：

  • BaseExecutor：基础执行器，封装了子类的公共方法，包括一级缓存、延迟加载、回滚、关闭等功能；
  • SimpleExecutor：简单执行器，每执行一条 sql，都会打开一个 Statement，执行完成后关闭；
  • ReuseExecutor：重用执行器，相较于 SimpleExecutor 多了 Statement 的缓存功能，其内部维护一个 Map<String, Statement>，每次编译完成的 Statement 都会进行缓存，不会关闭；
  • BatchExecutor：批量执行器，基于 JDBC 的 addBatch、executeBatch 功能，并且在当前 sql 和上一条 sql 完全一样的时候，重用 Statement，在调用 doFlushStatements 的时候，将数据刷新到数据库；
  • CachingExecutor：缓存执行器，装饰器模式，在开启二级缓存的时候。会在上面三种执行器的外面包上 CachingExecutor；

2. Executor 的生命周期

初始化：

// DefaultSqlSessionFactory
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
  Transaction tx = null;
  try {
    final Environment environment = configuration.getEnvironment();
    final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
    tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
    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 void close() {
  try {
    executor.close(isCommitOrRollbackRequired(false));
    dirty = false;
  } finally {
    ErrorContext.instance().reset();
  }
}

所以 Executor 的生命周期和 SqlSession 是一样的，之所以要明确的指出这一点是因为 Executor 中包含了缓存的处理，并且因为 SqlSession 是线程不安全的，所以在使用 Executor 一级缓存的时候，就很容易发生脏读；后面还会通过具体示例演示；

3. query 方法

@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  BoundSql boundSql = ms.getBoundSql(parameter);   //获取绑定的sql
  CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);  // hash(mappedStementId + offset + limit + sql + queryParams + environment)
  return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

@SuppressWarnings("unchecked")
@Override
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."); }
  
  // 查询的时候一般不清楚缓存，但是可以通过 xml配置或者注解强制清除，queryStack == 0 是为了防止递归调用
  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 {
      // 没有查到的时候直接到数据库查找
      list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }
  } finally {
    queryStack--;
  }
  if (queryStack == 0) {
    // 延迟加载队列
    for (DeferredLoad deferredLoad : deferredLoads) {
      deferredLoad.load();
    }
    deferredLoads.clear();
    if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
      // 一级缓存本身不能关闭，但是可以设置作用范围 STATEMENT，每次都清除缓存
      clearLocalCache();
    }
  }
  return list;
}

4. update 方法

@Override
public int update(MappedStatement ms, Object parameter) throws SQLException {
  ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
  if (closed) {
    throw new ExecutorException("Executor was closed.");
  }
  // update|insert|delete 方法首先会清除一级缓存
  clearLocalCache();
  return doUpdate(ms, parameter);
}

5. 模版方法

protected abstract int doUpdate(MappedStatement ms, Object parameter)
    throws SQLException;

protected abstract List<BatchResult> doFlushStatements(boolean isRollback)
    throws SQLException;

//query-->queryFromDatabase-->doQuery
protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
    throws SQLException;

这里就是一个典型的模版模式了，子类都会实现自己模版方法；

二、BaseExecutor 子类

1. SimpleExecutor

@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
  Statement stmt = null;
  try {
    Configuration configuration = ms.getConfiguration();
    StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
    stmt = prepareStatement(handler, ms.getStatementLog());
    return handler.update(stmt);
  } finally {
    closeStatement(stmt);
  }
}

@Override
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);
    stmt = prepareStatement(handler, ms.getStatementLog());
    return handler.<E>query(stmt, resultHandler);
  } finally {
    closeStatement(stmt);
  }
}

从上面的代码也可以看到 SimpleExecutor 非常的简单，每次打开一个 Statement，使用完成以后关闭；

2. ReuseExecutor

private final Map<String, Statement> statementMap = new HashMap<String, Statement>();  // Statement 缓存
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  BoundSql boundSql = handler.getBoundSql(); // 获取绑定的sql
  String sql = boundSql.getSql();
  if (hasStatementFor(sql)) { // 如果缓存中已经有了，直接得到Statement
    stmt = getStatement(sql);
  } else { // 如果缓存没有，就编译一个然后加入缓存
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection);
    putStatement(sql, stmt);
  }
  handler.parameterize(stmt);
  return stmt;
}

ReuseExecutor 就比 SimpleExecutor 多了一个 Statement 的缓存功能，其他的都是一样的；

3. BatchExecutor

首先需要明确一点 BachExecutor 是基于 JDBC 的 addBatch、executeBatch 功能的执行器，所以 BachExecutor 只能用于更新（insert|delete|update），不能用于查询（select），下面是一个 JDBC 的小 demo：

String url = "jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT";
String sql = "INSERT INTO user(username,password,address) VALUES (?,?,?)";
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(url, "root", "root");
PreparedStatement stmt = conn.prepareStatement(sql);
for (int i = 0; i < 4000; i++) {
    stmt.setString(1, "test" + i);
    stmt.setString(2, "123456");
    stmt.setString(3, "test");
    stmt.addBatch();
}
stmt.executeBatch();

下面从源码来看一下 mybatis 是如何实现的：

private final List<Statement> statementList = new ArrayList<Statement>();        // 待处理的 Statement
private final List<BatchResult> batchResultList = new ArrayList<BatchResult>();  // 对应的结果集
private String currentSql;                                                       // 上一次执行 sql
private MappedStatement currentStatement;                                        // 上次执行的 MappedStatement

@Override
public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {
  final Configuration configuration = ms.getConfiguration();
  final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);
  final BoundSql boundSql = handler.getBoundSql();
  final String sql = boundSql.getSql();  // 本次执行的 sql
  final Statement stmt;
  // 当本次执行的 sql 和 MappedStatement 与上次的相同时，直接复用上一次的 Statement
  if (sql.equals(currentSql) && ms.equals(currentStatement)) {
    int last = statementList.size() - 1;
    stmt = statementList.get(last);
    BatchResult batchResult = batchResultList.get(last);
    batchResult.addParameterObject(parameterObject);
  } else {
    // 不同时，新建 Statement，并加入缓存
    Connection connection = getConnection(ms.getStatementLog());
    stmt = handler.prepare(connection);
    currentSql = sql;
    currentStatement = ms;
    statementList.add(stmt);
    batchResultList.add(new BatchResult(ms, sql, parameterObject));
  }
  handler.parameterize(stmt);
  handler.batch(stmt);  // 添加批处理任务
  return BATCH_UPDATE_RETURN_VALUE;  // 注意这里返回的不再是更新的行数，而是一个常量
}

BatchExecutor 的批处理添加过程相当于添加了一个没有返回值的异步任务，那么在什么时候执行异步任务，将数据更新到数据库呢，答案是处理 update 的任何操作，包括 select、commit、close等任何操作，具体执行的方法就是 doFlushStatements；此外需要注意的是 Batch 方式插入使用 useGeneratedKeys 获取主键，在提交完任务之后，并不能马上取到，因为此时 sql 语句还在缓存中没有真正执行，当执行完 Flush 之后，会通过回调的方式反射设置主键；

三、效率对比

几种执行器效率对比

batchReusersimpleforeachforeach100
1003691481516870
1000485735911679148
10000274540644666386071002
50000883817788199077964443703

从上面的结果对比可以看到：

  • 整体而言 reuser 比 simple 多了缓存功能，所以无论批处理的大小，其效率都要高一些；
  • 此外在批处理量小的时候使用 foreach，效果还是可以的，但是当批量交大时，sql 编译的时间就大大增加了，当 foreach 固定批大小 + reuser 时，每次的 Statement 就可以重用，从表中也可以看到效率也时最高的；
  • batch 的优点则是所有的更新语句都能用；
  • 所以在配置的时候建议默认使用 reuser，而使用 foreach 和 batch 需要根据具体场景分析，如果更新比较多的时候，可以在批量更新的时候单独指定 ExecutorType.BATCH，如果批量插入很多的时候，可以固定批大小；

转载于:https://www.cnblogs.com/sanzao/p/11394969.html

weixin_30258901
关注
mybatis源码详解
m0_59114107的博客
02-24 458
mybatis源码详解
mybatis 源码分析（七）KeyGenerator 详解
li123128的博客
09-02 689
阅读目录 一、KeyGenerator 概述 二、Jdbc3KeyGenerator 三、SelectKeyGenerator 一、KeyGenerator 概述 在平时开发的时候经常会有这样的需求，插入数据返回主键，或者插入数据之前需要获取主键，这样的需求在 mybatis 中也是支持的，其中主要的逻辑部分就在 KeyGenerator 中，下面是他的类图： 其中： NoKeyGenera...
Mybatis核心处理层源码阅读分析（Executor系列组件）
Nicholas.S的博客
12-22 178
1 BaseExecutor 1.1 一级缓存简介 1.2 一级缓存的管理 1.3 事务操作 2 SimpleExecutor 3 ReuseExecutor 4 BatchExecutor 5 CachingExecutor
Mybatis源码阅读学习笔记(一)之Executor子类BaseExecutor源码超详细解析
qq_38925911的博客
04-13 597
Executor是一个大管家，核心功能包括：缓存维护、获取动态SQL、获取连接、以及最终的JDBC调用等。 BaseExecutor 是个很重要的抽像类，是基础执行器，包括一级缓存逻辑也在此实现，BaseExecutor是Executor的一个子类，其实现了接口Executor的部分方法，与其子类关系如下： BaseExecutor抽象类的源码及详解注释如下，源码较多，请耐心看 /** * @author Clinton Begin */ public abstract class BaseEx.
executeBatch()详解
weixin_45535710的博客
08-28 2万+
JDBC提供了数据库batch处理的能力，在数据大批量操作（新增、删除等）的情况下可以大幅度提升系统的性能。 // 关闭自动执行 con.setAutoCommit(false); Statement stmt = con.createStatement(); stmt.addBatch(“INSERT INTO employees VALUES (1000, ‘Joe Jones’)”); st...
MyBatis源码-解读Executor的三个实现类之BatchExecutor(批处理执行器)
小工匠
06-14 1万+
文章目录PreExecutor 执行器接口继承关系BatchExecutor(重用执行器)入门小demoBatchExecutor VS ReuseExecutor Pre MyBatis源码-深入理解MyBatis Executor的设计思想 工程部分见 MyBatis源码- SqlSession门面模式 & selectList 源码解析 实际中，我们都是面向SqlSession编程的，不会直接调用Executor来执行业务逻辑，这里我们仅仅是为了深入了解下Executor体系架构才这么搞
MyBatis 学习笔记（七）批量插入ExecutorType.BATCH效率对比
热门推荐
yangliuhbhd的博客
07-10 4万+
MyBatis 学习笔记（七）批量插入ExecutorType.BATCH效率对比一、在mybatis中ExecutorType的使用1.Mybatis内置的ExecutorType有3种，默认的是simple，该模式下它为每个语句的执行创建一个新的预处理语句，单条提交sql；而batch模式重复使用已经预处理的语句，并且批量执行所有更新语句，显然batch性能将更优； 2.但batch模式也有自...
Mybatis源码分析.pdf
08-30
总结起来，MyBatis源码分析涵盖了从配置加载到数据库操作的全过程，涉及到了配置解析、SQL执行、结果映射等多个关键环节，以及Executor、StatementHandler等核心组件。通过深入学习MyBatis的源码，开发者不仅可以...
MyBatis源码详解学习.zip
09-30
《MyBatis源码详解学习》是一份专为对MyBatis源码感兴趣的开发者准备的资料，它旨在帮助读者深入理解这个流行持久层框架的工作原理。MyBatis作为一个轻量级的ORM（对象关系映射）框架，因其简单易用、高度可定制化的...
myBatis源码之BatchExecutor
井底之蛙
08-14 3075
BatchExecutor是实现批处理操作，会将根据相同操作通过判断sql语句和MappedStatement来将执行放到List中，来执行批处理操作。 /** * @author Jeff Butler */ public class BatchExecutor extends BaseExecutor { public static final int BATCH_UPD
ExecutorService的正确关闭方式
韩卫卫的博客
03-08 2686
ExecutorService提供了两个接口 /** * Initiates an orderly shutdown in which previously submitted * tasks are executed, but no new tasks will be accepted. * Invocation has no additional effect if already shut down. * * 已经加入线程池的任务会被执行
Mybatis的Executor介绍（一）
Elim的博客
04-28 1万+
Mybatis的Executor介绍（一）        Mybatis中所有的Mapper语句的执行都是通过Executor进行的，Executor是Mybatis的一个核心接口，其定义如下。从其定义的接口方法我们可以看出，对应的增删改语句是通过Executor接口的update方法进行的，查询是通过query方法进行的。虽然Executor接口的实现类有BaseExecutor和Ca
Executor模块详解
MrGeroge的博客
12-05 995
Executor的功能：执行Task任务，并将计算结果传回给Driver(Task划分和调度)   6.1 Standalone模式的Executor分配详解 SparkContext->TaskScheduler->SchedulerBackend->DAGScheduler->AppClient(注册Application)->Master(启动Executor)->Worker->Ex
Mybatis 批量插入Batch模式与foreach对比
NothingToSay
11-25 4289
mysql默认接受sql的大小是 1M， 即第三种方式若数据量超过1M会报如下异常：（可通过调整MySQL安装目录下的my.ini文件中[mysqld]段的＂max_allowed_packet = 1M＂） JDBC连接url中添加参数rewriteBatchedStatements=true可 准备工作 表结构 CREATE TABLE `t_user` ( `id` varchar(32) CHARACTER SET utf8 NOT NULL COMMENT '主键', `name`.
executeUpdate()方法报错或者不执行
weixin_45827203的博客
06-20 8339
就是这句话死活不执行下去 因为我使用了查询（select）语句，所以不执行。微软官方文档明确指出， 只能使用SQL INSERT、UPDATE、MERGE 或 DELETE 语句；或是不返回任何内容的 SQL 语句，如 DDL 语句。 官方文档 https://docs.microsoft.com/zh-cn/sql/connect/jdbc/reference/executeupdate-method?view=sql-server-ver15 com.microsoft.sqlserver.jdbc
mybatis框架的分析（二）Executor执行器分析
羽枫760的博客
08-05 699
        昨天，我研究了一下mybatis框架的内部构造，对他的配置文件，SqlSessionFactory，SalSession以及xxxMapper配置文件进行了分析。今天，我们再来对它的sql语句的执行过程分析一下。        &nb...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1395
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
JDK1.0主要特性
FoolRabbit的专栏
10-06 759
JDK1.0主要特性。
Backend - Java 基础
最新发布
是萝卜干呀的博客
10-11 442
知识量决定了未来能走多远
揭秘Mybatis源码分析与高级实战策略
本资源是一份由James QQ（ID: 2904270631）主讲的咕泡学院JAVAVIP高级课程教案，名为《MyBatis源码分析专题之MyBatis源码分析与实现》。这份课程专注于深入剖析MyBatis框架的源码，适合咕泡学院JAVA高级VIP学员学习...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值