spring-cache 源码解析(无图)

最新推荐文章于 2025-10-16 09:49:26 发布
原创 最新推荐文章于 2025-10-16 09:49:26 发布 · 990 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java #后端

本文详细解读了SpringCache的内部工作机制，包括如何通过注解@Cachable简化缓存操作，以及与SpringBoot的Redis集成，重点讲解了AOP代理、BeanFactoryCacheOperationSourceAdvisor的配置和工作原理。

spring-cache 源码解析(无图)

简介

spring-cache 提供了高效的缓存相关数据存储和删除，通过运用注解@Cachable就可以简单完成从缓存中读取数据，减少在业务代码中加入缓存，读取缓存的操作，相对方便快捷。

用例

spring-boot-starter-cache
spring-boot-starter-data-redis

结合 redis + spring-cache，使用分布式缓存。

解析

依赖信息
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
引入了什么
@EnableCaching

对启动类加上 @EnableCaching 注解

  1. 引入CachingConfigurationSelector， 加载 ProxyCachingConfiguration 作为代理配置类
  2. ProxyCachingConfiguration 加载了 BeanFactoryCacheOperationSourceAdvisor
  3. BeanFactoryCacheOperationSourceAdvisor 使用 cacheInterceptor 作为 advice， 使用 CacheOperationSource 作为pointcut。
  4. 至此完成了代理类的配置。 
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(CachingConfigurationSelector.class)
public @interface EnableCaching {
    // ...
}

public class CachingConfigurationSelector extends AdviceModeImportSelector<EnableCaching> {
	// ProxyCachingConfiguration 代理类配置加载为bean
}


@Configuration
public class ProxyCachingConfiguration extends AbstractCachingConfiguration {

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

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public CacheOperationSource cacheOperationSource() {
		...
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public CacheInterceptor cacheInterceptor() {
        ...
	}

}
RedisAutoConfiguration
  1. RedisAutoConfiguration 加载 RedisProperties 属性类
  2. RedisAutoConfiguration 加载 LettuceConnectionConfiguration、JedisConnectionConfiguration 也就加载了 RedisConnectionFactory 
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
    // 加载restemplate, StringRedisTemplate
}
CacheAutoConfiguration
  1. 在有CacheAspectSupport这个bean作为条件，加载CacheProperties属性类，导入 CacheConfigurationImportSelector
  2. CachingConfigurationSelector 会加载 全部的缓存类型配置类，由shouldSkip进行条件过滤，就会剩下 RedisCacheConfiguration 可以被加载成 bean
  3. RedisCacheConfiguration 由于引入 RedisAutoConfiguration 加载了 RedisConnectionFactory作为bean，所以条件成立，加载 cacheManager 
@Configuration
@ConditionalOnClass(CacheManager.class)
@ConditionalOnBean(CacheAspectSupport.class)
@ConditionalOnMissingBean(value = CacheManager.class, name = "cacheResolver")
@EnableConfigurationProperties(CacheProperties.class)
@AutoConfigureAfter({ CouchbaseAutoConfiguration.class, HazelcastAutoConfiguration.class,
		HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class })
@Import(CacheConfigurationImportSelector.class)
public class CacheAutoConfiguration {

	// ....
	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;
		}
	}
}



final class CacheConfigurations {

	private static final Map<CacheType, Class<?>> MAPPINGS;

	static {
		Map<CacheType, Class<?>> mappings = new EnumMap<>(CacheType.class);
		mappings.put(CacheType.GENERIC, GenericCacheConfiguration.class);
		mappings.put(CacheType.EHCACHE, EhCacheCacheConfiguration.class);
		mappings.put(CacheType.HAZELCAST, HazelcastCacheConfiguration.class);
		mappings.put(CacheType.INFINISPAN, InfinispanCacheConfiguration.class);
		mappings.put(CacheType.JCACHE, JCacheCacheConfiguration.class);
		mappings.put(CacheType.COUCHBASE, CouchbaseCacheConfiguration.class);
		mappings.put(CacheType.REDIS, RedisCacheConfiguration.class);
		mappings.put(CacheType.CAFFEINE, CaffeineCacheConfiguration.class);
		mappings.put(CacheType.SIMPLE, SimpleCacheConfiguration.class);
		mappings.put(CacheType.NONE, NoOpCacheConfiguration.class);
		MAPPINGS = Collections.unmodifiableMap(mappings);
	}
}


