mybatis之执行器Executor

￡神魔★判官ぃ 2022-09-12 07:48 177阅读 0赞

## 写在前面 ##

在 [这篇文章][Link 1] 中分析了执行一个数据操作的时候，会话对象会调用执行器的API来执行操作，但是对于执行器并没有详细分析，这篇文章作为补充，来看下mybatis都提供了哪些类型的执行器，以及其各自提供的功能都是什么。  
想要系统学习的，可以参考 [这篇文章，重要！！！][Link 2] 。

其所在的包是`executor`，结构如下图：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_12_color_FFFFFF_t_70_g_se_x_16]

其中每个子包都实现了不同的功能，主要如下：

keygen:提供主键生成/获取策略相关功能
    loader：提供实现延迟加载功能
    parameter:提供了设置PreparedStatement占位符的功能
    result，resultSet：提供了处理查询结果集的功能
    statement：提供了向数据库发送sql命令的功能

而执行器相关的API是在包的根目录下，主要是提供了一级缓存，二级缓存和事务管理的相关功能，也就是提供一些`数据库操作相关的外围功能`,  
具体的数据库操作，委托给StatementHandler来完成，StatementHandler内部会使用ParameterHandler来完成查询语句的参数的  
处理工作，最后查询结果使用ResultSetHandler来完成结果集的映射，最终返回给用户，这个过程的发起就是SqlSession，如下图：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_20_color_FFFFFF_t_70_g_se_x_16]

上图中的Executor，执行器，就是我们本文要分析的重点。

## 1：会话中的执行器何时创建的？ ##

一般的，我们都是通过SqlSessionFactoryBuilder加载全局配置文件，然后生成SqlSessionFactory对象，会话中使用的执行器就是通过SqlSessionFactory对象的`openSession`相关的方法完成创建  
的，主要源码如下：

// org.apache.ibatis.session.defaults.DefaultSqlSessionFactory
    public class DefaultSqlSessionFactory implements SqlSessionFactory { 
      @Override
      public SqlSession openSession() { 
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
      }
    
      @Override
      public SqlSession openSession(boolean autoCommit) { 
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
      }
    
      @Override
      public SqlSession openSession(ExecutorType execType) { 
        return openSessionFromDataSource(execType, null, false);
      }
    
      @Override
      public SqlSession openSession(TransactionIsolationLevel level) { 
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), level, false);
      }
    
      @Override
      public SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level) { 
        return openSessionFromDataSource(execType, level, false);
      }
    
      @Override
      public SqlSession openSession(ExecutorType execType, boolean autoCommit) { 
        return openSessionFromDataSource(execType, null, autoCommit);
      }
    
      @Override
      public SqlSession openSession(Connection connection) { 
        return openSessionFromConnection(configuration.getDefaultExecutorType(), connection);
      }
    
      @Override
      public SqlSession openSession(ExecutorType execType, Connection connection) { 
        return openSessionFromConnection(execType, connection);
      }
    }

其中大量出现了`ExecutorType`,这是一个指定执行器都有哪些类型的枚举类，源码如下：

// org.apache.ibatis.session.ExecutorType 
    public enum ExecutorType { 
      SIMPLE, REUSE, BATCH
    }

继续看`openSessionFromDataSource`方法，主要源码如下：

// org.apache.ibatis.session.defaults.DefaultSqlSessionFactory.openSessionFromDataSource
    public class DefaultSqlSessionFactory implements SqlSessionFactory { 
        private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { 
            Transaction tx = null;
            try { 
              // ...snip...
              // 2021-09-23 15:34:06
              final Executor executor = configuration.newExecutor(tx, execType);
              // ...snip...
            } catch (Exception e) { 
              // ...snip...
            } finally { 
              // ...snip...
            }
          }
    }

`2021-09-23 15:34:06`处就是通过全局配置文件来创建执行器对象了，源码如下：

// org.apache.ibatis.session.Configuration.newExecutor(org.apache.ibatis.transaction.Transaction, org.apache.ibatis.session.ExecutorType)
    public class Configuration { 
      public Executor newExecutor(Transaction transaction, ExecutorType executorType) { 
          // 根据executorType枚举的类型，创建对应的Executor的实现类
          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);
          }
          // 如果是开启了缓存则使用CachingExecutor启用二级缓存功能
          // 具体配置是在全局配置文件中的settings标签中配置setting，其中key是cacheEnabled，可能如下配置:
          /* <settings> <setting name="cacheEnabled" value="true"/> </settings> */
          if (cacheEnabled) { 
            executor = new CachingExecutor(executor);
          }
          // 将创建的执行器，使用可能存在的插件生成代理类，这样后续就可以使用代理类操作，应用插件定义的信息了
          // 2021-09-23 16:06:25
          executor = (Executor) interceptorChain.pluginAll(executor);
          return executor;
        }  
    }

