mybatis之Executor

Executor是MyBatis的核心接口之一，其中定义了数据库操作的基本方法。在实际应用中经常涉及的SqlSession接口的功能，都是基于Executor接口实现的。Executor接口中定义的方法如下：

public interface Executor {

  ResultHandler NO_RESULT_HANDLER = null;

  // 执行insert、update、delete等操作
  int update(MappedStatement ms, Object parameter) throws SQLException;

  // 执行 select类型的SQL语句，返回位分为结果对象列表或游标对象
  <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;

  <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;

  // 批量执行SQL语句
  List<BatchResult> flushStatements() throws SQLException;

  // 提交事务
  void commit(boolean required) throws SQLException;

  // 回滚事务
  void rollback(boolean required) throws SQLException;

  // 创建缓存中用的CacheKey对象
  CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);

  // 根据CacheKey对象查找缓存
  boolean isCached(MappedStatement ms, CacheKey key);

  // 清空一级缓存
  void clearLocalCache();

  // 延迟加载一级缓存中的数据
  void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);

  // 获取事务对象
  Transaction getTransaction();

  // 关闭Executor对象
  void close(boolean forceRollback);

  // 检测Executor是否已关闭
  boolean isClosed();

  void setExecutorWrapper(Executor executor);

}

1.BaseExecutor

BaseExecutor是一个实现了Executor接口的抽象类，它实现了Executor接口的大部分方法，其中就使用了模板方法模式。BaseExecutor主要提供了缓存管理和事务管理的基本功能，继承BaseExecutor的子类只要实现四个基本方法来完成数据库的相关操作即可，这四个方法分别doUpdate()方法、doQuery()方法、doQueryCursor()方法、doFlushStatement()方法，其余的功能在BaseExecutor实现。

BaseExecutor各个字段的含义如下：

  // Transaction对象，实现事务的提交、回滚和关闭操作
  protected Transaction transaction;
  // 封装的Executor对象
  protected Executor wrapper;

  // 延迟加载队列
  protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
  // 一级缓存，用于缓存该Executor对象查询结果集映射得到的结果对象
  protected PerpetualCache localCache;
  // 一级缓存，用于缓存输出类型的参数
  protected PerpetualCache localOutputParameterCache;

  // 用来记录嵌套查询的层数
  protected int queryStack;

一级缓存

执行 select 语句查询数据库是最常用的功能，BaseExecutor.query()方法会首先创建CacheKey对象，并根据该CacheKey对象查找一级缓存，如果缓存命中则返回缓存中记录的结果对象，如果缓存未命中则查询数据库得到结果集，之后将结果集映射成结果对象并保存到一级缓存中，同时返回结果对象。query()方法的具体实现如下：

@Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 获取BoundSql对象
    BoundSql boundSql = ms.getBoundSql(parameter);
    // 创建CacheKey对象
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    // 调用query()的一个重载
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
  }

这里关注BaseExecutor.createCacheKey()方法创建的CacheKey对象由哪几部分构成，createCacheKey()方法具体实现如下：

 @Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    // 检测Executor是否关闭
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    // 添加MappedStatement的id
    cacheKey.update(ms.getId());
    // 添加offset
    cacheKey.update(rowBounds.getOffset());
    // 添加limit
    cacheKey.update(rowBounds.getLimit());
    // 添加SQL语句
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // mimic DefaultParameterHandler logic
    // 获取实参并添加到CacheKey
    for (ParameterMapping parameterMapping : parameterMappings) {
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) {
          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);
        }
        cacheKey.update(value);
      }
    }
    // 添加Environment的id
    if (configuration.getEnvironment() != null) {
      // issue #176
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }

由此可知该CacheKey对象由MappedStatement的id 、对应的offset、limit、SQL语句（包含?占位符）、用户传递的实参以及Environment.id这五部分构成。

继续来看上述代码中调用的query()方法的另一重载的具体实现，该重载会根据前面创建的CacheKey对象查询一级缓存，如果缓存命中则将缓存中记录的结果对象返回，如果缓存未命中，则调用 doQuery()方法完成数据库的查询操作并得到结果对象，之后将结果对象记录到一级缓存中。具体实现如下：

@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());
    // 检测Executor是否关闭
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      // 非嵌套查询，并且节点配置的flushCache属性为true时，才会清空一级缓存
      clearLocalCache();
    }
    List<E> list;
    try {
      // 增加查询层数
      queryStack++;
      // 查询一级缓存
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        // 针对存储过程调用的处理,其功能是：在一级缓存命中时，获取缓存中保存的输出类型参数，并设置到用户传入的实参对象中
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        // 调用doQuery()方法完成数据库查询，并得到映射后的结果对象，
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      // 当前查询完成，层数减少
      queryStack--;
    }
    // 延迟加载
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }
 
  
上面介绍了BaseExecutor中缓存的第一种功能，也就是缓存结查询得到的结果对象。除此之外，一级缓存还有第二个功能：前面在分析嵌套查询时，如果一级缓存中缓存了嵌套查询的结果对象，则可以从一级缓存中直接加载该结果对象；如果一级缓存中记录的嵌套查询的结果对象并未完全加载，则可以通过DeferredLoad实现类似延迟加载的功能。
 
  
Executor中与上述功能直接相关的方法有两个，一个是isCached()方法负责检测是否缓存指定查询的结果对象，具体实现如下：
 
  
 @Override
  public boolean isCached(MappedStatement ms, CacheKey key) {
    // 检测缓存中是否缓存了对应的对象
    return localCache.getObject(key) != null;
  }
 
  
另一个是 deferLoad()方法，它负责创建DeferredLoad对象并将其添加到deferredLoads集合中，具体实现如下：
 
  
  @Override
  public <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    return doQueryCursor(ms, parameter, rowBounds, boundSql);
  }

  @Override
  public void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    // 创建DeferredLoad对象
    DeferredLoad deferredLoad = new DeferredLoad(resultObject, property, key, localCache, configuration, targetType);
    if (deferredLoad.canLoad()) {
      // 一级缓存中已经记录了指定查询的结果对象 直接从缓存中加载对象，并设置到外层对象中
      deferredLoad.load();
    } else {
      // 将DeferredLoad对象添加到deferredLoads队列中，待整个外层查询结束后，再加载该结果对象
      deferredLoads.add(new DeferredLoad(resultObject, property, key, localCache, configuration, targetType));
    }
  }
 
  
DeferredLoad是定义在BaseExecutor中的内部类，它负责从localCache缓存中延迟加载结果对象，其字段的含义如下：
 
  
  // 外层对象对应的MetaObject对象
    private final MetaObject resultObject;
    // 延迟加载的局生名称
    private final String property;
    // 延迟加载的属性的类型
    private final Class<?> targetType;
    // 延迟加载的结果对象在一级缓存中相应的CacheKey对象
    private final CacheKey key;
    // 一级缓存
    private final PerpetualCache localCache;
    private final ObjectFactory objectFactory;
    // 负责结采对象的类型转换
    private final ResultExtractor resultExtractor;
 
  
DeferredLoad.canLoad()方法负责检测缓存项是否已经完全加载到了缓存中。首先要说明完全加载的含义BaseExecutor.queryFromDatabase()方法中，开始查询调用doQuery()方法查询数据库之前，会先在localCache中添加占位符，待查询完成之后才将真正的结果对象放到localCache中缓存，此时该缓存项才算完全加载。BaseExecutor.queryFromDatabase()方法具体实现如下：
 
  
 private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    // 在缓存中添加占位符
    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;
  }

 
  
