Mybatis二级缓存配置中readOnly属性的理解

最新推荐文章于 2024-01-13 11:18:00 发布

向上的狼

最新推荐文章于 2024-01-13 11:18:00 发布

阅读量1.3k

点赞数 6

分类专栏： mybatis 文章标签： mybatis java 缓存

本文链接：https://blog.csdn.net/m0_50370837/article/details/127136614

版权

mybatis 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、前提知识

一级缓存默认开启, 二级缓存默认是不开启的.

如果两次 ( 或者多次 ) 执行的查询 SQL 相同 , 每次都要从磁盘中去读数据 , 速度是受磁盘 IO 的限制 .

如果加入缓存, 相同的 sql 只有第一次需要从磁盘中查询数据 , 并且把数据缓存到内存中 , 那么从第二次查询开始, 程序就可以直接从内存中快速的拿到数据.

一, 二级的作用范围

二、一级缓存

这里先介绍一下一级缓存: 一级缓存默认开启 , 作用范围是当前的 sqlSession , 又被称为本地缓存

举例:

MybatisUtil类

package com.softeem.wolf.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.Reader;

/**
 * Created by 苍狼
 * Time on 2021-12-20
 */
public class MybatisUtil {

    /**
     * 让sqlSessionFactory全局唯一, 可以将它变成static修饰的, 这样它就不属于某个对象, 而属于MybatisUtil类了
     */
    private static SqlSessionFactory sqlSessionFactory = null;

    static {
        try{
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            //一旦成功创建了SqlSessionFactory对象, 代表Mybatis的环境已经被初始化了
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e){
            e.printStackTrace();
            //抛出异常, 让调用方知道初始化失败了
            throw new ExceptionInInitializerError(e);
        }
    }

    /**
     * 创建连接
     * @return
     */
    public static SqlSession createSession(){
        return sqlSessionFactory.openSession();
    }

    public static void closeSession(SqlSession sqlSession){
        if (sqlSession != null) {
            sqlSession.close();
        }
    }
}

测试类

@Test
    public void test01(){
        SqlSession sqlSession = null;
        try{
            sqlSession = MybatisUtil.createSession();
            StudentDao mapper = sqlSession.getMapper(StudentDao.class);
            Student student = mapper.selectStudentById(1);
            Student student1 = mapper.selectStudentById(1);
            System.out.println(student);
            System.out.println(student1);
            System.out.println(student.hashCode());
            System.out.println(student1.hashCode());
            System.out.println(student==student1);
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            MybatisUtil.closeSession(sqlSession);
        }
    }

运行结果

从这里可以看出一级缓存默认是开启的, 不需要再配置文件中开启, 还有就是一级缓存是作用在SqlSession类上.

测试类:

    @Test
    public void test05(){
        SqlSession sqlSession1 = null;
        SqlSession sqlSession2 = null;
        try{
            sqlSession1 = MybatisUtil.createSession();
            sqlSession2 = MybatisUtil.createSession();
            StudentDao mapper1 = sqlSession1.getMapper(StudentDao.class);
            StudentDao mapper2 = sqlSession2.getMapper(StudentDao.class);
            Student student1 = mapper1.selectStudentById(1);
            Student student2 = mapper2.selectStudentById(1);
            System.out.println(student1.hashCode());
            System.out.println(student2.hashCode());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            MybatisUtil.closeSession(sqlSession1);
            MybatisUtil.closeSession(sqlSession2);
        }
    }

运行结果:

三、二级缓存

1、xml 配置中开启二级缓存

<settings>

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

2、去mapper映射文件中使用二级缓存

<cache />

<cache eviction="LRU" flushInterval="60000" size="1024" readOnly="false"/>

测试类:

@Test
    public void test06(){
        SqlSession sqlSession1 = null;
        try{
            sqlSession1 = MybatisUtil.createSession();
            StudentDao mapper1 = sqlSession1.getMapper(StudentDao.class);
            Student student1 = mapper1.selectStudentById(1);
            Student student2 = mapper1.selectStudentById(1);
            System.out.println(student1.hashCode());
            System.out.println(student2.hashCode());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            MybatisUtil.closeSession(sqlSession1);
        }


        SqlSession sqlSession2 = null;
        try{
            sqlSession2 = MybatisUtil.createSession();
            StudentDao mapper1 = sqlSession2.getMapper(StudentDao.class);
            Student student1 = mapper1.selectStudentById(1);
            Student student2 = mapper1.selectStudentById(1);
            System.out.println(student1.hashCode());
            System.out.println(student2.hashCode());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            MybatisUtil.closeSession(sqlSession1);
        }
    }

