mybatis-03 一级二级缓存，使用注解开发

最新推荐文章于 2024-04-08 18:00:00 发布

杵意

最新推荐文章于 2024-04-08 18:00:00 发布

阅读量304

点赞数

分类专栏： java后端开发文章标签：缓存 java redis

王锡豪

本文链接：https://blog.csdn.net/wang121213145/article/details/123015673

版权

java后端开发专栏收录该内容

64 篇文章 1 订阅

订阅专栏

第一节概念

官网地址：https://mybatis.org/mybatis-3/zh/sqlmap-xml.html#cache
MyBatis 内置了一个强大的事务性查询缓存机制，它可以非常方便地配置和定制。为了使它更加强大而且易于配置，我们对 MyBatis 3 中的缓存实现进行了许多改进。

默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行。

第二节一级缓存

知识点：
一级缓存默认开启的，基于SqlSession级别的缓存,每一个sqlsession之间是相互独立的。
当SqlSession执行：关闭、更新操作（增删改）、清空缓存操作时：会清空缓存；

一级缓存（本地缓存）：
一级缓存也叫本地缓存，MyBatis 的一级缓存是在会话（SqlSession）层面进行缓存的。MyBatis 的一级缓存是默认开启的，不需要任何的配置。
每当我们使用MyBatis开启一次和数据库的会话，MyBatis会创建出一个SqlSession对象表示一次数据库会话。
在对数据库的一次会话中，我们有可能会反复地执行完全相同的查询语句，如果不采取一些措施的话，每一次查询都会查询一次数据库,而我们在极短的时间内做了完全相同的查询，那么它们的结果极有可能完全相同，由于查询一次数据库的代价很大，这有可能造成很大的资源浪费。
为了解决这一问题，减少资源的浪费，MyBatis会在表示会话的SqlSession对象中建立一个简单的缓存，将每次查询到的结果结果缓存起来，当下次查询的时候，如果判断先前有个完全一样的查询，会直接从缓存中直接将结果取出，返回给用户，不需要再进行一次数据库查询了。
一级缓存的生命周期有多长？

MyBatis在开启一个数据库会话时，会创建一个新的SqlSession对象，SqlSession对象中会有一个新的Executor对象，Executor对象中持有一个新的PerpetualCache对象；当会话结束时，SqlSession对象及其内部的Executor对象还有PerpetualCache对象也一并释放掉。
simple batch reuse

Executor是MyBatis的SQL顶层执行器接口，声明了对数据库所有的增删改查操作。其中 query()和queryCursor()方法用于执行查询操作，update()方法用于执行插入、删除、修改操作。

BaseExecutor是Executor的抽象实现类，采用模板设计模式，它声明的抽象方法由子类SimpleExecutor、ReuseExecutor、BatchExecutor实现。

SimpleExecutor是基础的Executor，能够完成基本的增删改查操作

BatchExecutor则会对调用同一个Mapper执行的update、insert和delete操作，调用Statement对象的批量操作功能。

ResueExecutor对JDBC中的Statement对象做了缓存，当执行相同的SQL语句时，直接从缓存中取出Statement对象进行复用，避免了频繁创建和销毁Statement对象，从而提升系统性能

如果SqlSession调用了close()方法，会释放掉一级缓存PerpetualCache对象，一级缓存将不可用；
如果SqlSession调用了clearCache()，会清空PerpetualCache对象中的数据，但是该对象仍可使用；
SqlSession中执行了任何一个update操作(update()、delete()、insert()) ，都会清空PerpetualCache对象的数据，但是该对象可以继续使用；

SqlSession 一级缓存的工作流程：
1.对于某个查询，根据statementId,params,rowBounds来构建一个key值，根据这个key值去缓存Cache中取出对应的key值存储的缓存结果
2.判断从Cache中根据特定的key值取的数据数据是否为空，即是否命中；
3.如果命中，则直接将缓存结果返回；
4.如果没命中：

去数据库中查询数据，得到查询结果；
将key和查询到的结果分别作为key,value对存储到Cache中；
将查询结果返回；

一级缓存的不足：
使用一级缓存的时候，因为缓存不能跨会话共享，不同的会话之间对于相同的数据可能有不一样的缓存。在有多个会话或者分布式环境下，会存在脏数据的问题。如果要解决这个问题，就要用到二级缓存。MyBatis 一级缓存（MyBaits 称其为 Local Cache）无法关闭，但是有两种级别可选：

session 级别的缓存，在同一个 sqlSession 内，对同样的查询将不再查询数据库，直接从缓存中。
statement 级别的缓存，避坑：为了避免这个问题，可以将一级缓存的级别设为 statement 级别的，这样每次查询结束都会清掉一级缓存。
图解：
MyBatis会在一次会话的表示----一个SqlSession对象中创建一个本地缓存(local cache)，对于每一次查询，都会尝试根据查询的条件去本地缓存中查找是否在缓存中，如果在缓存中，就直接从缓存中取出，然后返回给用户；否则，从数据库读取数据，将查询结果存入缓存并返回给用户。
实例讲解：

