mybatis源码解读：cache包（缓存基本功能）

╰+哭是因爲堅強的太久メ 2022-12-27 08:57 179阅读 0赞

欢迎关注本人公众号：

![20201220181343595.png][]

1.简述：

Mybatis每秒可能要处理数万条数据库查询请求，而这些请求可能是重复的。缓存能够减低数据库查询次数，提升mybatis的性能。

mybatis缓存使得每次数据库查询请求都会优先经过缓存系统的过滤，只有没有命中缓存的情况下才会去查询数据库。

cache包就是mybatis缓存能力的提供者。

2.cache包结构与cache包接口

cache包是典型的装饰器模式应用案例，在impl包存放实现类，在decorators包中存放了众多的装饰器类。而cache接口是实现类和装饰器类的共同接口。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTIyMDQ3Mg_size_16_color_FFFFFF_t_70][]

在cache接口的子类中，只有一个实现类却有10个装饰器类。通过使用不同的装饰器实现类可以有着不同的功能。

cache接口定义了实现类和装饰器类必须实现的代码，源代码如下：

>     public interface Cache {
>     
>       /**
>        * 获取缓存id
>        * @return 缓存id
>        */
>       String getId();
>     
>      
>       /**
>        * 向缓存写入一条信息
>        * @param key 信息的键
>        * @param value 信息的值
>        */
>       void putObject(Object key, Object value);
>     
>       /**
>        * 从缓存中读取一条信息
>        * @param key 信息的键
>        * @return 信息的值
>        */
>       Object getObject(Object key);
>     
>      
>       /**
>        * 从缓存中删除一条信息
>        * @param key 信息的键
>        * @return 原来的信息值
>        */
>       Object removeObject(Object key);
>     
>      
>       /**
>        * 清空缓存
>        */
>       void clear();
>     
>       /**
>        * 读取缓存中信息的数目
>        * @return 信息的数目
>        */
>       int getSize();
>     
>     
>       /**
>        * 获取读写锁，该方法已经废弃
>        * @return 读写锁
>        */
>       default ReadWriteLock getReadWriteLock() {
>         return null;
>       }
>     
>     }

3.缓存键

3.1 原理：

mybatis每秒过滤众多的数据库查询操作，所以对缓存键要求有：

1.键唯一性

2.高效比较

3.高效生成

所以mybatis设计了CacheKey类作为缓存键，主要属性如下：

>     // 乘数，用来计算hashcode时使用
>     private final int multiplier;
>     // 哈希值，整个CacheKey的哈希值。如果两个CacheKey该值不同，则两个CacheKey一定不同
>     private int hashcode;
>     // 求和校验值，整个CacheKey的求和校验值。如果两个CacheKey该值不同，则两个CacheKey一定不同
>     private long checksum;
>     // 更新次数，整个CacheKey的更新次数
>     private int count;
>     // 更新历史
>     private List<Object> updateList;
> 
>     /**
>      * 更新CacheKey
>      * @param object 此次更新的参数
>      */
>     public void update(Object object) {
>       int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);
>     
>       count++;
>       checksum += baseHashCode;
>       baseHashCode *= count;
>     
>       hashcode = multiplier * hashcode + baseHashCode;
>     
>       updateList.add(object);
>     }

可见每一次update操作都会引发count、checksum、 hashcode值的变化，并把更新值放进updateList.

>     /**
>      * 比较当前对象和入参对象（通常也是CacheKey对象）是否相等
>      * @param object 入参对象
>      * @return 是否相等
>      */
>     @Override
>     public boolean equals(Object object) {
>       // 如果地址一样，是一个对象，肯定相等
>       if (this == object) {
>         return true;
>       }
>       // 如果入参不是CacheKey对象，肯定不相等
>       if (!(object instanceof CacheKey)) {
>         return false;
>       }
>       final CacheKey cacheKey = (CacheKey) object;
>       // 依次通过hashcode、checksum、count判断。必须完全一致才相等
>       if (hashcode != cacheKey.hashcode) {
>         return false;
>       }
>       if (checksum != cacheKey.checksum) {
>         return false;
>       }
>       if (count != cacheKey.count) {
>         return false;
>       }
>     
>       // 详细比较变更历史中的每次变更
>       for (int i = 0; i < updateList.size(); i++) {
>         Object thisObject = updateList.get(i);
>         Object thatObject = cacheKey.updateList.get(i);
>         if (!ArrayUtil.equals(thisObject, thatObject)) {
>           return false;
>         }
>       }
>       return true;
>     }