DeferredLoad.canLoad()方法的具体实现如下：
 
  
  public boolean canLoad() {
      // 检测缓存是否存在指定的结果对象和是否为占位符
      return localCache.getObject(key) != null && localCache.getObject(key) != EXECUTION_PLACEHOLDER;
    }
 
  
DeferredLoad.load()方法负责从缓存中加载结果对象，并设置到外层对象的相应属性中，具体实现如下：
 
  
public void load() {
      @SuppressWarnings("unchecked")
      // we suppose we get back a List
      // 从缓存中查询结果对象
      List<Object> list = (List<Object>) localCache.getObject(key);
      // 将结果对象转换成指定类型
      Object value = resultExtractor.extractObjectFromList(list, targetType);
      // 设置到外层对象的对应属性
      resultObject.setValue(property, value);
    }
 
  
介绍完DeferredLoad对象之后，来看触发DeferredLoad缓存中加载结果对象的相关代码，这段代码在 BaseExecutor. query()方法中，具体实现如下：
 
  
 @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  	// ...
    // 延迟加载
    if (queryStack == 0) {
      // 在最外层的查询结束时，所有嵌套查询也已经完成，相关缓存项也已经完全加载，所以在这里可以触发DeferredLoad加载一级缓存中记录的嵌套查询的结果对象
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      // 加载完成后清空deferredLoads
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        // 根据localCacheScope配置决定是否清空一级缓存
        clearLocalCache();
      }
    }
    return list;
  }
 
  
BaseExecutor.queryCursor()方法的主要功能也是查询数据库，这一点与 query()方法类似，但它不会直接将结果集映射为结果对象，而是将结果集封装成Cursor对象并返回，待用户遍历Cursor时才真正完成结果集的映射操作。另外，queryCursor()方法是直接调用doQueryCursor()这个基本方法实现的，并不会像 query()方法那样使用查询一级缓存。
 
  
BaseExecutor.update()方法负责执行insert、update、delete三类SQL语句，它是调用doUpdate()模板方法实现的。在调用doUpdate()方法之前会清空缓存，因为执行SQL语句之后，数据库中的数据已经更新，一级缓存的内容与数据库中的数据可能己经不一致了，所以需要调用clearLocalCache()方法清空一级缓存中的脏数据。
 
  
@Override
  public int update(MappedStatement ms, Object parameter) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
    // 判断当前Executor是否已经关闭
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    // 清楚一级缓存
    clearLocalCache();
    // 调用doUpdate()方法
    return doUpdate(ms, parameter);
  }
 
  
事务相关操作
 
  
在BatchExecutor实现中，可以缓存多条SQL语句，等待合适的时机将缓存的多条SQL语句，并发送到数据库执行 Executor.flushStatements()方法主要是针对批处理多条SQL语句的，它会调用doFlushStatements()这个基本方法处理 Executor 缓存的多条SQL语句。在BaseExecutor.commit()、rollback()等方法中都会首先调用flushStatements()方法，然后再执行相关事务操作。
 
  
BaseExecutor. flushStatements()方法的具体实现如下：
 
  
public List<BatchResult> flushStatements(boolean isRollBack) throws SQLException {
    // 判断当前Executor是否已经关闭
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    // 调用doFlushStatements()这个基本方法，其参数isRollBack表示是否执行Executor中缓存的SQL语句，false表示执行，true表示不执行
    return doFlushStatements(isRollBack);
  }
 
  
BaseExecutor.commit()方法首先会清空一级缓存、调用flushStatements()方法，最后才根据参数决定是否真正提交事务。 commit()方法的实现如下：
 
  
  @Override
  public void commit(boolean required) throws SQLException {
    if (closed) {
      throw new ExecutorException("Cannot commit, transaction is already closed");
    }
    // 清空一级缓存
    clearLocalCache();
    // 执行缓存的SQL语句，其中调用了flushStatements(false)方法
    flushStatements();
    // 根据required参数决定是否提交事务
    if (required) {
      transaction.commit();
    }
  }

 
  
BaseExecutor.rollback()方法的实现与commit()实现类似，同样会根据参数决定是否真正回滚事务 ，区别是其中调用的是flushStatements()方法的isRollBack参数为true这就会导致Executor中缓存的 SQL 语句全部被忽略，即不会被发送到数据库执行。
 
  
BaseExecutor.close()方法首先会调用rollback()方法忽略缓存的SQL语句，之后根据参数决定是否关闭底层的数据库连接。
 
  
2.SimpleExecutor
 
  
SimpleExecutor继承了BaseExecutor抽象类，它是最简单的Executor接口实现。正如前面所说，Executor使用了模板方法模式，一级缓存等固定不变的操作都封装到了BaseExecutor。SimpleExecutor中就不必再关心一级缓存等操作，只需要专注实现四个基本方法的实现即可。
 
  
首先来看SimpleExecutor.doQuery()方法的具体实现：
 
  
  @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对象 ，实际返回的是RoutingStatementHandler对象
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      // 完成Statement的创建和初始化
      stmt = prepareStatement(handler, ms.getStatementLog());
      // 调用StatementHandler .query()方法，执行SQL语句，并通过ResultSetHandler，完成结果集的映射
      return handler.query(stmt, resultHandler);
    } finally {
      // 关闭Statement对象
      closeStatement(stmt);
    }
  }


  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    Connection connection = getConnection(statementLog);
    // 创建Statements对象
    stmt = handler.prepare(connection, transaction.getTimeout());
    // 处理占位符
    handler.parameterize(stmt);
    return stmt;
  }
 
  
SimpleExecutor.doQueryCursor()方法、doUpdate()方法与doQuery()方法实现类似，这里不再赘述。 SimpleExecutor不提供批量处理SQL语句的功能，所以其doFlushStatements()方法直接返回空集合，不做其他任何操作。
 
  
3.ReuseExecutor
 
  
在传统的JDBC编程中，重用Statement对象是常用的一种优化手段，该优化手段可以减少SQL预编译的开销以及创建和销毁Statement对象的开销，从而提高性能。
 
  
ReuseExecutor提供了Statement重用的功能，ReuseExecutor中通过statementMap字段缓存使用过的Statement对象，key是SQL语句，value是SQL对应的Statement对象。ReuseExecutor.doQuery()、doQueryCursor()、doUpdate()方法的实现与SimpleExecutor对应方法的实现一样，区别在于其中调用的preparestatement()方法，SimpleExecutor每次都会通过JDBC Connection创建新的Statement对象，而ReuseExecutor会先尝试重用StaternentMap缓存的Statement对象。
 
  
ReuseExecutor. prepareStatement()方法的具体实现如下：
 
  
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    // 获取BoundSql对象
    BoundSql boundSql = handler.getBoundSql();
    String sql = boundSql.getSql();
    // 判断该SQL是否缓存过Statement
    if (hasStatementFor(sql)) {
      // 获取缓存的Statement对象
      stmt = getStatement(sql);
      // 修改超时时间
      applyTransactionTimeout(stmt);
    } else {
      Connection connection = getConnection(statementLog);
      // 创建新的Statement对象，并缓存到statementMap集合中
      stmt = handler.prepare(connection, transaction.getTimeout());
      putStatement(sql, stmt);
    }
    handler.parameterize(stmt);
    return stmt;
  }
 
  
