Fork me on GitHub

spring cache 源码学习路线

阅读数:0次
字数统计: 4.4k字   |   阅读时长≈ 17分

Spring Cache利用AOP通过合理的抽象，实现了基于注解的缓存功能并且提供了一些默认实现。这样业务代码不用关心底层是使用了什么缓存框架，只需要简单地加一个注解，就能实现缓存功能了。优点替换缓存工具很方便，缺点对于缓存抽象缺少复杂的功能，例如缓存设置过期时间等功能没有很好的支持。

本篇文章主要介绍了阅读spring cache源码类的阅读顺序以及介绍使用

1、cache定义

1
2
// cache定义
Cache

2、cache manager定义

1
2
// 管理cache的管理器
CacheManager

3、cache&manager两者简单实现

3.1 空实现

1
2
3
4
// 空cache实现 
NoOpCache
// 空cache的manager 仅测试用途，不会实际存储缓存
NoOpCacheManager

3.2 默认实现

1
2
3
4
5
6
7
8
9
10
11
12
// 空值表示
NullValue
// cache value简单包装
SimpleValueWrapper
// 抽象cache实现 主要增加了lookup方法 子类实现
AbstractValueAdaptingCache
// Cache管理器抽象实现 增加了默认loadCaches
AbstractCacheManager
// 简单CacheManager实现
SimpleCacheManager
// 多个cache manager管理器
CompositeCacheManager

4、cache key生成器

1
2
3
4
5
6
// 定义key生成器
KeyGenerator
// key生成器简单实现
SimpleKeyGenerator
// key定义
SimpleKey

5、解析Cache对象

CacheResolver在AOP时会需要根据注解,解析出Cache对象.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Cache对象解析器
CacheResolver
// 特定对象的某个方法某些参数 的缓存操作调用上下文
CacheOperationInvocationContext
// 操作定义 主要获取cache名称列表，用于CacheResolver获取cache列表
BasicOperation
// 三个注解@Cacheable，@CacheEvict，@CachePut 解析器抽象实现对象里面没有具体的处理逻辑，只是用来存储属性值
CacheOperation
// @Cacheable该注解解析器
CacheableOperation
// @CacheEvict该注解解析器
CacheEvictOperation
// @CachePut该注解解析器
CachePutOperation
// CacheResolver的抽象实现，需要具体实现根据调用上下文提供缓存名称集合。主要根据CacheManager获取cache,需要根据CacheOperationInvocationContext这个获取cache name集合
AbstractCacheResolver
// 根据CacheOperationInvocationContext 中opertion获取cache names
SimpleCacheResolver
// 手动指定cache names
NamedCacheResolver

6、获取CacheOperation对象

判断一个目标类是否是注册过的CacheAnnotationParser 遍历所有的缓存注解解析器，只要有一个支持解析目标类，则返回true

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//  解析class or method注解，获取CacheOperation集合
CacheOperationSource
// 通过方法名称匹配
NameMatchCacheOperationSource
// 多个CacheOperationSource迭代获取CacheOperation集合
CompositeCacheOperationSource
// {@link CacheOperation}的抽象实现，它缓存方法的属性并实现回退策略：
AbstractFallbackCacheOperationSource
// {@link CacheOperationSource}接口的实现，用于注解格式缓存元数据。这里解析注解数据采用了CacheAnnotationParser默认SpringCacheAnnotationParser
AnnotationCacheOperationSource
// 支持解析class和method上的注解cache注解信息生成Collection<CacheOperation>
CacheAnnotationParser
// CacheAnnotationParser的默认实现支持Cacheable、CacheEvict、CachePut、Caching四个注解的解析
SpringCacheAnnotationParser

7、AOP增强代码定义

调用此实例定义的缓存操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// 缓存操作的调用,这里主要对异常进行抛出，告诉调用方需要专门处理此问题类型
CacheOperationInvoker
// 基本组件，用于在异常发生时调用{@link Cache}操作并使用可配置的{@link CacheErrorHandler}。
AbstractCacheInvoker
// Spring el中用户自定义表达式不可用异常定义
VariableNotAvailableException