在比较CacheKey对象是否相等时，会先进行类型判断，然后依次通过hashcode、checksum、count判断，必须完全一致才相等，以上操作都比较简单，能在很短的时间内完成。如果2个对象各项属性完全一致则会详细比较2个对象的变动历史，这一步虽然很复杂，但可以保证绝对不会出现碰撞问题。

这种设计好处：在准确度和效率之间取得平衡。

3.2 缓存键的生成

在数据库查询时会先根据当前的查询条件生成一个CacheKey.

>     public abstract class BaseExecutor implements Executor {
> 
>     /**
>      * 执行查询操作
>      * @param ms 映射语句对象
>      * @param parameter 参数对象
>      * @param rowBounds 翻页限制
>      * @param resultHandler 结果处理器
>      * @param <E> 输出结果类型
>      * @return 查询结果
>      * @throws SQLException
>      */
>     @Override
>     public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
>       BoundSql boundSql = ms.getBoundSql(parameter);
>       // 生成缓存的键
>       CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
>       return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
>     }
> 
>     /**
>      * 生成查询的缓存的键
>      * @param ms 映射语句对象
>      * @param parameterObject 参数对象
>      * @param rowBounds 翻页限制
>      * @param boundSql 解析结束后的SQL语句
>      * @return 生成的键值
>      */
>     @Override
>     public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
>       if (closed) {
>         throw new ExecutorException("Executor was closed.");
>       }
>       // 创建CacheKey，并将所有查询参数依次更新写入
>       CacheKey cacheKey = new CacheKey();
>       cacheKey.update(ms.getId());
>       cacheKey.update(rowBounds.getOffset());
>       cacheKey.update(rowBounds.getLimit());
>       cacheKey.update(boundSql.getSql());
>       List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
>       TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
>       // mimic DefaultParameterHandler logic
>       for (ParameterMapping parameterMapping : parameterMappings) {
>         if (parameterMapping.getMode() != ParameterMode.OUT) {
>           Object value;
>           String propertyName = parameterMapping.getProperty();
>           if (boundSql.hasAdditionalParameter(propertyName)) {
>             value = boundSql.getAdditionalParameter(propertyName);
>           } else if (parameterObject == null) {
>             value = null;
>           } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
>             value = parameterObject;
>           } else {
>             MetaObject metaObject = configuration.newMetaObject(parameterObject);
>             value = metaObject.getValue(propertyName);
>           }
>           cacheKey.update(value);
>         }
>       }
>       if (configuration.getEnvironment() != null) {
>         // issue #176
>         cacheKey.update(configuration.getEnvironment().getId());
>       }
>       return cacheKey;
>     }
>     
>     /**
>      * 查询数据库中的数据
>      * @param ms 映射语句
>      * @param parameter 参数对象
>      * @param rowBounds 翻页限制条件
>      * @param resultHandler 结果处理器
>      * @param key 缓存的键
>      * @param boundSql 查询语句
>      * @param <E> 结果类型
>      * @return 结果列表
>      * @throws SQLException
>      */
>     @SuppressWarnings("unchecked")
>     @Override
>     public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
>       ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
>       if (closed) {
>         // 执行器已经关闭
>         throw new ExecutorException("Executor was closed.");
>       }
>       if (queryStack == 0 && ms.isFlushCacheRequired()) { // 新的查询栈且要求清除缓存
>         // 清除一级缓存
>         clearLocalCache();
>       }
>       List<E> list;
>       try {
>         queryStack++;
>         // 尝试从本地缓存获取结果
>         list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
>         if (list != null) {
>           // 本地缓存中有结果，则对于CALLABLE语句还需要绑定到IN/INOUT参数上
>           handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
>         } else {
>           // 本地缓存没有结果，故需要查询数据库
>           list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
>         }
>       } finally {
>         queryStack--;
>       }
>       if (queryStack == 0) {
>         // 懒加载操作的处理
>         for (DeferredLoad deferredLoad : deferredLoads) {
>           deferredLoad.load();
>         }
>         deferredLoads.clear();
>         // 如果本地缓存的作用域为STATEMENT，则立刻清除本地缓存
>         if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
>           clearLocalCache();
>         }
>       }
>       return list;
>     }
> 
> \}

