玩转Spring Cache --- 开启基于注解的缓存功能@EnableCaching原理了解【享学Spring】

缺乏、安全感 2021-12-16 00:19 1013阅读 0赞

#### 每篇一句 ####

> 招聘要招优秀的人。如果可能，应让团队内优秀的人尽量多，这对团队是非常关键的。**优秀的人做事效率一般会高好几倍**，而且他们更可能做出正确的决定，决策过程快且一般不需要你的纠正

#### 前言 ####

缓存现已成为了项目的标配，更是**面必问**的知识点。若你说你的项目中还没有使用到缓存，估计你都不太好意思介绍你的项目。

`Spring3.1`之后就引入了**基于注解**的缓存技术，但是要明白Spring基于注解的缓存技术并不是一个具体的实现方案（**EHCache、OSCache、Redis**才是具体的缓存方案），而是对缓存使用的一个抽象。  
基于注解的缓存能够在**现有的代码**基础上只需要加入少量的缓存注解（`@Cacheable`、`@CachePut`、`@CacheEvict`、`@Caching`）即能够达到缓存方法的**返回结果**的效果。（使用缓存注解实现缓存无需关心缓存具体的实现产品~）

关于直接调用API方式来使用缓存，可参考：  
[【小家Spring】聊聊Spring Cache的缓存抽象与JSR107缓存抽象JCache，并使用API方式使用Spring Cache][Spring_Spring Cache_JSR107_JCache_API_Spring Cache]

### 开启缓存注解的步骤 ###

通过前面多篇文章的学习我们发现，启用Spring的一个功能模块是一件非常方便的事。自然作为Spring框架的核心功能之**缓存注解**，该功能自然也继承了Spring这个优良特性，使它生效只需要轻松两步：

1.  配置类上开启缓存注解支持：`@EnableCaching`
2.  向容器内至少放置一个`CacheManager`类型的Bean

仅仅简单的两步后，就可以开工使用Spring强大的缓存注解功能了。

##### 简单示例 #####

按照上面两个步骤配置如下：

@EnableCaching
    @Configuration
    public class CacheConfig { 
    
        @Bean
        public ConcurrentMapCacheManager cacheManager() { 
            ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
            //cacheManager.setStoreByValue(true); //true表示缓存一份副本，否则缓存引用
            return cacheManager;
        }
    
    }

配置好后，开工书写需要使用缓存的代码，此处以Service为例：

@Service
    public class CacheDemoServiceImpl implements CacheDemoService { 
    
        @Cacheable(cacheNames = "demoCache", key = "#id")
        @Override
        public Object getFromDB(Integer id) { 
            System.out.println("模拟去db查询~~~" + id);
            return "hello cache...";
        }
    }

单元测试：

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = { RootConfig.class, CacheConfig.class})
    public class TestSpringBean { 
    
        @Autowired
        private CacheDemoService cacheDemoService;
        @Autowired
        private CacheManager cacheManager;
    
        @Test
        public void test1() { 
            cacheDemoService.getFromDB(1);
            cacheDemoService.getFromDB(1);
    
            // 校验缓存里的内容~~~~
            Cache demoCache = cacheManager.getCache("demoCache");
            System.out.println(demoCache.getName());
            System.out.println(demoCache.get(1, String.class));
        }
    
    }

输出：

模拟去db查询~~~1
    ---------------------------------
    demoCache
    hello cache...

从打印结果的两个可以证明**缓存生效了**：

1.  `getFromDB(1)`调用了两次，但日志只输出一句，证明第二次并没有执行方法体，缓存生效
2.  校验代码中，可以拿到名为`demoCache`的这个Cache对象，并且该Cache内是存在`key=1`这个键值对的，证明结果确实存入到缓存里了

## `@EnableCaching`开启缓存的原理解析 ##

`@EnableCaching`这注解用于开启Spring的缓存注解功能，它是一个模块注解，功能类似于xml时代的：`<cache:annotation-driven>`配置项。本处介绍一下这个注解具体做了哪些事~

首先来到这个注解本身：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(CachingConfigurationSelector.class)
    public @interface EnableCaching { 
    	boolean proxyTargetClass() default false;
    	AdviceMode mode() default AdviceMode.PROXY;
    	int order() default Ordered.LOWEST_PRECEDENCE;
    }

该注解的这几个属性我此处略过不解释了，相信应该没有小伙伴有意见吧。同样的，此处重点关注对象为：`CachingConfigurationSelector`

### CachingConfigurationSelector ###

这个类继承自`AdviceModeImportSelector`。关于`AdviceModeImportSelector`这个抽象类，熟悉我博文的小伙伴对这个类应该都不默认了，因为在讲解`@EnableAsync`、`@EnableTransactionManagement`的时候都解释过多遍，因此本文对此**抽象父类**不再鳌诉。  
有疑惑的可参考：  
[【小家Spring】Spring异步处理@Async的使用以及原理、源码分析（@EnableAsync）][Spring_Spring_Async_EnableAsync]  
[【小家Spring】从基于@Transactional全注解方式的声明式事务入手，彻底掌握Spring事务管理的原理][Spring_Transactional_Spring]

