首页 / 缓存 / Mybatis学习系列（七）缓存机制

Mybatis学习系列（七）缓存机制

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Mybatis学习系列（七）缓存机制，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9593字，纯文字阅读大概需要14分钟。

内容图文

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
    publicvoid init() throws IOException {
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(inputStream);
    }

    // 一级缓存    @Test
    publicvoid 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
    publicvoid init() throws IOException {
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(inputStream);
    }
//二级缓存    @Test
    publicvoid 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();
    
    
    privatefinal ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
 
    private String id;
 
    public RedisCache(final String id) {
        if (id == null) {
            thrownew IllegalArgumentException("Cache instances require an ID");
        }
        
        this.id = id;
    }
 
    public String getId() {
        returnthis.id;
    }
 
    publicint getSize() {
        return Integer.valueOf(redisClient.dbSize().toString());
    }
 
    publicvoid 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);
    }
 
    publicvoid clear() {
        
        redisClient.flushDB();
    }
 
    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }
 
    protectedstatic Jedis createClient() {
        try {
            JedisPool pool = new JedisPool(new JedisPoolConfig(),"localhost");
            return pool.getResource();
        } catch (Exception e) {
            e.printStackTrace();
        }
        thrownew RuntimeException("初始化连接池错误");
    }
    

}

package com.sl.redis;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

publicclass SerializeHelper {
    publicstaticbyte[] 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();
        }
        returnnull;
    }
 
    publicstatic Object unserialize(byte[] bytes) {
        if (bytes == null)
            returnnull;
        ByteArrayInputStream bais = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        returnnull;
    }
}
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可配置），缓存容易造成脏读数据，影响数据的准确性，实际开发中往往放弃直接使用默认二级缓存。

原文：https://www.cnblogs.com/ashleyboy/p/9302507.html

内容总结

以上是互联网集市为您收集整理的Mybatis学习系列（七）缓存机制全部内容，希望文章能够帮你解决Mybatis学习系列（七）缓存机制所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1095638.html

来源：【匿名】