Spring缓存注解的使用与源码分析

缺乏、安全感 2022-11-15 00:11 199阅读 0赞

Spring Cache提供了一个对缓存使用的抽象，以及大量的实现方便开发者使用。

Spring Cache主要提供了如下注解：

<table> 
 <thead> 
  <tr> 
   <th>注解</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Cacheable</td> 
   <td>根据方法的请求参数对其结果进行缓存</td> 
  </tr> 
  <tr> 
   <td>@CachePut</td> 
   <td>根据方法的请求参数对其结果进行缓存，和@Cacheable不同的是，它每次都会触发真实方法的调用</td> 
  </tr> 
  <tr> 
   <td>@CacheEvict</td> 
   <td>根据一定的条件对缓存进行清空</td> 
  </tr> 
 </tbody> 
</table>

# 缓存注解的使用 #

## 配置类 ##

@PropertySource("classpath:redis.properties")
    @Configuration
    @EnableCaching // 开启缓存注解
    public class CacheConfig { 
    
    	@Value("${redis.host}")
    	private String hostName;
    
    	@Value("${redis.port}")
    	private Integer port;
    
    	@Value("${redis.password}")
    	private String password;
    	
    	@Bean
    	public RedisCacheManager redisCacheManager() { 
    		return RedisCacheManager.create(jedisConnectionFactory());
    	}
    
    	@Bean
    	public JedisConnectionFactory jedisConnectionFactory() { 
    		RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration(hostName, port);
    		redisStandaloneConfiguration.setPassword(password);
    		JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(redisStandaloneConfiguration);
    		return jedisConnectionFactory;
    	}
    }

## service层的使用 ##

@Cacheable(cacheNames = "redisCache", key = "'good' + #id")
    public Good queryById(Integer id) { 
    	System.out.println("-------queryById-------");
    	return goodDao.selectById(id);
    }
    
    @CachePut(cacheNames = "redisCache", key = "'good' + #id")
    public Good updateGood(Integer id) { 
    	Good good = new Good();
    	good.setId(id);
    	good.setGoodName("iphone xx");
    	goodDao.updateById(good);
    	return good;
    }

## 测试类 ##

public class CacheDemo { 
    
    	public static void main(String[] args) { 
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
    		applicationContext.register(GoodDao.class);
    		applicationContext.register(GoodServiceImpl.class);
    		applicationContext.register(CacheConfig.class);
    		applicationContext.register(JdbcConfig.class);
    		applicationContext.refresh();
    
    		GoodService goodService = applicationContext.getBean(GoodService.class);
    		Good good = goodService.updateGood(6);
    		goodService.queryById(good.getId());
    	}
    }

运行结果如下：

DEBUG JdbcTemplate:860 - Executing prepared SQL update
    DEBUG JdbcTemplate:609 - Executing prepared SQL statement [update t_good set good_name=? where id=?]
    DEBUG DataSourceUtils:115 - Fetching JDBC Connection from DataSource
    DEBUG DriverManagerDataSource:144 - Creating new JDBC DriverManager Connection to [jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&allowMultiQueries=true&characterEncoding=UTF-8&useFastDateParsing=false&zeroDateTimeBehavior=convertToNull]

从运行结果可以发现第二次查询直接走的缓存切面，并没有去查询数据库。

# 源码分析 #

## @EnableCaching ##

@EnableCaching用于向容器中注入相关配置类：

org.springframework.cache.annotation.EnableCaching

@Import(CachingConfigurationSelector.class)
    public @interface EnableCaching {

@EnableCaching导入了CachingConfigurationSelector。

org.springframework.cache.annotation.CachingConfigurationSelector

public String[] selectImports(AdviceMode adviceMode) { 
    	switch (adviceMode) { 
    		case PROXY:
    			return getProxyImports();
    		case ASPECTJ:
    			return getAspectJImports();
    		default:
    			return null;
    	}
    }
    
    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);
    }

CachingConfigurationSelector注入了AutoProxyRegistrar和ProxyCachingConfiguration。

