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

    2019-07-06 10:43:22
    mybatis开启二级缓存 二级缓存是mapper级别的。Mybatis默认是没有开启二级缓存。 下面就是开启二级缓存的步骤 1、 在核心配置文件SqlMapConfig.xml中加入以下内容(开启二级缓存总开关):cacheEnabled设置为 true &...

    mybatis开启二级缓存

    二级缓存是mapper级别的。Mybatis默认是没有开启二级缓存。
    下面就是开启二级缓存的步骤
    1、 在核心配置文件SqlMapConfig.xml中加入以下内容(开启二级缓存总开关):cacheEnabled设置为 true

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

    2、在映射文件中,加入以下内容,开启二级缓存:

    <mapper namespace="BlogMapper">	
    	<cache/>
    
    

    实现序列化
    由于二级缓存的数据不一定都是存储到内存中,它的存储介质多种多样,所以需要给缓存的对象执行序列化。
    如果该类存在父类,那么父类也要实现序列化。
    在这里插入图片描述

    展开全文
  • 开启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

    展开全文
  • springboot mybatis 开启二级缓存

    千次阅读 2020-02-08 12:34:33
    mybatis提供了缓存机制, 有一级缓存, 二级缓存, 用于缓存查询结果.... 开启事务就能看到缓存效果了), 要想使用二级缓存需要额外做配置. 配置二级缓存有两种方式, 第一种在mapper接口上添加@CacheNames...

    mybatis提供了缓存机制, 有一级缓存, 二级缓存, 用于缓存查询结果.  默认情况下mybatis仅开启一级缓存的(springboot没有事务的情况下, 每个mapper操作语句都会重新生成一个SQLSession, 所以看不到一级缓存的效果.  开启事务就能看到缓存效果了), 要想使用二级缓存需要额外做配置. 配置二级缓存有两种方式, 第一种在mapper接口上添加@CacheNamespace注解, 第二种在mapper.xml文件中添加<cache />, 本文主要讲在mapper.xml文件中添加<cache />标签的方式. 

    添加<cache />标签后, 默认整个mapper中的select方法都会被缓存, 如果部分select方法不想使用缓存, 则可以在select标签上添加useCache="false"属性. 注意二级缓存的结果需要实现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="dictionaryMapper" >
        <!-- 开启二级缓存 -->
        <cache />
        <select id="selectByDictNameAndParentType" resultType="dictionary">
            select * from t_dictionary t
            where t.dict_name=#{dictName,jdbcType=VARCHAR}
            and t.parent_type=#{parentType,jdbcType=VARCHAR}
        </select>
        <select id="selectById" resultType="dictionary">
            select * from t_dictionary t where t.id=#{id,jdbcType=BIGINT}
        </select>
        <!-- 不想使用缓存, 就添加useCache="false"属性,这样每次都是从数据库中查询 -->
        <select id="selectByIdNonCache" resultType="dictionary" useCache="false">
            select * from t_dictionary t where t.id=#{id,jdbcType=BIGINT}
        </select>
    </mapper>

    开启了一二级缓存,执行mapper获取结果的步骤:

    1. 先从二级缓存查询结果, 有就返回
    2. 再从一级缓存查询结果, 有就返回
    3. 从数据库冲查询结果, 并在事务提交之后将查询结果添加到二级缓存
    

    ***为什么提交后才将数据添加到二级缓存?
    1. 一个事务中, 先更新数据,然后查询记录(此时尚未提交),之后逻辑异常导致事务回滚. 
    2. 如果将更新完数据后的查询结果直接添加到二级缓存,因事务回滚致使该缓存信息是错误的.
    3. 在添加到二级缓存和事务回滚这段时间被其他线程拿到了这个错误的缓存信息, 会导致其他逻辑有误.


    一级缓存命中的条件:

    
    1. 同一会话(同一个sqlSession, 所以要开启事务)
    2. 同一个mapper接口,相同的参数
    3. 同一个mybatis环境(如: 一个使用生产环境, 一个使用开发环境配置文件)

    二级缓存命中的条件:

    1. 同一个mapper接口,相同的参数
    2. 同一个mybatis环境(如: 一个使用生产环境, 一个使用开发环境配置文件)

     

    展开全文
  • springmvc开启二级缓存.

    2015-09-25 09:14:33
    hibernate对二级缓存的管理,以及mvc对二级缓存管理方式,由此减轻数据库的压力
  • 开启二级缓存 mybatis 默认为一级缓存,同一个sqlsession中相同的操作只会从磁盘上获取一次 mybatis plus开启二级缓存只需要两步 1、启动类:@EnableCaching //允许二级缓存 2、需要缓存的service层上面加上注解 如:...
  • mybatis开启二级缓存小记 1.开启二级缓存 和一级缓存默认开启不一样,二级缓存需要我们手动开启 首先在全局配置文件 mybatis-configuration.xml 文件中加入如下代码: <!--开启二级缓存 --> <settings> ...
  • tkmybatis开启二级缓存

    千次阅读 2018-12-08 09:50:15
    1.MyBatis配置文件开启二级缓存功能  &lt;settings&gt; &lt;settingname="cacheEnabled"value="true"/&gt; &lt;/settings&gt; 2.在 XxxMapper 接口上使用@...
  • Mybatis中给我们提供了缓存,其中有一级缓存和二级缓存 缓存是用来干嘛的? 当我们使用查询语句到数据库查询,每一次查询都会去访问数据库,频繁的访问数据库就会有压力,缓存就是来缓解数据库压力的,提升系统的性能 一...
  • SpringBoot+Mybatis开启二级缓存

    千次阅读 2019-11-22 22:33:34
    MyBatis 内置了一个强大的事务性查询缓存机制,包括一级缓存,二级缓存,它可以非常方便地配置和定制。一级缓存是sqlSession级别的缓存,二级缓存是Mapper 命名空间级别的缓存。 MyBatis 默认是开启一级缓存的,即...
  • 一级缓存默认是打开的,二级缓存需要配置才可以开启。那么我们必须思考一个问题,在什么情况下才有必要去开启二级缓存? 1、因为所有的增删改都会刷新二级缓存,导致二级缓存失效,所以适合在查询为主的应用中使用...
  • hibernate开启二级缓存

    千次阅读 2018-08-03 12:08:55
    开启二级缓存需要导入三个jar包,还有一个配置文件到资源根目录下 ehcache.xml: &lt;ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="...
  • Mybatis-plus 开启二级缓存

    千次阅读 2019-12-04 10:54:41
    Mybatis-plus 开启二级缓存 一、Ehcache、Redis比较 ​ ehcache是直接在jvm虚拟机中缓存,速度快,效率高;但是共享缓存麻烦,在分布式下显得功能弱; ​ redis是通过socket访问到缓存服务,效率比ehcache低,但是比...
  • yml文件 mybatis: mapper-locations: classpath:mapper/*Mapper.xml ... # 开启二级缓存 cache-enabled: true # map-underscore-to-camel-case: true 驼峰功能 在Mapper接口上使用@CacheNamespace注解:
  • Mybatis开启二级缓存

    千次阅读 2021-04-07 09:06:27
    上面是没有打开缓存的控制台输出语句 开启缓存方法: 第一步:在总配置文件加入<setting>标签设置以下属性 <settings> <setting name="cacheEnabled" value="true"/> </settings> ...
  • NULL 博文链接:https://yizhaorong.iteye.com/blog/2119438
  • 在对应的Dao类上面增加注释以开启二级缓存 @CacheNamespace(blocking = true) 例如: package com.itheima.dao; import com.itheima.domain.User; import org.apache.ibatis.annotations.*; import org.apache....
  • MyBatis3开启二级缓存

    2014-09-23 14:19:54
    MyBatis开启二级缓存只需要在Mapper.xml中添加   &lt;cache/&gt;  即可使用。  
  • 使用hibernate-release-5.2.10.Final开启二级缓存配置 首先要导入所需要的jar包和配置文件分别为hibernate-release-5.2.10.Final包中的required文件夹中的所有jar包和optional文件夹中ehcache文件夹的所有jar包和...
  • hibernate开启二级缓存 在hibernate.cfg.xml文件中开启二级缓存: 设置启用二级缓存: <property name="hibernate.cache.use_second_level_cache">true</property> 设置二级缓存的实现类: ...
  • 并且发现这个接口比较频繁的查询某一个数据的时候,并且这个数据对于用户来说可以存在一定的延迟,那么mybatis的二级缓存就派上用场了,接下来看下我们怎么来开启mybatis的二级缓存的吧 一、基于Spring+Mybatis ...
  • 一级缓存是默认开启的,无需其他配置操作,二级缓存则需要手动设置开启。 一级缓存原理: Mybatis的一级缓存是指同一个SqlSession中的操作。一级缓存的作用域是一个SqlSession。 在同一个SqlSession中,执行相同的...
  • } } 第,数据表中department的id为自增,则默认情况下插入department后,department对象的id为null(数据表有值,id列为自增),如下图所示: 解决办法如下:添加@Options注解 @Options(useGeneratedKeys = true,...
  • springboot+mybatis 开启二级缓存

    千次阅读 2019-04-16 17:41:41
    mybatis 二级缓存在数据没有更新修改的情况下默认保存的作用域namespace 1 首先要在引入数据源的地方添加开启mybatis缓存 // 读取配置 sqlSessionFactoryBean.setTypeAliasesPackage("com.*.*.*.model"); //-...
  • Mybatis中的缓存及如何开启二级缓存

    千次阅读 2019-08-13 10:58:47
    什么是缓存? 指存储在内存中的临时数据 为什么使用缓存? 减少和数据库的交互次数,提高执行效率 ...什么样的数据适合放到缓存,什么不适合 ...Mybatis中的一级缓存 它指的是Mybatis中SqlS...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 216,599
精华内容 86,639
关键字:

开启二级缓存