@Configuration
@ConditionalOnClass(RedisConnectionFactory.class)
@AutoConfigureAfter(RedisAutoConfiguration.class)
@ConditionalOnBean(RedisConnectionFactory.class)
@ConditionalOnMissingBean(CacheManager.class)
@Conditional(CacheCondition.class)
class RedisCacheConfiguration {

	@Bean
	public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory,
			ResourceLoader resourceLoader) {
		RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory)
				.cacheDefaults(determineConfiguration(resourceLoader.getClassLoader()));
		List<String> cacheNames = this.cacheProperties.getCacheNames();
		if (!cacheNames.isEmpty()) {
			builder.initialCacheNames(new LinkedHashSet<>(cacheNames));
		}
		return this.customizerInvoker.customize(builder.build());
	}
}
总结引入部分
  • @EnableCaching 提供 代理类
  • spring-boot-starter-data-redis 引入RedisConnectionFactory， 满足redis缓存配置类的condition条件
  • spring-boot-starter-cache 引入各种缓存配置, 用于加载 CacheManager
  • 代理类advisor部分
  • BeanFactoryCacheOperationSourceAdvisor, 使用 cacheInterceptor 作为 advice, 覆写 invoke方法用于调用拦截
  • BeanFactoryCacheOperationSourceAdvisor，使用 CacheOperationSource 作为 pointCut, 覆写 methodMatcher.matches 方法用于 【装载代理类 && 实际调用生成调用链】
  • 其中 methodMatcher.matches() 方法就是判断有没有几个注解，并通过 SpringCacheAnnotationParser 解析这些注解成元数据CacheOperation。
  • cacheInterceptor 实现了 MethodInterceptor，而MethodInterceptor又实现了 Advice， 因此调用 目标方法时，就会调用到 cacheInterceptor 的 invoke 方法。
  • 解析过程，也就是matches识别注解的部分： 
  • @Nullable
private Collection<CacheOperation> parseCacheAnnotations(
    DefaultCacheConfig cachingConfig, AnnotatedElement ae, boolean localOnly) {

  Collection<CacheOperation> ops = null;

  Collection<Cacheable> cacheables = (localOnly ? AnnotatedElementUtils.getAllMergedAnnotations(ae, Cacheable.class) :
      AnnotatedElementUtils.findAllMergedAnnotations(ae, Cacheable.class));
  if (!cacheables.isEmpty()) {
    ops = lazyInit(null);
    for (Cacheable cacheable : cacheables) {
      ops.add(parseCacheableAnnotation(ae, cachingConfig, cacheable));
    }
  }
  Collection<CacheEvict> evicts = (localOnly ? AnnotatedElementUtils.getAllMergedAnnotations(ae, CacheEvict.class) :
      AnnotatedElementUtils.findAllMergedAnnotations(ae, CacheEvict.class));
  if (!evicts.isEmpty()) {
    ops = lazyInit(ops);
    for (CacheEvict evict : evicts) {
      ops.add(parseEvictAnnotation(ae, cachingConfig, evict));
    }
  }
  Collection<CachePut> puts = (localOnly ? AnnotatedElementUtils.getAllMergedAnnotations(ae, CachePut.class) :
      AnnotatedElementUtils.findAllMergedAnnotations(ae, CachePut.class));
  if (!puts.isEmpty()) {
    ops = lazyInit(ops);
    for (CachePut put : puts) {
      ops.add(parsePutAnnotation(ae, cachingConfig, put));
    }
  }
  Collection<Caching> cachings = (localOnly ? AnnotatedElementUtils.getAllMergedAnnotations(ae, Caching.class) :
      AnnotatedElementUtils.findAllMergedAnnotations(ae, Caching.class));
  if (!cachings.isEmpty()) {
    ops = lazyInit(ops);
    for (Caching caching : cachings) {
      Collection<CacheOperation> cachingOps = parseCachingAnnotation(ae, cachingConfig, caching);
      if (cachingOps != null) {
        ops.addAll(cachingOps);
      }
    }
  }

  return ops;
}
    invoke 方法
    1. contexts.get(CacheEvictOperation.class)： 识别CacheEvictOperation，前置缓存删除，默认不删：processCacheEvicts【beforeInvocation() default false】；
    2. contexts.get(CacheableOperation.class)：识别CacheableOperation，从缓存中获取，如果没有则使用get方法+lookup方法找到对应缓存中的数据
    3. contexts.get(CacheableOperation.class)：当命中为空时，识别CacheableOperation加入到请求列表
    4. 当命中时，包装 returnValue = cacheValue； 当未命中时，执行到cacheInterceptor 注册的 invocation.proceed(); 获取返回值作为 returnValue。cacheValue解包装returnValue
    5. contexts.get(CachePutOperation.class)：识别CachePutOperation，加入到请求列表中
    6. cachePutRequest.apply(): 将前面的 CacheableOperation、CachePutOperation 请求实际执行。put数据到缓存中
    7. contexts.get(CacheEvictOperation.class)：识别CacheEvictOperation，后置缓存删除，默认删除。即前置删除和后置删除只会成功一个。因为入参true / false， 会用于比较 operation.isBeforeInvocation(), 所以只能成功一个，就没有延时双删。 
    @Nullable