## AutoProxyRegistrar ##

顾名思义，AutoProxyRegistrar从名称上就可以看出其本质是一个ImportBeanDefinitionRegistrar，而ImportBeanDefinitionRegistrar最重要的方法为registerBeanDefinitions()，这个方法的主要作用就是用方法参数中的registry向容器中注入一些BeanDefinition。

> org.springframework.context.annotation.AutoProxyRegistrar\#registerBeanDefinitions

> –> org.springframework.aop.config.AopConfigUtils\#registerAutoProxyCreatorIfNecessary(org.springframework.beans.factory.support.BeanDefinitionRegistry)

> –> org.springframework.aop.config.AopConfigUtils\#registerAutoProxyCreatorIfNecessary(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object)

public static BeanDefinition registerAutoProxyCreatorIfNecessary(
    		BeanDefinitionRegistry registry, @Nullable Object source) { 
    
    	return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
    }

总结：AutoProxyRegistrar.registerBeanDefinitions()往容器中注入了一个类InfrastructureAdvisorAutoProxyCreator。

> 这段是不是很熟悉，没错，声明式事务中注入的也是这个InfrastructureAdvisorAutoProxyCreator类，用来生成代理对象。

## ProxyCachingConfiguration ##

ProxyCachingConfiguration向Spring容器中注入了三个Bean：

1.  BeanFactoryCacheOperationSourceAdvisor：切面，用来匹配目标方法和目标类，看那些方法需要实现缓存的增强。
2.  CacheOperationSource：用来解析缓存相关的注解
3.  CacheInterceptor：实现了Advice，是一个通知，实现对目标方法的增强。

@Configuration
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    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() { 
    		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;
    	}
    
    }

## BeanFactoryCacheOperationSourceAdvisor ##

BeanFactoryCacheOperationSourceAdvisor是一个切面，切面需要包括通知和切点：

*  Advice通知：CacheInterceptor，由ProxyCachingConfiguration注入。
 *  Pointcut切点：内部CacheOperationSourcePointcut类型的属性。

### CacheOperationSourcePointcut ###

Pointcut主要包含两部分，对目标类的匹配，对目标方法的匹配。

对目标类的匹配，其实啥也没干，返回true，主要逻辑在对目标方法的匹配上，大部分Pointcut都是如此：

private class CacheOperationSourceClassFilter implements ClassFilter { 
    
    	@Override
    	public boolean matches(Class<?> clazz) { 
    		if (CacheManager.class.isAssignableFrom(clazz)) { 
    			return false;
    		}
    		// 啥也没干
    		CacheOperationSource cas = getCacheOperationSource();
    		return (cas == null || cas.isCandidateClass(clazz));
    	}
    }

对目标方法的匹配：

public boolean matches(Method method, Class<?> targetClass) { 
    	CacheOperationSource cas = getCacheOperationSource();
    	/** * @see AbstractFallbackCacheOperationSource#getCacheOperations(java.lang.reflect.Method, java.lang.Class) */
    	// 就是看目标方法上面有没有缓存注解
    	return (cas != null && !CollectionUtils.isEmpty(cas.getCacheOperations(method, targetClass)));
    }

这里会委托给CacheOperationSource来解析缓存注解，这个类是在ProxyCachingConfiguration中注入的。

最终会调用到org.springframework.cache.annotation.SpringCacheAnnotationParser\#parseCacheAnnotations(org.springframework.cache.annotation.SpringCacheAnnotationParser.DefaultCacheConfig, java.lang.reflect.AnnotatedElement, boolean)