/**
     * 测试一级缓存
     */
    @Test
    public void testOneLevelCache(){

        //获取列表
        List<Dept> deptList = mapper.listDept();
        System.out.println(deptList);
        //间隔符
        System.out.println("--------------------------------------------------------");

        //获取列表
        List<Dept> deptList1 = mapper.listDept();
        System.out.println(deptList1);

        System.out.println("-----------------执行添加---------------------");
        Dept d=new Dept();
        d.setDname("test");
        d.setLoc("zhenghen");
        mapper.insertDept(d);
        System.out.println("--------------------------------------------------------");
        //获取列表
        List<Dept> deptList2 = mapper.listDept();
        System.out.println(deptList2);
        System.out.println("-----------------------------缓存---------------------------");
        List<Dept> deptList3 = mapper.listDept();
        System.out.println(deptList3);
        System.out.println("-----------------------------清空缓存---------------------------");
        session.clearCache();
        List<Dept> deptList4 = mapper.listDept();
        System.out.println(deptList4);

}

第三节二级缓存

知识点：

要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行：

这个简单语句的效果如下（细讲，实例测试）:

映射语句文件中的所有 select 语句的结果将会被缓存。
映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
缓存不会定时进行刷新（也就是说，没有刷新间隔）。
缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

eviction ：

LRU – 最近最少使用：移除最长时间不被使用的对象。
FIFO – 先进先出：按对象进入缓存的顺序来移除它们。

flushInterval（刷新间隔）属性可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新。

size（引用数目）属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。

readOnly（只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。速度上会慢一些，但是更安全，因此默认值是 false。

二级缓存是用来解决一级缓存不能跨会话共享的问题的，范围是namespace 级别的，可以被多个SqlSession 共享（只要是同一个接口里面的相同方法，都可以共享），生命周期和应用同步。如果你的MyBatis使用了二级缓存，并且你的Mapper和select语句也配置使用了二级缓存，那么在执行select查询的时候，MyBatis会先从二级缓存中取输入，其次才是一级缓存，即MyBatis查询数据的顺序是：二级缓存 —> 一级缓存 —> 数据库。作为一个作用范围更广的缓存，它肯定是在SqlSession 的外层，否则不可能被多个SqlSession 共享。而一级缓存是在SqlSession 内部的，所以第一个问题，肯定是工作在一级缓存之前，也就是只有取不到二级缓存的情况下才到一个会话中去取一级缓存。第二个问题，二级缓存放在哪个对象中维护呢？要跨会话共享的话，SqlSession 本身和它里面的BaseExecutor 已经满足不了需求了，那我们应该在BaseExecutor 之外创建一个对象。
实际上MyBatis 用了一个装饰器的类来维护，就是CachingExecutor。如果启用了二级缓存，MyBatis 在创建Executor 对象的时候会对Executor 进行装饰。CachingExecutor 对于查询请求，会判断二级缓存是否有缓存结果，如果有就直接返回，如果没有委派交给真正的查询器Executor 实现类，比如SimpleExecutor 来执行查询，再走到一级缓存的流程。最后会把结果缓存起来，并且返回给用户。

图解：
在这里插入图片描述
实例讲解：

/**
     * 测试2级缓存（基于mapper文件）
     */
    @Test
   public void testTwoLevelCache() throws InterruptedException {


       SqlSession session=SqlSessionFactoryUtil.getSqlSession();
        List<Dept> deptList = session.getMapper(IDeptDao.class).listDept();
        System.out.println(deptList);
        session.close();
        System.out.println("第2次查询----------------------------");
    SqlSession session1=SqlSessionFactoryUtil.getSqlSession();
    System.out.println(session==session1);
        List<Dept> deptList1 = session1.getMapper(IDeptDao.class).listDept();
        System.out.println(deptList1);
        session1.close();

        System.out.println("执行线程阻塞----------休息10秒--------");
        Thread.sleep(10000);
        System.out.println("第3次查询----------------------------");
        //使用工具类获取sqlSession
    SqlSession session2=SqlSessionFactoryUtil.getSqlSession();
        List<Dept> deptList2 = session2.getMapper(IDeptDao.class).listDept();
        System.out.println(deptList2);
        session2.close();
        System.out.println("第4次查询----------------------------");
    SqlSession  session3=SqlSessionFactoryUtil.getSqlSession();
        List<Dept> deptList3 = session3.getMapper(IDeptDao.class).listDept();
        System.out.println(deptList3);
        session3.close();
    System.out.println("----------------添加数据-----------");

    SqlSession session4=SqlSessionFactoryUtil.getSqlSession();
    Dept d=new Dept();
    d.setDname("test");
    d.setLoc("zhenghen");
     session4.getMapper(IDeptDao.class).insertDept(d);
     session4.commit();
     session4.close();
    SqlSession session5=SqlSessionFactoryUtil.getSqlSession();
    List<Dept> deptList4 = session5.getMapper(IDeptDao.class).listDept();
    System.out.println(deptList4);
    session5.close();

}