private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts) {
  // Special handling of synchronized invocation
  if (contexts.isSynchronized()) {
    CacheOperationContext context = contexts.get(CacheableOperation.class).iterator().next();
    if (isConditionPassing(context, CacheOperationExpressionEvaluator.NO_RESULT)) {
      Object key = generateKey(context, CacheOperationExpressionEvaluator.NO_RESULT);
      Cache cache = context.getCaches().iterator().next();
      try {
        return wrapCacheValue(method, cache.get(key, () -> unwrapReturnValue(invokeOperation(invoker))));
      }
      catch (Cache.ValueRetrievalException ex) {
        // The invoker wraps any Throwable in a ThrowableWrapper instance so we
        // can just make sure that one bubbles up the stack.
        throw (CacheOperationInvoker.ThrowableWrapper) ex.getCause();
      }
    }
    else {
      // No caching required, only call the underlying method
      return invokeOperation(invoker);
    }
  }


  // Process any early evictions
  processCacheEvicts(contexts.get(CacheEvictOperation.class), true,
      CacheOperationExpressionEvaluator.NO_RESULT);

  // Check if we have a cached item matching the conditions
  Cache.ValueWrapper cacheHit = findCachedItem(contexts.get(CacheableOperation.class));

  // Collect puts from any @Cacheable miss, if no cached item is found
  List<CachePutRequest> cachePutRequests = new LinkedList<>();
  if (cacheHit == null) {
    collectPutRequests(contexts.get(CacheableOperation.class),
        CacheOperationExpressionEvaluator.NO_RESULT, cachePutRequests);
  }

  Object cacheValue;
  Object returnValue;

  if (cacheHit != null && !hasCachePut(contexts)) {
    // If there are no put requests, just use the cache hit
    cacheValue = cacheHit.get();
    returnValue = wrapCacheValue(method, cacheValue);
  }
  else {
    // Invoke the method if we don't have a cache hit
    returnValue = invokeOperation(invoker);
    cacheValue = unwrapReturnValue(returnValue);
  }

  // Collect any explicit @CachePuts
  collectPutRequests(contexts.get(CachePutOperation.class), cacheValue, cachePutRequests);

  // Process any collected put requests, either from @CachePut or a @Cacheable miss
  for (CachePutRequest cachePutRequest : cachePutRequests) {
    cachePutRequest.apply(cacheValue);
  }

  // Process any late evictions
  processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue);

  return returnValue;
}

    附录

    spring-cache，基于aop，需要对aop有些了解，比较容易掌握。
    补充一下 spring-aop 加载的一个大致流程

  • doCreateBean 中会进行 bean的实例化 - 放入3级缓存 - 属性注入 - 初始化，其中初始化就会调用到后置处理器，使用 AbstractAutoProxyCreator.wrapIfNecessary() 完成代理类的加载。 （applyBeanPostProcessorsAfterInitialization，实现就有 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization）
  • wrapIfNecessary()， 就会加载容器中的 Advisor.class 类型的对象，然后执行canApply(), 基于 classFilter + 对类上的各个方法对比methodMatcher.matches方法，将满足切点的advisor都作为config加载到代理类中（org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors加载注解@Around等生成 Advisor）
  • 调用时，再调用jdk/cglib下的invoke方法。判断本地方法缓存有没有放入这个调用链，如果没有就生成一条调用链，就是通过config里的各个advisor对应的pointcut的methodMatcher.matches方法，返回值决定能不能添加到调用链中。这也就是为什么上面说 BeanFactoryCacheOperationSourceAdvisor，使用 CacheOperationSource 作为 pointCut, 覆写 methodMatcher.matches 方法用于 【装载代理类 && 实际调用生成调用链】的原因。之后将生成的调用链依次调用 MethodInterceptor.invoke，完成能力增强。 (List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); 形成调用链)