// 关与CacheAspectSupport先看下几个内部类
// 这个类比较重要 1、会自动从springFactory中获取CacheManager注入 2、支持获取cache 3、支持Evicts操作 4、支持对象或方法获取cache value 5、支持key获取value等
CacheAspectSupport
// 一个Class或Method+具体的CacheOperation作为一个key，将静态元数据CacheOperationMetadata缓存在CacheAspectSupport.metadataCache 这个map中
CacheAspectSupport#CacheOperationCacheKey
// cache 操作元数据 主要是CacheOperation，targetMethod，targetClass,AnnotatedElementKey,KeyGenerator,CacheResolver 其中包含了CacheOperationCacheKey所有信息
CacheAspectSupport#CacheOperationMetadata
// 相较于CacheOperationMetadata提供了代理实例对象的的一些信息包含实例对象，对象参数等信息，支持获取caches，cacheNames
CacheAspectSupport#CacheOperationContext
// 写缓存的请求@Cacheable和@CachePut内置CacheOperationContext
CacheAspectSupport#CachePutRequest
// cache operation contexts 缓存操作上下文管理器 主要支持一个CacheOperation可能对应多个CacheOperationContext
// 可以理解为共三个CacheOperation,但是每个定义了cache操作的方法为一个（或多个因为方法传递的参数可能不一致）CacheOperationContext
CacheAspectSupport#CacheOperationContexts
// 定义AOP中增强代码，主要是执行了CacheAspectSupport中的execute(CacheOperationInvoker invoker, Object target, Method method, Object[] args) 方法
CacheInterceptor

// 用于计算和缓存在{@link java.lang.reflect.AnnotatedElement}上定义的SpEL表达式的共享实用程序类。
CachedExpressionEvaluator
// 主要是spring表达式#root 代表缓存注解中#root对象，CacheExpressionRootObject的属性即#root可引用的参数；
CacheExpressionRootObject
// 执行缓存注解配置key、condition和unless中的SpEL表达式，获取表达式的值；
CacheOperationExpressionEvaluator

// 在获取/修改/移除缓存时发生异常时，处理特定的逻辑
CacheErrorHandler
// 默认的异常处理逻辑，直接抛出异常
SimpleCacheErrorHandler
// 缓存特定的计算上下文，以惰性方式将方法参数添加为SpEL变量。惰性特性消除了不必要的类解析和参数发现字节码
// 创建SpEL表达工式执行器上下文对象
CacheEvaluationContext

8、注解定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Spring在每次执行前都会检查Cache中是否存在相同key的缓存元素,如果存在就不再执行该方法,而是直接从缓存中获取结果进行返回,否则才会执行并将返回结果存入指定的缓存中
Cacheable
// CacheEvict是用来标注在需要清除缓存元素
// allEntries为true时,Spring Cache将忽略指定的key,清除所有的元素. allEntries = false,
// 清除操作默认是在"调用代理类的方法成功后"执行之后触发清除操作.
// 如果被代理后的方法抛出异常而未能成功返回时,则不会触发清除操作.
// 使用beforeInvocation可以改变触发清除操作的时间.beforeInvocation = false
// 当我们指定该属性值为beforeInvocation=true时,Spring会在调用"代理方法之前"清除缓存中的指定元素. 
CacheEvict
// @CachePut与@Cacheable不同的是,@CachePut标注的方法在执行前不会去检查缓存中是否存在之前执行过的结果,而是每次都会执行该方法,并将执行结果以键值对的形式存入指定的缓存中.
CachePut
// @Caching注解可以让我们在一个方法或者类上同时指定多个Spring Cache相关的注解. 其拥有三个属性:cacheable、put和evict,分别用于指定@Cacheable、@CachePut和@CacheEvict.
Caching
// 提供了一种在类级别共享公共缓存相关设置的机制。
CacheConfig
// 启用Spring的注释驱动缓存管理功能
EnableCaching