Cache Hit Ratio (缓冲命中率)
假设你将一段数据缓存至内存中
第一查询数据时:
由于你是在从数据库中查询的数据
缓存命中率为了，还没有进入缓存
关闭此数据库链接后
第二次再查询相同的数据时,假如你将数据缓存进内存中
第二次将会直接从内存中去取这条相同的数据
缓存将命中
所以此时的缓存命中率为0.5
第三次查询相同的数据，则命中率为0.66666
以此类推…

<!--默认缓存标签  使用默认属性  二级缓存可以能调用第三方做缓存，涉及对象传输，对象一定要序列化-->

通常来说，二级缓存的机制里会有一个: 当缓存的个数达到某个数量的时候，把缓存对象保存在硬盘上。如果要把对象保存在硬盘上，就必须实现序列化接口。

<cache  flushInterval="10" size="2"></cache>

cache使用的注意事项

只能在【只有单表操作】的表上使用缓存

不只是要保证这个表在整个系统中只有单表操作，而且和该表有关的全部操作必须全部在一个namespace下。

在可以保证查询远远大于insert,update,delete操作的情况下使用缓存

避免使用二级缓存

可能会有很多人不理解这里，二级缓存带来的好处远远比不上他所隐藏的危害。
缓存是以namespace为单位的，不同namespace下的操作互不影响。
insert,update,delete操作会清空所在namespace下的全部缓存。
通常使用MyBatis Generator生成的代码中，都是各个表独立的，每个表都有自己的namespace。
为什么避免使用二级缓存

在符合【Cache使用时的注意事项】的要求时，并没有什么危害。
其他情况就会有很多危害了。
针对一个表的某些操作不在他独立的namespace下进行。
例如在UserMapper.xml中有大多数针对user表的操作。但是在一个XXXMapper.xml中，还有针对user单表的操作。
这会导致user在两个命名空间下的数据不一致。如果在UserMapper.xml中做了刷新缓存的操作，在XXXMapper.xml中缓存仍然有效，如果有针对user的单表查询，使用缓存的结果可能会不正确。
更危险的情况是在XXXMapper.xml做了insert,update,delete操作时，会导致UserMapper.xml中的各种操作充满未知和风险。
有关这样单表的操作可能不常见。但是你也许想到了一种常见的情况。
多表操作一定不能使用缓存
为什么不能？
首先不管多表操作写到那个namespace下，都会存在某个表不在这个namespace下的情况。
例如两个表：role和user_role，如果我想查询出某个用户的全部角色role，就一定会涉及到多表的操作。

<select id="selectUserRoles" resultType="UserRoleVO">
    select * from user_role a,role b where a.roleid = b.roleid and a.userid = #{userid}
</select>

像上面这个查询，你会写到那个xml中呢？？
不管是写到RoleMapper.xml还是UserRoleMapper.xml，或者是一个独立的XxxMapper.xml中。如果使用了二级缓存，都会导致上面这个查询结果可能不正确。
如果你正好修改了这个用户的角色，上面这个查询使用缓存的时候结果就是错的。

第四节注解开发

package com.aaa.mybatis.dao;

import com.aaa.mybatis.entity.News;
import org.apache.ibatis.annotations.*;

import java.util.List;
import java.util.Map;

public interface NewsDao {

    /**
     * 新闻列表
     * @return
     */
    @Select("<script>select news_id newsId,title,addtime from tb_news " +
                "<where>" +
                   "<if test=\"newsNo!=null and newsNo!=''\"> and news_id=#{newsNo}</if>"+
                   "<if test=\"title!=null and title!=''\"> and title like '%'||#{title}||'%'</if>"+
                "</where>"+
            "</script>")
    List<News>  list(Map map);
    /**
     * 根据编号获取对象
     * @param newsId
     * @return
     */
    @Select("select news_id newsId,title,addtime from tb_news where news_id=#{newsId}")
    News  getById(int newsId);

    /**
     * 新闻添加
     * @param news
     * @return
     */
    @Insert("insert into tb_news(news_id,title,addtime) values(#{newsId},#{title},#{addTime})")
    int  add(News news);
    /**
     * 新闻更新
     * @param news
     * @return
     */
    @Update("update tb_news set title=#{title},addTime = #{addTime} where news_id=#{newsId}")
    int update(News news);

    /**
     * 新闻删除
     * @param newsId
     * @return
     */
    @Delete("delete from tb_news where news_id=#{id}")
    int deleteById(int newsId);
}

 <!--映射文件配置-->
    <mappers>
        <mapper class="com.aaa.mybatis.dao.NewsDao"></mapper>
    </mappers>