public class CachingConfigurationSelector extends AdviceModeImportSelector<EnableCaching> { 
    	
    	...
    
    	static { 
    		ClassLoader classLoader = CachingConfigurationSelector.class.getClassLoader();
    		jsr107Present = ClassUtils.isPresent("javax.cache.Cache", classLoader);
    		jcacheImplPresent = ClassUtils.isPresent(PROXY_JCACHE_CONFIGURATION_CLASS, classLoader);
    	}
    
    	// 绝大多数情况下我们不会使用ASPECTJ，若要使用它还得额外导包~
    	// getAspectJImports()这个方法略
    	@Override
    	public String[] selectImports(AdviceMode adviceMode) { 
    		switch (adviceMode) { 
    			case PROXY:
    				return getProxyImports();
    			case ASPECTJ:
    				return getAspectJImports();
    			default:
    				return null;
    		}
    	}
    
    	// 向容器导入了AutoProxyRegistrar和ProxyCachingConfiguration
    	// 若JSR107的包存在(导入了javax.cache:cache-api这个包)，并且并且存在ProxyJCacheConfiguration这个类
    	// 显然ProxyJCacheConfiguration这个类我们一般都不会导进来~~~~ 所以JSR107是不生效的。 但是但是Spring是支持的，非常良心
    	private String[] getProxyImports() { 
    		List<String> result = new ArrayList<>(3);
    		result.add(AutoProxyRegistrar.class.getName());
    		result.add(ProxyCachingConfiguration.class.getName());
    		if (jsr107Present && jcacheImplPresent) { 
    			result.add(PROXY_JCACHE_CONFIGURATION_CLASS);
    		}
    		return StringUtils.toStringArray(result);
    	}
    	...
    }

它完成了一件事：向容器内注入了`AutoProxyRegistrar`和`ProxyCachingConfiguration`这两个Bean。

#### AutoProxyRegistrar ####

关于`AutoProxyRegistrar`，先看图：  
![在这里插入图片描述][20190703154519303.png]  
看图的目的是这个类它在事务章节里也被用到，而且已在那做过详述，因此本文略过。需要了解详细的请参考：[【小家Spring】从基于@Transactional全注解方式的声明式事务入手，彻底掌握Spring事务管理的原理][Spring_Transactional_Spring]

说明：该类向Spring容器注入了一个自动代理创建器，因此可想而知缓存的代理对象，最终是委托给自动代理创建器来完成的（**和@Async不同哦~**）。

#### ProxyCachingConfiguration ####

其实这个哥们的设计思想和`ProxyTransactionManagementConfiguration`如出一辙，只是各自处理各自的业务属性不同而已。

// @since 3.1 内部注入的Bean角色都是ROLE_INFRASTRUCTURE 建议先看下面的父类
    @Configuration
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public class ProxyCachingConfiguration extends AbstractCachingConfiguration { 
    
    	// 缓存注解的增强器：重点在CacheOperationSource和CacheInterceptor
    	@Bean(name = CacheManagementConfigUtils.CACHE_ADVISOR_BEAN_NAME)
    	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    	public BeanFactoryCacheOperationSourceAdvisor cacheAdvisor() { 
    		BeanFactoryCacheOperationSourceAdvisor advisor = new BeanFactoryCacheOperationSourceAdvisor();
    		advisor.setCacheOperationSource(cacheOperationSource());
    		advisor.setAdvice(cacheInterceptor());
    		if (this.enableCaching != null) { 
    			advisor.setOrder(this.enableCaching.<Integer>getNumber("order"));
    		}
    		return advisor;
    	}
    
    	// 关于CacheOperationSource和CacheInterceptor是理解注解原理重要的两个类，放在下一章节讲解更妥
    	// 注意CacheOperationSource是给CacheInterceptor用的
    	@Bean
    	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    	public CacheOperationSource cacheOperationSource() { 
    		return new AnnotationCacheOperationSource();
    	}
    	@Bean
    	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    	public CacheInterceptor cacheInterceptor() { 
    		CacheInterceptor interceptor = new CacheInterceptor();
    		interceptor.configure(this.errorHandler, this.keyGenerator, this.cacheResolver, this.cacheManager);
    		interceptor.setCacheOperationSource(cacheOperationSource());
    		return interceptor;
    	}
    }
    
    // 抽象父类：定义和管理了Caching相关的API、类们
    @Configuration
    public abstract class AbstractCachingConfiguration implements ImportAware { 
    
    	// 这些属性都是protected的，子类可以直接访问哦~~~
    	@Nullable
    	protected AnnotationAttributes enableCaching;
    	@Nullable
    	protected Supplier<CacheManager> cacheManager;
    	@Nullable
    	protected Supplier<CacheResolver> cacheResolver; // 缓存注解的处理器
    	@Nullable
    	protected Supplier<KeyGenerator> keyGenerator; // key的生成器
    	@Nullable
    	protected Supplier<CacheErrorHandler> errorHandler; // 错误处理器
    
    
    	// 继承此抽象类前提条件：必须标注@EnableCaching注解~
    	@Override
    	public void setImportMetadata(AnnotationMetadata importMetadata) { 
    		this.enableCaching = AnnotationAttributes.fromMap(importMetadata.getAnnotationAttributes(EnableCaching.class.getName(), false));
    		if (this.enableCaching == null) { 
    			throw new IllegalArgumentException("@EnableCaching is not present on importing class " + importMetadata.getClassName());
    		}
    	}
    
    	// 可以通过实现CachingConfigurer接口来**指定缓存使用的默认**的：
    	// 缓存管理器
    	// 缓存解析器
    	// key生成器
    	// 错误处理器
    	@Autowired(required = false)
    	void setConfigurers(Collection<CachingConfigurer> configurers) { 
    		if (CollectionUtils.isEmpty(configurers)) { 
    			return;
    		}
    		// CachingConfigurer的实现类，最多只能有一个
    		if (configurers.size() > 1) { 
    			throw new IllegalStateException(configurers.size() + " implementations of " +
    					"CachingConfigurer were found when only 1 was expected. " +
    					"Refactor the configuration such that CachingConfigurer is " +
    					"implemented only once or not at all.");
    		}
    		CachingConfigurer configurer = configurers.iterator().next();
    		useCachingConfigurer(configurer);
    	}
    
    	/** * Extract the configuration from the nominated {@link CachingConfigurer}. */
    	protected void useCachingConfigurer(CachingConfigurer config) { 
    		this.cacheManager = config::cacheManager;
    		this.cacheResolver = config::cacheResolver;
    		this.keyGenerator = config::keyGenerator;
    		this.errorHandler = config::errorHandler;
    	}
    
    }

