mybatis 3.4.6源码深度解析之一级缓存（二）

最新推荐文章于 2022-08-24 16:27:59 发布
最新推荐文章于 2022-08-24 16:27:59 发布
阅读量325 收藏 1
点赞数
分类专栏： mybatis 3.4.6源码 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y1230601/article/details/106570648
版权

文章目录

1 概述

前面大概讲解了mybatis的配置文件解析和主流程的一个调用流程。接下来说说mybatis的缓存。
MyBatis的缓存分为两种：

  • 一级缓存，一级缓存是SqlSession级别的缓存，对于相同的查询，会从缓存中返回结果而不是查询数据库
  • 二级缓存，二级缓存是Mapper级别的缓存，定义在Mapper文件的标签中并需要开启此缓存，多个Mapper文件可以共用一个缓存，依赖标签配置
  • CacheKey，这个是缓存的key，一二级缓存使用的是相同的key，key为cacheKey对象 这个cacheKey要注意，里面通过重写hashCode和equals方法 来判断每个参数是否一样来判断key是否相
    key生成规则
    缓存键CacheKey的格式为：cacheKey=ID + offset + limit + sql + parameterValues + environmentId
    org.apache.ibatis.executor.BaseExecutor#createCacheKey

  @Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    // id
    cacheKey.update(ms.getId());
    // 分页的
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    // 执行的sql
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // mimic DefaultParameterHandler logic sql的value参数
    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);
      }
    }
    
    //environmentId
    if (configuration.getEnvironment() != null) {
      // issue #176
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }

2 一级缓存

一级缓存默认开启，但是只对当前SqlSession有效。不能夸SqlSession

2.1 一级缓存源码解析

一级缓存的声明周期

  1. MyBatis在开启一个数据库会话时，会创建一个新的SqlSession对象，SqlSession对象中会有一个新的Executor对象。Executor对象中持有一个新的PerpetualCache对象；当会话结束时，SqlSession对象及其内部的Executor对象还有PerpetualCache对象也一并释放掉。可以查看org.apache.ibatis.session.defaults.DefaultSqlSessionFactory#openSessionFromDataSource和org.apache.ibatis.session.Configuration#newExecutor(org.apache.ibatis.transaction.Transaction, org.apache.ibatis.session.ExecutorType)
    两个类创建Executor执行类。一级缓存主要是在org.apache.ibatis.executor.BaseExecutor中，可以看到构造方法中默认创建了一级缓存localCache
/**
 * @author Clinton Begin
 */
public abstract class BaseExecutor implements Executor {

  private static final Log log = LogFactory.getLog(BaseExecutor.class);

  protected Transaction transaction;
  protected Executor wrapper;

  protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
  protected PerpetualCache localCache;
  protected PerpetualCache localOutputParameterCache;
  protected Configuration configuration;

  protected int queryStack;
  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;
  }
  1. 如果SqlSession调用了close()方法，当前SqlSession将不可用，也就是不能进行数据库操作。org.apache.ibatis.executor.BaseExecutor中操作都做了如下判断
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
  1. 如果SqlSession调用了clearCache()、commit()、rollback()，都会清空PerpetualCache对象中的数据，但是该对象仍可使用。commit()、rollback()这个相当于是我们开发中涉及的事物调用的方法，所以事物的提交和回滚也会清空PerpetualCache对象中的数据
 @Override
  public boolean isCached(MappedStatement ms, CacheKey key) {
    return localCache.getObject(key) != null;
  }

  @Override
  public void commit(boolean required) throws SQLException {
    if (closed) {
      throw new ExecutorException("Cannot commit, transaction is already closed");
    }
    clearLocalCache();
    flushStatements();
    if (required) {
      transaction.commit();
    }
  }

  @Override
  public void rollback(boolean required) throws SQLException {
    if (!closed) {
      try {
        clearLocalCache();
        flushStatements(true);
      } finally {
        if (required) {
          transaction.rollback();
        }
      }
    }
  }

  @Override
  public void clearLocalCache() {
    if (!closed) {
      localCache.clear();
      localOutputParameterCache.clear();
    }
  }
  1. SqlSession中执行了任何一个update操作(update()、delete()、insert()) ，都会清空PerpetualCache对象的数据，但是该对象可以继续使用，因为所有的SqlSession中的方法最终都会调用org.apache.ibatis.executor.BaseExecutor中对应的方法，SqlSession中delete调的也是BaseExecutor中的update