9、自动加载以及配置项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// spring 会回调selectImports方法注册了ProxyCachingConfiguration
CachingConfigurationSelector
// spring cache提供的配置文件用户一般需要至少实现一个.采用@Configuration进行配置，
CachingConfigurer
// CachingConfigurer的一种实现，其中包含空方法，允许子类仅重写它们感兴趣的方法。
CachingConfigurerSupport
// 定义了一些配置参数CacheManager、CacheResolver、KeyGenerator、CacheErrorHandler。且AbstractCachingConfiguration有一个@Autowired方法会从容器中选出一个唯一的CachingConfigurer来获取缓存需要的配置包括：CacheManager、CacheResolver、KeyGenerator、CacheErrorHandler。 所以一般用户至少指定一个CachingConfigurer
AbstractCachingConfiguration
// 向容器中注册一个可以处理缓存的通知器BeanFactoryCacheOperationSourceAdvisor(根据AnnotationCacheOperationSource和CacheInterceptor)
ProxyCachingConfiguration
// StaticMethodMatcherPointcut是静态方法切点的抽象基类，默认情况下匹配所有的类。这里如果基础{@link CacheOperationSource}具有给定方法的属性，则匹配的切入点。默认使用AnnotationCacheOperationSource#isCandidateClass方法检查是否存在这4个注解
CacheOperationSourcePointcut
// 内置了CacheOperationSourcePointcut 提供配置CacheOperationSourcePointcut匹配方法的对象设置（CacheOperationSource设置）
BeanFactoryCacheOperationSourceAdvisor

10、spring cache额外配置(这一部分代码可以略)

10.1 并发包

基于{@code java.util.concurrent}的缓存的实现包。提供{@link org.springframework.cache.CacheManager CacheManager}和{@link org.springframework.cache.cache cache}实现，以便在运行时使用基于JDK的线程池在Spring上下文中使用

1
2
3
4
5
6
// ConcurrentMapCacheManager使用了JDK的ConcurrentMap。 没什么特殊的类似于SimpleCacheManager
ConcurrentMapCache
// 用于在Spring容器中使用时轻松配置ConcurrentMapCache.可以通过bean属性进行配置；使用指定的Springbean名称作为默认缓存名称
ConcurrentMapCacheFactoryBean
// 使用ConcurrentMap作为缓存技术（默认），需要显式的删除缓存，无过期机制
ConcurrentMapCacheManager

10.2 配置项

声明式缓存配置的支持包，XML模式是主要配置格式。

1
2
3
4
5
6
7
8
// {@link org.springframework.beans.factory.xml.BeanDefinitionParser}实现，允许用户轻松配置启用注释驱动的缓存划分所需的所有基础结构bean。
AnnotationDrivenCacheBeanDefinitionParser
// {@code<tx:advice>}标记的{@link org.springframework.beans.factory.xml.BeanDefinitionParser BeanDefinitionParser}。
CacheAdviceParser
// 用于跨子包内部共享的配置常量
CacheManagementConfigUtils
// {@code NamespaceHandler}允许使用XML或注释配置声明性缓存管理。
CacheNamespaceHandler

11、总结

至此我们已经把org.springframework.cache下的所有类库功能讲了一边下面我们进行个小结，看看整个流程是怎样的。

这里copy了一张图：来自https://blog.csdn.net/zhouping118/article/details/108440982

cache基础类

11.1 启动流程

先看看几个字段

1
2
3
4
CacheManager固名思义:就是对Cache进行管理,可以管理多个Cache.
Cache是对缓存的一些基本操作(添加数据到缓存/剔除缓存中的数据/清空整个缓存…)
CacheResolver在AOP时会需要根据注解,解析出Cache对象.
KeyGenerator用于缓存时自定义KEY策略,注意,与注解上的key是互斥的.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1 启用spring chche
@EnableCaching 
2 @EnableCaching中Import CachingConfigurationSelector 
CachingConfigurationSelector 会像Spring中注册一个bean ProxyCachingConfiguration
3 ProxyCachingConfiguration
	(1) ProxyCachingConfiguration是一个配置类(@Configuration).继承AbstractCachingConfiguration，AbstractCachingConfiguration会自动在spring中搜索CachingConfigurer实现类选择一个进行配置如果没有会选择默认配置项  this.errorHandler = new SingletonSupplier<>(errorHandler, SimpleCacheErrorHandler::new);
        this.keyGenerator = new SingletonSupplier<>(keyGenerator, SimpleKeyGenerator::new);
        this.cacheResolver = new SingletonSupplier<>(cacheResolver,
                () -> SimpleCacheResolver.of(SupplierUtils.resolve(cacheManager)));
                
	(2) 创建CacheInterceptor,它属于AOP进行动态代理的核心.
	(3) 创建BeanFactoryCacheOperationSourceAdvisor,这个属于定义要拦截的point.