ITket
关注
浅析Spring-kafka源码——消费者模型的实现
WannaRunning的博客
06-17 2849
在使用Spring-kafka时，一般都是通过使用@KafkaListener注解的方法来实现消息监听和消费。今天写一下基于这个注解实现的消费端模型和实现的原理。
SpringCache源码解析（三）——@EnableCaching
moneywenxue的博客
09-09 1098
总结：AutoProxyRegistrar.registerBeanDefinitions()往容器中注入了一个类InfrastructureAdvisorAutoProxyCreator。这段是不是很熟悉，没错，声明式事务中注入的也是这个InfrastructureAdvisorAutoProxyCreator类，用来生成代理对象。
Spring cache源码分析
Java烘焙师
03-30 1112
Spring cache是一个缓存API层，封装了对多种缓存的通用操作，可以借助注解方便地为程序添加缓存功能。 常见的注解有@Cacheable、@CachePut、@CacheEvict，有没有想过背后的原理是什么？楼主带着疑问，阅读完Spring cache的源码后，做一个简要总结。 先说结论，核心逻辑在CacheAspectSupport类，封装了所有的缓存操作的主体逻辑，下面详细介绍。 题外话：如何阅读开源代码？ 有2种方法，可以结合起来使用： 静态代码阅读：查找关键类、方法的usage之处，熟练
Spring Cache源码分析
逗逗大魔王的博客
03-11 540
一、Cache介绍 Spring引入了对Cache的支持。其使用方法和原理都类似于Spring对事务管理的支持。它只是对缓存使用的抽象，通过它我们可以在不侵入业务代码的基础上让现有代码即刻支持缓存，具体的实现还要看去结合什么缓存，比如用redis来作缓存。 CacheManager是Spring定义的一个用来管理Cache的接口。Spring自身已经为我们提供了两种CacheManager的实...
spring boot框架中本地缓存@Cacheable原理与踩坑点详细解析
最新发布
Mr_hwt_123的博客
10-16 925
Spring Boot本地缓存使用存在对象引用共享风险，当修改@Cacheable返回的缓存对象时，会直接污染缓存数据。本文详细分析了这一风险机制，通过测试验证了修改缓存对象属性的危险性，并提出了两种解决方案：1）防御性拷贝（手动深拷贝或序列化深拷贝），确保返回缓存副本而非引用；2）采用不可变对象模式，通过设计不可变DTO从根本上防止缓存污染。这些最佳实践能有效避免因对象引用导致的缓存数据意外修改问题。
Spring-Cache 源码解析
weixin_44175409的博客
03-06 376
有了EnableCaching,才有了CacheInterceptor有了CacheInterceptor，CacheAutoConfiguration就会生效CacheAutoConfiguration会提供CacheProperties和CacheManagerCustomizers有了CacheProperties和CacheManagerCustomizers，ConcurrentMapCacheManager就会生效。
springCache源码分析
snail-jie的博客
06-12 1243
概括 springCache主要利用切面+拦截器去实现的 切面的matches方法判断是否要进行拦截 2.1 判断依据：方法上是否有Cacheable、CacheEvict、CachePut、Caching注解 BeanFactoryCacheOperationSourceAdvisor分析 继承SpringAop的AbstractBeanFactoryPointcutAdvisor类，重写其getPointcut方法，返回CacheOperationSourcePointcut 重点关注Cac
Spring Cache 源码分析
补
11-06 397
今天简单分析下了SpringCache的原理，记录下分析过程 当我们在Springboot下使用SpringCache时，需要使用@EnableCaching 注解开启Cache装配的，所以就从这里入手： @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(CachingConfigurationSelector.class) public @interface Enab...
SpringCache源码解析（一）
moneywenxue的博客
08-24 1362
SpringBoot 确实是通过 spring.factories 文件实现自动配置的。Spring Cache 也是遵循这一机制来实现自动装配的。具体来说,Spring Cache 的自动装配是通过 org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration 这个类来实现的。这个类位于 spring-boot-autoconfigure 包下。
深入 MyBatis-Spring 源码解析 ——揭秘 MyBatis 与 Spring 的完美融合
喵手的博客
12-09 1746
当谈到 Java 的持久层框架，MyBatis 几乎总会出现在讨论中；它轻量、灵活，非常适合需要复杂 SQL 查询的场景。而我们的大管家 Spring，除了帮我们管理依赖和控制反转之外，还可以跟 MyBatis 完美地配合在一起！这就是我们今天要讨论的主题——。在这个分析中，我们将通过源码来揭秘 MyBatis-Spring 是如何在两者间架起桥梁的，希望让你对其工作原理有一个深入的理解。MyBatis-Spring 是 Spring 提供的一个适配器模块，它的目标是帮助开发者在 Spring 应用中。
spring-cache.xsd+spring-encache.xsd
09-01
1. 引入Schema：在XML文件的头部声明对spring-cache.xsd或spring-encache.xsd的引用，以便解析器理解相关的元素。 2. 配置缓存管理器：声明一个`<beans>`元素内的`<cache:annotation-driven/>`或`<cache:advice/>`来...
Spring-4.3源码
07-05
Spring框架是Java开发中不可或缺的一部分，它以其强大的依赖注入（DI）和面向切面...通过深入学习Spring 4.3的源码，我们可以更深入地理解Spring的运作机制，从而更好地利用这个框架来构建高效、可维护的企业级应用。
SpringBoot-Cache源码分享.zip
11-24
SpringBoot与缓存原理，整合redis、redis序列化，缓存注解、运行流程、原理讲解 配套三篇文章，推荐大家哦 https://blog.youkuaiyun.com/xiaozhegaa/article/details/110084902
SpringCache框架加载/拦截原理详解
08-26
主要介绍了SpringCache框架加载/拦截原理详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spring cache源码解析（四）——从@EnableCaching开始来阅读源码
moneywenxue的博客
12-24 1071
@EnableCaching：开启缓存功能; @Cacheable：获取缓存; @CachePut：更新缓存; @CacheEvict：删除缓存;
Spring-Cache源码：基于注解的缓存
zzzj的博客
05-29 377
首先，通过注解引入注入到容器中将注入到容器中基于Spring-AOP创建代理对象代理对象执行方法时被拦截将@Cacheable@CachePut转换为对应的在execute()方法中基于介入方法的执行流程，处理各种缓存逻辑。
springCache源码解读
shanliang
12-31 939
springCache源码解读
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值