可见，生成的 CacheKey对象中包含了这次查询的所有信息，包括查询语句的id,查询的翻页限制，数据总数，完整的sql语句，这些信息一致就保证了2次查询的一致，结合CacheKey的equals方法可以知道只要判断2个CacheKey对象相等，则2次查询操作的条件必定完全一致。

4.缓存的实现类

cache接口的实现类是PerpetualCache，属性id是用来标识唯一的一个缓存，cache是用户存储缓存信息。PerpetualCache实现类非常简单。

>     public class PerpetualCache implements Cache {
>     
>       // Cache的id，一般为所在的namespace
>       private final String id;
>       // 用来存储要缓存的信息
>       private Map<Object, Object> cache = new HashMap<>();
>     }

5.缓存装饰器

虽然缓存实现类PerpetualCache非常简单，但mybatis提供了很多装饰器类来为其添加更多的功能。

主要有：

5.1.同步装饰器：SynchronizedCache类，为缓存增加同步功能。

PerpetualCache实现类没有增加任何保证多线程安全的措施，如果多个线程同时调用userMapper下面的selectById, 则这些线程会同时访问同一个id的缓存，这会引发多线程安全问题。而mybatis把保证缓存多线程安全工作交给了SynchronizedCache类，通过直接在被包装的对象的操作方法增加synchronized关键字，把包装对象的方法转变为同步方法。

2.日志装饰器：LoggingCache类，为缓存增加日志功能

主要为缓存增加日志统计功能，即在缓存查询时记录查询的总次数与命中次数。

>     public class LoggingCache implements Cache {
> 
>     /**
>      * 从缓存中读取一条信息
>      * @param key 信息的键
>      * @return 信息的值
>      */
>     @Override
>     public Object getObject(Object key) {
>       // 请求缓存次数+1
>       requests++;
>       final Object value = delegate.getObject(key);
>       if (value != null) { // 命中缓存
>         // 命中缓存次数+1
>         hits++;
>       }
>       if (log.isDebugEnabled()) {
>         log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());
>       }
>       return value;
>     }
> 
>     private double getHitRatio() {
>       return (double) hits / (double) requests;
>     }
> 
> \}

3.清理装饰器：FifoCache，LruCache，SoftCache，WeakCache类，为缓存增加清理功能

虽然缓存能够极大提升数据查询效率，但这是以消耗内存空间为代价的，而且缓存空间是有限的，所以缓存添加合理的清理策略可以最大化利用缓存空间。

FifoCache类采用先进先出的策略来清理缓存，它内部使用了keyList属性存储了缓存数据的写入顺序，使用size来限制缓存数据数量。当数量达到限制后会将最先放入缓存中的数据删除。

