mybatis 缓存

  • Author: HuiFer
  • Description: 该文介绍 mybatis Cache 源码

  • 源码阅读工程: SourceHot-Mybatis

  • org.apache.ibatis.cache.Cache

  1. public interface Cache {
  3.     String getId();
  5.     /**
  6.      * 放入数据
  7.      */
  8.     void putObject(Object key, Object value);
  10.     /**
  11.      * 获取数据
  12.      */
  13.     Object getObject(Object key);
  15.     /**
  16.      * 移除数据
  17.      */
  18.     Object removeObject(Object key);
  20.     /**
  21.      * 清空数据
  22.      */
  23.     void clear();
  25.     /**
  26.      * 有多少缓存数据
  27.      */
  28.     int getSize();
  30.     /**
  31.      * 重入锁
  32.      * @return A ReadWriteLock
  33.      */
  34.     default ReadWriteLock getReadWriteLock() {
  35.         return null;
  36.     }
  38. }
  • BlockingCache: 阻塞的缓存
  • FifoCache: 按对象进入缓存的顺序来移除它们。
  • LruCache: 最近最少使用的：移除最长时间不被使用的对象。
  • SoftCache: 软引用：移除基于垃圾回收器状态和软引用规则的对象
  • WeakCache: 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。

BlockingCache

  • BlockingCache 内部使用了ReentrantLock来进行加锁开锁这个操作.在插入缓存时上锁,插入缓存后释放.请求缓存值得时候同理
  1. public class BlockingCache implements Cache {
  3.     private final Cache delegate;
  4.     /**
  5.      * 线程安全的map
  6.      */
  7.     private final ConcurrentHashMap<Object, ReentrantLock> locks;
  8.     private long timeout;
  10.     public BlockingCache(Cache delegate) {
  11.         this.delegate = delegate;
  12.         this.locks = new ConcurrentHashMap<>();
  13.     }
  15.     @Override
  16.     public String getId() {
  17.         return delegate.getId();
  18.     }
  20.     @Override
  21.     public int getSize() {
  22.         return delegate.getSize();
  23.     }
  25.     @Override
  26.     public void putObject(Object key, Object value) {
  27.         try {
  28.             delegate.putObject(key, value);
  29.         } finally {
  30.             releaseLock(key);
  31.         }
  32.     }
  34.     @Override
  35.     public Object getObject(Object key) {
  36.         acquireLock(key);
  37.         Object value = delegate.getObject(key);
  38.         if (value != null) {
  39.             // 释放锁
  40.             releaseLock(key);
  41.         }
  42.         return value;
  43.     }
  45.     @Override
  46.     public Object removeObject(Object key) {
  47.         // despite of its name, this method is called only to release locks
  48.         releaseLock(key);
  49.         return null;
  50.     }
  52.     @Override
  53.     public void clear() {
  54.         delegate.clear();
  55.     }
  57.     private ReentrantLock getLockForKey(Object key) {
  58.         return locks.computeIfAbsent(key, k -> new ReentrantLock());
  59.     }
  61.     /**
  62.      * 请求锁
  63.      * @param key
  64.      */
  65.     private void acquireLock(Object key) {
  66.         Lock lock = getLockForKey(key);
  67.         if (timeout > 0) {
  68.             try {
  69.                 // 上锁
  70.                 boolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS);
  71.                 if (!acquired) {
  72.                     throw new CacheException("Couldn't get a lock in " + timeout + " for the key " + key + " at the cache " + delegate.getId());
  73.                 }
  74.             } catch (InterruptedException e) {
  75.                 throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e);
  76.             }
  77.         } else {
  78.             lock.lock();
  79.         }
  80.     }
  82.     /**
  83.      * 释放锁
  84.      * @param key
  85.      */
  86.     private void releaseLock(Object key) {
  87.         ReentrantLock lock = locks.get(key);
  88.         if (lock.isHeldByCurrentThread()) {
  89.             lock.unlock();
  90.         }
  91.     }
  93.     public long getTimeout() {
  94.         return timeout;
  95.     }
  97.     public void setTimeout(long timeout) {
  98.         this.timeout = timeout;
  99.     }
  100. }

