精华内容
下载资源
问答
  • 主要介绍了MyBatis开启二级缓存实现过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 开启mybatis开启二级缓存

    千次阅读 2020-08-19 17:49:56
    Mybatis中有一级缓存和二级缓存,默认情况下一级缓存是开启的,而且是不能关闭的。一级缓存是指SqlSession级别的缓存,当在同一个SqlSession中进行相同的SQL语句查询时,第二次以后的查询不会从数据库查询,而是直接...

    Mybatis中有一级缓存和二级缓存,默认情况下一级缓存是开启的,而且是不能关闭的。一级缓存是指SqlSession级别的缓存,当在同一个SqlSession中进行相同的SQL语句查询时,第二次以后的查询不会从数据库查询,而是直接从缓存中获取,一级缓存最多缓存1024条SQL。二级缓存是指可以跨SqlSession的缓存,是mapper级别的缓存,对于mapper级别的缓存不同的sqlsession是可以共享的,mapper以命名空间为单位创建缓存数据结构,需要手动开启。

    一、开启二级缓存

    和一级缓存默认开启不一样,二级缓存需要我们手动开启

    1、开启缓存

    首先在全局配置文件 mybatis-configuration.xml 文件中加入如下代码:

    <!--开启二级缓存  -->
    <settings>    
         <setting name="cacheEnabled" value="true"/>
    </settings>
    

    springboot配置开启二级缓存

    mybatis:
      mapper-locations: classpath:mapper/*.xml
      type-aliases-package: com.example.demo.entity
      configuration:
        cache-enabled: true
    

    2、在XXXmapper.xml文件中使用缓存

    <!-- 开启二级缓存 -->
    <cache></cache>
    

    我们可以看到 mapper.xml 文件中就这么一个空标签,其实这里可以配置,PerpetualCache这个类是mybatis默认实现缓存功能的类。我们不写type就使用mybatis默认的缓存,也可以去实现 Cache 接口来自定义缓存。

        <cache type="org.apache.ibatis.cache.impl.PerpetualCache">
            <property name="eviction" value="LRU" />
            <property name="flushInterval" value="6000000" />
            <property name="size" value="1024" />
            <property name="readOnly" value="false" />
        </cache>
    

    二、useCache和flushCache

    1、useCache
    mybatis中还可以配置userCache和flushCache等配置项,userCache是用来设置是否禁用二级缓存的,useCache=false禁用当前select语句的二级缓存,即每次查询都会发出sql去查询,默认情况是true,即该sql使用二级缓存。

    #禁用缓存
    <select id="selectUserByUserId" useCache="false" resultType="com.ys.twocache.User" parameterType="int">    
    select * from user where id=#{id}
    </select>
    

    对每次查询都需要最新的数据sql,要设置成useCache=false,禁用二级缓存,直接从数据库中获取。

    在mapper的同一个namespace中,如果有其它insert、update、delete操作数据后需要刷新缓存,如果不执行刷新缓存会出现脏读。

    2、flushCache

    flushCache=”true”,默认情况下为true,即刷新缓存,如果改成false则不会刷新。使用缓存时如果手动修改数据库表中的查询数据会出现脏读。

    #flushCache="true" 刷新缓存,flushCache="false" 不刷新缓存,可能出现脏读
    <select id="selectUserByUserId" flushCache="true" useCache="false" resultType="com.ys.twocache.User" parameterType="int">    
    select * from user where id=#{id}
    </select>
    

    一般下执行完commit操作都需要刷新缓存,flushCache=true表示刷新缓存,这样可以避免数据库脏读。
    所以我们不用设置,默认即可。

    三、关于@CacheNamespace

    @CacheNamespace注解主要用于mybatis二级缓存,等同于属性。但是在使用过程中要注意:

    @CacheNamespace虽然xml配置和注解的功能基本相同,但是使用@CacheNamespace时候要注意:

    配置文件和接口注释是不能够配合使用的。只能通过全注解的方式或者全部通过xml配置文件的方式使用,配合使用二级缓存会出问题,比如更新数据后不刷新缓存

    见下面的例子:

    //通过注解的方式使用二级缓存
    @CacheNamespace(implementation = MybatisRedisCache.class)
    public interface UserMapper(
        @Select("select * from t_user where user_id = #{userId}")
        @Options(useCache = true)
        List<User> getUser(User u);
    }
    
    //通过配置文件的方式,使用二级缓存
    <?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.mybatis.UserMapper">
     
        <cache type="cn.mybatis.MybatisRedisCache">
            <property name="eviction" value="LRU" />
            <property name="flushInterval" value="6000000" />
            <property name="size" value="1024" />
            <property name="readOnly" value="false" />
        </cache>
     
        <select id="selectById">
            select * from test where id = #{id}
        </select >
    </mapper>
    

    四、mybatis二级缓存的局限性

    mybatis二级缓存粒度不够细,他是以mapper为单位进行缓存的,比如对所有商品进行缓存,但是其中只有一个商品发生了更新,那么将会刷新所有的缓存,这时可以采用其他的方式进行缓存,比如第三方缓存redis等等。
    在这里插入图片描述

    参考链接:
    http://www.mybatis.cn/archives/128.html
    https://www.cnblogs.com/charlypage/p/9747145.html

    展开全文
  • 主要介绍了Mybatis基于注解开启使用二级缓存,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 文章目录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);
        }
    

    运行结果
    >

    展开全文
  • SpringBoot+Mybatis开启二级缓存

    千次阅读 2019-11-22 22:33:34
    MyBatis 内置了一个强大的事务性查询缓存机制,包括一级缓存,二级缓存,它可以非常方便地配置和定制。一级缓存是sqlSession级别的缓存,二级缓存是Mapper 命名空间级别的缓存。 MyBatis 默认是开启一级缓存的,即...

    MyBatis 内置了一个强大的事务性查询缓存机制,包括一级缓存,二级缓存,它可以非常方便地配置和定制。一级缓存是sqlSession级别的缓存,二级缓存是Mapper 命名空间级别的缓存。

    MyBatis 默认是开启一级缓存的,即同一个 sqlSession 每次查询都会先去缓存中查询,没有数据的话,再去数据库获取数据。

    <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.0</version>
    </dependency>
    

    它的默认配置就是启用二级缓存的,所以这个不用我们操心。因为Mybatis二级缓存是基于mapper级别的,所以还需要在各个Mapper 命名空间中进行进一步设置。

    1)对于sql语句存在于mapper.xml上时,在mapper中开启二级缓存需要在mapper.xml文件里添加二级缓存的属性配置:

    <cache />

    加上这个标签,二级缓存就会启用,它的默认属性如下:

    1、映射语句文件中的所有 select 语句将会被缓存。
    2、映射语句文件中的所有 insert,update 和 delete 语句会刷新缓存。
    3、缓存会使用 Least Recently Used(LRU,最近最少使用的)算法来收回。
    4、根据时间表(比如 no Flush Interval,没有刷新间隔), 缓存不会以任何时间顺序来刷新。
    5、缓存会存储列表集合或对象(无论查询方法返回什么)的 1024 个引用。
    6、缓存会被视为是 read/write(可读/可写)的缓存,意味着对象检索不是共享的,而且可以安全地被调用者修改,而不干扰其他调用者或线程所做的潜在修改。
    

    可用的清除策略有:

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

    默认的清除策略是 LRU。

    2)对于sql语句存在与接口注解中,需要在该接口类中添加如下注解:

    @CacheNamespace

     命中缓存后会提示:

    Cache hit ratio ...

    另外,Mapper中的数据表类也需要实现序列化。

    注意:

    使用二级缓存时,sql语句的映射要么全xml格式表示,要么注解表示,二选一,不然可能会出现无法利用二级缓存或二级缓存没有及时清空的bug问题。

    参考文章:https://mybatis.org/mybatis-3/zh/sqlmap-xml.html#cache

    展开全文
  • springboot mybatis 开启二级缓存 步骤: 1.我们要在mapper的xml文件下配置cache节点 2. 注意这个配置之后该mapper下的所有的查询语句都会走缓存 如果我们想指定莫一条查询语句不走缓存,我们就可以再该sql下 配置 ...

    springboot mybatis 开启二级缓存 步骤:

    1.我们要在mapper的xml文件下配置cache节点

    在这里插入图片描述

    2. 注意这个配置之后该mapper下的所有的查询语句都会走缓存

    如果我们想指定莫一条查询语句不走缓存,我们就可以再该sql下 配置 useCache=“false” ,
    注意useCache 默认值为true,
    例如:

    <select id="getUsers" resultMap="userMap" useCache="false">
           select * from t_user t <include refid="queryByCondition"></include>
       </select>
    

    那么该sql就不走缓存

    3. 注意我们还有给我们该maper的实体类实现序列化,不然会报错

    public class User implements Serializable{ 
    
    展开全文
  • (2)二级缓存二级缓存需要我们手动开启。(全局级别) 注:缓存说白了就是查询时可以去历史记录找一找,不用去数据库中查询(不用执行查询语句)。 1.配置文件配置二级缓存(两步): 1.在myb...
  • --这个配置使全局的映射器(二级缓存)启用或禁用缓存--> <setting name="cacheEnabled" value="true" /> </settings> </configuration> 三、然后开始创建实体类实现业务流程 创建包controller、entity、mapper、...
  •  Mybatis提供对缓存的支持,但是在没有配置的默认情况下,它只开启一级缓存,二级缓存需要手动开启。  一级缓存只是相对于同一个SqlSession而言。也就是针对于同一事务,多次执行同一Mapper的相同查询方法,第一...
  • Mybatis默认没有开启二级缓存,需要在全局配置(mybatis-config.xml)中开启二级缓存。本文讲述的是使用Redis作为缓存,与springboot、mybatis进行集成的方法。需要的朋友参考下吧
  • mybatis开启二级缓存

    万次阅读 2018-06-01 23:15:10
    1.修改配置文件mybatis-config.xml加入&lt;setting name="cacheEnabled"value="true"/&gt;,全局配置参数,需要时再设置cacheEnabled 介绍描述 : ...在mapper.xml中开启二缓存,ma...
  • Mybatis开启二级缓存

    千次阅读 2021-04-07 09:06:27
    上面是没有打开缓存的控制台输出语句 开启缓存方法: 第一步:在总配置文件加入<setting>标签设置以下属性 <settings> <setting name="cacheEnabled" value="true"/> </settings> ...
  • 一级缓存是默认开启的,无需其他配置操作,二级缓存则需要手动设置开启。 一级缓存原理: Mybatis的一级缓存是指同一个SqlSession中的操作。一级缓存的作用域是一个SqlSession。 在同一个SqlSession中,执行相同的...
  • Mybatis中给我们提供了缓存,其中有一级缓存和二级缓存 缓存是用来干嘛的? 当我们使用查询语句到数据库查询,每一次查询都会去访问数据库,频繁的访问数据库就会有压力,缓存就是来缓解数据库压力的,提升系统的性能 一...
  • 第一种方法xml配置法,第一步,下图是mybatis配置xml中的configuration标签下加入 第步,mapper.xml下加入cache标签,有配置加配置,这里没配置就没加 第种方法,第一步设置为真 第步,mapper中加注解...
  • yml文件 mybatis: mapper-locations: classpath:mapper/*Mapper.xml ... # 开启二级缓存 cache-enabled: true # map-underscore-to-camel-case: true 驼峰功能 在Mapper接口上使用@CacheNamespace注解:
  • 主要介绍了Mybatis-plus基于redis实现二级缓存过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • mybatis的一级缓存是SqlSession级别的它是默认打开的,二级缓存为SQLSessionFactory级别的默认关闭。下面介绍二级缓存如何开启和配置。 二级缓存开启 1、首先在mybatis配置文件的节点中配置整体开启二级缓存。 ...
  • Springboot集成Mybatis二级缓存

    千次阅读 2020-02-13 14:36:02
    什么是缓存? 简单来讲,缓存就是存储在缓冲区里的内容,或者可以理解为存在内存中的内容。用户可以将经常查询的内容放到缓存中,再次使用时直接从缓存中取值,而不需要...Mybatis的缓存分为一级缓存和二级缓存。一...
  • 由于在最近的面试中,多次被问到Mybatis的一级缓存和二级缓存,因此在此进行总结,文章中的代码截图和最后的缓存执行顺序图摘抄自B站up主“狂神说”的Mybatis视频讲解,以下附上视频链接:...【一】Mybatis的一级缓存和...
  • spring整合mybatis开启mybatis的二级缓存

    千次阅读 2017-03-17 16:49:30
    第一步,配置mybatis的配置文件sqlMapConfig.xml <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> ...第步,添加到sprin
  • MyBatis的一级缓存和二级缓存有什么区别? MyBatis的一级缓存:该缓存仅仅只会对sqlSession数据查询数据进行缓存,缓存至一个map中,生命周期很短,当sqlSession 消失时候消失,一级缓存是默认开启的,,每次的增...
  • tkmybatis开启二级缓存

    千次阅读 2018-12-08 09:50:15
    1.MyBatis配置文件开启二级缓存功能  &lt;settings&gt; &lt;settingname="cacheEnabled"value="true"/&gt; &lt;/settings&gt; 2.在 XxxMapper 接口上使用@...
  • MyBatis3开启二级缓存

    2019-08-07 02:03:23
    NULL 博文链接:https://yizhaorong.iteye.com/blog/2119592
  • mybatis.xml 直接贴出来了 可复制 需要注意的是这里的声明不同于mapper的声明,复制对比可看出来效果 这是mybatis的配置文件 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration PUBLIC "-...
  • mybatis实现二级缓存

    2019-11-18 19:47:39
    mybatis实现二级缓存mybatis集成ehcache介绍ehcachehibernate整合ehcache作为二级缓存mybatis整合ehcache作为二级缓存对比具体操作mybatis集成redis mybatis集成ehcache 介绍ehcache 为什么需要缓存 拉高程序的...
  • Spring Boot 整合 MyBatis 启用二级缓存

    千次阅读 2019-04-12 17:56:22
    首先,MyBatis 默认是开启一级缓存的,即同一个 ... 这时候我们还有二级缓存,它的范围是整个 mapper 的,以命名空间进行区分。 Spring Boot 是号称要消灭配置的框架,底层依然还是 Spring 那些东西,主要...
  • 一、MyBatis的一级缓存和二级缓存有什么区别? 1.一级缓存:存在于同一个 SqlSession生命周期中,默认是开启的 在同一个 SqlSession中MyBatis 会把执行的方法和参数通过算法生成缓存的键值, 将键值和结果存放在一个 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,346
精华内容 10,938
关键字:

mybatis开启二级缓存