zoukankan      html  css  js  c++  java
  • Mybatis学习系列(七)缓存机制

    Mybatis缓存介绍

    MyBatis提供一级缓存和二级缓存机制。

    一级缓存是Sqlsession级别的缓存,Sqlsession类的实例对象中有一个hashmap用于缓存数据。不同的Sqlsession实例缓存的hashmap数据区域互不影响。Mybatis默认启用一级缓存,在同一个sqlsession中多次执行相同的sql语句,第一次执行后会将数据缓存起来,后面的查询将会从缓存中读取。当一个sqlsession结束后(close),该sqlsession中缓存的数据也将不存在。

    二级缓存是Mapper级别的缓存,多个sqlsession实例操作同一个Mapper配置可共享二级缓存。Mybatis默认没有启用二级缓存,需要手动配置开启二级缓存。

    一张图看看一集缓存和二级缓存的区别:

    一级缓存

    一级缓存区域按sqlsession划分,当执行查询时会先从缓存区域查找,如果存在则直接返回数据,否则从数据库查询,并将结果集写入缓存区。 Mybatis一级缓存是在sqlsession内部维护一个hashmap用于存储,缓存key为hashcode+sqlid+sql,value则为查询的结果集。一级缓存在执行sqlsession.commit()后将会被清空。

    一级缓存示例:

    编写cacheMapper.xml配置文件

    <mapper namespace="com.sl.mapper.CacheMapper">
        <cache/>
        <select id="selectProductById" parameterType="int" resultType="com.sl.po.Product" >
            select * from products where id = #{id}
        </select>
    </mapper>

    Mapper接口:

    public interface CacheMapper {
        
        Product selectProductById(int id);
        
        @Options(flushCache=FlushCachePolicy.TRUE)
        int updateProductById(Product product);
        
    }
    View Code

    测试方法:

    public class TestCacheMapperClient {
    
    SqlSessionFactory factory
    = null; @Before public void init() throws IOException { String resource = "SqlMapConfig.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); factory = builder.build(inputStream); } // 一级缓存 @Test public void testSelectProductById() { SqlSession session = factory.openSession(); CacheMapper mapper = session.getMapper(CacheMapper.class); Product product = mapper.selectProductById(1); System.out.println(product.getName()); //执行commit 将清空一级缓存 //session.commit(); //再次执行查询 从一级缓存读取 Product product2 = mapper.selectProductById(1); System.out.println(product.getName()); // 关闭会话 session.close(); } }

    执行第一次执行selectProductById,查询数据库,第二次执行,从缓存中读取

    如果在两次查询中间执行commit,即上面的注释掉的session.commit(),则运行结果如下,显然清空了一级缓存,再次执行数据库查询

    二级缓存

    二级缓存按照mapper划分,一个mapper有一个自己的二级缓存(按照namespace区分不同缓存区域,如果多个mapper的namespace相同,则公用一个缓存区域),当多个sqlsession类实例加载相同的Mapper文件,执行mapper配置文件中的sql查询时,这些sqlsession可共享一个二级缓存。Mybatis默认没有启用二级缓存,需要自行配置。

    二级缓存示例:

    1. 启用二级缓存:

    在mybatis置文件SqlMapConfig.xml中加入一下配置

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

    在Mapper.xml配置文件中添加cache标签

    <cache />  <!-- 表示此mapper开启二级缓存。-->

    还可以配置其他参数,如:

    <cache  flushInterval="60000"  size="512"  readOnly="true" eviction="FIFO"  type=”xxxxx” />

    flushInterval:刷新时间间隔,单位毫秒,不设置则没有刷新时间间隔,在执行配置了flushCache标签的sql时刷新(清空)

    size:缓存原数个数,默认1024

    readOnly:是否只读,默认false:mybatis将克隆一份数据返回,true:直接返回缓存数据的引用(不安全,程序如果修改,直接改了缓存项)

    eviction:缓存的回收策略(LRU 、FIFO、 SOFT 、WEAK ),默认LRU

    type:指定自定义缓存的全类名(实现Cache接口即可)

    2. 结果集映射对象实现序列化接口

    使用Mybatis二级缓存需要将sql结果集映射的pojo对象实现java.io.Serializable接口,否则将出现序列化错误。

    public class Product implements Serializable{ …}

    3.编写cacheMapper.xml配置文件

    <mapper namespace="com.sl.mapper.CacheMapper">
        <cache/>
       
    <select id="selectProductById" parameterType="int" resultType="com.sl.po.Product" ><!-- useCache="false" 禁用二级缓存或者在Mapper接口上通过注解禁用--> select * from products where id = #{id} </select> <!-- update – 映射更新语句 --> <update id="updateProductById" parameterType="com.sl.po.Product" flushCache="true"> <!-- flushCache="true" 禁用二级缓存或者在Mapper接口上通过注解禁用--> update products set Name = #{Name},IsNew=#{IsNew} where id=#{id} </update> </mapper>

    4.Mapper.java接口

    public interface CacheMapper {
        Product selectProductById(int id);
        
        //@Options(flushCache=FlushCachePolicy.TRUE)  //清空 二级缓存
        int updateProductById(Product product);
    }

    5.测试方法:

    public class TestCacheMapperClient {
    SqlSessionFactory factory
    = null; @Before public void init() throws IOException { String resource = "SqlMapConfig.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); factory = builder.build(inputStream); }
    //二级缓存 @Test public void testSelectProductById2() throws IOException { SqlSession session1 = factory.openSession(); CacheMapper mapper1 = session1.getMapper(CacheMapper.class); Product product = mapper1.selectProductById(1); System.out.println(product.getName()); /************同一session 共享一级缓存***************/ //CacheMapper mapper2 = session1.getMapper(CacheMapper.class); //Product product2 = mapper2.selectProductById(1); //System.out.println(product2.getName()); //执行commit 将清空一级缓存,无法情况二级缓存 session1.commit(); session1.close(); //清空二级缓存 //Mapper接口注解@Options(flushCache=FlushCachePolicy.TRUE) 或者Mapper.xml配置属性 flushCache="true" SqlSession session4 = factory.openSession(); CacheMapper mapper4 = session4.getMapper(CacheMapper.class); Product up = new Product(); up.setId(1); up.setIsNew(true); up.setName("缓存测试2"); int count = mapper4.updateProductById(up); session4.commit(); session4.close(); /**********不同session实例 共享二级缓存************/ SqlSession session3 = factory.openSession(); CacheMapper mapper3 = session3.getMapper(CacheMapper.class); Product product3 = mapper3.selectProductById(1); System.out.println(product3.getName()); // 关闭会话 session3.close(); } }

    测试结果,上面updateProductById方法在配置sql中清空了二级缓存,所以后面mapper3.selectProductById(1)仍然执行数据库查询。

     

    6. 禁用二级缓存

    Mybatis还提供属性用于对指定的查询禁用二级缓存,在Mapper.xml配置文件中可是使用useCache=false禁止当前select使用二级缓存,即:

     <select id="selectProductById" parameterType="int" resultType="com.sl.po.Product" useCache="false" ><!-- useCache="false" 禁用二级缓存或者在Mapper接口上通过注解禁用-->
                select * from products where id = #{id}
     </select>

    在Mapper.Java接口中可是通过注解来禁用二级缓存,即:

        @Options(useCache=false)
        Product selectProductById(int id);

    7.缓存刷新

    当mybatis执行数据更新sql语句后,DB数据与缓存数据可能已经不一致,如果不执行刷新缓存则可能出现脏读的情况,Mybatis同样提供xml配置和注解两种方式来实现缓存刷新

    Xml配置形式:

    <update id="updateProductById" parameterType="com.sl.po.Product" flushCache="true"> <!-- flushCache="true" 禁用二级缓存或者在Mapper接口上通过注解禁用-->
                update products set
                Name = #{Name},IsNew=#{IsNew} 
                where id=#{id}
    </update>

    注解形式:

    @Options(flushCache=FlushCachePolicy.TRUE)  //清空 二级缓存
    int updateProductById(Product product);

    使用Redis做Mybatis二级缓存

    Mybatis默认启用二级缓存是服务器本地缓存,在程序部署到多台服务器时可能出现数据不一致的情况,这种情况下最好能有个集中式缓存来解决此问题。MyBatis的二级缓存允许自定义实现,Mybatis提供二级缓存接口,我们可以通过实现org.apache.ibatis.cache.Cache接口来整合第三方缓存,比如redis、memcache等。

    Demo实现步骤:

    1.  添加jar包依赖

            <!-- redis client -->
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>${jedis.version}</version>
            </dependency>

    2. 实现 Mybatis二级缓存org.apache.ibatis.cache.Cache接口

    package com.sl.redis;
    
    import java.util.concurrent.locks.ReadWriteLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    import org.apache.ibatis.cache.Cache;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    public class RedisCache implements Cache
    {
        
        private Jedis redisClient = createClient();
        
        
        private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
     
        private String id;
     
        public RedisCache(final String id) {
            if (id == null) {
                throw new IllegalArgumentException("Cache instances require an ID");
            }
            
            this.id = id;
        }
     
        public String getId() {
            return this.id;
        }
     
        public int getSize() {
            return Integer.valueOf(redisClient.dbSize().toString());
        }
     
        public void putObject(Object key, Object value) {
            
            redisClient.set(SerializeHelper.serialize(key.toString()), SerializeHelper.serialize(value));
        }
     
        public Object getObject(Object key) {
            Object value = SerializeHelper.unserialize(redisClient.get(SerializeHelper.serialize(key.toString())));
            return value;
        }
     
        public Object removeObject(Object key) {
            return redisClient.expire(SerializeHelper.serialize(key.toString()), 0);
        }
     
        public void clear() {
            
            redisClient.flushDB();
        }
     
        public ReadWriteLock getReadWriteLock() {
            return readWriteLock;
        }
     
        protected static Jedis createClient() {
            try {
                JedisPool pool = new JedisPool(new JedisPoolConfig(),"localhost");
                return pool.getResource();
            } catch (Exception e) {
                e.printStackTrace();
            }
            throw new RuntimeException("初始化连接池错误");
        }
        
    
    }
    
    package com.sl.redis;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    public class SerializeHelper {
        public static byte[] serialize(Object object) {
            ObjectOutputStream oos = null;
            ByteArrayOutputStream baos = null;
            try {
                // 序列化
                baos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(baos);
                oos.writeObject(object);
                byte[] bytes = baos.toByteArray();
                return bytes;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
     
        public static Object unserialize(byte[] bytes) {
            if (bytes == null)
                return null;
            ByteArrayInputStream bais = null;
            try {
                // 反序列化
                bais = new ByteArrayInputStream(bytes);
                ObjectInputStream ois = new ObjectInputStream(bais);
                return ois.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    View Code

    3. 修改Mapper.xml配置文件,通过type属型指定自定义二级缓存实现  type="com.sl.redis.RedisCache"

    <mapper namespace="com.sl.mapper.CacheMapper">
        
            <cache type="com.sl.redis.RedisCache"/>
            
            <select id="selectProductById" parameterType="int" resultType="com.sl.po.Product" ><!-- useCache="false" 禁用二级缓存或者在Mapper接口上通过注解禁用-->
                select * from products where id = #{id}
            </select>
            
            <!-- update – 映射更新语句 -->
            <update id="updateProductById" parameterType="com.sl.po.Product" flushCache="true"> <!-- flushCache="true" 禁用二级缓存或者在Mapper接口上通过注解禁用-->
                update products set
                Name = #{Name},IsNew=#{IsNew} 
                where id=#{id}
            </update>
        </mapper>

    测试方法同上。

    以上通过重写Mybatis二级缓存接口Cache类中的方法,将mybatis中默认的二级缓存空间替换成Redis。mybatis的二级缓存默认存储1024个对象(通过size可配置),且自带的二级缓存是存储在服务器本地内存的,实际开发中往往放弃直接使用默认二级缓存。使用redis 可以将数据存储到专用缓存服务器上,同时redis的高性能也保证了缓存数据的高速读取。

  • 相关阅读:
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    小程序之scroll-view用法
    uni-app解决小程序圆角样式不生效
    MAC设置允许任何来源
    小技巧:使用命令行打开vscode 以及 sublime 工具
  • 原文地址:https://www.cnblogs.com/ashleyboy/p/9302507.html
Copyright © 2011-2022 走看看