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

// @since 3.1
public class SimpleCacheManager extends AbstractCacheManager {
  private Collection<? extends Cache> caches = Collections.emptySet();
  public void setCaches(Collection<? extends Cache> caches) {
    this.caches = caches;
  }
  @Override
  protected Collection<? extends Cache> loadCaches() {
    return this.caches;
  }
}

// @since 3.1
public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware {
  private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<>(16);
  // true表示：若为null，就新创建一个缓存添加进去
  private boolean dynamic = true;
  // 是否允许value为null
  private boolean allowNullValues = true;
  // 指定此缓存管理器是存储每个条目的副本，还是存储其所有缓存的引用
  // 影响到ConcurrentMapCache对value值的存储~~~
  // false表示：存储它自己（引用）
  // true表示：存储一个副本（对序列化有要求~~~） 很少这么使用~~~
  private boolean storeByValue = false;
  public ConcurrentMapCacheManager() {
  }
  public ConcurrentMapCacheManager(String... cacheNames) {
    setCacheNames(Arrays.asList(cacheNames));
  }
  public void setCacheNames(@Nullable Collection<String> cacheNames) {
    if (cacheNames != null) {
      for (String name : cacheNames) {
        this.cacheMap.put(name, createConcurrentMapCache(name));
      }
      this.dynamic = false; // 手动设置了，就不允许在动态创建了
    } else {
      this.dynamic = true;
    }
  }
  protected Cache createConcurrentMapCache(String name) {
    // isStoreByValue=true需要存储值的副本的时候，才对序列化有要求~~~否则直接存引用即可
    SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
    return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256), isAllowNullValues(), actualSerialization);
  }
  @Override
  public void setBeanClassLoader(ClassLoader classLoader) {
    this.serialization = new SerializationDelegate(classLoader);
    if (isStoreByValue()) {
      // 重新创建Cache 因为要副本嘛
      recreateCaches();
    }
  }
  private void recreateCaches() {
    for (Map.Entry<String, Cache> entry : this.cacheMap.entrySet()) {
      entry.setValue(createConcurrentMapCache(entry.getKey()));
    }
  }
  @Override
  @Nullable
  public Cache getCache(String name) {
    Cache cache = this.cacheMap.get(name);
    // dynamic=true  为null的时候会动态创建一个
    if (cache == null && this.dynamic) {
      synchronized (this.cacheMap) {
        cache = this.cacheMap.get(name);
        if (cache == null) {
          cache = createConcurrentMapCache(name);
          this.cacheMap.put(name, cache);
        }
      }
    }
    return cache;
  }
  @Override
  public Collection<String> getCacheNames() {
    return Collections.unmodifiableSet(this.cacheMap.keySet());
  }
  ...
}

// @since 3.1  
public class CompositeCacheManager implements CacheManager, InitializingBean {
  // 内部聚合管理着一批CacheManager
  private final List<CacheManager> cacheManagers = new ArrayList<>();
  // 若这个为true，则可以结合NoOpCacheManager实现效果~~~
  private boolean fallbackToNoOpCache = false;
  public CompositeCacheManager() {
  }
  public CompositeCacheManager(CacheManager... cacheManagers) {
    setCacheManagers(Arrays.asList(cacheManagers));
  }
  // 也可以调用此方法，来自己往里面添加（注意是添加）CacheManager们
  public void setCacheManagers(Collection<CacheManager> cacheManagers) {
    this.cacheManagers.addAll(cacheManagers);
  }
  public void setFallbackToNoOpCache(boolean fallbackToNoOpCache) {
    this.fallbackToNoOpCache = fallbackToNoOpCache;
  }
  // 如果fallbackToNoOpCache=true，那么在这个Bean初始化完成后，也就是在末尾添加一个NoOpCacheManager
  // 当然fallbackToNoOpCache默认值是false
  @Override
  public void afterPropertiesSet() {
    if (this.fallbackToNoOpCache) {
      this.cacheManagers.add(new NoOpCacheManager());
    }
  }
  // 找到一个cache不为null的就return了~
  @Override
  @Nullable
  public Cache getCache(String name) {
    for (CacheManager cacheManager : this.cacheManagers) {
      Cache cache = cacheManager.getCache(name);
      if (cache != null) {
        return cache;
      }
    }
    return null;
  }
  // 可以看到返回的是所有names，并且用的set
  @Override
  public Collection<String> getCacheNames() {
    Set<String> names = new LinkedHashSet<>();
    for (CacheManager manager : this.cacheManagers) {
      names.addAll(manager.getCacheNames());
    }
    return Collections.unmodifiableSet(names);
  }
}

public interface Cache {
  String getName();
  // 返回本地存储的那个。比如ConcurrentMapCache本地就是用的一个ConcurrentMap
  Object getNativeCache();
  // 就是用下面的ValueWrapper把值包装了一下而已~
  @Nullable
  ValueWrapper get(Object key);
  @Nullable
  <T> T get(Object key, @Nullable Class<T> type);
  @Nullable
  <T> T get(Object key, Callable<T> valueLoader);
  void put(Object key, @Nullable Object value);
  // @since 4.1
  // 不存在旧值直接put就先去了返回null，否则返回旧值（并且不会把新值put进去）
  @Nullable
  ValueWrapper putIfAbsent(Object key, @Nullable Object value);
  // 删除
  void evict(Object key);
  // 清空
  void clear();
  @FunctionalInterface
  interface ValueWrapper {
    @Nullable
    Object get();
  }
}