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

<dependency>
    <groupId>javax.cache</groupId>
    <artifactId>cache-api</artifactId>
    <version>1.1.1</version>
</dependency>

// pring's central cache manager SPI.  它是个SPI接口
// @since 3.1
public interface CacheManager {
	@Nullable
	Cache getCache(String name);
	// 管理的所有的Cache的names~
	Collection<String> getCacheNames();
}

// @since 3.1 实现了InitializingBean接口~~
public abstract class AbstractCacheManager implements CacheManager, InitializingBean {
	
	// 保存着所有的Cache对象~~key为名字
	private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<>(16);	
	//  此处使用了volatile 关键字
	private volatile Set<String> cacheNames = Collections.emptySet();

	@Override
	public void afterPropertiesSet() {
		initializeCaches();
	}

	// @since 4.2.2  模版方法模式。   abstract方法loadCaches()交给子类实现~~~
	public void initializeCaches() {
		Collection<? extends Cache> caches = loadCaches();

		synchronized (this.cacheMap) {
			this.cacheNames = Collections.emptySet();
			this.cacheMap.clear();
			Set<String> cacheNames = new LinkedHashSet<>(caches.size());
			for (Cache cache : caches) {
				String name = cache.getName();
				// decorateCache是protected方法，交给子类  不复写也无所谓~~~
				this.cacheMap.put(name, decorateCache(cache));
				cacheNames.add(name);
			}
			// cacheNames是个只读视图~（框架设计中考虑读写特性~）
			this.cacheNames = Collections.unmodifiableSet(cacheNames);
		}
	}

	protected abstract Collection<? extends Cache> loadCaches();

	// 根据名称 获取Cache对象。若没有，就返回null
	@Override
	@Nullable
	public Cache getCache(String name) {
		Cache cache = this.cacheMap.get(name);
		if (cache != null) {
			return cache;
		} else {
			// Fully synchronize now for missing cache creation...
			synchronized (this.cacheMap) {
				cache = this.cacheMap.get(name);
				if (cache == null) {
					// getMissingCache默认直接返回null，交给子类复写~~~~
					// 将决定权交给实现者，你可以创建一个Cache，或者记录日志
					cache = getMissingCache(name);
					// cache  != null，主要靠getMissingCache这个方法了~~~向一个工厂一样创建一个新的~~~
					if (cache != null) {
						cache = decorateCache(cache);
						this.cacheMap.put(name, cache);
						// 向全局缓存里面再添加进去一个Cache~~~~
						updateCacheNames(name);
					}
				}
				return cache;
			}
		}
	}

	@Override
	public Collection<String> getCacheNames() {
		return this.cacheNames;
	}

	// @since 4.1
	protected final Cache lookupCache(String name) {
		return this.cacheMap.get(name);
	}
	...
}

// @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();
	}
}

// @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
    }