`2021-09-23 16:06:25`处使用定义的插件生成创建的执行器的代理类（当然也可能不生成，当`@org.apache.ibatis.plugin.Signature`注解中没有配置对应type接口时），实现的原理  
是jdk反射包中的动态代理API`Proxy.newProxyInstance`,为了制定规范，定义了接口`org.apache.ibatis.plugin.Interceptor`,想要自定义插件只需要实现该接口，然后再类上使用  
`@Intercepts+@Signature`注解的组合来定义要代理哪些类的哪些方法。具体详细可以参考 [这篇文章][Link 3] ,也可以  
参考 [这篇文章][Link 4] 看其具体应用实例。  
到这里，执行器的创建过程基本清晰了，下面来看下执行期不同的实现类提供了哪些具体的功能。

## 2：接口Executor ##

执行器对应的顶层接口是`org.apache.ibatis.executor.Executor`,源码如下：

public interface Executor { 
    
      ResultHandler NO_RESULT_HANDLER = null;
      // 更新，可更新，可插入，可删除，具体有MappedStatement的SQL语句决定
      int update(MappedStatement ms, Object parameter) throws SQLException;
      // 查询
      <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
      <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
    
      List<BatchResult> flushStatements() throws SQLException;
      // 提交事务
      void commit(boolean required) throws SQLException;
      // 回滚事务
      void rollback(boolean required) throws SQLException;
      // 生成缓存键
      CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
      // 判断是否缓存
      boolean isCached(MappedStatement ms, CacheKey key);
      // 清空本地缓存
      void clearLocalCache();
      // 延迟加载
      void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);
      // 获取事务对象
      Transaction getTransaction();
      // 关闭
      void close(boolean forceRollback);
      // 判断是否关闭
      boolean isClosed();
      
      void setExecutorWrapper(Executor executor);
    
    }

其实现类如下图：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_20_color_FFFFFF_t_70_g_se_x_16 1]

其中`BaseExecutor`提供了一级缓存的功能，就是其本地缓存。`CachingExecutor`是提供了二级缓存的功能。其他的实现类我们都一起在后面一起分析。

## 3：BaseExecutor ##

该类是`org.apache.ibatis.executor.Executor`接口的基础子类，对于公共的行为提供了实现，对于需要子类实现的特性化行为提供了模板方法，提供了一级缓存的功能，具体是通过维护  
一个`org.apache.ibatis.cache.Cache`接口的子类`org.apache.ibatis.cache.impl.PerpertualCache`来缓存数据，其实就是通过维护一个`HashMap的kv结构`，可参考下图：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_20_color_FFFFFF_t_70_g_se_x_16 2]

### 3.1：构造函数 ###

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
          // 事务
          protected Transaction transaction;
          protected Executor wrapper;
          // 延迟加载
          protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
          // 提供一级缓存功能，默认开启，不可关闭！！！
          protected PerpetualCache localCache;
          protected PerpetualCache localOutputParameterCache;
          // 全局配置文件对应的org.apache.ibatis.session.Configuration对象
          protected Configuration configuration;
          // 查询栈深度
          protected int queryStack = 0;
          // 执行器是否关闭状态
          private boolean closed;
        
          protected BaseExecutor(Configuration configuration, Transaction transaction) { 
            this.transaction = transaction;
            this.deferredLoads = new ConcurrentLinkedQueue<DeferredLoad>();
            this.localCache = new PerpetualCache("LocalCache");
            this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
            this.closed = false;
            this.configuration = configuration;
            this.wrapper = this;
          }
    
    }

### 3.2：清空本地一级缓存 ###

使用的方法是`org.apache.ibatis.executor.BaseExecutor.clearLocalCache`源码如下：

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
      public void clearLocalCache() { 
        // 当前执行器没有关闭才处理
        if (!closed) { 
          // 清空一级缓存,其实就是清空底层的Map
          // private Map<Object, Object> cache = new HashMap<Object, Object>();
          // cache.clear();最终调用该方法
          localCache.clear();
          localOutputParameterCache.clear();
        }
      }
    }

