精华内容
下载资源
问答
  • MyBatis一二级缓存

    2020-08-30 06:41:33
    主要介绍了MyBatis一二级缓存的相关知识,非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • mybatis一二级缓存

    2017-11-28 16:02:19
    关于mybatis一二级缓存测试demo,一二级缓存详细测试
  • Mybatis一二级缓存

    多人点赞 2020-07-11 16:57:47
    面试官:虫虫你简历上写了了解mybatis缓存,那你能说说一级缓存和二级缓存的区别吗? 虫虫:我只知道这是用来缓存sql查询的数据 面试官:没了? 虫虫:没了 面试官:公司门知道在哪里吧 自己走还是我送你 以上是虫虫的...

    在这里插入图片描述

    前言

    面试官:虫虫你简历上写了了解mybatis缓存,那你能说说一级缓存和二级缓存的区别吗?



    虫虫:我只知道这是用来缓存sql查询的数据



    面试官:没了?



    虫虫:没了



    面试官:公司门知道在哪里吧 自己走还是我送你

    以上是虫虫的面试经历 于是虫虫决定恶补一下Mybatis缓存机制的知识
    image

    Mybatis的缓存,包括一级缓存和二级缓存

    Mybatis对缓存提供支持,一级缓存是默认使用的



    二级缓存需要手动开启



    区别:一级缓存的作用域是一个sqlsession内;二级缓存作用域是针对mapper进行缓存.

    一级缓存:

    在参数和SQL完全一样的情况下,我们使用同一个SqlSession对象调用一个Mapper方法,往往只执行一次SQL,因为使用SelSession第一次查询后,MyBatis会将其放在缓存中,以后再查询的时候,如果没有声明需要刷新,并且缓存没有超时的情况下,SqlSession都会取出当前缓存的数据,而不会再次发送SQL到数据库。

    image

    一级缓存时执行commit,close,增删改等操作,就会清空当前的一级缓存;当对SqlSession执行更新操作(update、delete、insert)后并执行commit时,不仅清空其自身的一级缓存(执行更新操作的效果),也清空二级缓存(执行commit()的效果)。



    二级缓存:

    二级缓存指的就是同一个namespace下的mapper,二级缓存中,也有一个map结构,这个区域就是一级缓存区域。一级缓存中的key是由sql语句、条件、statement等信息组成一个唯一值。一级缓存中的value,就是查询出的结果对象。
    image

    1、在配置文件中 开启二级缓存的总开关

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

    2、 在mapper映射文件中开启二级缓存

    <cache eviction="FIFO" flushInterval="60000" size="512" 
    readOnly="true"/>
    
    参数名属性
    eviction收回策略
    flushInterval刷新间隔
    size引用数目
    readOnly只读
    关于eviction的各个参数属性:
    参数名属性
    eviction=“LRU”最近最少使用的:移除最长时间不被使用的对象。 (默认)
    eviction=“FIFO”先进先出:按对象进入缓存的顺序来移除它们。
    eviction=“SOFT”软引用:移除基于垃圾回收器状态和软引用规则的对象。
    eviction=“WEAK”弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。

    3、实体类实现Serializable

    禁用缓存

    如测试sql语句性能时缓存会影响测试准确性 需要禁用
    在映射文件中:
    默认值是true useCache=”false”

    <select id="findAllPets" resultMap="petsMap" useCache="false">
     select * from pets
    </select>
    

    刷新缓存

    在映射文件中:
    属性:flushCache=”true”

    刷新缓存,在查询语句中,默认值是false,在新增删除修改语句中,默认值是true(清空缓存)

    image


    要是能为您提供帮助,请给予支持(关注、点赞、分享),虫虫蟹蟹大家了!
    展开全文
  • 像大多数的持久化框架一样,Mybatis 也提供了缓存策略,通过缓存策略来减少数据库的查询次数,从而提高性能 Mybatis缓存分为一级缓存二级缓存 Mybatis 一级缓存 Mybatis 二级缓存 ...

    像大多数的持久化框架一样,Mybatis 也提供了缓存策略,通过缓存策略来减少数据库的查询次数,从而提高性能

    Mybatis 中缓存分为一级缓存,二级缓存
    在这里插入图片描述

    Mybatis 一级缓存

    一级缓存是 SqlSession 级别的缓存,只要 SqlSession 没有 flush 或 close,它就存在。

    证明一级缓存的存在

    新建数据库映射实体类 User.java

    package cn.lemon.domain;
    
    import java.io.Serializable;
    import java.util.Date;
    
    public class User implements Serializable {
        private Integer id;
        private String username;
        private Date birthday;
        private String sex;
        private String address;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public Date getBirthday() {
            return birthday;
        }
    
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", birthday=" + birthday +
                    ", sex='" + sex + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }
    

    新建持久层接口 IUserDao.java

    package cn.lemon.dao;
    
    import cn.lemon.domain.User;
    
    public interface IUserDao {
        User findById(Integer userId);
    }
    

    新建配置文件 SqlMapConfig.xml 和 jdbc.properties

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    <configuration>
        <properties resource="jdbc.properties"/>
        <typeAliases>
            <package name="cn.lemon.domain"/>
        </typeAliases>
        <environments default="mysql">
            <environment id="mysql">
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <property name="driver" value="${jdbc.driver}"/>
                    <property name="url" value="${jdbc.url}"/>
                    <property name="username" value="${jdbc.username}"/>
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
        </environments>
        <mappers>
            <package name="cn.lemon.dao"/>
        </mappers>
    </configuration>
    
    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql:///db_mybatis
    jdbc.username=root
    jdbc.password=lemon
    

    新建接口映射文件 IUserDao.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="cn.lemon.dao.IUserDao">
        <select id="findById" parameterType="int" resultType="user">
            select * from user where id = #{id}
        </select>
    </mapper>
    

    测试类

    package cn.lemon.dao;
    
    import cn.lemon.domain.User;
    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 org.junit.Test;
    
    import java.io.InputStream;
    
    public class IUserDaoTest {
        private InputStream inputStream;
        private SqlSessionFactory sqlSessionFactory;
        private SqlSession sqlSession;
        private IUserDao iUserDao;
    
        @Test
        public void findById() throws Exception{
            inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            sqlSession = sqlSessionFactory.openSession(true);
            iUserDao = sqlSession.getMapper(IUserDao.class);
    
            /*第一次查询*/
            User user1 = iUserDao.findById(58);
            System.out.println("第一次查询:" + user1);
            System.out.println("-------------------------------------------");
    
            /*第二次查询*/
            User user2 = iUserDao.findById(58);
            System.out.println("第二次查询:" + user2);
    
            sqlSession.close();
            inputStream.close();
        }
    }
    

    运行结果:
    在这里插入图片描述
    关闭缓存,或者使用sqlSession.clearCache 清除缓存,或者对查询的这条语句执行修改,就会出现两次查询
    在这里插入图片描述

    Mybatis 二级缓存 (重要)

    二级缓存的特点

    • 二级缓存是 mapper 映射级别的缓存
    • 多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句
    • 多个SqlSession 可以共用二级缓存
    • 二级缓存是跨 SqlSession 的。
      在这里插入图片描述

    二级缓存的配置

    第一步:在 SqlMapConfig.xml 文件开启二级缓存

        <settings>
            <!-- 
                开启二级缓存的支持
                因为 cacheEnabled 的取值默认就为 true,所以这一步可以省略不配置。为 true 代表开启二级缓存;为 false 代表不开启二级缓存
             -->
            <setting name="cacheEnabled" value="true"/>
        </settings>
    

    第二步:在 IUserDao.xml 中,配置相关的 Mapper 映射文件

        <!--
            开启二级缓存的支持
            <cache>标签表示当前这个 mapper 映射将使用二级缓存,区分的标准就看 mapper 的 namespace
        -->
        <cache></cache>
    

    第三步:在 IUserDao.xml 中,配置 statement 上面的 useCache 属性
    在这里插入图片描述
    第四步:测试类

    package cn.lemon.dao;
    
    import cn.lemon.domain.User;
    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 org.junit.Test;
    
    import java.io.InputStream;
    
    public class IUserDaoTest {
    
        @Test
        public void findById() throws Exception {
            InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    
            /*第一次查询*/
            SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
            IUserDao iUserDao1 = sqlSession1.getMapper(IUserDao.class);
            User user1 = iUserDao1.findById(58);
            System.out.println("第一次查询:" + user1);
            System.out.println("-------------------------------------------");
            sqlSession1.close();//关闭资源
    
            /*第二次查询*/
            SqlSession sqlSession2 = sqlSessionFactory.openSession(true);//重新开启
            IUserDao iUserDao2 = sqlSession2.getMapper(IUserDao.class);
            User user2 = iUserDao2.findById(58);
            System.out.println("第二次查询:" + user2);
            System.out.println("-------------------------------------------");
            sqlSession2.close();
    
            /*第三次查询*/
            SqlSession sqlSession3 = sqlSessionFactory.openSession(true);//重新开启
            IUserDao iUserDao3 = sqlSession3.getMapper(IUserDao.class);
            User user3 = iUserDao3.findById(58);
            System.out.println("第三次查询:" + user3);
            System.out.println("-------------------------------------------");
            sqlSession3.close();
    
            inputStream.close();
        }
    }
    

    运行结果:
    在这里插入图片描述
    特别提醒:

    • 二级缓存要实现序列化接口,也就是 implements Serializable
    • 二级缓存要在同一个命名空间下,不用的命名空间有不同的缓存,如上面的例子 namespace="cn.lemon.dao.IUserDao"
    展开全文
  • 下面小编就为大家带来一篇【MyBatis源码全面解析】MyBatis一二级缓存介绍。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Mybatis一二级缓存实现原理与使用指南.pdf
  • 文章目录MyBatis缓存机制Spring+MyBatis开启二级缓存1. 创建MyBatis核心配置文件,在settings中开启二级缓存2. 在spring的核心配置文件中,sqlSessionFactory的bean中,将mybatis的配置粘入3. 在mapper.xml映射文件...

    1. MyBatis缓存机制

    1.1 一级缓存、二级缓存

       一级缓存:它指的是Mybatis中sqlSession对象的缓存(基于PerpetualCacheHashMap本地缓存,作用域是Session),当我们执行查询以后,查询的结果会同时存入到SqlSession为我们提供的一块区域中,该区域的结构是一个Map集合,当我们再次查询同样的数据,mybatis会先去sqlsession中查询是否有,有的话直接拿出来用,当SqlSession对象消失时,mybatis的一级缓存也就消失了,同时一级缓存是SqlSession范围的缓存当调用SqlSession对象的修改、添加、删除、commit()、flush、close等方法时,就会清空一级缓存。

       二级缓存:是Mybatis中SqlSessionFactory对象的缓存(默认也是采用 PerpetualCacheHashMap存储,不同在于其存储作用域为 Mapper(Namespace),并且可自定义存储源,如 Ehcache),由同一个SqlSessionFactory对象创建的SqlSession共享其缓存,但是其中缓存的是数据而不是对象,所以从二级缓存再次查询出的结果的对象与第一次存入的对象是不一样的。(就是二级缓存存下来的是对象的数据(堆中具体存放的数据,而不是对象的引用,所以如果修改对象的值,但是二级缓存里面该对象的数据是不变的))

       MyBatis的缓存数据更新机制中,当某一个作用域(不管是一级缓存sqlSession/二级缓存SqlSessionFactory)的进行了C/U/D 操作后,默认该作用域下所有select查询中的缓存都将被clear(因为数据被改变更新,所以缓存就无效了,继续使用就可能是没有更新的数值)
       update、delete、insert修改数据库的方法,无论是否commit提交,会同时清空一级和二级缓存。


    1.2 关于一级缓存(本地缓存)

    缓存:就是把数据放到内存数据中,下次使用直接去缓存(内存)中查找
    MyBatis的一级缓存默认是开启状态,且不能关闭,开发人员不需要管理它。
    一级缓存对于不同的session对应各自的缓存,session之间不能相互访问对方的缓存(session间不共享缓存)
    当一个 SqlSession 关闭和提交时,该 SqlSession 中的一级查询缓存也会清空。
    可以通过session.clearCache();来清空一级缓存

    数据查询时:

    • 第一次查询后,将数据放入一级缓存中,也就是默认缓存。
    • 第二次查询,会先从一级缓存中查询数据,如果命中(缓存中找到):使用一级缓存数据 ;如果未命中:发sql语句去数据库查询然后返回结果。

    1.2 关于二级缓存

    • MyBatis的二级缓存是mapper范围级别的(namespace)
    • 二级缓存是默认开启的。(想开启就不必做任何配置)
    • SqlSession关闭后才会将数据写到二级缓存区域

    每个sql语句都可以有一个针对二级缓存的设置(sql语句中的useCache属性)
      除了遵循大的< cache >设置外,针对每一条sql语句可以单独设置是否使用二级缓存。通过useCache="true"开启二级缓存,false关闭二级缓存。如果缓存设置flushCache="false" ,那么缓存将不清空。

    <select … flushCache=“false” useCache=“true”/>
    <inser … flushCache=“true”/>
    (insert update delete更新数据库的时候,默认情况下会同时清空一级、二级缓存,只有session被关闭的时候,才会将自己一级缓存中的数据放入二级缓存。)

      < cache-ref >用于 在多个命名空间中共享相同的缓存配置和实例,通过cache-ref来引用另一个缓存,每个二级缓存是针对命名空间设置的,可以通过cache-ref 将多个缓存合并,缓存合并只是内存空间的合并,存储数据的时候还是按照命名空间存储。
      如果AMapper和当前BMapper共用一个缓存空间,如果一个1M大小,一个2M大小,那么这个缓存空间就是3M数据。

    	<!-- 在Mapper.xml映射文件中开启二级缓存 -->
    	<cache flushInterval="10000" eviction="LRU" blocking="false" readOnly="false" size="1024"/>
    	<!-- 当前缓存和UserMapper共享一个缓存空间 -->
        <cache-ref namespace="com.xgf.cache.dao.UserMapper"/>
    


    2. Spring整合MyBatis开启二级缓存【*****】

    启用二级缓存步骤:

    1. mybatis核心配置文件中开启二级缓存全局变量:cacheEnabled = true (在mybatis核心配置文件中,设置属性<setting name="cacheEnabled" value="true"/>
    2. 在spring核心配置文件,sqlSessionFactory的bean中,将mybatis的配置粘入
    3. 需要在对应的映射文件XxxMapper.xml的命名空间namespace下加入< cache/ >来开启二级缓存。
    4. 需要在bean对象实现Serializable 接口序列化,仅用于标识(如果cache的readonly设置为true可以不用这一步)

    2.1 创建MyBatis核心配置文件,在settings中开启二级缓存

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    <configuration>
    
        <!-- 使用mybatis方式全局变量设置在核心配置文件sqlMapConfig.xml的settings中
             spring和mybatis整合的情况下,mybatis下的全局参数<settings>在spring的配置文件中设置,
                在spring的sqlSessionFactory对象中,将配置粘入bean的property中
    
            settings用于配置全局变量,有顺序要求,要放在environment前面,配置全局参数
            lazyLoadingEnabled 配置懒加载,全局允许或静止懒加载,所有的任务都懒加载
            具体实现懒加载:通过在resultMap中设置fetchType实现懒加载
    
            <setting name="cacheEnabled" value="true"/> cacheEnabled允许二级缓存
        -->
        <settings>
            <!-- 打开延迟加载 -->
            <setting name="lazyLoadingEnabled" value="true"/>
            <!-- 将积极加载改为消极加载即按需要加载 -->
            <setting name="aggressiveLazyLoading" value="false"/>
            <!-- 开启二级缓存(默认也是开启的)-->
            <setting name="cacheEnabled" value="true"/>
        </settings>
    
    </configuration>
    

    2.2 在spring的核心配置文件中,sqlSessionFactory的bean中,将mybatis的配置粘入

    	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource" />
            <!--将缓存添加到spring中的sessionFactory中-->
            <property name="configLocation" value="com/xgf/mysql_cache/config/sqlMapConfig.xml"></property>
        </bean>
    

    2.3 在mapper.xml映射文件中添加< cache >< /cache >开启二级缓存

    cache属性描述
    size二级缓存中可以存储多少对象,默认1024个,超过就会按照指定的算法清除
    eviction二级缓存size存满的时候,按照什么规则来清除对象,默认LRU(最近最少使用),其他方式FIFO(先进先出)、SOFT(软引用)、WEAK(弱引用)
    flushInterval刷新间隔、清除时间,每隔多长时间进行缓存的清除
    blocking默认为false,为true时为阻塞式缓存,当有一个线程读取的时候,其他线程只能等待,只有当前线程操作完其他线程才能操作
    type第三方缓存,将第三方缓存实现类写在这里(比如EhcacheCache)
    readOnly默认为false
    true:只读方式,缓存当中对象的引用(地址)交给程序,速度快,但是不安全 。
    false: 兑换成中对象进行克隆clone操作,速度慢,但是安全,类需要实现Serializable
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    <mapper namespace="com.xgf.mysql_cache.dao.CustomerMapper">
    
        <!--在映射文件中开启二级缓存,flushInterval:每隔多长时间进行缓存的清除
            eviction:二级缓存size存满的时候,按照什么规则来清除对象
            size:二级缓存中可以存储多少对象
            readOnly:设置为false,会兑换成中对象进行克隆clone操作,速度慢,但是安全,类需要实现Serializable
            blocking:设置为false,为非阻塞式缓存
         -->
        <cache flushInterval="10000" eviction="LRU" blocking="false" readOnly="false" size="1024"/>
    
        <!-- 可以在sql语句中单独设置是否启用二级缓存 通过useCache="true"设置启用二级缓存 -->
        <select id="getCustomerByNameAndJobForWhere"
                parameterType="com.xgf.mysql_cache.bean.Customer"
                resultType="com.xgf.mysql_cache.bean.Customer" 
                useCache="true">
            select id,username,job
            from customer
            <where>
                <if test="username!=null and username!=''">
                    and username like concat('%',#{username},'%')
                </if>
                <if test="job!=null and job!=''">
                    and job=#{job}
                </if>
            </where>
        </select>
    </mapper>
    

    2.4 在对应的javabean类实现序列化接口Serializable(仅仅是一个标识作用,不实现会报错)(如果缓存cache的readOnly属性为true,就可以不设置)

    public class beanClass implements Serializable {}
    

    3. MyBatis中开启二级缓存

      MyBatis中开启二级缓存机制和Spring整合MyBatis开启二级缓存步骤差不多,只是少了一个步骤(2.2 在spring的核心配置文件中,sqlSessionFactory的bean中,将mybatis的配置粘入),其他都一样。



    4. Spring整合MyBatis实现二级缓存案例

    4.1 创建customer表

    -- ----------------------------
    -- customer表,主键自动递增
    -- ----------------------------
    DROP TABLE IF EXISTS `customer`;
    CREATE TABLE `customer` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `username` varchar(50) DEFAULT NULL,
      `job` varchar(50) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=14 DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- 初始数据
    -- ----------------------------
    INSERT INTO `customer` VALUES ('1', '张三', '程序员');
    INSERT INTO `customer` VALUES ('2', '李四', '项目经理');
    INSERT INTO `customer` VALUES ('3', '王五', '测试员');
    INSERT INTO `customer` VALUES ('4', '赵六', '开发人员');
    INSERT INTO `customer` VALUES ('5', '赵钱孙李', '开发人员');
    INSERT INTO `customer` VALUES ('6', '赵云', '保卫工作');
    INSERT INTO `customer` VALUES ('7', '完璧归赵', '历史人物');
    

    4.2 创建javabean对象

    public class Customer {
    
        private Integer id;         //id主键自动增长
        private String username;    //用户名
        private String job;         //工作
        //省略getter/setter方法
    }
    

    4.3 创建dao层接口

    public interface CustomerMapper {
    //    where标签查询数据 name和job满足条件
        List<Customer> getCustomerByNameAndJobForWhere(Customer customer);
    }
    
    

    4.4 创建连接数据库的属性文件db.properties(键值对形式)

    jdbc.driver = com.mysql.jdbc.Driver
    jdbc.url = jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8&useSSL=false
    jdbc.username = root
    jdbc.password = 861221293
    

    4.5 MyBatis核心配置文件开启二级缓存

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    <configuration>
        <settings>
            <!-- 打开延迟加载/懒加载 具体实现懒加载:通过在resultMap中设置fetchType实现懒加载 -->
            <setting name="lazyLoadingEnabled" value="true"/>
            <!-- 将积极加载改为消极加载即按需要加载 -->
            <setting name="aggressiveLazyLoading" value="false"/>
            <!-- 开启二级缓存 -->
            <setting name="cacheEnabled" value="true"/>
        </settings>
    
    </configuration>
    

    4.6 spring整合MyBatis,在sqlSessionFactory的bean中,将mybatis配置粘入bean的property中

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mybatis="http://mybatis.org/schema/mybatis-spring" xmlns:tx="http://www.springframework.org/schema/tx"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    
        <!--1. 引入jdbc的属性文件,在配置中通过占位使用 -->
        <context:property-placeholder location="classpath*:db.properties" />
    
        <!--2. <context:component-scan>扫描包中注解所标注的类(@Component、@Service、@Controller、@Repository) -->
        <context:component-scan base-package="com.xgf.mysql_cache"/>
    
        <!--3. 由spring管理    配置数据源数据库连接(从jdbc属性文件中读取参数) -->
        <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="driverClassName" value="${jdbc.driver}"/>
        </bean>
    
        <!--  通过spring来管理Mybatis的sqlSessionFactory对象创建,将MyBatis的二级缓存配置configLocation粘入  -->
        <!--4. 通过完全限定名匹配查找  创建SqlSessionFactoryBean  -->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource" />
            <!-- 将缓存添加到spring中的sessionFactory中 【***】-->
            <property name="configLocation" value="com/xgf/mysql_cache/config/sqlMapConfig.xml"></property>
        </bean>
    
        <!-- 5. mybatis提供的一个注解扫描标签(搜索映射器 Mapper 接口),通过自动扫描注解的机制,创建每个dao接口定义的bean  -->
        <mybatis:scan base-package="com.xgf.mysql_cache.dao"/>
    
    </beans>
    

    4.7 映射文件mapper.xml中加入< cache/ >实现二级缓存

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    <mapper namespace="com.xgf.mysql_cache.dao.CustomerMapper">
    
        <!--在映射文件中开启二级缓存,flushInterval:每隔多长时间进行缓存的清除
            eviction:二级缓存size存满的时候,按照什么规则来清除对象
            size:二级缓存中可以存储多少对象
            readOnly:设置为false,会兑换成中对象进行克隆clone操作,速度慢,但是安全,类需要实现Serializable
            blocking:设置为false,为非阻塞式缓存
         -->
        <cache flushInterval="10000" eviction="LRU" blocking="false" readOnly="false" size="1024"/>
    
        <!--where标签,如果后面没有条件(条件都不满足)不加where,如果后面有条件,会自动增加一个where
        会将多余的and、or去掉,会自动填充第一个缺失的and、or-->
        <!-- 可以在sql语句中单独设置是否启用二级缓存 通过useCache="true"设置启用二级缓存 -->
        <select id="getCustomerByNameAndJobForWhere"
                parameterType="com.xgf.mysql_cache.bean.Customer"
                resultType="com.xgf.mysql_cache.bean.Customer"
                useCache="true">
            select id,username,job
            from customer
            <where>
                <if test="username!=null and username!=''">
                    and username like concat('%',#{username},'%')
                </if>
                <if test="job!=null and job!=''">
                    and job=#{job}
                </if>
            </where>
        </select>
    </mapper>
    

    4.8 创建测试类

    4.8.1 数据准备

    public class TestCache {
    
        private static ApplicationContext applicationContext = null;
        private static CustomerMapper customerMapper = null;
        //查询对象
        //通过getCustomerByNameAndJobForWhere查询相当于
        private static Customer customer = new Customer("赵","开发人员");//初始化customer数据
        //查询结果
        private List<Customer> customerList = null;
    
        //只加载一次  @BeforeClass@BeforeClass只在类中执行一次, 必须声明为public static
        @BeforeClass
        public static void init(){
            //加载配置文件
            applicationContext = new ClassPathXmlApplicationContext("com/xgf/mysql_cache/config/applicationContext.xml");
            //获取bean的两种方式
            // 1.类名首字母小写
    //        customerMapper = (CustomerMapper) applicationContext.getBean("customerMapper");
            // 2.类.class
            customerMapper = (CustomerMapper) applicationContext.getBean(CustomerMapper.class);
        }
    }
    

    4.8.2 测试一级缓存

    //测试一级缓存
        @Test
        public void test01(){
    
            System.out.println("******第一次查询******");
    //        查询数据customerList和customer是前面的声明
            customerList = customerMapper.getCustomerByNameAndJobForWhere(customer);
            System.out.println(customerList);
    
            //第二次查询(非第一次),去一级缓存中查询数据,命中:使用一级缓存数据  未命中:发sql去数据库查询
            System.out.println("\n******第二次查询,查询和第一次相同内容(命中:使用一级缓存数据 )******");
            customerList = customerMapper.getCustomerByNameAndJobForWhere(customer);
            System.out.println(customerList);
    
            System.out.println("\n*****第三次查询,修改查询内容,未命中,发送sql语句去数据库查询********");
            customer.setUsername("修改username");
            customer.setJob("修改job");
            customerList = customerMapper.getCustomerByNameAndJobForWhere(customer);
            System.out.println(customerList);
        }
    

    运行结果
    >

    展开全文
  • MyBatis一级缓存二级缓存

    万次阅读 多人点赞 2018-09-05 22:44:30
    MyBatis自带的缓存一级缓存二级缓存 一级缓存 Mybatis一级缓存是指Session缓存一级缓存的作用域默认是个SqlSession。Mybatis默认开启一级缓存。 也就是在同个SqlSession中,执行相同的查询SQL,第次...

    MyBatis自带的缓存有一级缓存和二级缓存

    一级缓存

    Mybatis的一级缓存是指Session缓存。一级缓存的作用域默认是一个SqlSession。Mybatis默认开启一级缓存。
    也就是在同一个SqlSession中,执行相同的查询SQL,第一次会去数据库进行查询,并写到缓存中;
    第二次以后是直接去缓存中取。
    当执行SQL查询中间发生了增删改的操作,MyBatis会把SqlSession的缓存清空。

    一级缓存的范围有SESSION和STATEMENT两种,默认是SESSION,如果不想使用一级缓存,可以把一级缓存的范围指定为STATEMENT,这样每次执行完一个Mapper中的语句后都会将一级缓存清除。
    如果需要更改一级缓存的范围,可以在Mybatis的配置文件中,在下通过localCacheScope指定。

    1

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

    建议不需要修改

    需要注意的是
    当Mybatis整合Spring后,直接通过Spring注入Mapper的形式,如果不是在同一个事务中每个Mapper的每次查询操作都对应一个全新的SqlSession实例,这个时候就不会有一级缓存的命中,但是在同一个事务中时共用的是同一个SqlSession。
    如有需要可以启用二级缓存。

    二级缓存

    Mybatis的二级缓存是指mapper映射文件。二级缓存的作用域是同一个namespace下的mapper映射文件内容,多个SqlSession共享。Mybatis需要手动设置启动二级缓存。

    二级缓存是默认启用的(要生效需要对每个Mapper进行配置),如想取消,则可以通过Mybatis配置文件中的元素下的子元素来指定cacheEnabled为false。

    1

    2

    3

    <settings>

      <setting name="cacheEnabled" value="false" />

    </settings>

    cacheEnabled默认是启用的,只有在该值为true的时候,底层使用的Executor才是支持二级缓存的CachingExecutor。具体可参考Mybatis的核心配置类org.apache.ibatis.session.Configuration的newExecutor方法实现。
    可以通过源码看看

    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

    ...

        public Executor newExecutor(Transaction transaction) {

            return this.newExecutor(transaction, this.defaultExecutorType);

        }

     

        public Executor newExecutor(Transaction transaction, ExecutorType executorType) {

            executorType = executorType == null this.defaultExecutorType : executorType;

            executorType = executorType == null ? ExecutorType.SIMPLE : executorType;

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

            }

     

            if (this.cacheEnabled) {//设置为true才执行的

                executor = new CachingExecutor((Executor)executor);

            }

     

            Executor executor = (Executor)this.interceptorChain.pluginAll(executor);

            return executor;

        }

    ...

    要使用二级缓存除了上面一个配置外,我们还需要在我们每个DAO对应的Mapper.xml文件中定义需要使用的cache

    1

    2

    3

    4

    5

    ...

    <mapper namespace="...UserMapper">

        <cache/><!-- 加上该句即可,使用默认配置、还有另外一种方式,在后面写出 -->

        ...

    </mapper>

    具体可以看org.apache.ibatis.executor.CachingExecutor类的以下实现
    其中使用的cache就是我们在对应的Mapper.xml中定义的cache。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {

        BoundSql boundSql = ms.getBoundSql(parameterObject);

        CacheKey key = this.createCacheKey(ms, parameterObject, rowBounds, boundSql);

        return this.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);

    }

     

    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {

        Cache cache = ms.getCache();

        if (cache != null) {//第一个条件 定义需要使用的cache 

            this.flushCacheIfRequired(ms);

            if (ms.isUseCache() && resultHandler == null) {//第二个条件 需要当前的查询语句是配置了使用cache的,即下面源码的useCache()是返回true的  默认是true

                this.ensureNoOutParams(ms, parameterObject, boundSql);

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

                if (list == null) {

                    list = this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);

                    this.tcm.putObject(cache, key, list);

                }

     

                return list;

            }

        }

     

        return this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);

    }

    还有一个条件就是需要当前的查询语句是配置了使用cache的,即上面源码的useCache()是返回true的,默认情况下所有select语句的useCache都是true,如果我们在启用了二级缓存后,有某个查询语句是我们不想缓存的,则可以通过指定其useCache为false来达到对应的效果。
    如果我们不想该语句缓存,可使用useCache="false

    1

    2

    3

    4

    5

    6

    <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" useCache="false">

            select

            <include refid="Base_Column_List"/>

            from tuser

            where id = #{id,jdbcType=VARCHAR}

        </select>

    cache定义的两种使用方式

    上面说了要想使用二级缓存,需要在每个DAO对应的Mapper.xml文件中定义其中的查询语句需要使用cache来缓存数据的。
    这有两种方式可以定义,一种是通过cache元素定义,一种是通过cache-ref元素来定义。
    需要注意的是
    对于同一个Mapper来讲,只能使用一个Cache,当同时使用了和时,定义的优先级更高(后面的代码会给出原因)。
    Mapper使用的Cache是与我们的Mapper对应的namespace绑定的,一个namespace最多只会有一个Cache与其绑定。

    cache元素定义

    使用cache元素来定义使用的Cache时,最简单的做法是直接在对应的Mapper.xml文件中指定一个空的元素(看前面的代码),这个时候Mybatis会按照默认配置创建一个Cache对象,准备的说是PerpetualCache对象,更准确的说是LruCache对象(底层用了装饰器模式)。
    具体的可看org.apache.ibatis.builder.xml.XMLMapperBuilder中的cacheElement()方法解析cache元素的逻辑。

    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

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    ...

        private void configurationElement(XNode context) {

            try {

                String namespace = context.getStringAttribute("namespace");

                if (namespace.equals("")) {

                    throw new BuilderException("Mapper's namespace cannot be empty");

                else {

                    this.builderAssistant.setCurrentNamespace(namespace);

                    this.cacheRefElement(context.evalNode("cache-ref"));

                    this.cacheElement(context.evalNode("cache"));//执行在后面

                    this.parameterMapElement(context.evalNodes("/mapper/parameterMap"));

                    this.resultMapElements(context.evalNodes("/mapper/resultMap"));

                    this.sqlElement(context.evalNodes("/mapper/sql"));

                    this.buildStatementFromContext(context.evalNodes("select|insert|update|delete"));

                }

            catch (Exception var3) {

                throw new BuilderException("Error parsing Mapper XML. Cause: " + var3, var3);

            }

        }

    ...

        private void cacheRefElement(XNode context) {

            if (context != null) {

                this.configuration.addCacheRef(this.builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));

                CacheRefResolver cacheRefResolver = new CacheRefResolver(this.builderAssistant, context.getStringAttribute("namespace"));

     

                try {

                    cacheRefResolver.resolveCacheRef();

                catch (IncompleteElementException var4) {

                    this.configuration.addIncompleteCacheRef(cacheRefResolver);

                }

            }

     

        }

     

        private void cacheElement(XNode context) throws Exception {

            if (context != null) {

                String type = context.getStringAttribute("type""PERPETUAL");

                Class<? extends Cache> typeClass = this.typeAliasRegistry.resolveAlias(type);

                String eviction = context.getStringAttribute("eviction""LRU");

                Class<? extends Cache> evictionClass = this.typeAliasRegistry.resolveAlias(eviction);

                Long flushInterval = context.getLongAttribute("flushInterval");

                Integer size = context.getIntAttribute("size");

                boolean readWrite = !context.getBooleanAttribute("readOnly"false).booleanValue();

                Properties props = context.getChildrenAsProperties();

                this.builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, props);

    //如果同时存在<cache>和<cache-ref>,这里的设置会覆盖前面的cache-ref的缓存

            }

     

        }

    空cache元素定义会生成一个采用最近最少使用算法最多只能存储1024个元素的缓存,而且是可读写的缓存,即该缓存是全局共享的,任何一个线程在拿到缓存结果后对数据的修改都将影响其它线程获取的缓存结果,因为它们是共享的,同一个对象。

    cache元素可指定如下属性,每种属性的指定都是针对都是针对底层Cache的一种装饰,采用的是装饰器的模式。

    1. blocking:默认为false,当指定为true时将采用BlockingCache进行封装,blocking,阻塞的意思,使用BlockingCache会在查询缓存时锁住对应的Key,如果缓存命中了则会释放对应的锁,否则会在查询数据库以后再释放锁,这样可以阻止并发情况下多个线程同时查询数据,详情可参考BlockingCache的源码。
      简单理解,也就是设置true时,在进行增删改之后的并发查询,只会有一条去数据库查询,而不会并发

       

    2. eviction:eviction,驱逐的意思。也就是元素驱逐算法,默认是LRU,对应的就是LruCache,其默认只保存1024个Key,超出时按照最近最少使用算法进行驱逐,详情请参考LruCache的源码。如果想使用自己的算法,则可以将该值指定为自己的驱逐算法实现类,只需要自己的类实现Mybatis的Cache接口即可。除了LRU以外,系统还提供了FIFO(先进先出,对应FifoCache)、SOFT(采用软引用存储Value,便于垃圾回收,对应SoftCache)和WEAK(采用弱引用存储Value,便于垃圾回收,对应WeakCache)这三种策略。
      这里,根据个人需求选择了,没什么要求的话,默认的LRU即可

    3. flushInterval:清空缓存的时间间隔,单位是毫秒,默认是不会清空的。当指定了该值时会再用ScheduleCache包装一次,其会在每次对缓存进行操作时判断距离最近一次清空缓存的时间是否超过了flushInterval指定的时间,如果超出了,则清空当前的缓存,详情可参考ScheduleCache的实现。

    4. readOnly:是否只读
      默认为false。当指定为false时,底层会用SerializedCache包装一次,其会在写缓存的时候将缓存对象进行序列化,然后在读缓存的时候进行反序列化,这样每次读到的都将是一个新的对象,即使你更改了读取到的结果,也不会影响原来缓存的对象,即非只读,你每次拿到这个缓存结果都可以进行修改,而不会影响原来的缓存结果;
      当指定为true时那就是每次获取的都是同一个引用,对其修改会影响后续的缓存数据获取,这种情况下是不建议对获取到的缓存结果进行更改,意为只读(不建议设置为true)。
      这是Mybatis二级缓存读写和只读的定义,可能与我们通常情况下的只读和读写意义有点不同。每次都进行序列化和反序列化无疑会影响性能,但是这样的缓存结果更安全,不会被随意更改,具体可根据实际情况进行选择。详情可参考SerializedCache的源码。

    5. size:用来指定缓存中最多保存的Key的数量。其是针对LruCache而言的,LruCache默认只存储最多1024个Key,可通过该属性来改变默认值,当然,如果你通过eviction指定了自己的驱逐算法,同时自己的实现里面也有setSize方法,那么也可以通过cache的size属性给自定义的驱逐算法里面的size赋值。

    6. type:type属性用来指定当前底层缓存实现类,默认是PerpetualCache,如果我们想使用自定义的Cache,则可以通过该属性来指定,对应的值是我们自定义的Cache的全路径名称。

    cache-ref元素定义

    cache-ref元素可以用来指定其它Mapper.xml中定义的Cache,有的时候可能我们多个不同的Mapper需要共享同一个缓存的
    是希望在MapperA中缓存的内容在MapperB中可以直接命中的,这个时候我们就可以考虑使用cache-ref,这种场景只需要保证它们的缓存的Key是一致的即可命中,二级缓存的Key是通过Executor接口的createCacheKey()方法生成的,其实现基本都是BaseExecutor,源码如下。

    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

    27

    28

    29

    30

    31

    32

    33

    34

    35

    public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {

        if (this.closed) {

            throw new ExecutorException("Executor was closed.");

        else {

            CacheKey cacheKey = new CacheKey();

            cacheKey.update(ms.getId());

            cacheKey.update(rowBounds.getOffset());

            cacheKey.update(rowBounds.getLimit());

            cacheKey.update(boundSql.getSql());

            List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();

            TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();

     

            for(int i = 0; i < parameterMappings.size(); ++i) {

                ParameterMapping parameterMapping = (ParameterMapping)parameterMappings.get(i);

                if (parameterMapping.getMode() != ParameterMode.OUT) {

                    String propertyName = parameterMapping.getProperty();

                    Object value;

                    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 = this.configuration.newMetaObject(parameterObject);

                        value = metaObject.getValue(propertyName);

                    }

     

                    cacheKey.update(value);

                }

            }

     

            return cacheKey;

        }

    }

    打个比方我想在MenuMapper.xml中的查询都使用在UserMapper.xml中定义的Cache,则可以通过cache-ref元素的namespace属性指定需要引用的Cache所在的namespace,即UserMapper.xml中的定义的namespace,假设在UserMapper.xml中定义的namespace是cn.chenhaoxiang.dao.UserMapper,则在MenuMapper.xml的cache-ref应该定义如下。

    1

    <cache-ref namespace="cn.chenhaoxiang.dao.UserMapper"/>

    这样这两个Mapper就共享同一个缓存了

    自定义cache就不介绍了。

    测试二级缓存

    查询测试

    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

    27

    28

    <br />/**

     * Created with IntelliJ IDEA.

     * User: 陈浩翔.

     * Date: 2018/1/10.

     * Time: 下午 10:15.

     * Explain:

     */

    @RunWith(SpringJUnit4ClassRunner.class)

    //配置了@ContextConfiguration注解并使用该注解的locations属性指明spring和配置文件之后

    @ContextConfiguration(locations = {"classpath:spring.xml","classpath:spring-mybatis.xml"})

    public class MyBatisTestBySpringTestFramework {

     

        //注入userService

        @Autowired

        private UserService userService;

     

        @Test

        public void testGetUserId(){

            String userId = "4e07f3963337488e81716cfdd8a0fe04";

            User user = userService.getUserById(userId);

            System.out.println(user);

     

     

            //前面说到spring和MyBatis整合

            User user2 = userService.getUserById(userId);

            System.out.println("user2:"+user2);

        }

    }

    接下来我们把Mapper中的cache元素删除,不使用二级缓存

    再运行测试

    对二级缓存进行了以下测试,获取两个不同的SqlSession(前面有说,Spring和MyBatis集成,每次都是不同的SqlSession)执行两条相同的SQL,在未指定Cache时Mybatis将查询两次数据库,在指定了Cache时Mybatis只查询了一次数据库,第二次是从缓存中拿的。

    Cache Hit Ratio 表示缓存命中率。
    开启二级缓存后,每执行一次查询,系统都会计算一次二级缓存的命中率。
    第一次查询也是先从缓存中查询,只不过缓存中一定是没有的。
    所以会再从DB中查询。由于二级缓存中不存在该数据,所以命中率为0.但第二次查询是从二级缓存中读取的,所以这一次的命中率为1/2=0.5。
    当然,若有第三次查询,则命中率为1/3=0.66
    0.5这个值可以从上面开启cache的图看出来,0.0的值未截取到~漏掉了~

    注意:
    增删改操作,无论是否进行提交sqlSession.commit(),均会清空一级、二级缓存,使查询再次从DB中select。
    说明:
    二级缓存的清空,实质上是对所查找key对应的value置为null,而非将对,即entry对象删除。
    从DB中进行select查询的条件是:缓存中根本不存在这个key或者缓存中存在该key所对应的entry对象,但value为null。

    设置增删改操作不刷新二级缓存:
    若要使某个增、删或改操作不清空二级缓存,则需要在其或或中添加属性flushCache="false",默认为true。

    二级缓存的使用原则

    1. 只能在一个命名空间下使用二级缓存
      由于二级缓存中的数据是基于namespace的,即不同namespace中的数据互不干扰。在多个namespace中若均存在对同一个表的操作,那么这多个namespace中的数据可能就会出现不一致现象。
    2. 在单表上使用二级缓存
      如果一个表与其它表有关联关系,那么久非常有可能存在多个namespace对同一数据的操作。而不同namespace中的数据互补干扰,所以就有可能出现多个namespace中的数据不一致现象。
    3. 查询多于修改时使用二级缓存
      在查询操作远远多于增删改操作的情况下可以使用二级缓存。因为任何增删改操作都将刷新二级缓存,对二级缓存的频繁刷新将降低系统性能。
    展开全文
  • mybatis一级缓存二级缓存 mybatis缓存概述 mybatis一级缓存 mybatis二级缓存 mybatis缓存概述CacheKey: hashcode(哈希值),checksum,namespace+id(namespace为mapper文件的命名空间,id为sql的id),.sql(查询sql),...
  • 1、如何使用 2、缓存的生命周期、失效机制 3、缺点不足以及如何避免   参考文章: 1、MyBatis一二级缓存 2、聊聊MyBatis缓存机制
  • MyBatisMyBatis一级缓存二级缓存

    千次阅读 2018-01-27 19:35:53
    MyBatis自带的缓存一级缓存二级缓存 一级缓存Mybatis一级缓存是指Session缓存一级缓存的作用域默认是个SqlSession。Mybatis默认开启一级缓存。 也就是在同个SqlSession中,执行相同的查询SQL,第次会...
  • MySql缓存机制MyBatis一级缓存MyBatis一级缓存是sesssion会话级别的缓存,是基于当前SqlSession对象的,MyBatis一级缓存实际上是以当前sql为key对执行语句进行缓存(跟mysql缓存一样,修改任何参数的值都会导致缓存...
  • MyBatis 3】MyBatis一级缓存二级缓存.pdf
  • myBatis一二级缓存配置

    2020-09-07 22:42:24
    一级缓存一级缓存不能关闭,但可以配置一级缓存的作用域。 一级缓存默认开启: <setting name="localCacheScope" value="SESSION"/> localCacheScope:value有两个SESSION(默认)、STATEMENT。 ...
  • Mybatis 一级缓存二级缓存的使用

    万次阅读 2021-01-19 10:28:52
    目录Mybatis缓存一级缓存二级缓存缓存原理 Mybatis缓存 官方文档:https://mybatis.org/mybatis-3/zh/sqlmap-xml.html#cache MyBatis 内置了一个强大的事务性查询缓存机制,它可以非常方便地配置和定制 Mybatis中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 103,926
精华内容 41,570
关键字:

mybatis一二级缓存