Spring -- Cache原理

@Component
public class SimpleCacheCustomizer implements CacheManagerCustomizer<ConcurrentMapCacheManager> {
    @Override
    public void customize(ConcurrentMapCacheManager cacheManager) {
        cacheManager.setCacheNames(Lists.newArrayList("quding","mrdear"));
    }   
}

// 实例化一个基于内存的缓存管理器, 其内部有users，addresses两个Cache对象。
@Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("users","addresses");
}

// 实例化一个基于Caffeine的缓存管理器，其内部有users Cache对象。
    @Bean
    public CacheManager hoursCache() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
            .initialCapacity(50)
            .maximumSize(100)
            .expireAfterWrite(1, TimeUnit.HOURS);

        cacheManager.setCaffeine(caffeine);
        cacheManager.setCacheNames(Collections.singletonList("users"));
        return cacheManager;
    }

/**
 * 结果放入缓存users中
 * 使用缓存管理器为(bean名) cacheManager
 * 缓存key为 参数id
 * id小于2的不缓存
 */
@Cacheable(cacheNames = "users", cacheManager = "cacheManager", key = "#id", unless = "#id < 2")
public User findById(Long id) {
    logger.info("query user={} from db ", id);
    return new User(id);
}

@Nullable
protected Object execute(CacheOperationInvoker invoker, Object target, Method method, Object[] args) {
	// Check whether aspect is enabled (to cope with cases where the AJ is pulled in automatically)
	if (this.initialized) {
		Class<?> targetClass = getTargetClass(target);
		// 存储所有缓存操作的池子,一个注解可以理解为一次缓存操作
		CacheOperationSource cacheOperationSource = getCacheOperationSource();
		if (cacheOperationSource != null) {
			// 根据 方法 + 类 定位对应的缓存操作
			Collection<CacheOperation> operations = cacheOperationSource.getCacheOperations(method, targetClass);
			if (!CollectionUtils.isEmpty(operations)) {
				// 下一步调用
				return execute(invoker, method,
						new CacheOperationContexts(operations, method, args, target, targetClass));
			}
		}
	}
	return invoker.invoke();
}

@Nullable
private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts) {
	....
	// 从命令中,取出过期指令,优先处理
	processCacheEvicts(contexts.get(CacheEvictOperation.class), true,
			CacheOperationExpressionEvaluator.NO_RESULT);

	// 获取对应的缓存
	Cache.ValueWrapper cacheHit = findCachedItem(contexts.get(CacheableOperation.class));

	// 缓存不存在,则从context中获取 PUT命令
	List<CachePutRequest> cachePutRequests = new LinkedList<>();
	if (cacheHit == null) {
		collectPutRequests(contexts.get(CacheableOperation.class),
				CacheOperationExpressionEvaluator.NO_RESULT, cachePutRequests);
	}

	Object cacheValue;
	Object returnValue;

	// 缓存命令,且不存在PUT
	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
		// 存在PUT指令则会执行真实调用
		returnValue = invokeOperation(invoker);
		cacheValue = unwrapReturnValue(returnValue);
	}

	// 根据结果,从context中获取需要执行的put命令
	collectPutRequests(contexts.get(CachePutOperation.class), cacheValue, cachePutRequests);

	// 执行PUT操作
	for (CachePutRequest cachePutRequest : cachePutRequests) {
		cachePutRequest.apply(cacheValue);
	}

	// 根据结果处理过期命令
	processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue);

	return returnValue;
}

if (contexts.isSynchronized()) {
            // 获取@Cacheable注解配置
			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);
			}
		}

/**
		 * Compute the key for the given caching operation.
		 */
		@Nullable
		protected Object generateKey(@Nullable Object result) {
        // 当没指定key，则使用SpEL生成该key
			if (StringUtils.hasText(this.metadata.operation.getKey())) {
				EvaluationContext evaluationContext = createEvaluationContext(result);
				return evaluator.key(this.metadata.operation.getKey(), this.metadata.methodKey, evaluationContext);
			}
        // 使用自定义key生成策略
			return this.metadata.keyGenerator.generate(this.target, this.metadata.method, this.args);
		}
        

    // EL上下文创建，可以看到其能获取到的信息，基本是参数中所有的值了
		private EvaluationContext createEvaluationContext(@Nullable Object result) {
			return evaluator.createEvaluationContext(this.caches, this.metadata.method, this.args,
					this.target, this.metadata.targetClass, this.metadata.targetMethod, result, beanFactory);
		}