4 创建BeanFactoryCacheOperationSourceAdvisor
BeanFactoryCacheOperationSourceAdvisor里定义了切点和增强。切点是cacheOperationSource（AnnotationCacheOperationSource）仅仅支持4个注解；另外添加了增强代码CacheInterceptor
5 CacheInterceptor实现了MethodInterceptor
主要创建了CacheOperationInvoker调用了CacheAspectSupport中的execute
6 CacheAspectSupport 用来执行操作，get,put之类的
	(1) spring SmartInitializingSingleton afterSingletonsInstantiated 初始化CacheManager。会自动从springFactory中获取CacheManager注入
	(2) 根据AnnotationCacheOperationSource获取CacheOperation集合进行进一步execute，期间创建了CacheOperationContexts，创建期间创建了CacheOperationContexts的时候会去解析@Cacheable 中sync对象
	(3) Spring Cache 为了避免缓存穿透，@Cacheable(cacheNames = “users” , sync = true),当对相同的key进行操作时,会运用Java的synchronized关键字,在同一个进程里,只会允许一个线程去访问后面的业务代码.
	(4)  <T> T get(Object key, Callable<T> valueLoader); valueLoader实现应该确保加载操作是同步的，

11.2 运行流程

  • 使用：在User类上编写方法String getName()，标注注解@Cacheable;
  • 运行过程
    • 拦截：
      • 拦截器拦截标注有@Cacheable的getName方法，调用父类CacheAspectSupport的execute方法执行；
    • 解析缓存注解
      • 使用AnnotationCacheOperationSource，AnnotationCacheOperationSource委托SpringCacheAnnotationParser把@Cacheable解析为CacheableOperation，返回CacheOperation集合（一个方法上可以有多个缓存注解，所以返回集合）；
      • 使用DefaultCacheConfig读取类上的CacheConfig参数;
    • 拼装配置
      • 把getName上的所有缓存注解封装为CacheOperationContexts。里面包含多个CacheOperationContext，CacheableOperation封装为其中的一个CacheOperationContext（CacheOperationContext包含CacheOperationMetadata）；
    • 如果配置了sync=true（只有解@Cacheable可配置sync）
      • 获取缓存的key值
        • 如果@Cacheable没有配置key，则使用SimpleKeyGenerator生成key；
        • 如果配置了key，使用CacheOperationExpressionEvaluator创建EvaluationContext，然后计算key中的SpEL表达式的值，做为key返回；
      • 获取Cache
        • 使用SimpleCacheResolver，SimpleCacheResolver根据@Cacheable配置的cacheNames，调用CacheManager获取Cache；
        • 然后调用Cache获取缓存，如果没有缓存，则调用目标方法，并返回目标方法的返回值；
    • 如果没有配置sync=true
      • 执行移除缓存(beforeInvocation=true)
        • 如果指定了key，执行上面获取缓存的key的逻辑。移除指定key的缓存/移除所有缓存；
      • 执行获取缓存
        • 执行上面获取缓存的key的逻辑，然后从配置的所有缓存中获取缓存值；
        • 如果缓存没有命中，则执行目标方法，并把返回值保存在缓存中；
      • 执行修改缓存
      • 执行移除缓存(beforeInvocation=false)

12、Redis CacheManager实现

先贴一张图

RedisCacheManager结构