运行结果:

总结:

在开二级缓存之后 , 日志会多一个关于某个 namespace 的二级缓存命中率的记录

另外 , 如果某个 sql 的执行 , 既可以命中一级缓存 , 也可以命中二级缓存 , 优先使用一级缓存, 一级缓存拿到的对象就是原本缓存的对象

<cache eviction="LRU" flushInterval="60000" size="1024" readOnly="false"/>

1. eviction:指定内存的淘汰/回收策略

LRU(Least Recently Used 默认) – 最近最少使用：移除最长时间不被使用的对象。比较符合我们的预期的 ,因为缓存就是希望保留热点数据,淘汰非热点数据
FIFO(First In First Out) – 先进先出：类似于队列,按对象进入缓存的顺序来移除它们。
SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。比软引用更弱

2. flushInterval:刷新间隔,单位是毫秒.默认是不刷新

3. size:缓存的数量的上限,默认值是1024.超过就会触发淘汰策略

4. readOnly:只读,默认是false(可读可写)

-false的情况,缓存的对象必须要实现序列化接口,这是因为拿到的缓存对象不是原本缓存的对象 ,是因为在false的情况下,Mybatis对缓存的对象进行了拷贝,拷贝需要序列化,这样的情况,因为涉及到序列化的操作,所以效率会更慢一些,但是更安全.
-true代表只读,就是拿到的缓存对象就是原本缓存的那个对象

清空缓存的方式

1、 session.clearCache( ) ;
2、 execute update(增删改) ;
3、 session.close( );
4、 xml配置 flushCache=“true” ；
5、 rollback；
6、 commit。

这里主要讲一下readOnly这个属性

true:只读缓存;会给所有调用者返回缓存对象的相同实例。因此返回的这些缓存对象自己没事不要去修改。一旦修改，就会影响下一个相同查询条件的查询结果。这提供了很重要的性能优势。

false:读写缓存;会返回缓存对象的拷贝(通过序列化)。这些对象可以随意修改，不会影响后续相同查询条件的结果。这会慢一些，但是安全，因此默认是false。

测试一:

<cache eviction="LRU" flushInterval="60000" size="1024" readOnly="true"/>

测试类:

@Test
    public void test06(){
        SqlSession sqlSession1 = null;
        try{
            sqlSession1 = MybatisUtil.createSession();
            StudentDao mapper1 = sqlSession1.getMapper(StudentDao.class);
            Student student1 = mapper1.selectStudentById(1);
            Student student2 = mapper1.selectStudentById(1);
            System.out.println(student1.hashCode());
            System.out.println(student2.hashCode());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            MybatisUtil.closeSession(sqlSession1);
        }

        SqlSession sqlSession2 = null;
        try{
            sqlSession2 = MybatisUtil.createSession();
            StudentDao mapper1 = sqlSession2.getMapper(StudentDao.class);
            Student student1 = mapper1.selectStudentById(1);
            System.out.println(student1);
            student1.setStudentName("aaaa");
            System.out.println(student1);
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            MybatisUtil.closeSession(sqlSession1);
        }

        try{
            StudentDao mapper1 = sqlSession2.getMapper(StudentDao.class);
            Student student1 = mapper1.selectStudentById(1);
            System.out.println(student1);
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            MybatisUtil.closeSession(sqlSession1);
        }
    }

运行结果:

测试二:

<cache eviction="LRU" flushInterval="60000" size="1024" readOnly="false"/>

测试类:

@Test
    public void test06(){
        SqlSession sqlSession1 = null;
        try{
            sqlSession1 = MybatisUtil.createSession();
            StudentDao mapper1 = sqlSession1.getMapper(StudentDao.class);
            Student student1 = mapper1.selectStudentById(1);
            Student student2 = mapper1.selectStudentById(1);
            System.out.println(student1.hashCode());
            System.out.println(student2.hashCode());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            MybatisUtil.closeSession(sqlSession1);
        }

        SqlSession sqlSession2 = null;
        try{
            sqlSession2 = MybatisUtil.createSession();
            StudentDao mapper1 = sqlSession2.getMapper(StudentDao.class);
            Student student1 = mapper1.selectStudentById(1);
            System.out.println(student1);
            student1.setStudentName("aaaa");
            System.out.println(student1);
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            MybatisUtil.closeSession(sqlSession1);
        }

        try{
            StudentDao mapper1 = sqlSession2.getMapper(StudentDao.class);
            Student student1 = mapper1.selectStudentById(1);
            System.out.println(student1);
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            MybatisUtil.closeSession(sqlSession1);
        }
    }

运行结果: