聊聊Spring Cache的缓存抽象与JSR107缓存抽象JCache，并使用API方式使用Spring Cache【享学Spring】（下）

// @since 4.2.2 出现得还是挺晚的~~~
public abstract class AbstractValueAdaptingCache implements Cache {
  private final boolean allowNullValues;
  protected AbstractValueAdaptingCache(boolean allowNullValues) {
    this.allowNullValues = allowNullValues;
  }
  // lookup为抽象方法
  @Override
  @Nullable
  public ValueWrapper get(Object key) {
    Object value = lookup(key);
    return toValueWrapper(value);
  }
  @Nullable
  protected abstract Object lookup(Object key);
  // lookup出来的value继续交给fromStoreValue()处理~  其实就是对null值进行了处理
  // 若是null值就返回null,而不是具体的值了~~~
  @Override
  @SuppressWarnings("unchecked")
  @Nullable
  public <T> T get(Object key, @Nullable Class<T> type) {
    Object value = fromStoreValue(lookup(key));
    if (value != null && type != null && !type.isInstance(value)) {
      throw new IllegalStateException("Cached value is not of required type [" + type.getName() + "]: " + value);
    }
    return (T) value;
  }
  // 它是protected 方法  子类有复写
  @Nullable
  protected Object fromStoreValue(@Nullable Object storeValue) {
    if (this.allowNullValues && storeValue == NullValue.INSTANCE) {
      return null;
    }
    return storeValue;
  }
  // 提供给子类使用的方法，对null值进行转换~  子类有复写
  protected Object toStoreValue(@Nullable Object userValue) {
    if (userValue == null) {
      if (this.allowNullValues) {
        return NullValue.INSTANCE;
      }
      throw new IllegalArgumentException("Cache '" + getName() + "' is configured to not allow null values but null was provided");
    }
    return userValue;
  }
  // 把value进行了一层包装为SimpleValueWrapper
  @Nullable
  protected Cache.ValueWrapper toValueWrapper(@Nullable Object storeValue) {
    return (storeValue != null ? new SimpleValueWrapper(fromStoreValue(storeValue)) : null);
  }
}

public class ConcurrentMapCache extends AbstractValueAdaptingCache {
  private final String name;
  // 底层存储就是个java.util.concurrent.ConcurrentMap~~
  private final ConcurrentMap<Object, Object> store;
  ...
  // 本处只写出这个最全的构造器  它是protected 的，其它的构造器是public的
  // 说白了serialization这个类不允许外部知道，子类知道即可~~~
  protected ConcurrentMapCache(String name, ConcurrentMap<Object, Object> store, boolean allowNullValues, @Nullable SerializationDelegate serialization) {
    super(allowNullValues);
    Assert.notNull(name, "Name must not be null");
    Assert.notNull(store, "Store must not be null");
    this.name = name;
    this.store = store;
    this.serialization = serialization;
  }
  // 显然只有指定了序列化器，才有可能true：存储副本
  public final boolean isStoreByValue() {
    return (this.serialization != null);
  }
  ...
  @Override
  public final ConcurrentMap<Object, Object> getNativeCache() {
    return this.store;
  }
  // 这是父类的抽象方法
  @Override
  @Nullable
  protected Object lookup(Object key) {
    return this.store.get(key);
  }
  @Override
  @Nullable
  public <T> T get(Object key, Callable<T> valueLoader) {
    return (T) fromStoreValue(this.store.computeIfAbsent(key, r -> {
      try {
        return toStoreValue(valueLoader.call());
      } catch (Throwable ex) {
        throw new ValueRetrievalException(key, valueLoader, ex);
      }
    }));
  }
  @Override
  public void put(Object key, @Nullable Object value) {
    this.store.put(key, toStoreValue(value));
  }
  @Override
  @Nullable
  public ValueWrapper putIfAbsent(Object key, @Nullable Object value) {
    Object existing = this.store.putIfAbsent(key, toStoreValue(value));
    return toValueWrapper(existing);
  }
  @Override
  public void evict(Object key) {
    this.store.remove(key);
  }
  @Override
  public void clear() {
    this.store.clear();
  }
  ...
}

    public static void main(String[] args) {
        CacheManager cacheManager = new ConcurrentMapCacheManager(); //使用ConcurrentMapCacheManager可以不用初始化指定，可以get的时候动态创建Cache
        //CacheManager cacheManager = new ConcurrentMapCacheManager("car");
    // 即使我们上面没有放进去名字为car的Cache，此处也会帮我们自动生成~~~
        Cache carCache = cacheManager.getCache("car");
        // 向缓存里加数据
        carCache.put("benz", "奔驰");
        carCache.put("bmw", "宝马");
        carCache.put("audi", "奥迪");
        System.out.println(carCache.getClass()); //class org.springframework.cache.concurrent.ConcurrentMapCache
        // 从缓存里获取数据 
        System.out.println(carCache.get("benz").get()); //奔驰
        System.out.println(carCache.get("benz", String.class)); //奔驰
    }

    public static void main(String[] args) {
        CacheManager cacheManager = new SimpleCacheManager();
        Cache car = cacheManager.getCache("car");
        System.out.println(car); //null
    }

    public static void main(String[] args) {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        ConcurrentMapCache carMapCache = new ConcurrentMapCache("car");
        cacheManager.setCaches(Collections.singleton(carMapCache));
        cacheManager.afterPropertiesSet(); // 这一步是必须的
        Cache car = cacheManager.getCache("car");
        System.out.println(car); //org.springframework.cache.concurrent.ConcurrentMapCache@19469ea2
    }