【1】CacheAutoConfiguration
在SpringBoot中,Cache的自动配置类,源码如下。
/** * {@link EnableAutoConfiguration Auto-configuration} for the cache abstraction. Creates a * {@link CacheManager} if necessary when caching is enabled via {@link EnableCaching}. * <p> * Cache store can be auto-detected or specified explicitly via configuration. * * @author Stephane Nicoll * @since 1.3.0 * @see EnableCaching */ @Configuration @ConditionalOnClass(CacheManager.class) @ConditionalOnBean(CacheAspectSupport.class) @ConditionalOnMissingBean(value = CacheManager.class, name = "cacheResolver") @EnableConfigurationProperties(CacheProperties.class) @AutoConfigureBefore(HibernateJpaAutoConfiguration.class) @AutoConfigureAfter({ CouchbaseAutoConfiguration.class, HazelcastAutoConfiguration.class, RedisAutoConfiguration.class }) @Import(CacheConfigurationImportSelector.class) public class CacheAutoConfiguration { static final String VALIDATOR_BEAN_NAME = "cacheAutoConfigurationValidator"; @Bean @ConditionalOnMissingBean public CacheManagerCustomizers cacheManagerCustomizers( ObjectProvider<List<CacheManagerCustomizer<?>>> customizers) { return new CacheManagerCustomizers(customizers.getIfAvailable()); } @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public static CacheManagerValidatorPostProcessor cacheAutoConfigurationValidatorPostProcessor() { return new CacheManagerValidatorPostProcessor(); } @Bean(name = VALIDATOR_BEAN_NAME) public CacheManagerValidator cacheAutoConfigurationValidator() { return new CacheManagerValidator(); } @Configuration @ConditionalOnClass(LocalContainerEntityManagerFactoryBean.class) @ConditionalOnBean(AbstractEntityManagerFactoryBean.class) protected static class CacheManagerJpaDependencyConfiguration extends EntityManagerFactoryDependsOnPostProcessor { public CacheManagerJpaDependencyConfiguration() { super("cacheManager"); } } /** * {@link BeanFactoryPostProcessor} to ensure that the {@link CacheManagerValidator} * is triggered before {@link CacheAspectSupport} but without causing early * instantiation. */ static class CacheManagerValidatorPostProcessor implements BeanFactoryPostProcessor { @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { for (String name : beanFactory.getBeanNamesForType(CacheAspectSupport.class, false, false)) { BeanDefinition definition = beanFactory.getBeanDefinition(name); definition.setDependsOn( append(definition.getDependsOn(), VALIDATOR_BEAN_NAME)); } } private String[] append(String[] array, String value) { String[] result = new String[array == null ? 1 : array.length + 1]; if (array != null) { System.arraycopy(array, 0, result, 0, array.length); } result[result.length - 1] = value; return result; } } /** * Bean used to validate that a CacheManager exists and provide a more meaningful * exception. */ static class CacheManagerValidator { @Autowired private CacheProperties cacheProperties; @Autowired(required = false) private CacheManager cacheManager; @PostConstruct public void checkHasCacheManager() { Assert.notNull(this.cacheManager, "No cache manager could " + "be auto-configured, check your configuration (caching " + "type is '" + this.cacheProperties.getType() + "')"); } } /** * {@link ImportSelector} to add {@link CacheType} configuration classes. */ static class CacheConfigurationImportSelector implements ImportSelector { //拿到系统中的所有缓存配置类 @Override public String[] selectImports(AnnotationMetadata importingClassMetadata) { CacheType[] types = CacheType.values(); String[] imports = new String[types.length]; for (int i = 0; i < types.length; i++) { imports[i] = CacheConfigurations.getConfigurationClass(types[i]); } return imports; } } }
如下所示,添加了11个缓存配置类:
0 = "org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration" 1 = "org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration" 2 = "org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration" 3 = "org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration" 4 = "org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration" 5 = "org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration" 6 = "org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration" 7 = "org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration" 8 = "org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration" 9 = "org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration" 10 = "org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration"
也就是说,CacheManager产品有:
- Generic
- JCache(JSR107)(EhCache3 Hazelcast Infinispan .etc)
- EhCache 2.X
- Hazelcast
- Infinispan
- Couchbase
- Redis
- Caffeine
- Guava
- Simple
【2】默认缓存配置
在application.properties中开启debug:debug=true
。在控制台即可打印自动配置报告:
默认使用的是SimpleCacheConfiguration!
其源码如下:
@Configuration @ConditionalOnMissingBean(CacheManager.class) @Conditional(CacheCondition.class) class SimpleCacheConfiguration { private final CacheProperties cacheProperties; private final CacheManagerCustomizers customizerInvoker; SimpleCacheConfiguration(CacheProperties cacheProperties, CacheManagerCustomizers customizerInvoker) { this.cacheProperties = cacheProperties; this.customizerInvoker = customizerInvoker; } // 注册了ConcurrentMapCacheManager @Bean public ConcurrentMapCacheManager cacheManager() { ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager(); List<String> cacheNames = this.cacheProperties.getCacheNames(); if (!cacheNames.isEmpty()) { cacheManager.setCacheNames(cacheNames); } return this.customizerInvoker.customize(cacheManager); } }
ConcurrentMapCacheManager (可以获取和创建ConcurrentMapCache)源码如下:
/** * {@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} or * {@link org.springframework.cache.guava.GuavaCacheManager}. * * @author Juergen Hoeller * @since 3.1 * @see ConcurrentMapCache */ public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware { private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<String, Cache>(16); private boolean dynamic = true; private boolean allowNullValues = true; private boolean storeByValue = false; 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(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()); } //根据名字获取Cache组件 @Override 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<Object, Object>(256), isAllowNullValues(), actualSerialization); } }
ConcurrentMapCache作用:将数据保存在ConcurrentMap中,并进行获取。
【3】运行流程
这里以注解@Cacheable为例,过程如下。
① 方法运行之前,先去Cache组件中进行查询。Cache组件是CacheManager根据cacheNames获取,如果没有则自动创建。
② 根据key 从Cache中查询缓存的内容,默认key为使用keyGenerator(默认为SimpleKeyGenerator)生成的。
SimpleKeyGenerator的生成key的策略:
- 如果没有参数,则key = new SimpleKey();
- 如果有一个参数,key = 参数值;
- 如果有多个参数,key = new SimpleKey(params)。
③ 如果没有查到缓存就调用目标方法
④ 将目标方法的返回结果放入缓存中
⑤ 如果从缓存中查到了就不调用目标方法,直接从缓存中获取然后返回
CacheAspectSupport中源码示例如下:
private Cache.ValueWrapper findCachedItem(Collection<CacheOperationContext> contexts) { Object result = CacheOperationExpressionEvaluator.NO_RESULT; for (CacheOperationContext context : contexts) { if (isConditionPassing(context, result)) { Object key = generateKey(context, result); Cache.ValueWrapper cached = findInCaches(context, key); if (cached != null) { return cached; } else { if (logger.isTraceEnabled()) { logger.trace("No cache entry for key '" + key + "' in cache(s) " + context.getCacheNames()); } } } } return null; }