>     public class FifoCache implements Cache {
>     
>       // 被装饰对象
>       private final Cache delegate;
>       // 按照写入顺序保存了缓存数据的键
>       private final Deque<Object> keyList;
>       // 缓存空间的大小
>       private int size;
> 
>     /**
>      * 向缓存写入一条数据
>      * @param key 数据的键
>      * @param value 数据的值
>      */
>     @Override
>     public void putObject(Object key, Object value) {
>       cycleKeyList(key);
>       delegate.putObject(key, value);
>     }
> 
>     /**
>      * 记录当前放入的数据的键，同时根据空间设置清除超出的数据
>      * @param key 当前放入的数据的键
>      */
>     private void cycleKeyList(Object key) {
>       keyList.addLast(key);
>       if (keyList.size() > size) {
>         Object oldestKey = keyList.removeFirst();
>         delegate.removeObject(oldestKey);
>       }
>     }
> 
> \}

LruCache类采用最近最久未使用算法，会在缓存数据达到限制时将最久未使用的数据删除。

>     public class LruCache implements Cache {
>     
>       // 被装饰对象
>       private final Cache delegate;
>       // 使用LinkedHashMap保存的缓存数据的键
>       private Map<Object, Object> keyMap;
>       // 最近最少使用的数据的键
>       private Object eldestKey;
> 
>     /**
>      * LruCache构造方法
>      * @param delegate 被装饰对象
>      */
>     public LruCache(Cache delegate) {
>       this.delegate = delegate;
>       setSize(1024);
>     }
> 
>     /**
>      * 设置缓存空间大小
>      * @param size 缓存空间大小
>      */
>     public void setSize(final int size) {
>       keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
>         private static final long serialVersionUID = 4267176411845948333L;
>         /**
>          * 每次向LinkedHashMap放入数据时触发
>          * @param eldest 最久未被访问的数据
>          * @return 最久未必访问的元素是否应该被删除
>          */
>         @Override
>         protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
>           boolean tooBig = size() > size;
>           if (tooBig) {
>             eldestKey = eldest.getKey();
>           }
>           return tooBig;
>         }
>       };
>     }
> 
> \}

在LruCache类的构造方法中，会调用setSize方法来设置缓存的空间大小，会创建用了存储缓存数据键的LinkedHashMap对象，并重写removeEldestEntry方法，该方法会每次向LinkedHashMap中放入数据后被自动触发，其输入参数为最久未访问的元素，在数量达到限制后会把它放进eldesKey属性中。

为了删除最久未使用的数据，LruCache类还做了以下2项工作：

1.在每次进行缓存查询操作时更新keyMap中键的排序，将当前被查询的键排到最前面。

2.在每次进行缓存写入操作时向keyMap写入新的键，并且在当前缓存中数据量超过限制时删除最近未访问的数据。

>     /**
>      * 向缓存写入一条信息
>      * @param key 信息的键
>      * @param value 信息的值
>      */
>     @Override
>     public void putObject(Object key, Object value) {
>       // 真正的查询操作
>       delegate.putObject(key, value);
>       // 向keyMap中也放入该键，并根据空间情况决定是否要删除最久未访问的数据
>       cycleKeyList(key);
>     }
>     
>     /**
>      * 从缓存中读取一条信息
>      * @param key 信息的键
>      * @return 信息的值
>      */
>     @Override
>     public Object getObject(Object key) {
>       // 触及一下当前被访问的键，表明它被访问了
>       keyMap.get(key);
>       // 真正的查询操作
>       return delegate.getObject(key);
>     }
> 
>     /**
>      * 向keyMap中存入当前的键，并删除最久未被访问的数据
>      * @param key 当前的键
>      */
>     private void cycleKeyList(Object key) {
>       keyMap.put(key, key);
>       if (eldestKey != null) {
>         delegate.removeObject(eldestKey);
>         eldestKey = null;
>       }
>     }

可以看出真正的缓存数据都存储在被装饰对象中，keyMap的引入只是存储缓存数据的键，而没有存储值。这是因为仅仅用它来保存缓存数据的访问情况，而不是参与数据的保存。

WeakCache类通过将缓存数据包装成弱引用的数据，从而使得jvm可以清理掉缓存数据。