### 3.3：创建缓存键 ###

在查询数据后添加缓存时，需要生成缓存键，主要是依赖于`statementId+rowbounds+传入PreparedStatement的sql语句+传入PreparedStatement的参数`,这里关于参数需要注意，是传入PreparedStatement的参数  
，即最终使用的参数，即调用了`PreparedStatement#setXXX`方法进行设置的参数，而非调用mapper接口方法传入的参数，因为可能存在传入的参数没有使用的场景（如，动态sql语句）。

创建缓存键调用的方法是`createCacheKey`,源码如下,重点看下标了数字的，无关的源码进行了删除：

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
      @Override
        public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) { 
          // ...snip...
          // 1：创建缓存键对象
          CacheKey cacheKey = new CacheKey();
          // 2：加入statementId到键计算中
          cacheKey.update(ms.getId());
          // 3：加入rowBounds中的offset到键计算中
          cacheKey.update(Integer.valueOf(rowBounds.getOffset()));
          // 4：加入rowBounds中的limit到键计算中
          cacheKey.update(Integer.valueOf(rowBounds.getLimit()));
          // 5：加入boundSql中的sql语句到键计算中
          cacheKey.update(boundSql.getSql());
          List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
          TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
          // mimic DefaultParameterHandler logic
          for (int i = 0; i < parameterMappings.size(); i++) { 
            ParameterMapping parameterMapping = parameterMappings.get(i);
            if (parameterMapping.getMode() != ParameterMode.OUT) { 
              // ...snip...
              // 6：加入参数值到键计算中
              cacheKey.update(value);
            }
          }
          // ...snip...
          return cacheKey;
        }
    }

### 3.4：是否已经缓存 ###

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
        public boolean isCached(MappedStatement ms, CacheKey key) { 
            return localCache.getObject(key) != null;
        }
    }

### 3.5：查询 ###

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
        public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { 
            // 获取BoundSql（sql+执行sql的参数对象）
            BoundSql boundSql = ms.getBoundSql(parameter);
            // 创建缓存键
            CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
            // 重构版本查询
            return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
        }
    }

关于查询详细参考 [这篇文章][Link 5]。

### 3.6：更新 ###

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
        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.");
            }
            clearLocalCache();
            return doUpdate(ms, parameter);
         }
    }

关于更新详细参考 [这篇文章][Link 6]。

### 3.7：事务 ###

#### 3.7.1：获取事务 ####

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
        public Transaction getTransaction() { 
            if (closed) { 
              throw new ExecutorException("Executor was closed.");
            }
            return transaction;
        }
    }

#### 3.7.2：提交事务 ####

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
        public void commit(boolean required) throws SQLException { 
            if (closed) { 
              throw new ExecutorException("Cannot commit, transaction is already closed");
            }
            clearLocalCache();
            flushStatements();
            if (required) { 
              transaction.commit();
            }
        }
    }

#### 3.7.3：回滚事务 ####

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
        public void rollback(boolean required) throws SQLException { 
            if (!closed) { 
              try { 
                clearLocalCache();
                flushStatements(true);
              } finally { 
                if (required) { 
                  transaction.rollback();
                }
              }
            }
        }
    }

### 3.8：关闭 ###

#### 3.8.1：关闭执行器 ####

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
        public void close(boolean forceRollback) { 
            try { 
              try { 
                rollback(forceRollback);
              } finally { 
                if (transaction != null) { 
                  transaction.close();
                }
              }
            } catch (SQLException e) { 
              // Ignore. There's nothing that can be done at this point.
              log.warn("Unexpected exception on closing transaction. Cause: " + e);
            } finally { 
              transaction = null;
              deferredLoads = null;
              localCache = null;
              localOutputParameterCache = null;
              closed = true;
            }
        }
    }

#### 3.8.2：执行器是否关闭 ####

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
        public boolean isClosed() { 
            return closed;
        }
    }

### 3.9：其他方法 ###

// org.apache.ibatis.executor.BaseExecutor
    public abstract class BaseExecutor implements Executor { 
        // 获取JDBC的java.sql.Connection对象,即获取数据库连接
        protected Connection getConnection(Log statementLog) throws SQLException { 
            Connection connection = transaction.getConnection();
            if (statementLog.isDebugEnabled()) { 
              return ConnectionLogger.newInstance(connection, statementLog, queryStack);
            } else { 
              return connection;
            }
        }
        
        // 关闭JDBC的java.sql.Statement对象
        protected void closeStatement(Statement statement) { 
            if (statement != null) { 
              try { 
                statement.close();
              } catch (SQLException e) { 
                // ignore
              }
            }
        }    
    }

