Java tutorial
/* * Copyright 2002-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * https://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.cache.concurrent; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import org.springframework.beans.factory.BeanClassLoaderAware; import org.springframework.cache.Cache; import org.springframework.cache.CacheManager; import org.springframework.core.serializer.support.SerializationDelegate; import org.springframework.lang.Nullable; /** * {@link CacheManager} implementation that lazily builds {@link ConcurrentMapCache} * instances for each {@link #getCache} request. Also supports a 'static' mode where * the set of cache names is pre-defined through {@link #setCacheNames}, with no * dynamic creation of further cache regions at runtime. * * <p>Note: This is by no means a sophisticated CacheManager; it comes with no * cache configuration options. However, it may be useful for testing or simple * caching scenarios. For advanced local caching needs, consider * {@link org.springframework.cache.jcache.JCacheCacheManager}, * {@link org.springframework.cache.ehcache.EhCacheCacheManager}, * {@link org.springframework.cache.caffeine.CaffeineCacheManager}. * * @author Juergen Hoeller * @since 3.1 * @see ConcurrentMapCache */ public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware { private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<>(16); private boolean dynamic = true; private boolean allowNullValues = true; private boolean storeByValue = false; @Nullable private SerializationDelegate serialization; /** * Construct a dynamic ConcurrentMapCacheManager, * lazily creating cache instances as they are being requested. */ public ConcurrentMapCacheManager() { } /** * Construct a static ConcurrentMapCacheManager, * managing caches for the specified cache names only. */ public ConcurrentMapCacheManager(String... cacheNames) { setCacheNames(Arrays.asList(cacheNames)); } /** * Specify the set of cache names for this CacheManager's 'static' mode. * <p>The number of caches and their names will be fixed after a call to this method, * with no creation of further cache regions at runtime. * <p>Calling this with a {@code null} collection argument resets the * mode to 'dynamic', allowing for further creation of caches again. */ 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; } } /** * Specify whether to accept and convert {@code null} values for all caches * in this cache manager. * <p>Default is "true", despite ConcurrentHashMap itself not supporting {@code null} * values. An internal holder object will be used to store user-level {@code null}s. * <p>Note: A change of the null-value setting will reset all existing caches, * if any, to reconfigure them with the new null-value requirement. */ public void setAllowNullValues(boolean allowNullValues) { if (allowNullValues != this.allowNullValues) { this.allowNullValues = allowNullValues; // Need to recreate all Cache instances with the new null-value configuration... recreateCaches(); } } /** * Return whether this cache manager accepts and converts {@code null} values * for all of its caches. */ public boolean isAllowNullValues() { return this.allowNullValues; } /** * Specify whether this cache manager stores a copy of each entry ({@code true} * or the reference ({@code false} for all of its caches. * <p>Default is "false" so that the value itself is stored and no serializable * contract is required on cached values. * <p>Note: A change of the store-by-value setting will reset all existing caches, * if any, to reconfigure them with the new store-by-value requirement. * @since 4.3 */ public void setStoreByValue(boolean storeByValue) { if (storeByValue != this.storeByValue) { this.storeByValue = storeByValue; // Need to recreate all Cache instances with the new store-by-value configuration... recreateCaches(); } } /** * Return whether this cache manager stores a copy of each entry or * a reference for all its caches. If store by value is enabled, any * cache entry must be serializable. * @since 4.3 */ public boolean isStoreByValue() { return this.storeByValue; } @Override public void setBeanClassLoader(ClassLoader classLoader) { this.serialization = new SerializationDelegate(classLoader); // Need to recreate all Cache instances with new ClassLoader in store-by-value mode... if (isStoreByValue()) { recreateCaches(); } } @Override public Collection<String> getCacheNames() { return Collections.unmodifiableSet(this.cacheMap.keySet()); } @Override @Nullable public Cache getCache(String name) { Cache cache = this.cacheMap.get(name); 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; } private void recreateCaches() { for (Map.Entry<String, Cache> entry : this.cacheMap.entrySet()) { entry.setValue(createConcurrentMapCache(entry.getKey())); } } /** * Create a new ConcurrentMapCache instance for the specified cache name. * @param name the name of the cache * @return the ConcurrentMapCache (or a decorator thereof) */ protected Cache createConcurrentMapCache(String name) { SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null); return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256), isAllowNullValues(), actualSerialization); } }