Mybatis缓存机制

 

概述：MyBatis的二级缓存是Application级别的缓存，它可以提高对数据库查询的效率，以提高应用的性能 。

 

一、mybatis缓存机制的整体设计以及二级缓存的工作模式

如上图所示，当开启一个会话时，一个SqlSession对象会使用一个Executor对象来完成会话操作，MyBatis的二级缓存机制的关键就是对这个Executor对象做文章。如果用户配置了"cacheEnabled=true"，那么MyBatis在为SqlSession对象创建Executor对象时，会对Executor对象加上一个装饰者：CachingExecutor，这时SqlSession使用CachingExecutor对象来完成操作请求。CachingExecutor对于查询请求，会先判断该查询请求在Application级别的二级缓存中是否有缓存结果，如果有查询结果，则直接返回缓存结果；如果缓存中没有，再交给真正的Executor对象来完成查询操作，之后CachingExecutor会将真正Executor返回的查询结果放置到缓存中，然后在返回给用户。

注释：Executor是一个比Windows“运行”功能更为强大、自定义更强的工具，如果你需要经常查找程序或者想快速运行程序这个功能比较适合你。功能大致有：自定义关键字、历史、自动完成、下拉菜单，Executor会自动匹配关键字，并提供下拉列表选项 。

 

CachingExecutor是Executor的装饰者，以增强Executor的功能，使其具有缓存查询的功能，这里用到了设计模式中的装饰者模式。

二、Mybatis二级缓存划分

MyBatis并不是简单地对整个Application就只有一个Cache缓存对象，它将缓存划分的更细，即是Mapper级别的，即每一个Mapper都可以拥有一个Cache对象具体如下：

  **a.为每一个Mapper分配一个Cache缓存对象（使用<cache>节点配置）；**   

**b.多个Mapper共用一个Cache缓存对象（使用<cache-ref>节点配置）；**

多个Mapper共用一个Cache缓存对象（使用节点配置）

如果你想让多个Mapper公用一个Cache的话，你可以使用<cache-ref namespace="">节点，来指定你的这个Mapper使用到了哪一个Mapper的Cache缓存。

 

三、使用二级缓存必须要具备的条件

MyBatis对二级缓存的支持粒度很细，它会指定某一条查询语句是否使用二级缓存。

虽然在Mapper中配置了<cache>,并且为此Mapper分配了Cache对象，这并不表示我们使用Mapper中定义的查询语句查到的结果都会放置到Cache对象之中，我们必须指定Mapper中的某条选择语句是否支持缓存，即如下所示，在<select> 节点中配置useCache="true"，Mapper才会对此Select的查询支持缓存特性，否则，不会对此Select查询，不会经过Cache缓存。如下所示，Select语句配置了useCache="true"，则表明这条Select语句的查询会使用二级缓存。<select id="selectByMinSalary" resultMap="BaseResultMap" parameterType="java.util.Map" useCache="true">

总之，要想使某条Select查询支持二级缓存，你需要保证：

MyBatis支持二级缓存的总开关：全局配置变量参数   cacheEnabled=true

该select语句所在的Mapper，配置了<cache> 或<cached-ref>节点，并且有效

该select语句的参数 useCache=true

 

四、一级缓存和 二级缓存的使用顺序

请注意，如果你的MyBatis使用了二级缓存，并且你的Mapper和select语句也配置使用了二级缓存，那么在执行select查询的时候，MyBatis会先从二级缓存中取输入，其次才是一级缓存，即MyBatis查询数据的顺序是：

 二级缓存 ———> 一级缓存——> 数据库

五、二级缓存实现的选择

MyBatis对二级缓存的设计非常灵活，它自己内部实现了一系列的Cache缓存实现类，并提供了各种缓存刷新策略如LRU，FIFO等等；另外，MyBatis还允许用户自定义Cache接口实现，用户是需要实现org.apache.ibatis.cache.Cache接口，然后将Cache实现类配置在<cache  type="">节点的type属性上即可；除此之外，MyBatis还支持跟第三方内存缓存库如Memecached的集成，总之，使用MyBatis的二级缓存有三个选择:

 