## 4：SimpleExecutor ##

代码不是特别多，直接看源码：

// org.apache.ibatis.executor.SimpleExecutor
    public class SimpleExecutor extends BaseExecutor { 
    
      public SimpleExecutor(Configuration configuration, Transaction transaction) { 
        super(configuration, transaction);
      }
    
      @Override
      public int doUpdate(MappedStatement ms, Object parameter) throws SQLException { 
        Statement stmt = null;
        try { 
          // 获取全局配置文件对应的org.apache.ibatis.session.Configuration对象
          Configuration configuration = ms.getConfiguration();
          // 通过configuration对象创建StatementHandler
          StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
          // 通过Statement Handler获取java.sql.Statement对象
          stmt = prepareStatement(handler, ms.getStatementLog());
          // 通过StatementHandler使用java.sql.Statement执行更新
          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 { 
          // 获取全局配置文件对应的org.apache.ibatis.session.Configuration对象
          Configuration configuration = ms.getConfiguration();
          // 通过configuration对象获取StatementHandler
          StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
          // 准备java.sql.Statement
          stmt = prepareStatement(handler, ms.getStatementLog());
          // 通过StatementHandler使用java.sql.Statement执行查询
          return handler.<E>query(stmt, resultHandler);
        } finally { 
          closeStatement(stmt);
        }
      }
    
      @Override
      public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException { 
        // 因为不支持批处理，直接返回空集合
        return Collections.emptyList();
      }
    
      // 准备java.sql.Statement
      private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { 
        Statement stmt;
        // 获取java.sql.Connection连接对象
        Connection connection = getConnection(statementLog);
        // 通过statementhandler获取java.sql.Statement对象
        stmt = handler.prepare(connection);
        // 设置参数信息
        handler.parameterize(stmt);
        return stmt;
      }
    
    }

## 5：ReuseExecutor ##

和`4：SimpleExecutor`唯一不同之处在于增加了`java.sql.Statement`的缓存功能，因为对于相同的sql语句该对象是可以被复用的，只需要重新设置参数就可以了，源码如下：

// org.apache.ibatis.executor.ReuseExecutor
    public class ReuseExecutor extends BaseExecutor { 
      // java.sql.Statement的缓存对象，key：sql，value：java.sql.Statement
      private final Map<String, Statement> statementMap = new HashMap<String, Statement>();
    
      public ReuseExecutor(Configuration configuration, Transaction transaction) { 
        super(configuration, transaction);
      }
    
      @Override
      public int doUpdate(MappedStatement ms, Object parameter) throws SQLException { 
        // 获取全局配置文件对应的org.apache.ibatis.session.Configuration对象
        Configuration configuration = ms.getConfiguration();
        // 获取org.apache.ibatis.executor.statement.StatementHandler对象
        StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
        // 获取java.sql.Statement对象
        Statement stmt = prepareStatement(handler, ms.getStatementLog());
        // 执行更新
        return handler.update(stmt);
      }
    
      @Override
      public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { 
        // 获取全局配置文件对应的org.apache.ibatis.session.Configuration对象
        Configuration configuration = ms.getConfiguration();
        // 获取org.apache.ibatis.executor.statement.StatementHandler对象
        StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
        // 获取java.sql.Statement对象
        Statement stmt = prepareStatement(handler, ms.getStatementLog());
        // 执行查询
        return handler.<E>query(stmt, resultHandler);
      }
    
      @Override
      public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException { 
        // 关闭缓存的java.sql.Statement对象们
        // 放在这关闭的原因是，在org.apache.ibatis.executor.BaseExecutor的close方法中会调用rollback方法
        // 而在rollback方法中就会调用该方法，因此此时这里的实现就会被调用到，从而关闭缓存的java.sql.Statement
        for (Statement stmt : statementMap.values()) { 
          closeStatement(stmt);
        }
        // 清空java.sql.Statement缓存map
        statementMap.clear();
        // 不支持批处理，直接返回空集合
        return Collections.emptyList();
      }
    
      private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { 
        Statement stmt;
        // 获取org.apache.ibatis.mapping.BoundSql（sql+参数）
        BoundSql boundSql = handler.getBoundSql();
        // 获取sql
        String sql = boundSql.getSql();
        // 在缓存中已经有的话，则直接从缓存中
        if (hasStatementFor(sql)) { 
          // 从缓存中获取java.sql.Statement，ReuseExecutor中的"reuse"也正是体现在这里的
          stmt = getStatement(sql);
        } else { 
          // 获取java.sql.Statement对象
          Connection connection = getConnection(statementLog);
          stmt = handler.prepare(connection);
          putStatement(sql, stmt);
        }
        handler.parameterize(stmt);
        return stmt;
      }
      
      // 判断指定SQL语句是否已经缓存了java.sql.Statement对象
      private boolean hasStatementFor(String sql) { 
        try { 
          // 缓存map中包含并且底层的java.sql.Connection对象没有关闭，才认为存在
          return statementMap.keySet().contains(sql) && !statementMap.get(sql).getConnection().isClosed();
        } catch (SQLException e) { 
          return false;
        }
      }
      
      // 从缓存中获取java.sql.Statement
      private Statement getStatement(String s) { 
        return statementMap.get(s);
      }
    
      // 放置java.sql.Statement到缓存中
      private void putStatement(String sql, Statement stmt) { 
        statementMap.put(sql, stmt);
      }
    
    }

## 6：BatchExecutor ##

提供了批处理功能的执行器的实现类。为了便于理解BatchExecutor提供的批处理实现，先来看下JDBC的原生`java.sql.Statement`和`java.sql.PreparedStatement`执行批处理的  
方式。

*  java.sql.Statement

public class Foo { 
         public void pseudoCode() { 
             // 添加sql
             Statement.addBatch(sql1);
             Statement.addBatch(sql2);
             Statement.addBatch(sql3);
             // 执行批量更新
             Statement.executeBatch();
         }
    }

> 优点：可以向数据库发送多条不同的ＳＱＬ语句。  
> 缺点：没有预编译，存在sql注入风险，且当sql只有参数不同时，也需要重复多次，冗余。

*  java.sql.PreparedStatement

public class Foo { 
         public void pseudoCode() { 
            Connection conn = DBUtils.getConnection();
            // 只有一个sql语句
            String sql = "insert into testbatch(id,name) values(?,?)";
            PreparedStatement st = conn.prepareStatement(sql);
            // 加入参数到批处理中
            for(int i=1;i<1000008;i++){   //i=1000 2000
                st.setInt(1, i);
                st.setString(2, "aa" + i);
                // 加入到批处理
                st.addBatch();
                // 每1000次执行一次批处理
                if(i%1000==0){ 
                    st.executeBatch();
                    // 清空已处理的参数信息
                    st.clearBatch();
                }
            }
            // 批处理剩下的
            st.executeBatch();
         }
    }

BatchExecutor源码如下：

// org.apache.ibatis.executor.BatchExecutor
    public class BatchExecutor extends BaseExecutor { 
    
      public static final int BATCH_UPDATE_RETURN_VALUE = Integer.MIN_VALUE + 1002;
      // 保存待处理的Statement的集合，因为同一个sql语句只能有一个Statement，所以当sql语句不通的时候就会存在多个Statement
      // 按照sql语句的顺序生成，比如AABBCCDD就会有4个Statement
      // 这里的Statement可以是java.sql.Statement,也可以是java.sql.PreparedStatement(这是java.sql.Statement的子接口)
      private final List<Statement> statementList = new ArrayList<Statement>();
      // BatchResult:封装更新结果信息的类，如更新影响的行数，这里和statementList是一一对应的关系
      private final List<BatchResult> batchResultList = new ArrayList<BatchResult>();
      // 因为可能为多次调用更新，这里记录已经调用更新的最后一个SQL语句
      private String currentSql;
      // 因为可能为多次调用更新，这里记录已经调用更新的最后一个MappedStatement
      private MappedStatement currentStatement;
    
      public BatchExecutor(Configuration configuration, Transaction transaction) { 
        super(configuration, transaction);
      }
    
      @Override
      public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException { 
        // 获取全局配置文件对应的org.apache.ibatis.session.Configuration对象
        final Configuration configuration = ms.getConfiguration();
        // 获取statementhandler
        final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);
        // 获取boundSql对象
        final BoundSql boundSql = handler.getBoundSql();
        // 从boundSql对象中获取要执行的sql语句
        final String sql = boundSql.getSql();
        final Statement stmt;
        // 如果是相同的sql语句，并且是相同statement，即StatementId相同
        if (sql.equals(currentSql) && ms.equals(currentStatement)) { 
          // 获取最后一个java.sql.Statement，其实也就是currentSql所设置的statement
          // 因为是相同的sql语句，所以可以使用相同的java.sql.Statment对象
          int last = statementList.size() - 1;
          stmt = statementList.get(last);
          // 设置新的参数
          handler.parameterize(stmt);
          BatchResult batchResult = batchResultList.get(last);
          batchResult.addParameterObject(parameterObject);
        } else {  // 如果是新的sql语句
          // 重新获取java.sql.Connection
          Connection connection = getConnection(ms.getStatementLog());
          // 生成新的java.sql.Statement
          stmt = handler.prepare(connection);
          // 设置参数到批处理中
          handler.parameterize(stmt);    
          // 赋值为当前sql，便于下次执行更新时使用
          currentSql = sql;
          // 赋值到当前MappedStatement
          currentStatement = ms;
          // 添加到待处理的java.sql.Statement集合中
          statementList.add(stmt);
          batchResultList.add(new BatchResult(ms, sql, parameterObject));
        }
        // 调用对应的StatementHandler的实现类，添加到批处理中，如下是java.sql.PreparedStatement对应的额PreparedStatementHandler的源码：
        /* public void batch(Statement statement) throws SQLException { PreparedStatement ps = (PreparedStatement) statement; ps.addBatch(); } */
        // 如下是java.sql.Statement对应的SimpleStatementHandler的源码：
        /* public void batch(Statement statement) throws SQLException { String sql = boundSql.getSql(); statement.addBatch(sql); } */
        // 这里就是使用的JDBC的API了，和前面给出的JDBC批处理的简单代码就对应起来了！！！
        handler.batch(stmt);
        return BATCH_UPDATE_RETURN_VALUE;
      }
    
      // ...snip...
        
      // 执行批处理的更新
      @Override
      public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException { 
        try { 
          List<BatchResult> results = new ArrayList<BatchResult>();
          if (isRollback) { 
            return Collections.emptyList();
          }
          // 循环批处理更新
          for (int i = 0, n = statementList.size(); i < n; i++) { 
            // 获取java.sql.Statement对象
            Statement stmt = statementList.get(i);
            // 获取对应的存储更新结果的BatchResult对象
            BatchResult batchResult = batchResultList.get(i);
            try { 
              // 执行更新，并将返回结果，设置到影响行数字段
              batchResult.setUpdateCounts(stmt.executeBatch());
              MappedStatement ms = batchResult.getMappedStatement();
              List<Object> parameterObjects = batchResult.getParameterObjects();
              KeyGenerator keyGenerator = ms.getKeyGenerator();
              // 执行生成主键设置,按照JdbcKeyGenerator和非Jdbc3KeyGenerator处理
              if (Jdbc3KeyGenerator.class.equals(keyGenerator.getClass())) { 
                Jdbc3KeyGenerator jdbc3KeyGenerator = (Jdbc3KeyGenerator) keyGenerator;
                jdbc3KeyGenerator.processBatch(ms, stmt, parameterObjects);
              } else if (!NoKeyGenerator.class.equals(keyGenerator.getClass())) {  
                for (Object parameter : parameterObjects) { 
                  keyGenerator.processAfter(this, ms, stmt, parameter);
                }
              }
            } catch (BatchUpdateException e) { 
              // ...snip...
            }
            // 添加批处理结果
            results.add(batchResult);
          }
          return results;
        } finally { 
          // 执行完毕，关闭资源，释放对象
          for (Statement stmt : statementList) { 
            closeStatement(stmt);
          }
          currentSql = null;
          statementList.clear();
          batchResultList.clear();
        }
      }
    
    }