private Collection<CacheOperation> parseCacheAnnotations(
    		DefaultCacheConfig cachingConfig, AnnotatedElement ae, boolean localOnly) { 
    
    	Collection<? extends Annotation> anns = (localOnly ?
    			AnnotatedElementUtils.getAllMergedAnnotations(ae, CACHE_OPERATION_ANNOTATIONS) :
    			AnnotatedElementUtils.findAllMergedAnnotations(ae, CACHE_OPERATION_ANNOTATIONS));
    	if (anns.isEmpty()) { 
    		return null;
    	}
    
    	// @Cacheable解析为CacheableOperation
    	// @CacheEvict解析为CacheEvictOperation
    	// @CachePut解析为CachePutOperation
    	final Collection<CacheOperation> ops = new ArrayList<>(1);
    	anns.stream().filter(ann -> ann instanceof Cacheable).forEach(
    			ann -> ops.add(parseCacheableAnnotation(ae, cachingConfig, (Cacheable) ann)));
    	anns.stream().filter(ann -> ann instanceof CacheEvict).forEach(
    			ann -> ops.add(parseEvictAnnotation(ae, cachingConfig, (CacheEvict) ann)));
    	anns.stream().filter(ann -> ann instanceof CachePut).forEach(
    			ann -> ops.add(parsePutAnnotation(ae, cachingConfig, (CachePut) ann)));
    	anns.stream().filter(ann -> ann instanceof Caching).forEach(
    			ann -> parseCachingAnnotation(ae, cachingConfig, (Caching) ann, ops));
    	return ops;
    }

### CacheInterceptor ###

CacheInterceptor是一个Advice，用来实现对目标方法的增强，当调用目标方法时会先进入CacheInterceptor.invoke()方法：

org.springframework.cache.interceptor.CacheInterceptor\#invoke

public Object invoke(final MethodInvocation invocation) throws Throwable { 
    	Method method = invocation.getMethod();
    
    	CacheOperationInvoker aopAllianceInvoker = () -> { 
    		try { 
    			// 调用目标方法，后面的代码会回调到这里
    			return invocation.proceed();
    		}
    		catch (Throwable ex) { 
    			throw new CacheOperationInvoker.ThrowableWrapper(ex);
    		}
    	};
    
    	try { 
    		return execute(aopAllianceInvoker, invocation.getThis(), method, invocation.getArguments());
    	}
    	catch (CacheOperationInvoker.ThrowableWrapper th) { 
    		throw th.getOriginal();
    	}
    }

org.springframework.cache.interceptor.CacheAspectSupport\#execute(org.springframework.cache.interceptor.CacheOperationInvoker, java.lang.reflect.Method, org.springframework.cache.interceptor.CacheAspectSupport.CacheOperationContexts)

private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts) { 
    	// Special handling of synchronized invocation
    	if (contexts.isSynchronized()) {  // false不会进入
    		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, handleSynchronizedGet(invoker, key, cache));
    			}
    			catch (Cache.ValueRetrievalException ex) { 
    				// Directly propagate ThrowableWrapper from the invoker,
    				// or potentially also an IllegalArgumentException etc.
    				ReflectionUtils.rethrowRuntimeException(ex.getCause());
    			}
    		}
    		else { 
    			// No caching required, only call the underlying method
    			return invokeOperation(invoker);
    		}
    	}
    
    
    	// Process any early evictions
    	// 先调用@CacheEvict注解中的属性beforeInvocation=true的，实际上这个值默认为false，这里一般不会干啥，看后面的调用
    	// cache.evict()
    	processCacheEvicts(contexts.get(CacheEvictOperation.class), true,
    			CacheOperationExpressionEvaluator.NO_RESULT);
    
    	// Check if we have a cached item matching the conditions
    	// cache.get()
    	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
    	// 调用@CacheEvict注解中的属性beforeInvocation=false的
    	processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue);
    
    	return returnValue;
    }

# 扩展缓存注解 #

有时候由于业务需要或者Spring提供的缓存不满足我们的要求，如无法解决缓存雪崩问题，扩展步骤如下：

1.  实现CacheManager接口或继承AbstractCacheManager，管理自身的cache实例，也可以直接使用内置的SimpleCacheManager。
2.  实现Cache接口，自定义缓存实现逻辑。
3.  将自定义的Cache和CacheManager进行关联并注入到Spring容器中。