当事务提交或回滚、连接关闭时，都需要关闭这些缓存的Statement对象 。前面介绍了BaseExecutor.commit()、 rollback()和close()方法时提到，其中都会调用doFlushStatements()方法，所以在该方法实现关闭Statement对象的逻辑非常合适，具体实现如下：
 
  
@Override
  public List<BatchResult> doFlushStatements(boolean isRollback) {
    // 遍历statementMap集合并关闭其中的Statement对象
    for (Statement stmt : statementMap.values()) {
      closeStatement(stmt);
    }
    // 清空statementMap
    statementMap.clear();
    return Collections.emptyList();
  }
 
  
这里需要注意一下ReuseExecutor.queryCursor()方法的使用，熟悉JDBC编程的读者知道，每个Statement对象只能对应一个结果集，当多次调用queryCursor()方法执行同SQL语句时，会复用Statement对象，只有最后一个ResultSet是可用的 。而queryCursor()方法返回的Cursor对象，在用户迭代Cursor对象时，才会真正遍历结果集对象并进行映射操作，这就可能导致使用前面Cursor对象中封装的结果集关闭。
 
  
5.BatchExecutor
 
  
应用系统在执行一条SQL语句时，会将SQL语句以及相关参数通过网络发送到数据库系统。对于频繁操作数据库的应用系统来说，如果执行SQL语句就向数据库发送一次请求，很多时间会浪费在网络通信上。使用批量处理的优化方式可以在客户端缓存多条SQL语句，并在合适的时机将多条SQL语句打包发送给数据库执行，从而减少网络方面的开销，提升系统的性能。
 
  
不过有一点需要注意，在批量执行多条SQL语句时，每次向数据库发送的SQL语句条数是有上限的，如果超过这个上限，数据库会拒绝执行这些SQL语句井抛出异常 所以批量发送SQL语句的时机很重要。
 
  
BatchExecutor实现了批处理多条SQL语句的功能，其中核心字段的含义如下：
 
  
 // 缓存多个Statement对象其中每个Statement对象中都缓存了多条SQL语句
  private final List<Statement> statementList = new ArrayList<>();
  // 记录批处理的结果，BatchResult中通过updateCounts字段记录每个Statement执行批处理的结果
  private final List<BatchResult> batchResultList = new ArrayList<>();
  // 记录当前执行的SQL语句
  private String currentSql;
  // 记录当前执行的MappedStatement对象
  private MappedStatement currentStatement;
 
  
JDBC中的批处理只支持insert、update、delete等类型的SQL语句，不支持select类型的SQL语句，所以下面要分析的是BatchExecutor.doUpdate方法。
 
  
BatchExecutor.doUpdate()方法在添加一条SQL语句时，首先会将currentSql字段记录的SQL语句以及currentStatement字段记录的MappedStatement对象与当前添加的SQL以及MappedStatement对象进行比较，如果相同则加到同一个Statement对象等待执行，如果不同则创建新的Statement对象并将其缓存到statementList集合中等待执行。doUpdate()方法具体实现如下：
 
  
@Override
  public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {
    // 获取配置对象
    final Configuration configuration = ms.getConfiguration();
    // 创建StatementHandler对象
    final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);
    final BoundSql boundSql = handler.getBoundSql();
    // 获取SQL语句
    final String sql = boundSql.getSql();
    final Statement stmt;
    // 如果当前执行的SQL模式与上次执行的SQL模式相同且对应的MappedStatement对象相同
    if (sql.equals(currentSql) && ms.equals(currentStatement)) {
      // 获取statementList中的最后一个
      int last = statementList.size() - 1;
      stmt = statementList.get(last);
      applyTransactionTimeout(stmt);
      // 绑定实参
      handler.parameterize(stmt);// fix Issues 322
      // 查找对应的BatchResult对象，并记录用户传入的实参
      BatchResult batchResult = batchResultList.get(last);
      batchResult.addParameterObject(parameterObject);
    } else {
      Connection connection = getConnection(ms.getStatementLog());
      // 创建新的Statement对象
      stmt = handler.prepare(connection, transaction.getTimeout());
      // 绑定实参
      handler.parameterize(stmt);    // fix Issues 322
      // 更新currentSql、currentStatement
      currentSql = sql;
      currentStatement = ms;
      // 添加刚创建的Statement对象
      statementList.add(stmt);
      // 添加新的BatchResult对象
      batchResultList.add(new BatchResult(ms, sql, parameterObject));
    }
    // 底层通过调用Statement.addBatch()方法添SQL语句
    handler.batch(stmt);
    return BATCH_UPDATE_RETURN_VALUE;
  }
 
  
JDBC批处理功能中Statement可以添加不同模式的SQL，但是每添加一个新模式的SQL语句都会触发一次编译操作PreparedStatement中只能添加同一模式的SQL语句，只会触发一次编译操作，但是可以通过绑定多组不同的实参实现批处理。通过上面对doUpdate()方法的分析可知，BatchExecutor会将连续添加的、相同模式的SQL语句添加到同一个Statement/PreparedStatement对象中，这样可以有效地减少编译操作的次数。
 
  
在添加完待执行的SQL语句之后来看一下BatchExecutor.doFlushStatemnts()方法是如何批量处理这些SQL语句的：
 
  
@Override
  public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
    try {
      // 用于储存批量处理的结果
      List<BatchResult> results = new ArrayList<>();
      // 如果明确指定了要回滚事务，则直接返回空集合，忽略statementList集合中记录的SQL语句
      if (isRollback) {
        return Collections.emptyList();
      }
      // 遍历statementList集合
      for (int i = 0, n = statementList.size(); i < n; i++) {
        // 获取Statement对象
        Statement stmt = statementList.get(i);
        applyTransactionTimeout(stmt);
        // ／获取对应的BatchResult对象
        BatchResult batchResult = batchResultList.get(i);
        try {
          // 调用Statement.executeBatch()方法批量执行其中记录的SQL语句，并使用返回的int数组
          // 更新BatchResult.updateCounts字段，其中每一个元素都表示一条SQL语句影响的记录条数
          batchResult.setUpdateCounts(stmt.executeBatch());
          MappedStatement ms = batchResult.getMappedStatement();
          List<Object> parameterObjects = batchResult.getParameterObjects();
          // 获取配置的KeyGenerator对象
          KeyGenerator keyGenerator = ms.getKeyGenerator();
          if (Jdbc3KeyGenerator.class.equals(keyGenerator.getClass())) {
            Jdbc3KeyGenerator jdbc3KeyGenerator = (Jdbc3KeyGenerator) keyGenerator;
            // 获取数据库生成的主键，并设置到parameterObjects中
            jdbc3KeyGenerator.processBatch(ms, stmt, parameterObjects);
          } else if (!NoKeyGenerator.class.equals(keyGenerator.getClass())) { //issue #141
            // 对于其他类型的keyGenerator，会调用其processAfter()方法
            for (Object parameter : parameterObjects) {
              keyGenerator.processAfter(this, ms, stmt, parameter);
            }
          }
          // Close statement to close cursor #1109
          // 关闭Statement对象
          closeStatement(stmt);
        } catch (BatchUpdateException e) {
          StringBuilder message = new StringBuilder();
          message.append(batchResult.getMappedStatement().getId())
              .append(" (batch index #")
              .append(i + 1)
              .append(")")
              .append(" failed.");
          if (i > 0) {
            message.append(" ")
                .append(i)
                .append(" prior sub executor(s) completed successfully, but will be rolled back.");
          }
          throw new BatchExecutorException(message.toString(), e, results, batchResult);
        }
        // 添加BatchResult到results集合
        results.add(batchResult);
      }
      return results;
    } finally {
      // 关闭Statement对象，并清空currentSql字段、清空statementList集合、清空batchResultList集合
      for (Statement stmt : statementList) {
        closeStatement(stmt);
      }
      currentSql = null;
      statementList.clear();
      batchResultList.clear();
    }
  }
 
  
