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

}

测试方法：

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;

    }

}

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的高性能也保证了缓存数据的高速读取。

最新文章

  1. RESTful API的重磅好伙伴Swagger2
  2. 图片ping、JSONP和CORS跨域
  3. linux 多线程信号处理总结
  4. WPF仿360卫士9.0界面设计
  5. uvision4 ide已停止工作
  6. Android多语言支持以及各国语言Values文件夹命名规则
  7. Eclipse中Java文件图标由实心J变成空心J的问题
  8. [JS][jQuery]清空元素html(&quot;&quot;)、innerHTML=&quot;&quot; 与 empty()的区别 、remove()区别
  9. 【麦克风阵列增强】Delay and sum beamforming
  10. eclipse的格式化规则（即format.xml文件）.
  11. 小白的学习之路（hello wold！）
  12. java 使用for循环打印杨辉三角形
  13. PHP 类的命名空间 和自动载入
  14. gitolite的部署
  15. 4 HttpServletResponse 与 HttpServletRequest
  16. python 5
  17. 个人博客作业Week2 是否需要有代码规范
  18. caffe训练脚本文件时遇到./build/tools/caffe: not found
  19. phpStorm中Structure窗口中的符号代表的意思
  20. Maven传递依赖的范围

热门文章

  1. 最长公共子序列Lcs （51Nod - 1006）
  2. 进一步理解 frame 和 bounds
  3. 发送post请求几种常见content-type类型
  4. I/O流、文件操作
  5. 数据分析处理库Pandas——索引进阶
  6. R语言学习笔记（七）： 排序函数：sort(), rank(), order()
  7. java 上溯造型与下塑造型
  8. Django的命令操作，python
  9. sqlserver一次性删除master数据库中的所有用户添加的表
  10. awk用法介绍