1.MyBatis自身提供的缓存实现；

用户自定义的Cache接口实现；

跟第三方内存缓存库的集成；

5.1、Mybatis自身提供的二级缓存的实现

MyBatis自身提供了丰富的，并且功能强大的二级缓存的实现，它拥有一系列的Cache接口装饰者，可以满足各种对缓存操作和更新的策略。

MyBatis定义了大量的Cache的装饰器来增强Cache缓存的功能，如下类图所示。

对于每个Cache而言，都有一个容量限制，MyBatis各供了各种策略来对Cache缓存的容量进行控制，以及对Cache中的数据进行刷新和置换。下面来看不同置换策略实现类的源码：

5.1.1Cache接口以及实现

Cache接口

MyBatis中的Cache以SPI实现，给需要集成其它Cache或者自定义Cache提供了接口。

 

public interface Cache {     String getId(); void putObject(Object key, Object value); Object getObject(Object key); Object removeObject(Object key); void clear(); int getSize(); ReadWriteLock getReadWriteLock(); }

C

Cache实现

Cache的实现类中，Cache有不同的功能，每个功能独立，互不影响,则对于不同的Cache功能，这里使用了装饰者模式实现。

perpetualCache

作为为最基础的缓存类，底层实现比较简单，直接使用了HashMap。

FifoCache

FIFO回收策略，装饰类，内部维护了一个队列，来保证FIFO，一旦超出指定的大小，则从队列中获取Key并从被包装的Cache中移除该键值对。