BatchExecutor.doQuery和doQueryCursor()方法的实现与前面介绍的SimpleExecutor类似，主要区别就是BatchExecutor中的这两个方法在最开始都会先调用flushStatement()方法，执行缓存SQL语句，这样才能从数据库中查询到最新的数据。
 
  
6.CachingExecutor
 
  
CachingExecutor是Executor接口的装饰器，它为Executor对象增加了二级缓存的相关的功能，先来简单介绍MyBatis中的二级缓存及其依赖的相关组件。
 
  
二级缓存简介
 
  
MyBatis中提供的二级缓存是应用级别的缓存，它的生命周期与应用程序的生命周期相同。与二级缓存相关的配置有三个：
 
  
（1）首先是mybatis-config.xml配置文件中的cacheEnabled配置，它是二级缓存的总开关。只有当该配置设置为true时，后面两项的配置才会有效果，cacheEnabled的默认值为 true 。具体配置如下：
 
  
 <settings>
        <setting name="cacheEnabled" value="true"/>
        
 settings>
 
  
（2）在前面介绍映射配置文件的解析流程时提到，映射配置文件中可以配置节点或节点。如果映射配置文件中配置了这两者中的任一一个节点，则表示开启了二级缓存功能。如果配置了节点，在解析时会为该映射配置文件指定的命名空间创建相应的Cache对象作为其二级缓存，默认是PerpetualCache对象，用户可以通过节点的type属性指定自定义Cache对象。如果配置了节点，在解析时则不会为当前映射配置文件指定的命名 空间创建独立的Cache对象，而是认为它与节点的namespace属性指定的命名空间共享同一个Cache对象。通过节点和节点的配置，用户可以在命名空间的粒度上管理二级缓存的开启和关闭。
 
  
（3）最后一个配置项是节点中的useCache属性，该属性表示查询操作产生的结果对象是否要保存到二级缓存中。useCache属性的默认值是true。
 
  
TransactionalCache&TransactionalCacheManager
 
  
TransactionalCache和TransactionalCacheManager是CachingExecutor依赖的两个组件。其中，TransactionalCache继承了Cache接口，主要用于保存在某个SqlSession的某个事务中需要向某个二
 
  
级缓存中添加的缓存数据。TransactionalCache中核心字段的含义如下：
 
  
 // 底层封装的二级缓存所对应的Cache对象
  private final Cache delegate;
  // 当该字段为true时，则表示当前TransactionalCache不可查询，且提交事务时会将底层Cache清空
  private boolean clearOnCommit;
  // 暂时记录添加到TransactionalCache中的数据。在事务提交时，会将其中的数据添加到二级缓存中
  private final Map<Object, Object> entriesToAddOnCommit;
  // 记录缓存未命中的CacheKey对象
  private final Set<Object> entriesMissedInCache;
 
  
TransactionalCache.putObject()方法并没有直接将结果对象记录到其封装二级缓存中，而是暂时保存在 entriesToAddOnCommit集合中，在事务提交时才会将这些结果对象从entriesToAddOnCommit集合添加到二级缓存中。 putObject()方法的具体实现如下：
 
  
  @Override
  public void putObject(Object key, Object object) {
    entriesToAddOnCommit.put(key, object);
  }

 
  
再来看TransactionalCache.getObject()方法，它首先会查询底层的二级缓存，并将未命中的key添加到entriesMissedInCache中，之后会根据clearOnCommit字段的值决定具体的返回值，具体实现如下：
 
  
@Override
  public Object getObject(Object key) {
    // issue #116
    Object object = delegate.getObject(key);
    if (object == null) {
      // 将未命中的key添加到entriesMissedInCache中
      entriesMissedInCache.add(key);
    }
    // issue #146
    // 根据clearOnCommit字段的值决定具体的返回值
    if (clearOnCommit) {
      return null;
    } else {
      return object;
    }
  }
 
  
TransactionalCache.clear()方法会清空entriesToAddOnCommit集合，并设置 clearOnCommi为true 。
 
  
TransactionalCache. commit()方法会根据clearOnCommit字段的值决定是否清空二级缓存，然后调用 flushPendingEntries()方法将entriesToAddOnCommit集合中记录的结果对象保存到二级缓存中，具体实现如下：
 
  
 public void commit() {
    // 在事务提交前 清空二级缓存
    if (clearOnCommit) {
      delegate.clear();
    }
    // 将entriesToAddOnCommit集合中的数据保存到二级缓存
    flushPendingEntries();
    // 重置clearOnCommit为false ，并清空entriesToAddOnCommit和entriesMissedInCache 集合
    reset();
  }
 private void flushPendingEntries() {
    // 遍历entriesToAddOnCommit集合，将其中记录的缓存项添加到二级缓存中
    for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
      delegate.putObject(entry.getKey(), entry.getValue());
    }
    // 遍历entriesMissedInCache集合，将entriesToAddOnCommit集合中不包含的缓存项添加到二级缓存中
    for (Object entry : entriesMissedInCache) {
      if (!entriesToAddOnCommit.containsKey(entry)) {
        delegate.putObject(entry, null);
      }
    }
  }

 
  
TransactionalCache.rollback()方法会将entriesMissedlnCache集合中记录的缓存项从二级缓存中删除，并清空entriesToAddOnCommit集合和entriesMissedlnCache集合，具体实现如下：
 
  
public void rollback() {
    // 将entriesMissedInCache集合中记录的缓存项从二级缓存中删除
    unlockMissedEntries();
    // 遍历entriesMissedInCache集合，将entriesToAddOnCommit集合中不包含的缓存项添加到二级缓存中
    reset();
  }
 
  
TransactionalCacheManager用于管理CachingExecutor使用的二级缓存对象，其中只定义了transactionalCaches字段，它的 key 是对应的CachingExecutor使用的 二级缓存对象，value是相应TransactionaCach对象，在该TransactionalCache中封装了对应二级缓存对象，也就是这里的 key。
 
  
TransactionalCacheManager的实现比较简单，下面简单介绍各个方法的功能和实现。
 
  
*clear()方法、 putObject方法、 getObject()方法：*调用指定二级缓存对应的TransactionalCache对象的对应方法，如果transactionalCaches集合中没有对应的TransactionalCache对象，则通过getTransactiona!Cache()方法创建。
 
  
  private TransactionalCache getTransactionalCache(Cache cache) {
    // 如果transactionalCaches集合中没有对应的TransactionalCache对象,则新建
    return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
  }
 
  