## 7：CachingExecutor ##

通过该类来实现二级缓存的功能，不同于一级缓存，二级缓存的作用范围更大，在一个namespace范围内有效，可跨多个SqlSession会话，在BaseExecutor的分析中我们知道一级缓存是使用其  
PerpetualCache类型的localCache变量来实现的，每次新建会话，都会新建执行器，因此该缓存变量也会重建，二级缓存使用的也是`org.apache.ibatis.cache.Cache`接口的子类，默认  
也是PerpetualCache(也可通过`<cache type="xxxx"/>`进行自定义)来实现的，但是变量是定义在statement对应额MappedStatement对象中的，因为一个statement对应的  
MappedStatement只会有一个，所以可以实现跨会话的缓存功能，那么为什么要定义在MappedStatement中呢？因为能够利用到缓存的只可能是针对同一个statement的查询操作，二者缓存  
变量定义源码如下：

*  一级缓存

// org.apache.ibatis.executor.
    // 一个会话一个该对象实例，因此一级缓存会话内有效
    public abstract class BaseExecutor implements Executor { 
      protected PerpetualCache localCache;
    }

*  二级缓存

// org.apache.ibatis.mapping.MappedStatement
    // 一个statement对应一个该对象，因此二级缓存可以实现跨会话查询,但是注意一个命名空间只有一个Cache类，但是会在
    // MappedStatement中被引用
    public final class MappedStatement { 
      private Cache cache;
    }