>     public class WeakCache implements Cache {
>       // 强引用的对象列表
>       private final Deque<Object> hardLinksToAvoidGarbageCollection;
>       // 弱引用的对象列表
>       private final ReferenceQueue<Object> queueOfGarbageCollectedEntries;
>       // 被装饰对象
>       private final Cache delegate;
>       // 强引用对象的数目限制
>       private int numberOfHardLinks;
> 
>     public WeakCache(Cache delegate) {
>       this.delegate = delegate;
>       this.numberOfHardLinks = 256;
>       this.hardLinksToAvoidGarbageCollection = new LinkedList<>();
>       this.queueOfGarbageCollectedEntries = new ReferenceQueue<>();
>     }
> 
> \}

WeakCache也准备了一个hardLinksToAvoidGarbageCollection属性进行强引用，只不过该属性提供的空间有限为256。

>     /**
>      * 向缓存写入一条信息
>      * @param key 信息的键
>      * @param value 信息的值
>      */
>     @Override
>     public void putObject(Object key, Object value) {
>       // 清除垃圾回收队列中的元素
>       removeGarbageCollectedItems();
>       // 向被装饰对象中放入的值是弱引用的句柄
>       delegate.putObject(key, new WeakEntry(key, value, queueOfGarbageCollectedEntries));
>     }
> 
>     /**
>      * 将值已经被JVM清理掉的缓存数据从缓存中删除
>      */
>     private void removeGarbageCollectedItems() {
>       WeakEntry sv;
>       while ((sv = (WeakEntry) queueOfGarbageCollectedEntries.poll()) != null) { // 轮询该垃圾回收队列
>         // 将该队列中涉及的键删除
>         delegate.removeObject(sv.key);
>       }
>     }
> 
>     private static class WeakEntry extends WeakReference<Object> {
>       // 该变量不会被JVM清理掉，这里存储了目标对象的键
>       private final Object key;
>     
>       private WeakEntry(Object key, Object value, ReferenceQueue<Object> garbageCollectionQueue) {
>         super(value, garbageCollectionQueue);
>         this.key = key;
>       }
>     }
> 
>     /**
>      * 从缓存中读取一条信息
>      * @param key 信息的键
>      * @return 信息的值
>      */
>     @Override
>     public Object getObject(Object key) {
>       Object result = null;
>       // 假定被装饰对象只被该装饰器完全控制
>       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;
>     }

在向缓存中存入数据时存入的是该数据的弱引用包装类，而从缓存中取出数据时也是取出弱引用的包装类。WeakEntry内部类的key属性是强引用，不会被jvm随意清理掉，所以可以用来上传"数据键：null"这条数据。

SoftCache类和WeakCache功能，结构上是一致的，只是把弱引用改为软引用而已。

4.阻塞装饰器：BlockingCache类，为缓存增加阻塞功能

主要是mybatis接收到一条数据库查询请求，而对应的查询结果在缓存中不存在时，会去数据库进行查询，但在查询未结束时，又收到一条完全相同的数据库查询请求时会先阻塞第二次的查询请求，等待数据库查询结束后，将数据库查询结果返回给2次查询请求即可。