*commit()方法、 rollback()方法：*遍历transactionalCaches集合，井调用其中各个TransactionalCache对象的相应方法。
 
  
CachingExecutor的实现
 
  
CachingExecutor.query()方法执行查询操作的步骤如下：
 
  
（1）获取BoundSql对象，创建查询语句对应的CacheKey对象。
 
  
（2）检测是否开启了二级缓存，如果没有开启二级缓存，则直接调用底层Executor对象的query()方法查询数据库。如果开启了二级缓存，则继续后面的步骤。
 
  
（3）检测查询操作是否包含输出类型的参数，如果是这种情况，则报错
 
  
（4）调用TransactionalCacheManager.getObject()方法查询二级缓存，如果二级缓存中查找到相应的结果对象，则直接将该结果对象返回。
 
  
（5）如果二级缓存没有相应的结果对象，则调用底层Executor对象的query()方法。正如前面介绍的 ，它会先查询一级缓存，一级缓存未命中时，才会查询数据库。最后还会将得到的结果对象放入TransactionalCache.entriesToAddOnCommit集合中保存。
 
  
CachingExecutor.query()方法的具体代码如下：
 
  
@Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 获取BoundSql对象
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    // 创建CacheKey对象
    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);
      // 检测SQL节点的useCache配置以及是否使用了resultHandler配置
      if (ms.isUseCache() && resultHandler == null) {
        // 二级缓存不能保存输出类型的参数 如果查询操作调用了包含输出参数的存储过程，则报错
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        // 查询二级缓存
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          // 二级缓存没有相应的结果对象，调用封装的Executor对象的query()方法
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          // 将查询结果保存到TransactionalCache.entriesToAddOnCommit集合中
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    // 没有启动二级缓存，调用封装的Executor对象的query()方法
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }
 
  
再看CachingExecutor.commit()和rollback()方法的实现，它们首先调用底层的Executor对象的对应方法完成提交和回滚，然后调用TransactionalCacheManager的对应方法完成对二级缓存的操作。具体实现如下：
 
  
@Override
  public void commit(boolean required) throws SQLException {
    // 调用底层的Executor提交事务
    delegate.commit(required);
    // 遍历相关TransactionalCache对象执行commit()方法
    tcm.commit();
  }

  @Override
  public void rollback(boolean required) throws SQLException {
    try {
      // 调用底层的Executor回滚事务
      delegate.rollback(required);
    } finally {
      if (required) {
        // 遍历相关TransactionalCache对象执行rollback()方法
        tcm.rollback();
      }
    }
  }
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(Mybatis)
        

            

                

                    
2025最新Mybatis-plus教程（二）
                        

                        
三、CRUD（一）BaseMapper接口方法介绍BaseMapper中提供了crud方法，具体方法如下：//插入一条记录intinsert(Tentity);//根据entity条件，删除记录intdelete(@Param(Constants.WRAPPER)Wrapperwrapper);//删除（根据ID批量删除）intdeleteBatchIds(@Param(Constants.COL
                    
                    
2025最新Mybatis-plus教程（四）
                        

                        
五、MyBatis-Plus的service封装（一）通用Service简介MyBatis-Plus除了通用的Mapper还有通用的Service层，这也减少了相对应的代码工作量，把通用的接口提取到公共。其实按照mp的这种思想，可以自己也实现一些通用的Controller。（二）通用Service方法介绍/***插入一条记录（选择字段，策略插入）**@paramentity实体对象*/defaul
                    
                    
2025最新Mybatis-plus教程（三）
                        

                        
四、MyBatis-Plus条件构造器（一）条件构造器介绍在MyBatis-Plus中提了构造条件的类Wrapper，它可以根据自己的意图定义我们需要的条件。Wrapper是一个抽象类，一般情况下我们用它的子类QueryWrapper来实现自定义条件查询。（二）selectOne方法@TestpublicvoidtestSelectOne(){ QueryWrapperqueryWrapper=n
                    
                    
Java 代理机制详解：从静态代理到动态代理，彻底掌握代理模式的原理与实战
                        大葱白菜
java合集java开发语言后端个人开发学习代理模式
                        
作为一名Java开发工程师，你一定在使用Spring、MyBatis、RPC框架等技术时接触过“代理”（Proxy）这个概念。无论是Spring的AOP（面向切面编程）、事务管理，还是远程调用、日志记录、权限控制等场景，代理机制都扮演着至关重要的角色。本文将带你全面掌握：什么是代理？静态代理与动态代理的区别JDK动态代理与CGLIB动态代理的实现原理代理模式的典型应用场景代理在主流框架中的使用（如
                    
                    
Java朴实无华按天计划从入门到实战（强化速战版-66天）
                        岫珩
Java后端java开发语言学习Java时间安排学习计划
                        
致敬读者感谢阅读笑口常开生日快乐⬛早点睡觉博主相关博主信息博客首页专栏推荐活动信息文章目录Java朴实无华按天计划从入门到实战（强化速战版-66天）1.基础（18）1.1JavaSE核心（5天）1.2数据库与SQL（5天）1.3前端基础（8天）2.进阶（17天）2.1JavaWeb核心（5天）2.2Mybatis与Spring全家桶（6天）2.3中间件入门（4天）2.4实践项目（2天）3.高阶（1
                    
                    
Mybatisplus的雪花算法及代码生成器的使用
                        你我约定有三
算法dreamweaver
                        
1.雪花算法1.1背景:雪花算法（Snowflake）的使用背景主要源于高并发分布式系统环境下对唯一ID生成的需求。这种需求在像Twitter这样的社交媒体平台上尤为突出，因为Twitter需要处理每秒上万条消息的请求，并且每条消息都必须分配一个唯一的ID。这些ID不仅需要全局唯一，以跨机器、跨时间区分，还需要保持一定的顺序性（尽管不要求连续），以方便客户端排序和后续的数据处理。1.2与自动递增的
                    
                    
并发编程与MyBatis精髓
                        AIHacksCash
Java场景面试宝典ConcurrencyJavaDatabaseFramework
                        
我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、Spri
                    
                    
mybatis的insert(pojo),会返回pojo吗
                        

                        
在MyBatis中，执行insert操作时，Mapper接口的insert方法本身不会直接返回一个包含数据库生成字段的POJO对象。其默认返回值是受影响的数据库行数（通常是int或Integer）。以下是具体分析和解决方案：1.默认行为返回值类型：insert方法返回的是受影响的行数（整数），不是插入后的POJO对象。POJO状态：执行插入后，如果数据库生成了自增ID或其他字段（如创建时间），PO
                    
                    
MyBatis与MyBatis-Plus批量插入实战指南
                        代码小侦探
mybatis
                        
在实际项目中，批量插入数据是一个常见且重要的需求。本文将详细总结MyBatis和MyBatis-Plus常用的几种批量插入方式，并通过实际代码示例和运行结果，帮助大家更好地理解和应用。一、准备工作导入pom.xml依赖mysqlmysql-connector-javaruntimeorg.mybatis.spring.bootmybatis-spring-boot-starter2.2.2com.
                    
                    
Spring Boot与MyBatis完美融合：整合实战指南
                        

                        
目录1、梳理整合思路2、整合实现2.1环境搭建2.2案例3、整合mybatis-plus报错1.依赖问题2.配置问题3.Mapper接口与XML文件问题4.实体类问题5.数据库连接问题6.SQL语句问题7.Spring容器问题8.其他1、梳理整合思路将MyBatis的DataSource交给SpringIoC容器创建并管理，使用第三方数据库连接池(Druid，C3P0等)代替MyBatis内置的数
                    
                    
MyBatis中#{}与${}的实战避坑指南
                        

                        
MyBatis在持久层框架中占据举足轻重的地位，其映射文件中的两种参数占位符——#{}与${}——常常令初学者困惑，也令资深开发者反复斟酌。笔者在日常代码审计与性能调优过程中，屡次遇到因二者混用而导致的生产事故，因此决定撰写一篇技术博客，结合真实项目片段，系统梳理二者的使用差异、安全边界与工程落地细节。全文约三千字，力求言必有据，例证皆来自可运行的源码仓库，读者可直接复现并验证。在MyBatis的
                    
                    
AI-调查研究-26-【时间管理】全球不同人群社交媒体使用时间情况
                        武子康
AIDeepSearch人工智能ai学习职场和发展职场发展个人开发程序人生
                        
点一下关注吧！！！非常感谢！！持续更新！！！AI篇持续更新中！（长期更新）AI炼丹日志-29-字节跳动DeerFlow深度研究框斜体样式架私有部署测试上手架构研究，持续打造实用AI工具指南！Java篇正式开启！（300篇）目前2025年07月10日更新到：Java-68深入浅出分布式服务Netty实现自定义RPC附详细代码MyBatis已完结，Spring已完结，Nginx已完结，Tomcat已完
                    
                    
【Spring Boot 整合 MyBatis 详细教程】
                        打会游戏睡会觉
springbootspringbootmybatis后端
                        
文章目录SpringBoot整合MyBatis详细教程简介环境准备项目搭建项目结构配置项目1.`pom.xml`配置2.`数据源和MyBatis`配置3.`启动类`配置4.`Mapper接口`和`XML映射文件`测试总结SpringBoot整合MyBatis详细教程简介SpringBoot与MyBatis的整合可以让你轻松地构建数据访问层，通过简化配置和自动配置功能，使得开发者可以更加专注于业务逻
                    
                    
Spring Boot 整合 MyBatis 全流程指南
                        

                        
目录SpringBoot整合MyBatis全流程指南一、整合回顾与准备（一）Spring整合MyBatis回顾（二）SpringBoot整合MyBatis优势（三）案例需求（四）准备数据库二、创建工程并引入依赖三、配置数据源信息四、编写代码（一）引入实体类（二）创建mapper接口（三）创建service接口及实现类（四）创建controller类五、测试工程在实际开发中，配置文件的使用至关重要。
                    
                    
并发编程与MyBatis核心知识
                        

                        
我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队
                    
                    
Java+Vue 地下停车场管理系统的设计与实现
                        不若浮生一梦
计算机毕设javavue.js开发语言
                        
一、项目简介本项目是一款基于SpringBoot+Vue开发的地下停车场管理系统，采用前后端分离架构，后端使用MyBatis操作MySQL数据库，前端使用Vue进行页面展示和用户交互。系统涵盖车位监控、车辆登记、订单生成与结算、在线支付、公告通知、留言反馈、用户积分管理等模块，支持用户端和管理员端的全流程停车管理，适用于中小型停车场数字化转型。项目定位：提升停车场管理效率与用户体验，实现“高效停车
                    
                    
SSM+Vue共享充电宝管理系统 充电宝投放管理系统 共享充电宝维护管理系统Java
                        计算机程序老哥

                        
作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆前端页面功能：首页、合作商户、充电宝投放、公告栏、个人中心、后台管理首页.png充电宝投放.png
                    
                    
MyBatisPlus 批量添加
                        

                        
文章目录现状优化效果报错现状一般来说，批量插入可以使用MyBatisPlus中ServiceImpl自带的方法saveBatch打开sql日志，application.yml添加配置，mapper-locations配置mapper路径mybatis-plus:configuration:log-impl:org.apache.ibatis.logging.stdout.StdOutImpl#开启
                    
                    
springboot + mybatis使用xml方式九
                        AmeeLove

                        
springboot集成mybatis使用xml方式依赖org.springframework.bootspring-boot-starter-parent1.5.12.RELEASEorg.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-starter-testtestorg.sprin
                    
                    
【经验分享】如何找到适合初学者的Java项目案例？
                        

                        
Java项目开发案例全程实录涉及从需求分析到部署维护的全流程，结合实战经验总结如下关键步骤：‌项目规划与需求分析‌：明确业务需求，定义功能范围和用户故事，如电商项目涉及订单处理和库存管理‌15。‌系统设计与技术选型‌：基于需求选择框架和技术栈，例如使用SpringBoot构建微服务架构，MyBatis处理数据交互，Redis作为缓存层优化性能‌5。‌编码实现与核心功能开发‌：‌业务逻辑层‌：编写核
                    
                    
狂神说Linux笔记
                        是你牛天成
项目部署linux
                        
B站视频狂神说LinuxJava开发之路：JavaSE,MySQL,前端（html,css,js）,javaweb,SSM框架，SpringBootvue,SpringCloud,(mybatis-plusgit)LinuxLinux操作系统：Window、Mac消息队列(Kafka,RabbitMQ,RockeetMQ)缓存(Redis)搜索引擎(ElasticSearch)集群分布式(需要购买
                    
                    
MyBatis Plus 中的条件构造器
                        中东大鹅
mybatisspringboot后端java
                        
一、WrapperWrapper：条件构造抽象类，最顶端父类AbstractWrapper：用于查询条件封装，生成sql的where条件QueryWrapper：查询条件封装UpdateWrapper：Update条件封装AbstractLambdaWrapper：使用Lambda语法LambdaQueryWrapper：用于Lambda语法使用的查询WrapperLambdaUpdateWrap
                    
                    
MyBatis Plus 分页
                        中东大鹅
mybatisjava数据库springboot
                        
一、分页插件MyBatisPlus自带分页插件，只要简单的配置即可实现分页功能1、添加配置类@ConfigurationpublicclassMyConfig{@BeanpublicMybatisPlusInterceptormybatisPlusInterceptor(){MybatisPlusInterceptorinterceptor=newMybatisPlusInterceptor();
                    
                    
MyBatis Plus 对数据表常用注解
                        中东大鹅
mybatisoracle数据库springboot
                        
1.@TableName(1)解释说明@TableName注解用于指定实体类对应的数据库表名，当实体类的名称与数据库表名不一致时，可以用此注解进行映射。此外，@TableName还支持设置一些其他的配置选项，比如全局表名前缀、后缀的处理。value：指定数据库表名。如果没有设置此注解，则会默认映射到与类名相同的表名。schema：指定数据库的schema，适用于多schema的情况。(2)应用示例
                    
                    
Postgresql数据库Java中mybatis问题记录
                        haokan_Jia
postgresqlJAVA数据库postgresqljava
                        
项目场景：Java中使用mybatis进行数据查询，使用实体类接收报错“Errorattemptingtogetcolumn‘basin_code’fromresultset.Cause:org.postgresql.util.PSQLException:不良的类型值long:WFG_1\n;不良的类型值long:WFG_1;nestedexceptionisorg.postgresql.util
                    
                    
基于ssm框架的管理系统如何开题，有哪些步骤，怎么设计更合理
                        勤劳的史蒂夫

                        
1、SSM框架简介SSM框架是SpringMVC，Spring和Mybatis框架的整合，是标准的MVC模式，将整个系统划分为View层，Controller层，Service层，DAO层四层，使用SpringMVC负责请求的转发和视图管理，Spring实现业务对象管理，Mybatis作为数据对象的持久化引擎。DAO层：DAO层主要是做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此。D
                    
                    
Day20: Spring与MyBatis的量子纠缠 —— 解密Mapper接口如何获得魔法实现的终极指南
                        zhysunny
Springspringmybatisjava
                        
目录灵魂拷问时刻：一、Mapper接口的"借尸还魂"术——MapperFactoryBean解剖室1.1Mapper的诞生时刻轴1.2MapperFactoryBean的克隆工厂源码级实例生成流程：1.3接口炼金术——MyBatisProxyFactory核心代码关键对象关系图：二、线程安全防御体系——SqlSessionTemplate的奥秘2.1传统SqlSession的危险性2.2Sprin
                    
                    
[附源码]java毕业设计篮球俱乐部管理系统
                        卓杰计算机程序设计
java开发语言mysql
                        
项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
                    
                    
数据封装、参数接收、日志技术
                        

                        
数据封装Mybatis默认数据封装规则：实体类属性名和数据库表的字段名一致，mybatis会自动封装如果字段名和实体类属性名不一致解决办法：1).手动结果映射在DeptMapper接口方法上，通过@Results及@Result进行手动结果映射。@Results({@Result(column="create_time",property="createTime"),@Result(column=
                    
                    
JAVA图文短视频交友+自营商城系统源码支持小程序+Android+IOS+H5
                        

                        
JAVA图文短视频交友+自营商城系统：社交电商新生态的技术实践一、市场需求与技术定位2025年社交电商市场规模突破3.2万亿，用户需求从“单纯购物”转向“社交+消费”融合体验。JAVA图文短视频交友+自营商城系统源码支持小程序+Android+IOS+H5应运而生，以SpringBoot+MyBatisPlus+MySQL为后端核心，Uniapp（Vue语法）实现跨端兼容，Vue+ElementU
                    
                                
开发者关心的那些事
                                    圣子足道
ios游戏编程apple支付
                                    
我要在app里添加IAP，必须要注册自己的产品标识符（product identifiers）。产品标识符是什么？ 
产品标识符（Product Identifiers）是一串字符串，它用来识别你在应用内贩卖的每件商品。App Store用产品标识符来检索产品信息，标识符只能包含大小写字母（A-Z）、数字（0-9）、下划线（-）、以及圆点(.)。你可以任意排列这些元素，但我们建议你创建标识符时使用
                                
                                
负载均衡器技术Nginx和F5的优缺点对比
                                    bijian1013
nginxF5
                                    
        对于数据流量过大的网络中，往往单一设备无法承担，需要多台设备进行数据分流，而负载均衡器就是用来将数据分流到多台设备的一个转发器。 
        目前有许多不同的负载均衡技术用以满足不同的应用需求，如软/硬件负载均衡、本地/全局负载均衡、更高
                                
                                
LeetCode[Math] - #9 Palindrome Number
                                    Cwind
javaAlgorithm题解LeetCodeMath
                                    
原题链接：#9 Palindrome Number 
  
要求： 
判断一个整数是否是回文数，不要使用额外的存储空间 
  
难度：简单 
  
分析： 
题目限制不允许使用额外的存储空间应指不允许使用O(n)的内存空间，O(1)的内存用于存储中间结果是可以接受的。于是考虑将该整型数反转，然后与原数字进行比较。 
注：没有看到有关负数是否可以是回文数的明确结论，例如
                                
                                
画图板的基本实现
                                    15700786134
画图板
                                    
 要实现画图板的基本功能，除了在qq登陆界面中用到的组件和方法外，还需要添加鼠标监听器，和接口实现。 
首先，需要显示一个JFrame界面： 
public class DrameFrame extends JFrame {              //显示
                                
                                
linux的ps命令
                                    被触发
linux
                                    
Linux中的ps命令是Process Status的缩写。ps命令用来列出系统中当前运行的那些进程。ps命令列出的是当前那些进程的快照，就是执行ps命令的那个时刻的那些进程，如果想要动态的显示进程信息，就可以使用top命令。 
要对进程进行监测和控制，首先必须要了解当前进程的情况，也就是需要查看当前进程，而 ps 命令就是最基本同时也是非常强大的进程查看命令。使用该命令可以确定有哪些进程正在运行
                                
                                
Android 音乐播放器 下一曲 连续跳几首歌
                                    肆无忌惮_
android
                                    
最近在写安卓音乐播放器的时候遇到个问题。在MediaPlayer播放结束时会回调 
player.setOnCompletionListener(new OnCompletionListener() {

			@Override
			public void onCompletion(MediaPlayer mp) {
				mp.reset();
				Log.i("H
                                
                                
java导出txt文件的例子
                                    知了ing
javaservlet
                                    
代码很简单就一个servlet,如下： 
 
package com.eastcom.servlet;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.net.URLEncoder;
import java.sql.Connection;
import java.sql.Resu
                                
                                
Scala stack试玩, 提高第三方依赖下载速度
                                    矮蛋蛋
scalasbt
                                    
原文地址： 
http://segmentfault.com/a/1190000002894524 
sbt下载速度实在是惨不忍睹, 需要做些配置优化 
 
下载typesafe离线包, 保存为ivy本地库 
 
wget http://downloads.typesafe.com/typesafe-activator/1.3.4/typesafe-activator-1.3.4.zip 
解压r
                                
                                
phantomjs安装(linux，附带环境变量设置) ，以及casperjs安装。
                                    alleni123
linuxspider
                                    
1. 首先从官网 
http://phantomjs.org/下载phantomjs压缩包，解压缩到/root/phantomjs文件夹。 
 
2. 安装依赖 
 
sudo yum install fontconfig freetype libfreetype.so.6 libfontconfig.so.1 libstdc++.so.6 
 
3. 配置环境变量 
vi /etc/profil
                                
                                
JAVA IO FileInputStream和FileOutputStream，字节流的打包输出
                                    百合不是茶
java核心思想JAVA IO操作字节流
                                    
在程序设计语言中，数据的保存是基本，如果某程序语言不能保存数据那么该语言是不可能存在的，JAVA是当今最流行的面向对象设计语言之一，在保存数据中也有自己独特的一面，字节流和字符流 
1，字节流是由字节构成的，字符流是由字符构成的 字节流和字符流都是继承的InputStream和OutPutStream ,java中两种最基本的就是字节流和字符流 
  
类 FileInputStream
                                
                                
Spring基础实例（依赖注入和控制反转）
                                    bijian1013
spring
                                    
前提条件：在http://www.springsource.org/download网站上下载Spring框架，并将spring.jar、log4j-1.2.15.jar、commons-logging.jar加载至工程1.武器接口 
package com.bijian.spring.base3;

public interface Weapon {

   
    void kil
                                
                                
HR看重的十大技能
                                    bijian1013
提升能力HR成长
                                    
    一个人掌握何种技能取决于他的兴趣、能力和聪明程度，也取决于他所能支配的资源以及制定的事业目标，拥有过硬技能的人有更多的工作机会。但是，由于经济发展前景不确定，掌握对你的事业有所帮助的技能显得尤为重要。以下是最受雇主欢迎的十种技能。 　　一、解决问题的能力 　　每天，我们都要在生活和工作中解决一些综合性的问题。那些能够发现问题、解决问题并迅速作出有效决
                                
                                
【Thrift一】Thrift编译安装
                                    bit1129
thrift
                                    
什么是Thrift 
The Apache Thrift software framework, for scalable cross-language services development, combines a software stack with a code generation engine to build services that work efficiently and s
                                
                                
【Avro三】Hadoop MapReduce读写Avro文件
                                    bit1129
mapreduce
                                    
Avro是Doug Cutting(此人绝对是神一般的存在）牵头开发的。 开发之初就是围绕着完善Hadoop生态系统的数据处理而开展的（使用Avro作为Hadoop MapReduce需要处理数据序列化和反序列化的场景）,因此Hadoop MapReduce集成Avro也就是自然而然的事情。 
这个例子是一个简单的Hadoop MapReduce读取Avro格式的源文件进行计数统计，然后将计算结果
                                
                                
nginx定制500，502，503，504页面
                                    ronin47
nginx　错误显示
                                    
server {
     listen 80;
     error_page  500/500.html;
     error_page  502/502.html;
     error_page  503/503.html;
     error_page  504/504.html;

     location /test {return502;}} 
配置很简单，和配
                                
                                
java-1.二叉查找树转为双向链表
                                    bylijinnan
二叉查找树
                                    

import java.util.ArrayList;
import java.util.List;


public class BSTreeToLinkedList {
	
	/*
把二元查找树转变成排序的双向链表
题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
10
/ \
6 14
/ \ 
                                
                                
Netty源码学习-HTTP-tunnel
                                    bylijinnan
javanetty
                                    
Netty关于HTTP tunnel的说明： 
 
http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/socket/http/package-summary.html#package_description 
 
这个说明有点太简略了 
 
一个完整的例子在这里： 
 
https://github.com/bylijinnan
                                
                                
JSONUtil.serialize(map)和JSON.toJSONString(map)的区别
                                    coder_xpf
jqueryjsonmapval()
                                    
 JSONUtil.serialize(map)和JSON.toJSONString(map)的区别 
  
数据库查询出来的map有一个字段为空 
  
通过System.out.println()输出  JSONUtil.serialize(map)： {"one":"1","two":"nul
                                
                                
Hibernate缓存总结
                                    cuishikuan
开源sshjavawebhibernate缓存三大框架
                                    
一、为什么要用Hibernate缓存？ 
Hibernate是一个持久层框架，经常访问物理数据库。 
为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。 
缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。 
  
二、Hibernate缓存原理是怎样的？ 
Hibernate缓存包括两大类：Hib
                                
                                
CentOs6
                                    dalan_123
centos
                                    
首先su - 切换到root下面1、首先要先安装GCC GCC-C++ Openssl等以来模块：yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel2、再安装ncurses模块yum -y install ncurses-develyum install ncurses-devel3、下载Erang
                                
                                
10款用 jquery 实现滚动条至页面底端自动加载数据效果
                                    dcj3sjt126com
JavaScript
                                    
  
无限滚动自动翻页可以说是web2.0时代的一项堪称伟大的技术，它让我们在浏览页面的时候只需要把滚动条拉到网页底部就能自动显示下一页的结果，改变了一直以来只能通过点击下一页来翻页这种常规做法。 
无限滚动自动翻页技术的鼻祖是微博的先驱：推特(twitter)，后来必应图片搜索、谷歌图片搜索、google reader、箱包批发网等纷纷抄袭了这一项技术，于是靠滚动浏览器滚动条
                                
                                
ImageButton去边框&Button或者ImageButton的背景透明
                                    dcj3sjt126com
imagebutton
                                    
在ImageButton中载入图片后，很多人会觉得有图片周围的白边会影响到美观，其实解决这个问题有两种方法 
一种方法是将ImageButton的背景改为所需要的图片。如：android:background="@drawable/XXX" 
第二种方法就是将ImageButton背景改为透明，这个方法更常用 
在XML里； 
   <ImageBut
                                
                                
JSP之c:foreach
                                    eksliang
jspforearch
                                    
原文出自：http://www.cnblogs.com/draem0507/archive/2012/09/24/2699745.html 
<c:forEach>标签用于通用数据循环，它有以下属性    属 性 描 述 是否必须 缺省值   items 进行循环的项目 否 无   begin 开始条件 否 0   end 结束条件 否 集合中的最后一个项目   step 步长 否 1
                                
                                
Android实现主动连接蓝牙耳机
                                    gqdy365
android
                                    
在Android程序中可以实现自动扫描蓝牙、配对蓝牙、建立数据通道。蓝牙分不同类型，这篇文字只讨论如何与蓝牙耳机连接。 
大致可以分三步： 
 
一、扫描蓝牙设备： 
1、注册并监听广播： 
 

BluetoothAdapter.ACTION_DISCOVERY_STARTED
BluetoothDevice.ACTION_FOUND
BluetoothAdapter.ACTION_DIS
                                
                                
android学习轨迹之四：org.json.JSONException: No value for
                                    hyz301
json
                                    
org.json.JSONException: No value for items  
在JSON解析中会遇到一种错误，很常见的错误 
  
06-21 12:19:08.714    2098-2127/com.jikexueyuan.secret I/System.out﹕ Result:{"status":1,"page":1,&
                                
                                
干货分享：从零开始学编程 系列汇总
                                    justjavac
编程
                                    
程序员总爱重新发明轮子，于是做了要给轮子汇总。 
 
  从零开始写个编译器吧系列 (知乎专栏)  
  从零开始写一个简单的操作系统 (伯乐在线)  
  从零开始写JavaScript框架 (图灵社区)  
  从零开始写jQuery框架 (蓝色理想 )  
  从零开始nodejs系列文章 (粉丝日志)  
  从零开始编写网络游戏 
                                
                                
jquery-autocomplete 使用手册
                                    macroli
jqueryAjax脚本
                                    
jquery-autocomplete学习 
一、用前必备 
官方网站：http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/  
当前版本：1.1 
需要JQuery版本：1.2.6 
二、使用 
<script src="./jquery-1.3.2.js" type="text/ja
                                
                                
PLSQL-Developer或者Navicat等工具连接远程oracle数据库的详细配置以及数据库编码的修改
                                    超声波
oracleplsql
                                    
　　在服务器上将Oracle安装好之后接下来要做的就是通过本地机器来远程连接服务器端的oracle数据库，常用的客户端连接工具就是PLSQL-Developer或者Navicat这些工具了。刚开始也是各种报错，什么TNS:no listener;TNS:lost connection;TNS:target hosts...花了一天的时间终于让PLSQL-Developer和Navicat等这些客户
                                
                                
数据仓库数据模型之：极限存储--历史拉链表
                                    superlxw1234
极限存储数据仓库数据模型拉链历史表
                                    
在数据仓库的数据模型设计过程中，经常会遇到这样的需求： 
 1. 数据量比较大; 2. 表中的部分字段会被update,如用户的地址，产品的描述信息，订单的状态等等; 3. 需要查看某一个时间点或者时间段的历史快照信息，比如，查看某一个订单在历史某一个时间点的状态，    比如，查看某一个用户在过去某一段时间内，更新过几次等等; 4. 变化的比例和频率不是很大，比如，总共有10
                                
                                
10点睛Spring MVC4.1-全局异常处理
                                    wiselyman
spring mvc
                                    
10.1 全局异常处理 
 
 使用@ControllerAdvice注解来实现全局异常处理; 
 使用@ControllerAdvice的属性缩小处理范围 
  
10.2 演示 
 
 演示控制器 
  
package com.wisely.web;

import org.springframework.stereotype.Controller;
import org.spring
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        
版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.