精华内容
下载资源
问答
  • 文章目录总览缓存的基本思想缓存优势缓存的代价 总览 首先,要熟练掌握缓存的基础知识,了解缓存常用的分类、读写模式,熟悉缓存的七大经典问题及解决应对之策,同时要从缓存组件的访问协议、Client 入手,熟练...

    在这里插入图片描述

    总览

    在这里插入图片描述

    • 首先,要熟练掌握缓存的基础知识,了解缓存常用的分类、读写模式,熟悉缓存的七大经典问题及解决应对之策,同时要从缓存组件的访问协议、Client 入手,熟练掌握如何访问各种缓存组件,如 Memcached、Redis、Pika 等。

    • 其次,要尽可能深入理解缓存组件的实现方案、设计原理,了解缓存的各种特性、优势和不足,这样在缓存数据与预期不一致时&

    展开全文
  • 小工匠架构 - 分布式缓存技术

    千次阅读 2020-11-20 00:06:02
    缓存的主要特点是技术比较简单,同时对性能提升的效果又很显著。 使用缓存需要注意几个关键指标:缓存键集合大小、缓存空间的大小以及缓存的使用寿命。这三个指标决定了缓存的有效性、缓存的使用效率、缓存实现的...
    展开全文
  • 聊聊MyBatis缓存机制

    千次阅读 多人点赞 2018-04-18 13:24:16
    点击上方“程序员小灰”,选择“置顶公众号”有趣有内涵的文章第一时间送达!本文转载自公众号 美团技术点评前言MyBatis是常见的Java数据库访问层框架。在日常工作中,开...

    点击上方“程序员小灰”,选择“置顶公众号”

    有趣有内涵的文章第一时间送达!



    本文转载自公众号 美团技术点评


    前言


    MyBatis是常见的Java数据库访问层框架。在日常工作中,开发人员多数情况下是使用MyBatis的默认缓存配置,但是MyBatis缓存机制有一些不足之处,在使用中容易引起脏数据,形成一些潜在的隐患。


    个人在业务开发中也处理过一些由于MyBatis缓存引发的开发问题,带着个人的兴趣,希望从应用及源码的角度为读者梳理MyBatis缓存机制。

    本次分析中涉及到的代码和数据库表均放在GitHub上,地址: mybatis-cache-demo 。


    目录


    本文按照以下顺序展开。

    • 一级缓存介绍及相关配置。

    • 一级缓存工作流程及源码分析。

    • 一级缓存总结。

    • 二级缓存介绍及相关配置。

    • 二级缓存源码分析。

    • 二级缓存总结。

    • 全文总结。


    一级缓存


    一级缓存介绍


    在应用运行过程中,我们有可能在一次数据库会话中,执行多次查询条件完全相同的SQL,MyBatis提供了一级缓存的方案优化这部分场景,如果是相同的SQL语句,会优先命中一级缓存,避免直接对数据库进行查询,提高性能。具体执行过程如下图所示。


    640?wx_fmt=jpeg


    每个SqlSession中持有了Executor,每个Executor中有一个LocalCache。当用户发起查询时,MyBatis根据当前执行的语句生成MappedStatement,在Local Cache进行查询,如果缓存命中的话,直接返回结果给用户,如果缓存没有命中的话,查询数据库,结果写入Local Cache,最后返回结果给用户。具体实现类的类关系图如下图所示。


    640?wx_fmt=jpeg


    一级缓存配置


    我们来看看如何使用MyBatis一级缓存。开发者只需在MyBatis的配置文件中,添加如下语句,就可以使用一级缓存。共有两个选项,SESSION或者STATEMENT,默认是SESSION级别,即在一个MyBatis会话中执行的所有语句,都会共享这一个缓存。一种是STATEMENT级别,可以理解为缓存只对当前执行的这一个Statement有效。

    <setting name="localCacheScope" value="SESSION"/>


    一级缓存实验


    接下来通过实验,了解MyBatis一级缓存的效果,每个单元测试后都请恢复被修改的数据。

    首先是创建示例表student,创建对应的POJO类和增改的方法,具体可以在entity包和mapper包中查看。

    CREATE TABLE `student` (  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,  `name` varchar(200) COLLATE utf8_bin DEFAULT NULL,  `age` tinyint(3) unsigned DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;


    在以下实验中,id为1的学生名称是凯伦。


    实验1


    开启一级缓存,范围为会话级别,调用三次getStudentById,代码如下所示:

    public void getStudentById() throws Exception {
            SqlSession sqlSession = factory.openSession(true); // 自动提交事务
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
            System.out.println(studentMapper.getStudentById(1));
            System.out.println(studentMapper.getStudentById(1));
            System.out.println(studentMapper.getStudentById(1));
        }


    执行结果:


    640?wx_fmt=jpeg


    我们可以看到,只有第一次真正查询了数据库,后续的查询使用了一级缓存。


    实验2


    增加了对数据库的修改操作,验证在一次数据库会话中,如果对数据库发生了修改操作,一级缓存是否会失效。

    @Testpublic void addStudent() throws Exception {
            SqlSession sqlSession = factory.openSession(true); // 自动提交事务
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
            System.out.println(studentMapper.getStudentById(1));
            System.out.println("增加了" + studentMapper.addStudent(buildStudent()) + "个学生");
            System.out.println(studentMapper.getStudentById(1));
            sqlSession.close();
    }


    执行结果:


    640?wx_fmt=jpeg


    我们可以看到,在修改操作后执行的相同查询,查询了数据库,一级缓存失效。


    实验3


    开启两个SqlSession,在sqlSession1中查询数据,使一级缓存生效,在sqlSession2中更新数据库,验证一级缓存只在数据库会话内部共享。

    @Testpublic void testLocalCacheScope() throws Exception {
            SqlSession sqlSession1 = factory.openSession(true); 
            SqlSession sqlSession2 = factory.openSession(true); 
    
            StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
            StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
    
            System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));
            System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));
            System.out.println("studentMapper2更新了" + studentMapper2.updateStudentName("小岑",1) + "个学生的数据");
            System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));
            System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
    }


    640?wx_fmt=jpeg


    sqlSession2更新了id为1的学生的姓名,从凯伦改为了小岑,但session1之后的查询中,id为1的学生的名字还是凯伦,出现了脏数据,也证明了之前的设想,一级缓存只在数据库会话内部共享。


    一级缓存工作流程&源码分析


    那么,一级缓存的工作流程是怎样的呢?我们从源码层面来学习一下。


    工作流程


    一级缓存执行的时序图,如下图所示。


    640?wx_fmt=png


    源码分析


    接下来将对MyBatis查询相关的核心类和一级缓存的源码进行走读。这对后面学

    习二级缓存也有帮助。

    SqlSession: 对外提供了用户和数据库之间交互需要的所有方法,隐藏了底层的细节。默认实现类是DefaultSqlSession。


    640?wx_fmt=jpeg


    Executor: SqlSession向用户提供操作数据库的方法,但和数据库操作有关的

    职责都会委托给Executor。


    640?wx_fmt=jpeg


    如下图所示,Executor有若干个实现类,为Executor赋予了不同的能力,大家可以根据类名,自行学习每个类的基本作用。


    640?wx_fmt=jpeg


    在一级缓存的源码分析中,主要学习BaseExecutor的内部实现。

    BaseExecutor: BaseExecutor是一个实现了Executor接口的抽象类,定义若干抽象方法,在执行的时候,把具体的操作委托给子类进行执行。

    protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException;


    在一级缓存的介绍中提到对Local Cache的查询和写入是在Executor内部完成的。在阅读BaseExecutor的代码后发现Local Cache是BaseExecutor内部的一个成员变量,如下代码所示。

    public abstract class BaseExecutor implements Executor {protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;protected PerpetualCache localCache;


    Cache: MyBatis中的Cache接口,提供了和缓存相关的最基本的操作,如下图所示。


    640?wx_fmt=jpeg


    有若干个实现类,使用装饰器模式互相组装,提供丰富的操控缓存的能力,部分实现类如下图所示。


    640?wx_fmt=jpeg


    BaseExecutor成员变量之一的PerpetualCache,是对Cache接口最基本的实现,其实现非常简单,内部持有HashMap,对一级缓存的操作实则是对HashMap的操作。如下代码所示。

    public class PerpetualCache implements Cache {  private String id;  private Map<Object, Object> cache = new HashMap<Object, Object>();


    在阅读相关核心类代码后,从源代码层面对一级缓存工作中涉及到的相关代码,出于篇幅的考虑,对源码做适当删减,读者朋友可以结合本文,后续进行更详细的学习。

    为执行和数据库的交互,首先需要初始化SqlSession,通过DefaultSqlSessionFactory开启SqlSession:

    private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
        ............    final Executor executor = configuration.newExecutor(tx, execType);     
        return new DefaultSqlSession(configuration, executor, autoCommit);
    }


    在初始化SqlSesion时,会使用Configuration类创建一个全新的Executor,作为DefaultSqlSession构造函数的参数,创建Executor代码如下所示:

    public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
        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);
        }    // 尤其可以注意这里,如果二级缓存开关开启的话,是使用CahingExecutor装饰BaseExecutor的子类
        if (cacheEnabled) {
          executor = new CachingExecutor(executor);                      
        }
        executor = (Executor) interceptorChain.pluginAll(executor);    return executor;
    }


    SqlSession创建完毕后,根据Statment的不同类型,会进入SqlSession的不同方法中,如果是Select语句的话,最后会执行到SqlSession的selectList,代码如下所示:

    @Overridepublic <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
          MappedStatement ms = configuration.getMappedStatement(statement);      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    }


    SqlSession把具体的查询职责委托给了Executor。如果只开启了一级缓存的话,首先会进入BaseExecutor的query方法。代码如下所示:

    @Overridepublic <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameter);
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }


    在上述代码中,会先根据传入的参数生成CacheKey,进入该方法查看CacheKey是如何生成的,代码如下所示:

    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    cacheKey.update(boundSql.getSql());//后面是update了sql中带的参数cacheKey.update(value);


    在上述的代码中,将MappedStatement的Id、sql的offset、Sql的limit、Sql本身以及Sql中的参数传入了CacheKey这个类,最终构成CacheKey。以下是这个类的内部结构:

    private static final int DEFAULT_MULTIPLYER = 37;private static final int DEFAULT_HASHCODE = 17;private int multiplier;private int hashcode;private long checksum;private int count;private List<Object> updateList;public CacheKey() {    this.hashcode = DEFAULT_HASHCODE;    this.multiplier = DEFAULT_MULTIPLYER;    this.count = 0;    this.updateList = new ArrayList<Object>();
    }


    首先是成员变量和构造函数,有一个初始的hachcode和乘数,同时维护了一个内部的updatelist。在CacheKey的update方法中,会进行一个hashcode和checksum的计算,同时把传入的参数添加进updatelist中。如下代码所示。

    public void update(Object object) {    int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object); 
        count++;
        checksum += baseHashCode;
        baseHashCode *= count;
        hashcode = multiplier * hashcode + baseHashCode;
    
        updateList.add(object);
    }


    同时重写了CacheKey的equals方法,代码如下所示:

    @Overridepublic boolean equals(Object object) {
        .............    for (int i = 0; i < updateList.size(); i++) {
          Object thisObject = updateList.get(i);
          Object thatObject = cacheKey.updateList.get(i);      if (!ArrayUtil.equals(thisObject, thatObject)) {        return false;
          }
        }    return true;
    }


    除去hashcode,checksum和count的比较外,只要updatelist中的元素一一对应相等,那么就可以认为是CacheKey相等。只要两条SQL的下列五个值相同,即可以认为是相同的SQL。


    Statement Id + Offset + Limmit + Sql + Params


    BaseExecutor的query方法继续往下走,代码如下所示:

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


    如果查不到的话,就从数据库查,在queryFromDatabase中,会对localcache进行写入。

    在query方法执行的最后,会判断一级缓存级别是否是STATEMENT级别,如果是的话,就清空缓存,这也就是STATEMENT级别的一级缓存无法共享localCache的原因。代码如下所示:

    if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
            clearLocalCache();
    }


    在源码分析的最后,我们确认一下,如果是insert/delete/update方法,缓存就会刷新的原因。

    SqlSession的insert方法和delete方法,都会统一走update的流程,代码如下所示:

    @Overridepublic int insert(String statement, Object parameter) {    return update(statement, parameter);
      }   @Override
      public int delete(String statement) {    return update(statement, null);
    }


    update方法也是委托给了Executor执行。BaseExecutor的执行方法如下所示。

    @Overridepublic 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);
    }


    每次执行update前都会清空localCache。


    至此,一级缓存的工作流程讲解以及源码分析完毕。


    小结


    1. MyBatis一级缓存的生命周期和SqlSession一致。

    2. MyBatis一级缓存内部设计简单,只是一个没有容量限定的HashMap,在缓存的功能性上有所欠缺。

    3. MyBatis的一级缓存最大范围是SqlSession内部,有多个SqlSession或者分布式的环境下,数据库写操作会引起脏数据,建议设定缓存级别为Statement。

        

    二级缓存


    二级缓存介绍


    在上文中提到的一级缓存中,其最大的共享范围就是一个SqlSession内部,如果多个SqlSession之间需要共享缓存,则需要使用到二级缓存。开启二级缓存后,会使用CachingExecutor装饰Executor,进入一级缓存的查询流程前,先在CachingExecutor进行二级缓存的查询,具体的工作流程如下所示。


    640?wx_fmt=png


    二级缓存开启后,同一个namespace下的所有操作语句,都影响着同一个Cache,即二级缓存被多个SqlSession共享,是一个全局的变量。

    当开启缓存后,数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。


    二级缓存配置


    要正确的使用二级缓存,需完成如下配置的。

    1. 在MyBatis的配置文件中开启二级缓存。

      <setting name="cacheEnabled" value="true"/>
    2. 在MyBatis的映射XML中配置cache或者 cache-ref 。

    cache标签用于声明这个namespace使用二级缓存,并且可以自定义配置。

    <cache/>
    • type:cache使用的类型,默认是PerpetualCache,这在一级缓存中提到过。

    • eviction: 定义回收的策略,常见的有FIFO,LRU。

    • flushInterval: 配置一定时间自动刷新缓存,单位是毫秒。

    • size: 最多缓存对象的个数。

    • readOnly: 是否只读,若配置可读写,则需要对应的实体类能够序列化。

    • blocking: 若缓存中找不到对应的key,是否会一直blocking,直到有对应的数据进入缓存。


    cache-ref代表引用别的命名空间的Cache配置,两个命名空间的操作使用的是同一个Cache。

    <cache-ref namespace="mapper.StudentMapper"/>


    二级缓存实验


    接下来我们通过实验,了解MyBatis二级缓存在使用上的一些特点。

    在本实验中,id为1的学生名称初始化为点点。


    实验1


    测试二级缓存效果,不提交事务,sqlSession1查询完数据后,sqlSession2相同的查询是否会从缓存中获取数据。

    @Testpublic void testCacheWithoutCommitOrClose() throws Exception {
            SqlSession sqlSession1 = factory.openSession(true); 
            SqlSession sqlSession2 = factory.openSession(true); 
    
            StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
            StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
    
            System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));
            System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
    }


    执行结果:

    640?wx_fmt=jpeg


    我们可以看到,当sqlsession没有调用commit()方法时,二级缓存并没有起到作用。


    实验2


    测试二级缓存效果,当提交事务时,sqlSession1查询完数据后,sqlSession2相同的查询是否会从缓存中获取数据。

    @Testpublic void testCacheWithCommitOrClose() throws Exception {
            SqlSession sqlSession1 = factory.openSession(true); 
            SqlSession sqlSession2 = factory.openSession(true); 
    
            StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
            StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
    
            System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));
            sqlSession1.commit();
            System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
    }

    640?wx_fmt=jpeg


    从图上可知,sqlsession2的查询,使用了缓存,缓存的命中率是0.5。


    实验3


    测试update操作是否会刷新该namespace下的二级缓存。

    @Testpublic void testCacheWithUpdate() throws Exception {
            SqlSession sqlSession1 = factory.openSession(true); 
            SqlSession sqlSession2 = factory.openSession(true); 
            SqlSession sqlSession3 = factory.openSession(true); 
    
            StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
            StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
            StudentMapper studentMapper3 = sqlSession3.getMapper(StudentMapper.class);
    
            System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));
            sqlSession1.commit();
            System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
    
            studentMapper3.updateStudentName("方方",1);
            sqlSession3.commit();
            System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
    }


    640?wx_fmt=jpeg


    我们可以看到,在sqlSession3更新数据库,并提交事务后,sqlsession2的StudentMapper namespace下的查询走了数据库,没有走Cache。


    实验4


    验证MyBatis的二级缓存不适应用于映射文件中存在多表查询的情况。

    通常我们会为每个单表创建单独的映射文件,由于MyBatis的二级缓存是基于namespace的,多表查询语句所在的namspace无法感应到其他namespace中的语句对多表查询中涉及的表进行的修改,引发脏数据问题。

    @Testpublic void testCacheWithDiffererntNamespace() throws Exception {
            SqlSession sqlSession1 = factory.openSession(true); 
            SqlSession sqlSession2 = factory.openSession(true); 
            SqlSession sqlSession3 = factory.openSession(true); 
    
            StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
            StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
            ClassMapper classMapper = sqlSession3.getMapper(ClassMapper.class);
    
            System.out.println("studentMapper读取数据: " + studentMapper.getStudentByIdWithClassInfo(1));
            sqlSession1.close();
            System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(1));
    
            classMapper.updateClassName("特色一班",1);
            sqlSession3.commit();
            System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(1));
    }


    执行结果:


    640?wx_fmt=jpeg


    在这个实验中,我们引入了两张新的表,一张class,一张classroom。class中保存了班级的id和班级名,classroom中保存了班级id和学生id。我们在StudentMapper中增加了一个查询方法getStudentByIdWithClassInfo,用于查询学生所在的班级,涉及到多表查询。在ClassMapper中添加了updateClassName,根据班级id更新班级名的操作。

    当sqlsession1的studentmapper查询数据后,二级缓存生效。保存在StudentMapper的namespace下的cache中。当sqlSession3的classMapper的updateClassName方法对class表进行更新时,updateClassName不属于StudentMapper的namespace,所以StudentMapper下的cache没有感应到变化,没有刷新缓存。当StudentMapper中同样的查询再次发起时,从缓存中读取了脏数据。


    实验5


    为了解决实验4的问题呢,可以使用Cache ref,让ClassMapper引用StudenMapper命名空间,这样两个映射文件对应的Sql操作都使用的是同一块缓存了。

    执行结果:


    640?wx_fmt=jpeg


    不过这样做的后果是,缓存的粒度变粗了,多个Mapper namespace下的所有操作都会对缓存使用造成影响。


    二级缓存源码分析


    MyBatis二级缓存的工作流程和前文提到的一级缓存类似,只是在一级缓存处理前,用CachingExecutor装饰了BaseExecutor的子类,在委托具体职责给delegate之前,实现了二级缓存的查询和写入功能,具体类关系图如下图所示。


    640?wx_fmt=jpeg


    源码分析


    源码分析从CachingExecutor的query方法展开,源代码走读过程中涉及到的知识点较多,不能一一详细讲解,读者朋友可以自行查询相关资料来学习。

    CachingExecutor的query方法,首先会从MappedStatement中获得在配置初始化时赋予的Cache。

    Cache cache = ms.getCache();


    本质上是装饰器模式的使用,具体的装饰链是


    SynchronizedCache -> LoggingCache -> SerializedCache -> LruCache -> PerpetualCache。


    640?wx_fmt=jpeg


    以下是具体这些Cache实现类的介绍,他们的组合为Cache赋予了不同的能力。

    • SynchronizedCache: 同步Cache,实现比较简单,直接使用synchronized修饰方法。

    • LoggingCache: 日志功能,装饰类,用于记录缓存的命中率,如果开启了DEBUG模式,则会输出命中率日志。

    • SerializedCache: 序列化功能,将值序列化后存到缓存中。该功能用于缓存返回一份实例的Copy,用于保存线程安全。

    • LruCache: 采用了Lru算法的Cache实现,移除最近最少使用的key/value。

    • PerpetualCache: 作为为最基础的缓存类,底层实现比较简单,直接使用了HashMap。


    然后是判断是否需要刷新缓存,代码如下所示:

    flushCacheIfRequired(ms);


    在默认的设置中SELECT语句不会刷新缓存,insert/update/delte会刷新缓存。进入该方法。代码如下所示:

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


    MyBatis的CachingExecutor持有了TransactionalCacheManager,即上述代码中的tcm。

    TransactionalCacheManager中持有了一个Map,代码如下所示:

    private Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();


    这个Map保存了Cache和用TransactionalCache包装后的Cache的映射关系。

    TransactionalCache实现了Cache接口,CachingExecutor会默认使用他包装初始生成的Cache,作用是如果事务提交,对缓存的操作才会生效,如果事务回滚或者不提交事务,则不对缓存产生影响。

    在TransactionalCache的clear,有以下两句。清空了需要在提交时加入缓存的列表,同时设定提交时清空缓存,代码如下所示:

    @Overridepublic void clear() {
        clearOnCommit = true;
        entriesToAddOnCommit.clear();
    }


    CachingExecutor继续往下走,ensureNoOutParams主要是用来处理存储过程的,暂时不用考虑。

    if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, parameterObject, boundSql);


    之后会尝试从tcm中获取缓存的列表。

    List<E> list = (List<E>) tcm.getObject(cache, key);


    在getObject方法中,会把获取值的职责一路传递,最终到PerpetualCache。如果没有查到,会把key加入Miss集合,这个主要是为了统计命中率。

    Object object = delegate.getObject(key);if (object == null) {
        entriesMissedInCache.add(key);
    }


    CachingExecutor继续往下走,如果查询到数据,则调用tcm.putObject方法,往缓存中放入值。

    if (list == null) {
        list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
        tcm.putObject(cache, key, list); // issue #578 and #116}


    tcm的put方法也不是直接操作缓存,只是在把这次的数据和key放入待提交的Map中。

    @Overridepublic void putObject(Object key, Object object) {
        entriesToAddOnCommit.put(key, object);
    }


    从以上的代码分析中,我们可以明白,如果不调用commit方法的话,由于TranscationalCache的作用,并不会对二级缓存造成直接的影响。因此我们看看Sqlsession的commit方法中做了什么。代码如下所示:

    @Overridepublic void commit(boolean force) {    try {
          executor.commit(isCommitOrRollbackRequired(force));


    因为我们使用了CachingExecutor,首先会进入CachingExecutor实现的commit方法。

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


    会把具体commit的职责委托给包装的Executor。主要是看下tcm.commit(),tcm最终又会调用到TrancationalCache。

    public void commit() {    if (clearOnCommit) {
          delegate.clear();
        }
        flushPendingEntries();
        reset();
    }


    看到这里的clearOnCommit就想起刚才TrancationalCache的clear方法设置的标志位,真正的清理Cache是放到这里来进行的。具体清理的职责委托给了包装的Cache类。之后进入flushPendingEntries方法。代码如下所示:

    private void flushPendingEntries() {    for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
          delegate.putObject(entry.getKey(), entry.getValue());
        }
        ................
    }


    在flushPendingEntries中,将待提交的Map进行循环处理,委托给包装的Cache类,进行putObject的操作。

    后续的查询操作会重复执行这套流程。如果是insert|update|delete的话,会统一进入CachingExecutor的update方法,其中调用了这个函数,代码如下所示:

    private void flushCacheIfRequired(MappedStatement ms)


    在二级缓存执行流程后就会进入一级缓存的执行流程,因此不再赘述。


    小结


    1. MyBatis的二级缓存相对于一级缓存来说,实现了SqlSession之间缓存数据的共享,同时粒度更加的细,能够到namespace级别,通过Cache接口实现类不同的组合,对Cache的可控性也更强。

    2. MyBatis在多表查询时,极大可能会出现脏数据,有设计上的缺陷,安全使用二级缓存的条件比较苛刻。

    3. 在分布式环境下,由于默认的MyBatis Cache实现都是基于本地的,分布式环境下必然会出现读取到脏数据,需要使用集中式缓存将MyBatis的Cache接口实现,有一定的开发成本,直接使用Redis,Memcached等分布式缓存可能成本更低,安全性也更高。


    全文总结


    本文对介绍了MyBatis一二级缓存的基本概念,并从应用及源码的角度对MyBatis的缓存机制进行了分析。最后对MyBatis缓存机制做了一定的总结,个人建议MyBatis缓存特性在生产环境中进行关闭,单纯作为一个ORM框架使用可能更为合适。


    作者简介


    凯伦,美团点评后端研发工程师,2016年毕业于上海海事大学,现从事美团点评餐饮平台相关的开发工作。公众号ID: KailunTalk,欢迎关注,一起探讨更多技术知识。



    —————END—————




    喜欢本文的朋友们,欢迎长按下图关注订阅号程序员小灰,收看更多精彩内容

    640?wx_fmt=jpeg


    展开全文
  • 本期我们来聊缓存的妙用和问题,说一说你是如何利用缓存解决问题,也谈一谈因为缓存又带来了哪些新的问题! 回顾一下缓存的原始意义:是指访问速度比一般随机存取存储器(RAM)快的一种高速存储器,通常它不像...

    朋友们,大家好呀。

    正在热火朝天的进行中,之前的技术专题对于技术领域领域有所限制,那我们本期就没有明显的领域限制啦。

    本期我们来聊一聊缓存的妙用和问题,说一说你是如何利用缓存解决问题,也谈一谈因为缓存又带来了哪些新的问题!

    回顾一下缓存的原始意义:是指访问速度比一般随机存取存储器(RAM)快的一种高速存储器,通常它不像系统主存那样使用DRAM技术,而使用昂贵但较快速的SRAM技术,缓存的设置是所有现代计算机系统发挥高性能的重要因素之一。

    可以看到缓存的最初使用是作用于系统级的,但随着一代代工程师的挖掘和实战,缓存慢慢的走进了更多的生态之中,比如:浏览器缓存,后端体系中如MyBatis框架中的一级、二级缓存、基于Redis搭建的缓存服务等等,甚至为了保证网络质量不佳情况时APP的正常使用,我们也会为所有的 API 加上缓存,从另一个方面说,缓存已经成为互联网生态中必不可少的一部分。

    总结一句话:缓存是提高性能最好的方式。

    在缓存的设计与使用中,存在多种多样的技巧和方案,本文抛砖引玉,以Cache Aside 更新模式为例来介绍一下最常用的缓存设计方案,主要逻辑即考虑:失效、命中、更新时的动作。

    失效:应用程序先从 Cache 取数据,如果没有得到,则从数据库中取数据,成功后,放到缓存中。 命中:应用程序从 Cache 中取数据,取到后返回。 更新:先把数据存到数据库中,成功后,再让缓存失效。

    如此一来,便可以建立起一个简单的缓存服务,为接口提高最高效率的查询速度。 但是朋友们,重点来了,这样做真的是完美方案吗?我们会问这样的几个问题:

    为什么不是写完数据库后更新缓存 如何保证缓存的命中 如何保证数据的强一致性 如何设计缓存的淘汰策略 如何有效的水平拓展缓存服务 如何配合缓存设计最大吞吐量的系统 如何做好针对缓存的监控 如何设计多级缓存

     

    展开全文
  • 声明:本位来自京东张开涛的微信公众号(kaitao-1234567),授权CSDN转载,如需转载请联系作者。...工作之余喜欢写技术博客,有《跟我学 Spring》、《跟我学Spring MVC》、《跟我学Shiro》、《跟我学Nginx+Lua开发》...
  • 本篇是聊聊分布式应用中的缓存方案(一)的姊妹篇。 【1】什么是静态数据 这里静态数据是指不经常发生变化或者变化频率比较低的数据,比如车型库、用户基本信息、车辆基本信息等。车型库这种可能每个月会更新一次,...
  • 聊聊分布式应用中的缓存方案(一)

    千次阅读 2019-01-15 11:34:38
    【1】本地缓存 本地缓存缓存和应用在同一个进程里,是基于JVM的缓存,应用生则生,应用死则亡。 常见产品有Guava、Caffeine和Ehcache。三者对比如下: 对比项 Guava Caffeine Ehcache 是否开源 Y(Google) ...
  • 聊聊db和缓存一致性常见的实现方式

    千次阅读 2019-10-21 19:23:58
    欢迎大家加我微信itsoku一起交流java、算法、数据库相关技术。数据存储在数据库中,为了加快业务访问的速度,我们将数据库中的一些数据放在缓存中,那么问题来了,如何确保...
  • Manifest是H5提供的一种应用缓存机制。基于它,Web应用可以实现离线访问(offline cache)。 为此,浏览器还提供了应用缓存的API——Application Cache。虽然Manifest的技术已被...了解详情:H5应用缓存:Mani...
  • 聊聊db和缓存一致性的5种实现方式

    千次阅读 2019-10-22 12:13:21
    数据库中,为了加快业务访问的速度,我们将数据库中的一些数据放在缓存中,那么问题来了,如何确保db和缓存中数据的一致性呢?我们列出了5种方法,大家都了解一下,然后根据业务自己选择。 方案1 获取缓存逻辑 ...
  • 1)线程 A 需要更新数据,首先删除了 Redis 缓存 2)线程 B 查询数据,发现缓存不存在,到数据库查询旧值,写入 Redis,返回 3)线程 A 更新了数据库
  • 聊聊Netflix的技术创新

    千次阅读 2019-02-11 11:12:11
    昨天晚上和同事一起吃晚饭,期间到Netflix技术那些大胆的创新,事后觉得有必要总结一下,给团队分享,让大家了解世界顶级的技术组织在技术、架构、组织和文化方面的创新。让大家在埋头干活的时候,偶尔也可以抬头...
  • 写在前面 在实际工作中,有一种非常普遍的并发场景:那就是读多写少的场景。在这种场景下,为了优化程序的性能,我们经常使用缓存来提高应用的访问性能。因为缓存非常适合使用...一起交流技术,一起进阶,一起牛逼~~
  • 本文将提及的缓存技术则是提升性能的另一把利刃。然而任何技术都是有可为有可不为,没有最好的技术只有最适合的技术,因此在使用缓存之前,我们也需要了解下引入缓存模块所带来的好处和坏处。 2. 缘起:为何使用缓存...
  • 前言:Redis的持久化机制和缓存淘汰策略在各大厂面试题中经常有出现,除此之外在一些场景下,了解Reids的持久化机制和缓存淘汰策略可以帮助我们更好的设计技术方案,以及解决一些实际问题,所以本篇再深入这些不...
  • MyBatis缓存

    2021-10-12 16:14:49
    聊聊MyBatis缓存机制 - 美团技术团队
  • Java作为一个跨平台的语言,它的实现要面对不同的底层硬件...要理解Java内存模型以及一些处理高并发的技术手段,理解一些基本的硬件知识是必须的。这篇会说一下跟并发编程相关的一些硬件知识。 一个基本的CPU执行
  • 在上一篇聊聊高并发(三十三)从一致性(Consistency)的角度理解Java内存模型 我们说了Java内存模型是一个语言级别的内存模型抽象,它屏蔽了底层硬件实现内存一致性需求的差异,提供了对上层的统一的接口来提供保证...
  • 虽互不曾谋面,但希望能和您成为笔尖下的朋友以读书,技术,生活为主,偶尔撒点鸡汤不作,不敷衍,意在真诚吐露,用心分享点击左上方,可关注本刊标星公众号(ID:itclanCoder)如果不知...
  • 聊聊这一年从技术麻瓜开始的奋斗史

    千次阅读 多人点赞 2016-12-15 10:53:32
    技术麻瓜的大三狗,从初创公司唯一一个前端,到独自北漂在去哪儿进行寒假实习,最后南下腾讯暑期实习并成功转正。 作为一只野生的程序员,经历了一年的野蛮生长。将这一年的经历记录下,回味这一年的成长。背景介绍...
  • 聊聊 API Gateway 和 Netflix Zuul

    千次阅读 2017-12-30 22:43:01
    聊聊 API Gateway 和 Netflix Zuul
  • 聊聊高并发系统之队列技术

    千次阅读 2018-03-09 17:40:32
    [京东技术]声明:本文转载自微信公众号“开涛的博客”,转载务必声明。 队列在数据结构中是一种线性表,从一端插入数据,然后从另一端删除数据。本文目的不是讲解各种队列算法,而是在应用层面讲述使用队列能解决...
  • 聊聊 Spring Boot 2.x 那些事儿

    万次阅读 多人点赞 2017-11-06 00:00:00
    本文来自作者泥瓦匠在GitChat上分享「聊聊 Spring Boot 2.x 那些事儿」 本文目录: 即将的 Spring 2.0 - Spring 2.0 是什么 - 开发环境和 IDE - 使用 Spring Initializr 快速入门 Starter 组件 - Web:REST ...
  • 聊聊并发系列文章

    2018-02-11 18:13:48
    聊聊并发(一)深入分析Volatile的实现原理聊聊并发(二)Java SE1.6中的Synchronized聊聊并发(三)Java线程池的分析和使用聊聊并发(四)深入分析ConcurrentHashMap聊聊并发(五)原子操作的实现原理聊聊并发(六...
  • 周末,跟阿里的一个朋友(去年晋升为P9了)了很久,的内容几乎全是技术,当然了,两个技术得最多的话题当然就是技术了。从基础到架构,从算法到AI,无所不谈。中间又穿插着不少天马行空的想象,虽然现在看...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,035
精华内容 12,414
关键字:

缓存技术聊聊