DefaultSqlSession 中的其实就是更新
   @Override
  public int delete(String statement) {
    return update(statement, null);
  }

  @Override
  public int delete(String statement, Object parameter) {
    return update(statement, parameter);
  }
  1. 一级缓存可以通过查询时候的比如select标签中的flushCache设置是否走缓存（包括一级和二级）。useCache是只针对二级缓存的后面再说
flushCache设置true时 会直接跳过一级和二级缓存
	<select id="selectWithOptions" resultType="org.apache.ibatis.domain.blog.Author" flushCache="false" useCache="false">
		select * from author
	</select>

跳过的逻辑org.apache.ibatis.executor.BaseExecutor#query()方法


  @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.");
    }
    // flushCache 设置判断是不是需要清理缓存  清理就不走一级缓存   默认除了select需要其他的都要。也可以在sql语句标签属性中设置
    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();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

2.2 操作一级缓存的源码

2.2.1一级缓存保存value

   /**
   * 查询数据库  并将结果保存到一级缓存   org.apache.ibatis.executor.BaseExecutor#queryFromDatabase    335行
   *
   * @param ms
   * @param parameter
   * @param rowBounds
   * @param resultHandler
   * @param key
   * @param boundSql
   * @param <E>
   * @return
   * @throws SQLException
   */
  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;
  }

2.2.2一级缓存获取value

  @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.");
    }
    // 判断是不是需要清理缓存   默认除了select需要其他的都要。也可以在sql语句标签属性中设置
    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();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

3 二级缓存

二级缓存是需要在配置文件中配置其他的存储引擎的，但是前面也说了 他会存在一个跨nameSpace的问题。

3.1 原理解析

他的相关操作都是在CachingExecutor类中处理的

  • flushCache设置是否走缓存（包括一级和二级）。useCache是只针对二级缓存，flushCache是操作前清除缓存数据，实际还是会查询缓存，但是返回是空，所以会再去查询数据库，useCache是业务逻辑直接查询数据，不会对缓存进行操作。
  • cacheEnable，要全局开启二级缓存才能使用。并且mapper.xml配置文件中还要配置缓存管理器。实际使用的缓存，
全局配置
  <settings>
    <setting name="cacheEnabled" value="true"/>
  </settings>

mapper配置文件
<mapper namespace="org.apache.ibatis.submitted.global_variables.Mapper">

	<cache type="org.apache.ibatis.submitted.global_variables.CustomCache"/>

	<select id="getUser" resultType="org.apache.ibatis.submitted.global_variables.User">
		select * from ${table} where id = #{id}
	</select>

</mapper>

org.apache.ibatis.submitted.global_variables.CustomCache必须实现 org.apache.ibatis.cache.Cache接口。重写里面的方法

在二级缓存容器的具体回收策略实现上，有下列几种：默认LRU

  • LRU – 最近最少使用的：移除最长时间不被使用的对象，也是默认的选项，其实现类是org.apache.ibatis.cache.decorators.LruCache。
  • FIFO – 先进先出：按对象进入缓存的顺序来移除它们，其实现类是org.apache.ibatis.cache.decorators.FifoCache。
  • SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象，其实现类是org.apache.ibatis.cache.decorators.SoftCache。
  • WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象，其实现类是org.apache.ibatis.cache.decorators.WeakCache。
    　　在缓存的设计上，Mybatis的所有Cache算法都是基于装饰器/Composite模式对PerpetualCache扩展增加功能。

3.2 主要源码

CachingExecutor源码

/**
 *    Copyright 2009-2018 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.executor;

import java.sql.SQLException;
import java.util.List;

import org.apache.ibatis.cache.Cache;
import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.cache.TransactionalCacheManager;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ParameterMode;
import org.apache.ibatis.mapping.StatementType;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.transaction.Transaction;

/**
 * 二级缓存类  默认=开启 但是还要有存储引擎  要不然二级缓存是不起作用的
 *
 * @author Clinton Begin
 * @author Eduardo Macarron
 */
public class CachingExecutor implements Executor {

  // 这里面一般就是默认就是 SimpleExecutor   看自己配置的执行器是哪个
  private final Executor delegate;
  // 这个是缓存管理器   使用装饰模式，再不改变原来类的基础上实现功能
  private final TransactionalCacheManager tcm = new TransactionalCacheManager();

  public CachingExecutor(Executor delegate) {
    this.delegate = delegate;
    delegate.setExecutorWrapper(this);
  }

  @Override
  public Transaction getTransaction() {
    return delegate.getTransaction();
  }

  @Override
  public void close(boolean forceRollback) {
    try {
      //issues #499, #524 and #573
      if (forceRollback) { 
        tcm.rollback();
      } else {
        tcm.commit();
      }
    } finally {
      delegate.close(forceRollback);
    }
  }