public class FifoCache implements Cache { ​ // 被包装的类 private final Cache delegate; // 队列，用来维持FIFO private LinkedList<Object> keyList; // 最大可容纳的大小 private int size; ​ public FifoCache(Cache delegate) {   this.delegate = delegate;   this.keyList = new LinkedList<Object>();   this.size = 1024; } ​ @Override public void putObject(Object key, Object value) {   // 将Key放入队列中，并且检查一遍，如果满了则移除队列头部的元素   cycleKeyList(key);   // 执行真正的操作   delegate.putObject(key, value); } ​ private void cycleKeyList(Object key) {   // 将Key放入队列   keyList.addLast(key);   if (keyList.size() > size) {     // 超出指定容量，移除队列头部Key     Object oldestKey = keyList.removeFirst();     // 从缓存中移除Key对应的值     delegate.removeObject(oldestKey);   } } ​ // 省略部分代码 ... }

LogginCache

日志功能，装饰类，用于记录缓存的命中率，如果开启了DEBUG模式，则会输出命中率日志。

public class LoggingCache implements Cache {   private Log log;     private Cache delegate;   // 请求次数   protected int requests = 0;   // 命中次数   protected int hits = 0;   public LoggingCache(Cache delegate) {     this.delegate = delegate;     this.log = LogFactory.getLog(getId());   }   @Override   public Object getObject(Object key) {     requests++;     final Object value = delegate.getObject(key);     if (value != null) {       // 命中       hits++;     }     if (log.isDebugEnabled()) {       // 如果开启了DEBUG模式，则输出命中率       log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());     }     return value;   }   // 获取命中率   private double getHitRatio() {     return (double) hits / (double) requests;   }   // 省略部分代码   ...

LRUCache

LRU回收策略，装饰类，在内部保存一个LinkedHashMap，用以实现LRU 。

public class LruCache implements Cache { ​ private final Cache delegate; private Map<Object, Object> keyMap; private Object eldestKey; ​ public LruCache(Cache delegate) {   this.delegate = delegate;   // 初始化设置LRU回收的边界容量   setSize(1024); } ​ public void setSize(final int size) {   keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {     private static final long serialVersionUID = 4267176411845948333L; ​     // 键值移除策略，当大于指定容量时则移除最近最少使用的key/value     protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {       boolean tooBig = size() > size;       if (tooBig) {         // 保存需要移除的键，因为在被包装的类中并不知道什么键需要移除         eldestKey = eldest.getKey();       }       return tooBig;     }   }; } ​ @Override public void putObject(Object key, Object value) {   delegate.putObject(key, value);   // 将当前Key放到LRU的Map中，如果大于指定容量，则移除筛选的键值对   cycleKeyList(key); } ​ @Override public Object getObject(Object key) {   // 让当前LRU的Map知道使用过   keyMap.get(key); //touch   return delegate.getObject(key); } ​ @Override public Object removeObject(Object key) {   // 这里没有移除当前维护的key，不过在后续也会被回收，可以忽略   return delegate.removeObject(key); } ​ private void cycleKeyList(Object key) {   keyMap.put(key, key);   if (eldestKey != null) {     // 从Cache中移除掉LRU筛选出的键值对     delegate.removeObject(eldestKey);     eldestKey = null;   } } // 省略部分代码... }

ScheduledCache

定时清空Cache，但是并没有开始一个定时任务，而是在使用Cache的时候，才去检查时间是否到了。

public class ScheduledCache implements Cache { ​ private Cache delegate; // 清除的时间间隔 protected long clearInterval; // 上一次清除的时间 protected long lastClear; ​ public ScheduledCache(Cache delegate) {   this.delegate = delegate;   this.clearInterval = 60 * 60 * 1000; // 1 hour   this.lastClear = System.currentTimeMillis(); } ​ public void setClearInterval(long clearInterval) {   this.clearInterval = clearInterval; } ​ @Override public Object getObject(Object key) {   if (clearWhenStale()) {     return null;   } else {     return delegate.getObject(key);   } } ​ private boolean clearWhenStale() {   if (System.currentTimeMillis() - lastClear > clearInterval) {     // 时间到了，清空     clear();     return true;   }   return false; } ​ @Override public void clear() {   // 更新清空时间   lastClear = System.currentTimeMillis();   delegate.clear(); } // 省略部分代码 }

SynchronizedCache

同步Cache，实现比较简单，直接使用synchronized修饰方法。

public class SynchronizedCache implements Cache { ​ private Cache delegate; ​ public SynchronizedCache(Cache delegate) {   this.delegate = delegate; } @Override public synchronized void putObject(Object key, Object object) {   delegate.putObject(key, object); } // 省略部分代码 }

SoftCache

软引用回收策略，软引用只有当内存不足时才会被垃圾收集器回收。这里的实现机制中，使用了一个链表来保证一定数量的值即使内存不足也不会被回收，但是没有保存在该链表的值则有可能会被回收。 在WeakHashMap中，可以看到是将引用应用到Key的，当Key被回收后，则移除相关的Value。但是这里是将其应用到Value中，因为Key不能被回收，如果被移除的话，就会影响到整个体系，最底层的实现使用HashMap实现的，没有Key，就没有办法移除相关的值。反过来，值被回收了，将软引用对象放到队列中，可以根据Key调用removeObject移除该关联的键和软引用对象 。

public class SoftCache implements Cache { // 用于保存一定数量强引用的值 private final LinkedList<Object> hardLinksToAvoidGarbageCollection; // 引用队列，当被垃圾收集器回收时，会将软引用对象放入此队列 private final ReferenceQueue<Object> queueOfGarbageCollectedEntries; private final Cache delegate; // 保存强引用值的数量 private int numberOfHardLinks; ​ public SoftCache(Cache delegate) {   this.delegate = delegate;   this.numberOfHardLinks = 256;   this.hardLinksToAvoidGarbageCollection = new LinkedList<Object>();   this.queueOfGarbageCollectedEntries = new ReferenceQueue<Object>(); } ​ @Override public void putObject(Object key, Object value) {   // 移除被垃圾收集器回收的键值   removeGarbageCollectedItems();   // 将软件用作用到Value中   delegate.putObject(key, new SoftEntry(key, value, queueOfGarbageCollectedEntries)); } ​ @Override public Object getObject(Object key) {   Object result = null;   @SuppressWarnings("unchecked")   SoftReference<Object> softReference = (SoftReference<Object>) delegate.getObject(key);   if (softReference != null) {     result = softReference.get();     if (result == null) {       // 该值被垃圾收集器回收，移除掉该项       delegate.removeObject(key);     } else {       // 这里以及下面的clear,想不通为什么要加hardLinksToAvoidGarbageCollection的同步？（在WeakCache中却没有加同步）       synchronized (hardLinksToAvoidGarbageCollection) {         hardLinksToAvoidGarbageCollection.addFirst(result);         if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {           // 超出容量，则移除最先保存的引用           hardLinksToAvoidGarbageCollection.removeLast();         }       }     }   }   return result; } ​ @Override public Object removeObject(Object key) {   // 移除被垃圾收集器回收的键值   removeGarbageCollectedItems();   return delegate.removeObject(key); } ​ @Override public void clear() {   synchronized (hardLinksToAvoidGarbageCollection) {     // 这里需要清空该队列，否则即使下面调用clear，其Map清空了，但是部分值保留有引用，垃圾收集器也不会回收，会造成短暂的内存泄漏。     hardLinksToAvoidGarbageCollection.clear();   }   removeGarbageCollectedItems();   delegate.clear(); } ​ private void removeGarbageCollectedItems() {   SoftEntry sv;   // 清空被垃圾收集器回收的value其相关联的键以及软引用   while ((sv = (SoftEntry) queueOfGarbageCollectedEntries.poll()) != null) {     delegate.removeObject(sv.key);   } } ​ // 这里软引用对象是用在value中的 private static class SoftEntry extends SoftReference<Object> {   // 保存与value相关联的Key，因为一旦被垃圾收集器回收，则此软引用对象会被放到关联的引用队列中，这样就可以根据Key，移除该键值对。   private final Object key; ​   private SoftEntry(Object key, Object value, ReferenceQueue<Object> garbageCollectionQueue) {     super(value, garbageCollectionQueue);     this.key = key;   } } // 省略部分代码 }

WeakCache

弱引用回收策略，弱引用的对象一旦被垃圾收集器发现，则会被回收，无论内存是否足够。这里的实现和上面的软引用类似，除了使用WeakReference替换掉SoftReference，其它基本一样。

public Object getObject(Object key) {   Object result = null;   @SuppressWarnings("unchecked") // assumed delegate cache is totally managed by this cache   WeakReference<Object> weakReference = (WeakReference<Object>) delegate.getObject(key);   if (weakReference != null) {     result = weakReference.get();     if (result == null) {       delegate.removeObject(key);     } else {       // 软引用这里加锁了       hardLinksToAvoidGarbageCollection.addFirst(result);       if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {         hardLinksToAvoidGarbageCollection.removeLast();       }     }   }   return result; }

TransactionalCache

事务缓存，在提交的时候，才真正的放到Cache中，或者回滚的时候清除掉，对Cache没有影响。

public class TransactionalCache implements Cache { ​ private Cache delegate; private boolean clearOnCommit; private Map<Object, AddEntry> entriesToAddOnCommit; private Map<Object, RemoveEntry> entriesToRemoveOnCommit; ​ public TransactionalCache(Cache delegate) {   this.delegate = delegate;   this.clearOnCommit = false;   this.entriesToAddOnCommit = new HashMap<Object, AddEntry>();   this.entriesToRemoveOnCommit = new HashMap<Object, RemoveEntry>(); } ​ @Override public Object getObject(Object key) {   if (clearOnCommit) return null; // issue #146   return delegate.getObject(key); } ​ @Override public void putObject(Object key, Object object) {   // 移除当前事务中 待移除键值对操作   entriesToRemoveOnCommit.remove(key);   // 添加当前事务中 待增加到缓存键值对操作   entriesToAddOnCommit.put(key, new AddEntry(delegate, key, object)); } ​ @Override public Object removeObject(Object key) {   // 移除增加该键值对的操作   entriesToAddOnCommit.remove(key);   // 添加移除键值对操作   entriesToRemoveOnCommit.put(key, new RemoveEntry(delegate, key));   return delegate.getObject(key); } ​ @Override public void clear() {   reset();   clearOnCommit = true; } ​ public void commit() {   if (clearOnCommit) {     // 当提交事务时需要先清空，则清空缓存     delegate.clear();   } else {     // 应用移除键值对操作     for (RemoveEntry entry : entriesToRemoveOnCommit.values()) {       entry.commit();     }   }   // 应用添加键值对操作   for (AddEntry entry : entriesToAddOnCommit.values()) {     entry.commit();   }   reset(); } ​ public void rollback() {   reset(); } ​ private void reset() {   clearOnCommit = false;   entriesToRemoveOnCommit.clear();   entriesToAddOnCommit.clear(); } ​ private static class AddEntry {   private Cache cache;   private Object key;   private Object value; ​   public AddEntry(Cache cache, Object key, Object value) {     this.cache = cache;     this.key = key;     this.value = value;   } ​   public void commit() {     // 提交的时候，才真正放入缓存     cache.putObject(key, value);   } } ​ private static class RemoveEntry {   private Cache cache;   private Object key; ​   public RemoveEntry(Cache cache, Object key) {     this.cache = cache;     this.key = key;   } ​   public void commit() {     // 提交的时候才真正从缓存中移除     cache.removeObject(key);   } } }

SerializedCache

序列化功能，将值序列化后存到缓存中。该功能用于缓存返回一份实例的Copy，用于保存线程安全。

public class SerializedCache implements Cache { ​ // 省略部分代码 @Override public void putObject(Object key, Object object) {   if (object == null || object instanceof Serializable) {     // 先序列化后再存放到缓存中     delegate.putObject(key, serialize((Serializable) object));   } else {     throw new CacheException("SharedCache failed to make a copy of a non-serializable object: " + object);   } } ​ @Override public Object getObject(Object key) {   Object object = delegate.getObject(key);   // 不为空，则反序列化，生成一份Copy   return object == null ? null : deserialize((byte[]) object); } ​ private byte[] serialize(Serializable value) {   try {     // 序列化     ByteArrayOutputStream bos = new ByteArrayOutputStream();     ObjectOutputStream oos = new ObjectOutputStream(bos);     oos.writeObject(value);     oos.flush();     oos.close();     return bos.toByteArray();   } catch (Exception e) {     throw new CacheException("Error serializing object. Cause: " + e, e);   } } ​ private Serializable deserialize(byte[] value) {   Serializable result;   try {     // 反序列化     ByteArrayInputStream bis = new ByteArrayInputStream(value);     ObjectInputStream ois = new CustomObjectInputStream(bis);     result = (Serializable) ois.readObject();     ois.close();   } catch (Exception e) {     throw new CacheException("Error deserializing object. Cause: " + e, e);   }   return result; } ​ public static class CustomObjectInputStream extends ObjectInputStream { ​   public CustomObjectInputStream(InputStream in) throws IOException {     super(in);   } ​   @Override   protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {     // 此方法只有在待序列化的类第一次序列化的时候才会被调用     // 遍历所支持的ClassLoader，加载对应的Class     return Resources.classForName(desc.getName());   } } }

 

5.1.2 用户自定义的Cache接口实现

自定义缓存对象，该对象必须实现 org.apache.ibatis.cache.Cache 接口，如下：

 

import org.apache.ibatis.cache.Cache; ​ import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; ​ /** * Created by zhangwd on 2019/7/15. */ public class BatisCache implements Cache {   private ReadWriteLock lock = new ReentrantReadWriteLock();   private ConcurrentHashMap<Object,Object> cache = new ConcurrentHashMap<Object, Object>();   private String id; ​   public BatisCache(){       System.out.println("初始化-1！");   } ​ //必须有该构造函数   public BatisCache(String id){       System.out.println("初始化-2！");       this.id = id;   } ​   // 获取缓存编号   public String getId() {       System.out.println("得到ID：" + id);       return id;   } ​   //获取缓存对象的大小   public int getSize() {       System.out.println("获取缓存大小！");       return 0;   }   // 保存key值缓存对象   public void putObject(Object key, Object value) {       System.out.println("往缓存中添加元素：key=" + key+",value=" + value);       cache.put(key,value);   } ​   //通过KEY   public Object getObject(Object key) {       System.out.println("通过kEY获取值：" + key);       System.out.println("OVER");       System.out.println("=======================================================");       System.out.println("值为：" + cache.get(key));       System.out.println("=====================OVER==============================");       return cache.get(key);   } ​   // 通过key删除缓存对象   public Object removeObject(Object key) {       System.out.println("移除缓存对象：" + key);       return null;   } ​   // 清空缓存   public void clear() {       System.out.println("清除缓存！");       cache.clear();   } ​   // 获取缓存的读写锁   public ReadWriteLock getReadWriteLock() {       System.out.println("获取锁对象！！！");       return lock;   } }

在Mapper文件里配置使用该自定义的缓存对象，如：

<cache type="com.sanyue.utils.BatisCache"/>

测试如下：

public static void main(String[] args) { ​       SqlSessionFactory factory = SqlSessionFactoryUtil.openSqlSession(); ​       // 获得SqlSession对象       SqlSession sqlSession = factory.openSession();       // 获得dao实体       UserMapper userMapper = sqlSession.getMapper(UserMapper.class);       // 进行两次相同的查询操作       userMapper.selectByPrimaryKey(1);       userMapper.selectByPrimaryKey(1);       // 注意，当我们使用二级缓存时候，sqlSession需要使用commit时候才会生效       sqlSession.commit(); ​       System.out.println("\n\n=============================================================");       // 获得一个新的SqlSession 对象       SqlSession sqlSession1 = factory.openSession();       // 进行相同的查询操作       sqlSession1.getMapper(UserMapper.class).selectByPrimaryKey(1);       sqlSession1.commit();   }

日志输出：

初始化-2！ 得到ID：com.sanyue.dao.UserMapper 获取锁对象！！！ 通过kEY获取值：151355725:1423317450:com.sanyue.dao.UserMapper.selectByPrimaryKey:0:2147483647:       select       user_ID, login_name,user_name, user_code, user_type, user_active, organization_ID,user_position,password       from user       where user_ID = ?   :1 OVER ======================================================= 值为：null =====================OVER============================== 获取锁对象！！！ 获取锁对象！！！ 通过kEY获取值：151355725:1423317450:com.sanyue.dao.UserMapper.selectByPrimaryKey:0:2147483647:       select       user_ID, login_name,user_name, user_code, user_type, user_active, organization_ID,user_position,password ​       from user       where user_ID = ?   :1 OVER ======================================================= 值为：null =====================OVER============================== 获取锁对象！！！ 获取锁对象！！！ 往缓存中添加元素：key=151355725:1423317450:com.sanyue.dao.UserMapper.selectByPrimaryKey:0:2147483647:       select       user_ID, login_name,user_name, user_code, user_type, user_active, organization_ID,user_position,password       from user       where user_ID = ?   :1,value=[User{userId=1, loginName='AS-01', password='12121212121', userName='小明', userCode='JSD-009', userType='ADMIN', userActive=true, userPosition='销售员'}] 获取锁对象！！！ ============================================================= 获取锁对象！！！ 通过kEY获取值：151355725:1423317450:com.sanyue.dao.UserMapper.selectByPrimaryKey:0:2147483647:       select       user_ID, login_name,user_name, user_code, user_type, user_active, organization_ID,user_position,password ​       from user       where user_ID = ?   :1 OVER ======================================================= 值为：[User{userId=1, loginName='AS-01', password='12121212121', userName='小明', userCode='JSD-009', userType='ADMIN', userActive=true, userPosition='销售员'}] =====================OVER============================== 获取锁对象！！！

 

可以看出，每次查询数据库前，MyBatis都会先在缓存中查找是否有该缓存对象。只有当调用了commit() 方法，MyBatis才会往缓存中写入数据，数据记录的键为 数字编号+Mapper名+方法名+SQL语句+参数 格式，值为返回的对象值。

5.1.3跟第三方内存缓存库集成（Ehcache）

MyBatis与Ehcache整合所需工具：https://gitee.com/sixiaojie/codes/hgumrf4k8ew2v1cjyqn7o57

1.加入ehcache包ehcache-core-2.6.5.jar和mybatis-ehcache-1.0.2.jar一个是ehcache自己的，一个是和mybatis的整合包

2.整合ehcache配置mapper中cache中的type为ehcache对cache接口的实现类型。我们在mybatis-ehcache-1.0.2.jar下找到org.mybatis.caches.ehcache包下有EhcacheCache.class类，这个就是ehcache整合mybatis的Cache接口的实现UserMapper.xml:

<mapper namespace="com.popo.UserMapper">     <!-- 开启本Mapper的namespace下的二级缓存   ​ type:执行cache接口实现类的类型，mybatis默认使用PerpatualCache,   ​ 要和ehcache整合，需要配置type为ehcache实现cache接口的类型-->   ​ <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>   ​ /*****************此处省略*******************/ ​ </mapper>

3.加入ehcache的配置文件 在classpath下配置ehcache.xml 代码如下：

<?xml version="1.0" encoding="UTF-8" ?> <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd" ​ <!-- 磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存 path:指定在硬盘上存储对象的路径 --> <!-- <diskStore path="java.io.tmpdir" /> --> ​ <!-- 指定磁盘文件夹存储缓存 --> <diskStore path="D:\ehcache3\ehcache-cache"/> ​ <!--   defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理   maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象   eternal:代表对象是否永不过期   timeToIdleSeconds:最大的发呆时间   timeToLiveSeconds:最大的存活时间   overflowToDisk:是否允许对象被写入到磁盘   memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。           默认策略是LRU （last resently used 最近最少使用）。           你可以设置为FIFO（first in first out先进先出）           或是LFU(lest requently used 较少使用)。 --> <defaultCache   maxElementsInMemory="10000"   eternal="false"   timeToIdleSeconds="120"   timeToLiveSeconds="120"   overflowToDisk="true"   diskExpiryThreadIntervalSeconds="120"   memoryStoreEvictionPolicy="LRU" /> <!--   cache:为指定名称的对象进行缓存的特殊配置   name:指定对象的完整名 --> <cache name="com.zbaccp.entity.Person" maxElementsInMemory="10000" eternal="false"   timeToIdleSeconds="300" timeToLiveSeconds="600" overflowToDisk="true" /> </ehcache>

 

4.ehcache.xml属性配置详解

1、diskStore ：指定数据(.data and .index)存储位置，可指定磁盘中的文件夹位置

２、defaultCache ： 默认的管理策略。

必须配置的：

　　1、name： Cache的名称，必须是唯一的(ehcache会把这个cache放到HashMap里)。　　2、maxElementsInMemory：在内存中缓存的element的最大数目。　　3、maxElementsOnDisk：在磁盘上缓存的element的最大数目，默认值为0，表示不限制。　　４、eternal：设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断。　　５、overflowToDisk： 如果内存中数据超过内存限制，是否要缓存到磁盘上。

可选配置：

１、timeToIdleSeconds： 对象空闲时间，指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值0，表示一直可以访问。　　

２、timeToLiveSeconds： 对象存活时间，指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值0，表示一直可以访问。　　

３、diskPersistent： 是否在磁盘上持久化。指重启jvm后，数据是否有效。默认为false。　　

４、diskExpiryThreadIntervalSeconds： 对象检测线程运行时间间隔。标识对象状态的线程多长时间运行一次。　

５、diskSpoolBufferSizeMB： DiskStore使用的磁盘大小，默认值30MB。每个cache使用各自的DiskStore。　　

６、memoryStoreEvictionPolicy： 如果内存中数据超过内存限制，向磁盘缓存时的策略。默认值LRU，可选FIFO、LFU。

缓存的三种清空策略：

１、FIFO ，first in first out (先进先出).　　

２、LFU ， Less Frequently Used (最少使用).意思是一直以来最少被使用的。缓存的元素有一个hit 属性，hit 值最小的将会被清出缓存。　　

３、LRU ，Least Recently Used(最近最少使用,即未被使用时间最长). (ehcache 默认值).缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。

                                                                                                                                                             --------郑重声明：本帖不得转载