二者工作原理可以参考下图：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_20_color_FFFFFF_t_70_g_se_x_16 3]

想要开启二级缓存需要配置2部分内容，首先，在全局配置文件中配置`<setting name="cacheEnabled" value="true"/>`，然后在mapper xml中配置`</cache>`。

看下源码：

// org.apache.ibatis.executor.CachingExecutor
    // 装饰设计模式，装饰真正执行数据库查询的执行器类
    public class CachingExecutor implements Executor { 
      // 装饰器设计模式中被装饰执行器类
      private Executor delegate;
      private TransactionalCacheManager tcm = new TransactionalCacheManager();
    
      public CachingExecutor(Executor delegate) { 
        this.delegate = delegate;
        delegate.setExecutorWrapper(this);
      }
    
      @Override
      public Transaction getTransaction() { 
        return delegate.getTransaction();
      }
    
      @Override
      public int update(MappedStatement ms, Object parameterObject) throws SQLException { 
        // 更新，刷新一级缓存和二级缓存
        flushCacheIfRequired(ms);
        // 使用代理类执行真正的更新操作
        return delegate.update(ms, parameterObject);
      }
    
      @Override
      public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { 
        // 从MappedStatement中获取BoundSql
        BoundSql boundSql = ms.getBoundSql(parameterObject);
        // 生成缓存键对象CacheKey
        CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
        // 调用重载的query方法
        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 { 
        // 从MappedStatement中获取Cache
        Cache cache = ms.getCache();
        // 配置了二级缓存
        if (cache != null) { 
          // ...snip...
          if (ms.isUseCache() && resultHandler == null) { 
            // ...snip...
            // 注意这里使用tcmTransactionCacheManager来管理二级缓存，原因是
            // 二级缓存是跨事务的，所以需要考虑到事务隔离的问题，简单说就是，没有提交的事务
            // 是不能放到二级缓存中的，此时其他会话也无法使用到这里的缓存，事务提交，才会将
            // 事务中产生的数据同步到缓存中
            // 从二级缓存中获取，这里正是二级缓存生效的地方了！！！
            List<E> list = (List<E>) tcm.getObject(cache, key);
            // ...snip...
            return list;
          }
        }
        // 调用代理类的query方法执行真正的查询操作
        return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }
     
      // 刷新缓存
      private void flushCacheIfRequired(MappedStatement ms) { 
        Cache cache = ms.getCache();
        if (cache != null && ms.isFlushCacheRequired()) {       
          tcm.clear(cache);
        }
      }
    
    }

## 写在后面 ##

参考文章列表：

[Mybatis3.3.x技术内幕（四）：五鼠闹东京之执行器Executor设计原本][Mybatis3.3.x_Executor]

[Link 1]: https://blog.csdn.net/wang0907/article/details/119804451
[Link 2]: https://blog.csdn.net/wang0907/article/details/118675622
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_12_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/2274bca549024519bca3589655485d45.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/0370a1b52d254d41b7690232101b2b72.png
[Link 3]: https://blog.csdn.net/wang0907/article/details/120001462
[Link 4]: https://blog.csdn.net/wang0907/article/details/120021924
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/fd1b06305b3d48a19147052aba8451e6.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/d0c20b4ce44e46e29f8903fefcc51c74.png
[Link 5]: https://blog.csdn.net/wang0907/article/details/119804451#t3
[Link 6]: https://blog.csdn.net/wang0907/article/details/119804451#t4
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220828/db19c275849c45a7bdbeaccdc6c0ebed.png
[Mybatis3.3.x_Executor]: https://my.oschina.net/zudajun/blog/667214