  @Override
  public boolean isClosed() {
    return delegate.isClosed();
  }

  @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 {
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

  @Override
  public <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException {
    flushCacheIfRequired(ms);
    return delegate.queryCursor(ms, parameter, rowBounds);
  }

  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    // 二级缓存是基于nameSpace的   跨nameSpace就可能会有问题
    // 这里获取的cache是在nameSpace中配置的<cache>缓存
    Cache cache = ms.getCache();
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        // 这里的getObject其实就是调用cache中的getObject方法  使用装饰模式
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

  @Override
  public List<BatchResult> flushStatements() throws SQLException {
    return delegate.flushStatements();
  }

  @Override
  public void commit(boolean required) throws SQLException {
    delegate.commit(required);
    tcm.commit();
  }

  @Override
  public void rollback(boolean required) throws SQLException {
    try {
      delegate.rollback(required);
    } finally {
      if (required) {
        tcm.rollback();
      }
    }
  }

  private void ensureNoOutParams(MappedStatement ms, BoundSql boundSql) {
    if (ms.getStatementType() == StatementType.CALLABLE) {
      for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
        if (parameterMapping.getMode() != ParameterMode.IN) {
          throw new ExecutorException("Caching stored procedures with OUT params is not supported.  Please configure useCache=false in " + ms.getId() + " statement.");
        }
      }
    }
  }