>     public class BlockingCache implements Cache {
>     
>       // 获取锁时的运行等待时间
>       private long timeout;
>       // 被装饰对象
>       private final Cache delegate;
>       // 锁的映射表。键为缓存记录的键，值为对应的锁。
>       private final ConcurrentHashMap<Object, ReentrantLock> locks;
>     
>       public BlockingCache(Cache delegate) {
>         this.delegate = delegate;
>         this.locks = new ConcurrentHashMap<>();
>       }
> 
>     /**
>      * 找出指定键的锁
>      * @param key 指定的键
>      * @return 该键对应的锁
>      */
>     private ReentrantLock getLockForKey(Object key) {
>       return locks.computeIfAbsent(key, k -> new ReentrantLock());
>     }
>     
>     /**
>      * 获取某个键的锁
>      * @param key 数据的键
>      */
>     private void acquireLock(Object key) {
>       // 找出指定对象的锁
>       Lock lock = getLockForKey(key);
>       if (timeout > 0) {
>         try {
>           boolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS);
>           if (!acquired) {
>             throw new CacheException("Couldn't get a lock in " + timeout + " for the key " +  key + " at the cache " + delegate.getId());
>           }
>         } catch (InterruptedException e) {
>           throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e);
>         }
>       } else {
>         // 锁住
>         lock.lock();
>       }
>     }
>     
>     /**
>      * 释放某个对象的锁
>      * @param key 被锁的对象
>      */
>     private void releaseLock(Object key) {
>       // 找出指定对象的锁
>       ReentrantLock lock = locks.get(key);
>       if (lock.isHeldByCurrentThread()) {
>         // 解锁
>         lock.unlock();
>       }
>     }
> 
>     /**
>      * 向缓存写入一条信息
>      * @param key 信息的键
>      * @param value 信息的值
>      */
>     @Override
>     public void putObject(Object key, Object value) {
>       try {
>         // 向缓存中放入数据
>         delegate.putObject(key, value);
>       } finally {
>         // 因为已经放入了数据，因此释放锁
>         releaseLock(key);
>       }
>     }
>     
>     /**
>      * 从缓存中读取一条信息
>      * @param key 信息的键
>      * @return 信息的值
>      */
>     @Override
>     public Object getObject(Object key) {
>       // 获取锁
>       acquireLock(key);
>       // 读取结果
>       Object value = delegate.getObject(key);
>       if (value != null) {
>         // 读取到结果后释放锁
>         releaseLock(key);
>       }
>       // 如果缓存中没有读到结果，则不会释放锁。对应的锁会在从数据库读取了结果并写入到缓存后，在putObject中释放。
>     
>       // 返回查询到的缓存结果
>       return value;
>     }
> 
> \}

可以看出每一条记录的键都有一个对应的锁，所以阻塞装饰器锁住的不是整个缓存，而是缓存中的某条记录。

5.定时清理装饰器：ScheduledCache类，为缓存增加定时刷新功能

可以按照一定的时间间隔来清理缓存中的数据，即调用clear方法。

>     public class ScheduledCache implements Cache {
>     
>       // 被装饰的对象
>       private final 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();
>       }
> 
>     @Override
>     public void putObject(Object key, Object object) {
>       clearWhenStale();
>       delegate.putObject(key, object);
>     }
>     
>     @Override
>     public Object getObject(Object key) {
>       return clearWhenStale() ? null : delegate.getObject(key);
>     }
>     
>     @Override
>     public Object removeObject(Object key) {
>       clearWhenStale();
>       return delegate.removeObject(key);
>     }
> 
>     /**
>      * 根据清理时间间隔设置清理缓存
>      * @return 是否发生了缓存清理
>      */
>     private boolean clearWhenStale() {
>       if (System.currentTimeMillis() - lastClear > clearInterval) {
>         clear();
>         return true;
>       }
>       return false;
>     }
> 
> \}

可以看出定时清理功能并非是实时的，即使是时间间隔到了，但putObject，getObject，removeObject等方法没有被调用，则clearWhenStale方法也不会被触发，也不会发生缓存清理操作。这种非实时的设计比较值得参考，因为实时操作需要增加单独的计时线程，会消耗大量的资源，而这种非实时的方式节约了资源，同时也不会造成太大的误差。

6.序列化装饰器：SerializedCache，为缓存增加序列化功能

每次向缓存中写入对象时，实际写入的是对象的序列化串；而每次读取对象时会将序列化串反序列化后再返回，通过序列化和反序列化过程保证了每一次缓存给出的对象都是一个全新的对象，对该对象的修改不会影响缓存中的对象，前提是被缓存的数据必须是可序列化的，否则会抛出异常。