可以看到`@EnableCaching`这个注解的模式和`@EnableTransactionManagement`的效果是何其相似，所以掌握模式往往比掌握具体某一种技术更重要~

上面配置类向容器放入的三个Bean：`BeanFactoryCacheOperationSourceAdvisor`、`CacheOperationSource`、`CacheInterceptor`它是AOP处理缓存注解的核心，这在下一章节有详细的解释说明~

#### 总结 ####

本文先介绍了`@EnableCaching`它开启缓存注解支持的基本原理，从本文更应该得到的一个道理是：掌握模式往往比掌握具体的一门技术更加重要，这也就是战略和战术的区别吧~

--------------------

# 关注A哥 #

<table> 
 <thead> 
  <tr> 
   <th>Author</th> 
   <th><a href="https://www.yourbatman.cn/about" rel="nofollow">A哥(YourBatman)</a></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>个人站点</td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow">www.yourbatman.cn</a></td> 
  </tr> 
  <tr> 
   <td>E-mail</td> 
   <td>yourbatman@qq.com</td> 
  </tr> 
  <tr> 
   <td><strong>微 信</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat.png" rel="nofollow">fsx641385712</a></td> 
  </tr> 
  <tr> 
   <td><strong><code>活跃平台</code></strong></td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow"><img src="https://img-blog.csdnimg.cn/2020071015182276.png" alt=""></a> <a href="https://fangshixiang.blog.csdn.net/" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151913394.png" alt=""></a><a href="https://yourbatman.cnblogs.com" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151929355.png" alt=""></a><a href="https://juejin.im/user/5b44d178f265da0fa1220efe/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151938937.png" alt=""></a><a href="https://www.zhihu.com/people/fangshixiang/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151950629.png" alt=""></a><a href="https://www.jianshu.com/u/8740f1fdd684" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152000530.png" alt=""></a><a href="https://segmentfault.com/u/yourbatman/articles" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152008726.png" alt=""></a><a href="https://github.com/yourbatman" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152015895.png" alt=""></a></td> 
  </tr> 
  <tr> 
   <td><strong>公众号</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat_channel.jpg" rel="nofollow">BAT的乌托邦（ID：BAT-utopia）</a></td> 
  </tr> 
  <tr> 
   <td>知识星球</td> 
   <td><a href="https://t.zsxq.com/nQBi66I" rel="nofollow">BAT的乌托邦</a></td> 
  </tr> 
  <tr> 
   <td>每日文章推荐</td> 
   <td><a href="https://github.com/yourbatman/reading/issues" rel="nofollow">每日文章推荐</a></td> 
  </tr> 
 </tbody> 
</table>

![BAT的乌托邦][BAT]

[Spring_Spring Cache_JSR107_JCache_API_Spring Cache]: https://blog.csdn.net/f641385712/article/details/94446903
[Spring_Spring_Async_EnableAsync]: https://blog.csdn.net/f641385712/article/details/89430276
[Spring_Transactional_Spring]: https://blog.csdn.net/f641385712/article/details/89607829
[20190703154519303.png]: /images/20211215/b4448c08a3a24791a2b83cadc330c18e.png
[BAT]: /images/20211215/ed2d0f71e48a45f094cdbf7da459bda6.png