  @Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    return delegate.createCacheKey(ms, parameterObject, rowBounds, boundSql);
  }

  @Override
  public boolean isCached(MappedStatement ms, CacheKey key) {
    return delegate.isCached(ms, key);
  }

  @Override
  public void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType) {
    delegate.deferLoad(ms, resultObject, property, key, targetType);
  }

  @Override
  public void clearLocalCache() {
    delegate.clearLocalCache();
  }

  private void flushCacheIfRequired(MappedStatement ms) {
    Cache cache = ms.getCache();
    if (cache != null && ms.isFlushCacheRequired()) {      
      tcm.clear(cache);
    }
  }

  @Override
  public void setExecutorWrapper(Executor executor) {
    throw new UnsupportedOperationException("This method should not be called");
  }
}
本人比较懒
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
把源码拆的这么碎，让你彻底明白mybatis缓存
wdj_yyds的博客
06-21 379
不知道大家看到这张图感觉怎么样，不是难，一共也没有几个组件，但是真的让我想当头疼，因为在面试的时候，就这张图，对，你没看错，就这几个组件，那是让我相当难受啊MyBatis中SQL执行的整体过程在 SqlSession 中，会将执行 SQL 的过程交由Executor执行器去执行，过程大致如下：上面还涉及到一级缓存、二级缓存和延迟加载等其他处理过程，下面我们来看一下具体的执行过程在MyBatis的SQL执行过程中，Executor执行器担当着一个重要的角色，相关操作都需要通过它来执行，相当于一个调度器，把SQ
【MyBatis源码全面解析】MyBatis一二级缓存介绍
08-30
下面小编就为大家带来一篇【MyBatis源码全面解析】MyBatis一二级缓存介绍。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Cannot commit, transaction is already closed
yaNew123的博客
08-24 429
Cannot commit, transaction is already closed
Mybatis系列2：模板模式在Mybatis中的执行器中的应用
纵横千里 捭阖四方 的专栏
04-09 192
执行器 从上面的例子可以看到，Statement是频繁使用的，如何管理将影响执行的效率，为此Mybatis提供了多种类型的执行器： 区别是： 1.SimpleExcutor：每执行一次update或者select，就开启一个Statement对象 2.ReuseExecutor：执行update或者select，以sql作为key，查找Statement对象，存在就使用，否则创建，其实就是将其缓存在一个一个map里。 3.BatchExecutor，执行update时，将所有sql都添加到批处理中，等待统
Mybatis3.4.6入门
码农践行
10-14 995
Mybatis3.4.6 http://www.mybatis.org/mybatis-3/zh/getting-started.html Eclipse创建maven工程： 步骤一：添加依赖 org.mybatis mybatis 3.4.6 步骤二：添加MySql驱动 mysql mysql-connector-java 5.1.41 步骤三：添加配置文件mybatis-c...
Mybatis二级缓存源码详解（二）
点滴之积
04-30 1665
Mybatis二级缓存的作用流程
mybatis3.x源码深度解析与最佳实践.pdf
09-12
MyBatis 3.x 源码深度解析与最佳实践 MyBatis 是当前最流行的 Java 持久层框架之一，其通过 XML 配置的方式消除了绝大部分 JDBC 重复代码以及参数的设置，结果集的映射。为了更好地学习和理解 MyBatis 背后的设计...
深入理解MyBatis中的一级缓存与二级缓存
08-30
主要给大家深入的介绍了关于MyBatis中一级缓存与二级缓存的相关资料，文中详细介绍MyBatis中一级缓存与二级缓存的工作原理及使用，对大家具有一定的参考性学习价值，需要的朋友们下面来一起看看吧。
基于Java的Mybatis二级缓存memcache设计源码
05-31
Mybatis二级缓存memcache项目源码，共20个文件，全部采用Java语言编写，涉及多种文件类型如Java源代码、XML配置文件、PREFS文件、CLASSPATH文件、Git忽略文件、PROJECT文件、LICENSE文件、NOTICE文件、README文件和...
mybatis一级缓存和二级缓存简单示例
01-01
配套博客内容，mybatis一级缓存和二级缓存简单示例，供初学童鞋予以参考。 博客地址 https://blog.csdn.net/magi1201/article/details/85524712
mybatis-3.4.6.jar
03-19
mybatis3架包欢迎来下载！..........................................................................................................................................................................
mybatis版本：3.5.6（jdk1.8（含）及以上）、3.4.6（jdk1.8以下）
11-18
两版mybatis，根据jdk版本选择使用哪一版，mybatis版本：3.5.6（jdk1.8（含）及以上）、3.4.6（jdk1.8以下）
MyBatis-3.4.6.zip
06-02
本资源内含有SSM框架中MyBatis——3.4.6 的所有的核心包
MyBatis的缓存机制原理以及实现
qq_43555164的博客
09-06 862
cache缓存 缓存是一般的ORM框架都会提供的功能，目的就是提升查询xiaolv和较少数据库的压力。在MyBatis中有一级缓存和二级缓存，并且预留了集成第三方缓存的接口。 MyBatis的缓存体系结构 MyBatis缓存相关的类都在cache包里，其中有一个接口Cache，他只有一个默认的实现类PerpetualCache，其内部使用HashMap实现数据存储的。 PerpetualCache叫做基础缓存，因为它一定会被创建，除了基础缓存之外，MyBatis也定义了很多的装饰器，同样实现了Cache接口
你可能忽视的 MyBatis 3.5.X 在 JDK8 中存在的性能问题
Java精选
04-15 671
>>号外：关注“Java精选”公众号，回复“2021面试题”关键词，领取全套500多份Java面试题文件。最近，有客户使用TiDB适配批处理场景，处理性能和预期相差很多。在相同...
我最喜欢的Mybatis 3.5新特性！超实用！
weixin_30448685的博客
04-10 313
Mybatis 3.5发布有段时间了，终于支持了Optional，这么实用的特性，竟然还没人安利……于是本文出现了。 新特性比较简单，但非常实用，因为能大量简化恶心的判空代码。 WARNING 由于本文非常简(low)单(比)，我相信又会有类似如下的大佬出现（最近莫名其妙地被若干大佬喷，也不知道得罪谁了，必须高能预警一下，免得脏了大佬们的眼睛）： •嫌低级喷：”这么简单文章也好意...
Mybatis一级缓存源码分析与效果演示
自律使我自由
06-05 2488
一级缓存生命周期 在mybatis中一级缓存是默认开启的，无需添加任何配置属性，一级缓存的生命周期默认是SqlSession级别的，也就是一次数据库会话级别的存在，不同的会话不能共享一级缓存。 一级缓存何时失效？ 因为生命周期是SqlSession级别的，自然SqlSession关闭缓存失效 调用SqlSession.clearCache方法 增删改操作会清空缓存 mapper文件中的配置flushCache为false <select id="xxx" resultType="xxx" flus
Executor介绍
weixin_30919919的博客
09-20 95
1.Executor介绍： Executor是mybatis的核心接口之一，其中定义了数据库操作的基本方法，它的子类结构图如下：这这张关系图中，涉及到了模板方法模式和装饰器模式。BaseExecutor是一个抽象父类，定义了一级缓存和事务相关的公共的固定不变的方法，同时定义了doUpdate，doQuery等抽象方法，这些抽象方法是在BaseExecutor的四个子类中实现的。这里用到了模板方法...
基于易支付二开的前端模板美化源码.zip
最新发布
06-17
基于易支付二开的前端模板美化源码
mybatis 3源码深度解析pdf下载
05-09
MyBatis 3 源码深度解析是一本非常优秀的 MyBatis 学习和使用指南。目前，随着大数据和分布式应用的火热发展，MyBatis 3 已经成为了 Java 企业级应用中的重要组件，越来越多的人选择使用 MyBatis 进行开发。而 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值