>     public class SerializedCache implements Cache {
>     
>       private final Cache delegate;
> 
>     /**
>      * 向缓存写入一条信息
>      * @param key 信息的键
>      * @param object 信息的值
>      */
>     @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);
>       }
>     }
>     
>     /**
>      * 从缓存中读取一条信息
>      * @param key 信息的键
>      * @return 信息的值
>      */
>     @Override
>     public Object getObject(Object key) {
>       // 读取缓存中的序列化串
>       Object object = delegate.getObject(key);
>       // 反序列化后返回
>       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();
>         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();
>       } catch (Exception e) {
>         throw new CacheException("Error deserializing object.  Cause: " + e, e);
>       }
>       return result;
>     }
> 
> \}

7.事务装饰器：TransactionalCache类， 为缓存增加支持事务的操作

事务操作中产生的数据需要在事务提交时写入缓存，在事务回滚时直接销毁。

>     public class TransactionalCache implements Cache {
>     
>       private static final Log log = LogFactory.getLog(TransactionalCache.class);
>     
>       // 被装饰的对象
>       private final Cache delegate;
>       // 事务提交后是否直接清理缓存
>       private boolean clearOnCommit;
>       // 事务提交时需要写入缓存的数据
>       private final Map<Object, Object> entriesToAddOnCommit;
>       // 缓存查询未命中的数据
>       private final Set<Object> entriesMissedInCache;
> 
>     /**
>      * 从缓存中读取一条信息
>      * @param key 信息的键
>      * @return 信息的值
>      */
>     @Override
>     public Object getObject(Object key) {
>       // 从缓存中读取对应的数据
>       Object object = delegate.getObject(key);
>       if (object == null) { // 缓存未命中
>         // 记录该缓存未命中
>         entriesMissedInCache.add(key);
>       }
>       if (clearOnCommit) { // 如果设置了提交时立马清除，则直接返回null
>         return null;
>       } else {
>         // 返回查询的结果
>         return object;
>       }
>     }
>     
>     /**
>      * 向缓存写入一条信息
>      * @param key 信息的键
>      * @param object 信息的值
>      */
>     @Override
>     public void putObject(Object key, Object object) {
>       // 先放入到entriesToAddOnCommit列表中暂存
>       entriesToAddOnCommit.put(key, object);
>     }
> 
>     /**
>      * 提交事务
>      */
>     public void commit() {
>       if (clearOnCommit) { // 如果设置了事务提交后清理缓存
>         // 清理缓存
>         delegate.clear();
>       }
>       // 将为写入缓存的操作写入缓存
>       flushPendingEntries();
>       // 清理环境
>       reset();
>     }
>     
>     /**
>      * 回滚事务
>      */
>     public void rollback() {
>       // 删除缓存未命中的数据
>       unlockMissedEntries();
>       reset();
>     }
>     
>     /**
>      * 清理环境
>      */
>     private void reset() {
>       clearOnCommit = false;
>       entriesToAddOnCommit.clear();
>       entriesMissedInCache.clear();
>     }
>     
>     /**
>      * 将未写入缓存的数据写入缓存
>      */
>     private void flushPendingEntries() {
>       // 将entriesToAddOnCommit中的数据写入缓存
>       for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
>         delegate.putObject(entry.getKey(), entry.getValue());
>       }
>       // 将entriesMissedInCache中的数据写入缓存
>       for (Object entry : entriesMissedInCache) {
>         if (!entriesToAddOnCommit.containsKey(entry)) {
>           delegate.putObject(entry, null);
>         }
>       }
>     }
>     
>     /**
>      * 删除缓存未命中的数据
>      */
>     private void unlockMissedEntries() {
>       for (Object entry : entriesMissedInCache) {
>         try {
>           delegate.removeObject(entry);
>         } catch (Exception e) {
>           log.warn("Unexpected exception while notifiying a rollback to the cache adapter."
>               + "Consider upgrading your cache adapter to the latest version.  Cause: " + e);
>         }
>       }
>     }
> 
> \}

[20201220181343595.png]: /images/20221120/4f697274d4f5443baab6ce98eeb292e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTIyMDQ3Mg_size_16_color_FFFFFF_t_70]: /images/20221120/3ac7a1d0d85c4aa08de9b54eee959cf3.png