13 spring cache的一些问题

  • 默认不支持TTL（Time To Live），也就是缓存过期时间；也不支持TTI（Time To Idle）空闲期，即一个数据多久没被访问将从缓存中移除的时间；还不支持移除策略（Eviction policy），即即如果缓存满了，从缓存中移除数据的策略。
    • 诸如上面属性或者其他具体缓存实现的特有属性应该直接通过Cache的具体实现来设置，并且只有Cache实现自己去完成，Spring Cache仅仅是一个抽象，仅提供了比较基本的缓存行为，或许有一些方案可以设置过期时间但是只能设置一个统一的过期时间，而不能精确到每一个key，这明显不够灵活。
    • 上面的这个缺点就导致了Spring Cache的实际应用并不是很广泛，就拿Redis来说，或许大部分人都还是在使用的RedisTemplate来操作Reids缓存，因此它可以设置过期时间、以及选择缓存的数据结构、以及获取缓存的方式，这明显比Spring Cache的几个注解要灵活得多！
  • 无法根据查询结果中的内容生成缓存key，比如getUser(uid)方法，想通过查询出来的user.email生成缓存key就无法实现了，因为#result不能应用在key上面！
  • 由于声明式的Spring Cache是基于Spring AOP实现的，因此默认的AOP实现的缺点在Spring Cache上同样不可避免：
    • 默认的AOP的机制导致了声明式缓存只能进行方法级别的缓存管理，也就是说只能在方法执行之前从缓存尝试取数据，方法执行完毕之后才能将结果添加到缓存中！
    • AOP的机制导致了同一个AOP类中的事务方法互相调用时，被调用方法的事务配置不会生效，因为Spring AOP的代理机制最终还是通过原始目标对象本身去调用目标方法的，这样被调用的方法就会因为是原始对象调用的而不被拦截，当然也有解决办法，和此前同一个类的AOP方法互相调用的解决办法是一样的，那就是获取代理对象，通过代理对象去调用内层方法！
    • 无论是基于JDK动态代理还是CGLIB代理，由于本身的缺陷，它们代理的方法的增强都具有限制。对于JDK的代理，目标类必须实现符合规则的接口（不是说只要是实现了接口就会使用JDK代理，具体规则在AOP源码部分有讲解），并且只能代理实现的接口的方法，而对于CGLIB的代理，目标类不能是final的，并且需要代理的方法也不能是private/final/static的。这些AOP代理的限制也是缓存增强方法的限制。而缓存的代理类型也是通过标签的proxy-target-class属性或者注解的proxyTargetClass属性统一控制的。

总结

  • Spring Cache是一个缓存抽象，将大多数缓存的基本功能抽取出来，然后定义一个统一的使用方式（配置和注解），只要是基于Spring的项目，都可以将第三方缓存与Spring Cache快速的结合起来。这样的好处就是我们只需要掌握Spring Cache的使用就能够相当于掌握了大多数第三方缓存的基本操作，降低了学习成本。
  • 当前，Spring Cache仅仅抽取了缓存的基本操作行为，对于具体的某些缓存的高级行为，Spring Cache是无能为力的，比如Redis，Spring Cache仅能比较方便的存取普通的key和value，而对于特殊的缓存结构，比如hash、set、zset等，以及它们的特殊操作，比如lpush、rpop等等，此时Spring Cache的能力就显得捉襟见肘了。
  • 为此，如果是项目没有使用的特别复杂的缓存操作和缓存结构，那么使用Spring Cache是非常方便（还要考虑过期时间的设置），如果项目的缓存操作比较复杂，那么建议还是建议使用专门的缓存操作API吧，比如RedisTemplate。

14 参考

1
2
3
4
5
6
7
8
9
10
11
12
https://blog.csdn.net/zhouping118/article/details/108440982
https://www.lixin.help/page5/
https://www.lixin.help/2021/07/05/Spring-Cache-Source.html
https://www.codenong.com/cs106708230/
# 配置项这个并没参考
https://muzinuo.com/article/spring_boot_cache_manager_redis.html
# 使用场景
https://luoluocaihong.gitbooks.io/study/content/zcache/springcacheshi-yong-chang-jing.html
http://www.imooc.com/wiki/springbootlesson/caching.html
https://xie.infoq.cn/article/26c54c246279306df0c291327
# spring cache使用少的原因
https://blog.csdn.net/weixin_43767015/article/details/114524674
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、聚合支付、
公众号开发、开源爱好者、Linux

联系QQ:2013881276

很惭愧

只做了一点微小的工作
谢谢大家