FifoCache

  • 存储结构是java.util.LinkedList
  1. public class FifoCache implements Cache {
  3.     private final Cache delegate;
  4.     /**
  5.      * 队列
  6.      */
  7.     private final Deque<Object> keyList;
  8.     private int size;
  10.     public FifoCache(Cache delegate) {
  11.         this.delegate = delegate;
  12.         this.keyList = new LinkedList<>();
  13.         this.size = 1024;
  14.     }
  16.     @Override
  17.     public String getId() {
  18.         return delegate.getId();
  19.     }
  21.     @Override
  22.     public int getSize() {
  23.         return delegate.getSize();
  24.     }
  26.     public void setSize(int size) {
  27.         this.size = size;
  28.     }
  30.     @Override
  31.     public void putObject(Object key, Object value) {
  32.         cycleKeyList(key);
  33.         delegate.putObject(key, value);
  34.     }
  36.     @Override
  37.     public Object getObject(Object key) {
  38.         return delegate.getObject(key);
  39.     }
  41.     @Override
  42.     public Object removeObject(Object key) {
  43.         return delegate.removeObject(key);
  44.     }
  46.     @Override
  47.     public void clear() {
  48.         delegate.clear();
  49.         keyList.clear();
  50.     }
  52.     /**
  53.      * 添加 key 删除最开始的一个
  54.      *
  55.      * @param key
  56.      */
  57.     private void cycleKeyList(Object key) {
  58.         keyList.addLast(key);
  59.         if (keyList.size() > size) {
  60.             Object oldestKey = keyList.removeFirst();
  61.             delegate.removeObject(oldestKey);
  62.         }
  63.     }
  65. }

LruCache

  • 存储结构是java.util.LinkedHashMap
  1. /**
  2.  * Lru (least recently used) cache decorator.
  3.  * LRU  緩存策略 最近最少使用的：移除最长时间不被使用的对象。
  4.  *
  5.  * @author Clinton Begin
  6.  */
  7. public class LruCache implements Cache {
  9.     private final Cache delegate;
  10.     /**
  11.      * {@link  LinkedHashMap}
  12.      */
  13.     private Map<Object, Object> keyMap;
  14.     private Object eldestKey;
  16.     public LruCache(Cache delegate) {
  17.         this.delegate = delegate;
  18.         setSize(1024);
  19.     }
  21.     @Override
  22.     public String getId() {
  23.         return delegate.getId();
  24.     }
  26.     @Override
  27.     public int getSize() {
  28.         return delegate.getSize();
  29.     }
  31.     /**
  32.      * 设置大小
  33.      *
  34.      * @param size
  35.      */
  36.     public void setSize(final int size) {
  37.         keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
  38.             private static final long serialVersionUID = 4267176411845948333L;
  40.             @Override
  41.             protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
  42.                 // 数量超出预设值 执行
  43.                 boolean tooBig = size() > size;
  44.                 if (tooBig) {
  45. //                    获取被移除的key
  46.                     eldestKey = eldest.getKey();
  47.                 }
  48.                 return tooBig;
  49.             }
  50.         };
  51.     }
  53.     @Override
  54.     public void putObject(Object key, Object value) {
  55.         delegate.putObject(key, value);
  56.         cycleKeyList(key);
  57.     }
  59.     @Override
  60.     public Object getObject(Object key) {
  61.         keyMap.get(key); //touch
  62.         return delegate.getObject(key);
  63.     }
  65.     @Override
  66.     public Object removeObject(Object key) {
  67.         return delegate.removeObject(key);
  68.     }
  70.     @Override
  71.     public void clear() {
  72.         delegate.clear();
  73.         keyMap.clear();
  74.     }
  76.     /**
  77.      * 删除最早的一个key
  78.      * @param key
  79.      */
  80.     private void cycleKeyList(Object key) {
  81.         keyMap.put(key, key);
  82.         if (eldestKey != null) {
  83.             delegate.removeObject(eldestKey);
  84.             eldestKey = null;
  85.         }
  86.     }
  88. }