• Spring Cache缓存原理与Redis实践

    说到Spring Boot缓存，那就不得不提JSR-107规范，它告诉我们在Java中如何规范地使用缓存。

    JSR是Java Specification Requests的简称，通常译为”Java 规范提案“。具体而言，是指向JCP(Java Community Process，Java标准制定组织)提出新增一个标准化技术规范的正式请求。任何人都可以提交JSR，通过一定的标准测试后，就可以向Java平台增添新的API和服务。JSR已成为Java界的一个重要标准。

    JSR-107规范即JCache API，JCache规范定义了一种对Java对象临时在内存中进行缓存的方法，包括对象的创建、共享访问、假脱机（spooling）、失效、各JVM的一致性等，可被用于缓存JSP内最经常读取的数据，如产品目录和价格列表。利用JCache的缓存数据，可以加快大多数查询的反应时间（内部测试表明反应时间大约快15倍）。

    一、JCache

    在Spring Boot中使用缓存之前，我们有必要了解一下JCache。JCache定义了五个核心接口，分别是CachingProvider，CacheManager，Cache，Entry和Expiry。

    • 一个CachingProvider可以创建和管理多个CacheManager，并且一个CacheManager只能被一个CachingProvider所拥有，而一个应用可以在运行期间访问多个CachingProvider。

    • 一个CacheManager可以创建和管理多个唯一命名的Cache，且一个Cache只能被一个CacheManager所拥有，这些Cache存在于CacheManager的上下文中。

    • Cache是一个类似Map的数据结构

    • Entry是一个存储在Cache中的key-value对

    • Expiry是指存储在Cache中的Entry的有效期，一旦超过这个时间，Entry将处于过期状态，即不可访问、更新和删除。缓存有效期可以通过ExpiryPolicy设置。

      image

     

    二、Spring Cache原理

    Spring 3.1开始，引入了Spring Cache，即Spring 缓存抽象。通过定义org.springframework.cache.Cache和org.springframework.cache.CacheManager接口来统一不同的缓存技术，并支持使用JCache注解简化开发过程。

    Cache接口为缓存的组件规范定义，包含缓存的各种操作集合。Spring中为Cache接口提供了各种xxxCache的实现：RedisCache，EhCacheCache，ConcurrentMapCache等。
    我们通过部分源码详细了解一下Cache接口和CacheManager接口。

    Cache接口

    1. public interface Cache {
    2.     //Cache名称
    3.     String getName();
    4.  
    5.     //Cache负责缓存的对象
    6.     Object getNativeCache();
    7.  
    8.     /**
    9.      * 获取key对应的ValueWrapper
    10.      * 没有对应的key，则返回null
    11.      * key对应的value是null，则返回null对应的ValueWrapper
    12.      */
    13.     @Nullable
    14.     Cache.ValueWrapper get(Object key);
    15.  
    16.     //返回key对应type类型的value
    17.     @Nullable
    18.      T get(Object key, @Nullable Class type);
    19.  
    20.     //返回key对应的value，没有则缓存Callable::call，并返回
    21.     @Nullable
    22.      T get(Object key, Callable valueLoader);
    23.  
    24.     //缓存目标key-value（替换旧值），不保证实时性
    25.     void put(Object key, @Nullable Object value);
    26.  
    27.     //插入缓存，并返回该key对应的value；先调用get，不存在则用put实现
    28.     @Nullable
    29.     default Cache.ValueWrapper putIfAbsent(Object key, @Nullable Object value) {
    30.         Cache.ValueWrapper existingValue = this.get(key);
    31.         if (existingValue == null) {
    32.             this.put(key, value);
    33.         }
    34.  
    35.         return existingValue;
    36.     }
    37.  
    38.     //删除缓存，不保证实时性
    39.     void evict(Object key);
    40.  
    41.     //立即删除缓存：返回false表示剔除前不存在制定key活不确定是否存在；返回true，表示该key之前存在
    42.     default boolean evictIfPresent(Object key) {
    43.         this.evict(key);
    44.         return false;
    45.     }
    46.  
    47.     //清除所有缓存，不保证实时性
    48.     void clear();
    49.  
    50.     //立即清楚所有缓存，返回false表示清除前没有缓存或不能确定是否有；返回true表示清除前有缓存
    51.     default boolean invalidate() {
    52.         this.clear();
    53.         return false;
    54.     }
    55.  
    56.     public static class ValueRetrievalException extends RuntimeException {
    57.         @Nullable
    58.         private final Object key;
    59.  
    60.         public ValueRetrievalException(@Nullable Object key, Callable loader, Throwable ex) {
    61.             super(String.format("Value for key '%s' could not be loaded using '%s'", key, loader), ex);
    62.             this.key = key;
    63.         }
    64.  
    65.         @Nullable
    66.         public Object getKey() {
    67.             return this.key;
    68.         }
    69.     }
    70.  
    71.     //缓存值的一个包装器接口，实现类为SimpleValueWrapper
    72.     @FunctionalInterface
    73.     public interface ValueWrapper {
    74.         @Nullable
    75.         Object get();
    76.     }
    77. }

    可以看出，Cache接口抽象了缓存的 get put evict 等相关操作。

    AbstractValueAdaptingCache

    1. public abstract class AbstractValueAdaptingCache implements Cache {
    2.  
    3.     //是否允许Null值
    4.     private final boolean allowNullValues;
    5.  
    6.     protected AbstractValueAdaptingCache(boolean allowNullValues) {
    7.         this.allowNullValues = allowNullValues;
    8.     }
    9.  
    10.     public final boolean isAllowNullValues() {
    11.         return this.allowNullValues;
    12.     }
    13.  
    14.     @Nullable
    15.     public ValueWrapper get(Object key) {
    16.         return this.toValueWrapper(this.lookup(key));
    17.     }
    18.  
    19.     @Nullable
    20.     public  T get(Object key, @Nullable Class type) {
    21.         //查询到的缓存值做fromStoreValue转换
    22.         Object value = this.fromStoreValue(this.lookup(key));
    23.         //转换后非null值且无法转换为type类型则抛出异常
    24.         if (value != null && type != null && !type.isInstance(value)) {
    25.             throw new IllegalStateException("Cached value is not of required type [" + type.getName() + "]: " + value);
    26.         } else {
    27.             return value;
    28.         }
    29.     }
    30.  
    31.     //从缓存中获取key对应的value，子类实现
    32.     @Nullable
    33.     protected abstract Object lookup(Object key);
    34.  
    35.     //对于从缓存中获取的值，允许为空且值为NullValue时，处理为null
    36.     @Nullable
    37.     protected Object fromStoreValue(@Nullable Object storeValue) {
    38.         return this.allowNullValues && storeValue == NullValue.INSTANCE ? null : storeValue;
    39.     }
    40.  
    41.     //对于要插入缓存的null值，在允许null值的情况下处理为NullValue；否则抛出异常IllegalArgumentException
    42.     protected Object toStoreValue(@Nullable Object userValue) {
    43.         if (userValue == null) {
    44.             if (this.allowNullValues) {
    45.                 return NullValue.INSTANCE;
    46.             } else {
    47.                 throw new IllegalArgumentException("Cache '" + this.getName() + "' is configured to not allow null values but null was provided");
    48.             }
    49.         } else {
    50.             return userValue;
    51.         }
    52.     }
    53.  
    54.     //get操作依据，查询到缓存值非null，则fromStoreValue转换后包装成SimpleValueWrapper返回
    55.     @Nullable
    56.     protected ValueWrapper toValueWrapper(@Nullable Object storeValue) {
    57.         return storeValue != null ? new SimpleValueWrapper(this.fromStoreValue(storeValue)) : null;
    58.     }
    59. }

    抽象类AbstractValueAdaptingCache实现了Cache接口，主要抽象了对NULL值的处理逻辑。

    • allowNullValues属性表示是否允许处理NULL值的缓存

    • fromStoreValue方法处理NULL值的get操作，在属性allowNullValues为true的情况下，将NullValue处理为NULL

    • toStoreValue方法处理NULL值得put操作，在属性allowNullValues为true的情况下，将NULL处理为NullValue，否则抛出异常

    • toValueWrapper方法提供Cache接口中get方法的默认实现，从缓存中读取值，再通过fromStoreValue转化，最后包装为SimpleValueWrapper返回

    • ValueWrapper get(Object key)和T get(Object key, @Nullable Classtype)方法基于上述方法实现

    • ValueWrapper get(Object key)和@Nullable Classtype)方法基于上述方法实现

    • lookup抽象方法用于给子类获取真正的缓存值

    ConcurrentMapCache

    1. public class ConcurrentMapCache extends AbstractValueAdaptingCache {
    2.     private final String name;
    3.     //定义ConcurrentMap缓存
    4.     private final ConcurrentMap store;
    5.     //如果要缓存的是值对象的copy，则由此序列化代理类处理
    6.     @Nullable
    7.     private final SerializationDelegate serialization;
    8.  
    9.     public ConcurrentMapCache(String name) {
    10.         this(name, new ConcurrentHashMap(256), true);
    11.     }
    12.  
    13.     //默认允许处理null
    14.     public ConcurrentMapCache(String name, boolean allowNullValues) {
    15.         this(name, new ConcurrentHashMap(256), allowNullValues);
    16.     }
    17.  
    18.     //默认serialization = null
    19.     public ConcurrentMapCache(String name, ConcurrentMap store, boolean allowNullValues) {
    20.         this(name, store, allowNullValues, (SerializationDelegate)null);
    21.     }
    22.  
    23.     protected ConcurrentMapCache(String name, ConcurrentMap store, boolean allowNullValues, @Nullable SerializationDelegate serialization) {
    24.         super(allowNullValues);
    25.         Assert.notNull(name, "Name must not be null");
    26.         Assert.notNull(store, "Store must not be null");
    27.         this.name = name;
    28.         this.store = store;
    29.         this.serialization = serialization;
    30.     }
    31.  
    32.     //serialization不为空，缓存值对象的copy
    33.     public final boolean isStoreByValue() {
    34.         return this.serialization != null;
    35.     }
    36.  
    37.     public final String getName() {
    38.         return this.name;
    39.     }
    40.  
    41.     public final ConcurrentMap getNativeCache() {
    42.         return this.store;
    43.     }
    44.  
    45.     //实现lookup：store#get
    46.     @Nullable
    47.     protected Object lookup(Object key) {
    48.         return this.store.get(key);
    49.     }
    50.  
    51.     //基于ConcurrentMap::computeIfAbsent方法实现；get和put的值由fromStoreValue和toStoreValue处理Null
    52.     @Nullable
    53.     public  T get(Object key, Callable valueLoader) {
    54.         return this.fromStoreValue(this.store.computeIfAbsent(key, (k) -> {
    55.             try {
    56.                 return this.toStoreValue(valueLoader.call());
    57.             } catch (Throwable var5) {
    58.                 throw new ValueRetrievalException(key, valueLoader, var5);
    59.             }
    60.         }));
    61.     }
    62.  
    63.     public void put(Object key, @Nullable Object value) {
    64.         this.store.put(key, this.toStoreValue(value));
    65.     }
    66.  
    67.     @Nullable
    68.     public ValueWrapper putIfAbsent(Object key, @Nullable Object value) {
    69.         Object existing = this.store.putIfAbsent(key, this.toStoreValue(value));
    70.         return this.toValueWrapper(existing);
    71.     }
    72.  
    73.     public void evict(Object key) {
    74.         this.store.remove(key);
    75.     }
    76.  
    77.     public boolean evictIfPresent(Object key) {
    78.         return this.store.remove(key) != null;
    79.     }
    80.  
    81.     public void clear() {
    82.         this.store.clear();
    83.     }
    84.  
    85.     public boolean invalidate() {
    86.         boolean notEmpty = !this.store.isEmpty();
    87.         this.store.clear();
    88.         return notEmpty;
    89.     }
    90.  
    91.     protected Object toStoreValue(@Nullable Object userValue) {
    92.         Object storeValue = super.toStoreValue(userValue);
    93.         if (this.serialization != null) {
    94.             try {
    95.                 return this.serialization.serializeToByteArray(storeValue);
    96.             } catch (Throwable var4) {
    97.                 throw new IllegalArgumentException("Failed to serialize cache value '" + userValue + "'. Does it implement Serializable?", var4);
    98.             }
    99.         } else {
    100.             return storeValue;
    101.         }
    102.     }
    103.  
    104.     protected Object fromStoreValue(@Nullable Object storeValue) {
    105.         if (storeValue != null && this.serialization != null) {
    106.             try {
    107.                 return super.fromStoreValue(this.serialization.deserializeFromByteArray((byte[])((byte[])storeValue)));
    108.             } catch (Throwable var3) {
    109.                 throw new IllegalArgumentException("Failed to deserialize cache value '" + storeValue + "'", var3);
    110.             }
    111.         } else {
    112.             return super.fromStoreValue(storeValue);
    113.         }
    114.     }
    115. }

    ConcurrentMapCache继承了抽象类AbstractValueAdaptingCache，是Spring的默认缓存实现。它支持对缓存对象copy的缓存，由SerializationDelegate serialization 处理序列化，默认为 null 即基于引用的缓存。缓存相关操作基于基类 AbstractValueAdaptingCache 的 null 值处理，默认允许为 null。

    CacheManager

    1. public interface CacheManager {
    2.     @Nullable
    3.     //获取指定name的Cache，可能延迟创建
    4.     Cache getCache(String name);
    5.  
    6.     //获取当前CacheManager下的Cache name集合
    7.     Collection getCacheNames();
    8. }

    CacheManager 基于 name 管理一组 Cache。当然，CacheManager也有很多实现类，如ConcurrentMapCacheManager、AbstractCacheManager及SimpleCacheManager，这些xxxCacheManager类都是为了制定Cache的管理规则，这里就不再深入探讨了。

    三、Spring Cache实践

    除了第二章中提到的Cache接口和CacheManager接口，在使用Spring 缓存抽象时，我们还会用到一些JCache注解。

     

     

  • 相关阅读:
    一片编程文章
    深度学习图像分割标签onehot
    A股风格因子看板 (2023.09 第03期)
    java计算机毕业设计教务管理系统源码+数据库+lw文档+系统
    Nacos做配置中心使用
    【计算机视觉40例】案例25：风格迁移
    【Redis使用】一年多来redis使用笔记md文档，第（2）篇：命令和数据库操作
    低代码在企业数字化转型中有什么价值？
    No converter found for return value of type: class
    力扣26--删除有序数组中的重复项
  • 原文地址：https://blog.csdn.net/m0_71777195/article/details/126225712