Mybatis缓存

发表于 | 分类于 | 本文总阅读量 次
字数统计: 2.1k | 阅读时长 ≈ 8

简介

所有的查询都要连接数据库, 比较耗资源

一次查询的结果,给它暂存在一个可以直接取到的地方 –>内存:缓存

我们再次查询相同数据的时候, 直接走缓存, 就不用走数据库了

  1. 什么是缓存[Cache]?

    • 存在内存中的临时数据
    • 将用户经常查询的数据放在缓存(内存)中, 用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询, 从缓存中查询, 从而提高查询效率, 解决了高并发系统的性能问题

  2. 为什么使用缓存?

    • 减少和数据库的交互次数, 减少系统开销, 提高系统效率

  3. 什么样的数据能使用缓存?

    • 经常查询并且不经常改变的数据

Mybatis缓存

Mybatis包含一个非常强大的查询缓存特性, 它可以非常方便地定制和配置缓存. 缓存可以极大地提升查询效率

Mybatis系统中默认定义了两级缓存:一级缓存 和 *二级缓存 *

  • 默认情况下, 只有一级缓存开启(SqlSession级别的缓存, 也称为本地缓存)
  • 二级缓存需要手动开启和配置, 他是基于namespace级别的缓存
  • 为了提高扩展性, Mybatis定义了缓存接口Cache, 我们可以通过实现Cache接口来自定义二级缓存

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

1
<cache/>

提示 缓存只作用于 cache 标签所在的映射文件中的语句。如果你混合使用 Java API 和 XML 映射文件，在共用接口中的语句将不会被默认缓存。你需要使用 @CacheNamespaceRef 注解指定缓存作用域。

这些属性可以通过 cache 元素的属性来修改。比如：

1
2
3
4
5
<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。

可用的清除策略有：

  • LRU – 最近最少使用：移除最长时间不被使用的对象。
  • FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
  • SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
  • WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。

默认的清除策略是 LRU。

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

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

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

一级缓存

一级缓存也叫本地缓存: SqlSession

  • 与数据库同一次会话期间查询到的数据会放在本地缓存里
  • 以后如果需要获取相同的数据, 直接从缓存中拿, 没必要再去查询数据库
  • 默认开启! 也关闭不掉, 从拿到连接到关闭连接

测试步骤:

  1. 开启日志!

  2. 搭建一个项目, 完成简单的查询功能

    1
    2
    3
    4
    5
    <mapper namespace="com.lxb.dao.UserMapper">
        <select id="queryUserById" parameterType="_int" resultType="user">
            select * from mybatis.user where id=#{id}
        </select>
    </mapper>

    在测试时对一个对象查询两次:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @Test
    public void test() {
        SqlSession sqlSession = MybtisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = mapper.queryUserById(1);
        System.out.println(user);
        System.out.println("========================");
        User user2 = mapper.queryUserById(1);
        System.out.println(user2);
        System.out.println(user == user2);
        sqlSession.close();
    }

    输出结果为:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    Opening JDBC Connection
    Created connection 8805846.
    ==>  Preparing: select * from mybatis.user where id=? 
    ==> Parameters: 1(Integer)
    <==    Columns: id, name, pwd
    <==        Row: 1, 刘潇博, 123456
    <==      Total: 1
    User{id=1, name='刘潇博', password='123456'}
    ========================
    User{id=1, name='刘潇博', password='123456'}
    true
    Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@865dd6]
    Returned connection 8805846 to pool.

    分析日志可知: 两次的查询操作都是在同一个会话中完成的, 两次取得的对象相同

缓存失效的情况

  1. 查询不同的东西
  2. 增删改操作, 可能会改变原来的数据, 所以必定会刷新缓存
  3. 查询不同的Mapper.xml
  4. 手动清理缓存

手动清理缓存语句:

1
sqlSession.clearCache();

二级缓存

二级缓存也叫全局缓存, 一级缓存作用域太低了, 所以诞生了二级缓存

基于namespace级别的缓存, 一个名称空间, 对应一个二级缓存

  • 工作机制
    • 一个会话查询一条数据, 这个数据就会被放在当前会话的一级缓存中
    • 如果当前会话关闭了, 这个会话对应的一级缓存就没了, 但是我们想要的是, 会话关闭了, 一级缓存中的数据被保存到二级缓存中
    • 新的会话查询信息, 就可以直接从二级缓存中获取内容
    • 不同的Mapper值查出的数据会放在自己对应的缓存中

  1. 开启全局缓存

    1
    <setting name="cacheEnabled" value="true"/>

    默认也会开启, 但是写出来可读性好

  2. 在要使用二级缓存的Mapper中开启, 在具体的SQL语句标签中使用该缓存

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <!--在当前Mapper.xml中使用二级缓存-->
    <cache
           eviction="FIFO"
           flushInterval="60000"
           size="512"
           readOnly="true"/>

    <select id="queryUserById" parameterType="_int" resultType="user" useCache="true">
        select * from mybatis.user where id=#{id}
    </select>

    也可以不自定义缓存属性, 直接写个空的

    1
    <cache/>

  3. 测试代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    @Test
    public void test() {
        SqlSession sqlSession = MybtisUtils.getSqlSession();
        SqlSession sqlSession1 = MybtisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.queryUserById(2);
        System.out.println(user);
        sqlSession.close();

        UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
        User user1 = mapper1.queryUserById(2);
        System.out.println(user1);

        System.out.println("==============");
        System.out.println(user==user1);

        sqlSession1.close();
    }

    注意要把第一个会话关闭之后,再开启新的会话

  4. 结果

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    Cache Hit Ratio [com.lxb.dao.UserMapper]: 0.0
    Opening JDBC Connection
    Created connection 1804379080.
    ==>  Preparing: select * from mybatis.user where id=? 
    ==> Parameters: 2(Integer)
    <==    Columns: id, name, pwd
    <==        Row: 2, asfsdaf, 98864
    <==      Total: 1
    User{id=2, name='asfsdaf', password='98864'}
    Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@6b8ca3c8]
    Returned connection 1804379080 to pool.
    Cache Hit Ratio [com.lxb.dao.UserMapper]: 0.5
    User{id=2, name='asfsdaf', password='98864'}
    ==============
    true

    可以看出第二个会话直接从缓存中取结果

小结:

  • 只要开启了二级缓存, 在同一个Mapper下就有效
  • 所有的数据都会先放在一级缓存中, 只有当会话提交或者关闭的时候才会转存到二级缓存中

自定义缓存-Ehcache

Ehcache是一种广泛使用的开源Java分布式缓存, 主要面向通用缓存

要在程序中使用, 先导包

1
2
3
4
5
6
<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.1.0</version>
</dependency>

在Mapper中指定使用的自定义缓存类型

1
2
<!--    在当前Mapper.xml中使用二级缓存-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

创建针对于Ehcache的配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">

    <diskStore path="./tmpdir/Tmp_EhCache"/>

    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>

    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
</ehcache>
-------------本文结束感谢您的阅读-------------
可以请我喝杯奶茶吗