@Cacheable(cacheNames = "cache1", key = "#id")
public User getUserById(int id) {
    User user = userMapper.selectById(id);
    log.info("getUserById: {}", user);
    return user;
}

@CachePut(cacheNames = "cache1", key = "#user.id", unless = "#result == null")
public User updateUser(User user) {
    int count = userMapper.updateUser(user);
    if (count == 0) {
        log.info("update failed");
        return null;
    }
    return user;
}

@CacheEvict(cacheNames = "cache1", key = "#id")
public int deleteUserById(int id) {
    int result = userMapper.deleteUserById(id);
    log.info("delete result: {}", result);
    return result;
}

@Caching(
    put = {@CachePut(cacheNames = "cache1", key = "#user.id", unless = "#result == null"),
        @CachePut(cacheNames = "cache1", key = "#user.username", unless = "#result == null")}
)
public User updateUser(User user) {
    int count = userMapper.updateUser(user);
    if (count == 0) {
        log.info("update failed");
        return null;
    }
    return user;
}

// ----------------------------------- CacheInterceptor -------------------------------------
public class CacheInterceptor extends CacheAspectSupport implements MethodInterceptor {
    @Override
    public Object invoke(final MethodInvocation invocation) throws Throwable {
        Method method = invocation.getMethod();
        // 采用函數(shù)對(duì)象的方式，把該函數(shù)對(duì)象傳給父類的 execute() 執(zhí)行
        // 最終還是執(zhí)行 invocation.proceed()
        CacheOperationInvoker aopAllianceInvoker = () -> {
            try {
                return invocation.proceed();
            }
            catch (Throwable ex) {
                // 這里對(duì)異常做了一次封裝，并拋出此異常
                throw new CacheOperationInvoker.ThrowableWrapper(ex);
            }
        };
        Object target = invocation.getThis();
        try {
            // 1. 執(zhí)行父類的 execute()
            return execute(aopAllianceInvoker, target, method, invocation.getArguments());
        }
        catch (CacheOperationInvoker.ThrowableWrapper th) {
            // 拋出原始異常
            throw th.getOriginal();
        }
    }
}

// --------------------------------- CacheAspectSupport -----------------------------------
protected Object execute(CacheOperationInvoker invoker, Object target, Method method, Object[] args) {
    if (this.initialized) {
        Class<?> targetClass = getTargetClass(target);
        // 1. 獲取 CacheOperationSource
        // 一般我們使用的都是注解類型的，所以會(huì)獲取到 AnnotationCacheOperationSource
        // AnnotationCacheOperationSource 內(nèi)部有注解解析器，可以解析得到 CacheOperations
        CacheOperationSource cacheOperationSource = getCacheOperationSource();
        if (cacheOperationSource != null) {
            // 2. 根據(jù) AnnotationCacheOperationSource 解析得到 targetClass#method() 上的 CacheOperations
            // CacheOperation 是一個(gè)抽象類，它的三個(gè)實(shí)現(xiàn)類分別對(duì)應(yīng) @Cacheable、@CachePut、@CacheEvict
            // CacheableOperation、CachePutOperation、CacheEvictOperation
            // 其實(shí)就是解析到目標(biāo)類目標(biāo)方法上的注解元信息 CacheOperations
            Collection<CacheOperation> operations = 
                cacheOperationSource.getCacheOperations(method, targetClass);
            if (!CollectionUtils.isEmpty(operations)) {
                // 3. CacheOperations 不為空，將 CacheOperations 等信息聚合為 CacheOperationContexts 對(duì)象
                // CacheOperationContexts 類功能很強(qiáng)大，debug 的時(shí)候可以點(diǎn)進(jìn)去看看
                // 每個(gè) CacheOperation 都會(huì)對(duì)應(yīng)一個(gè) CacheOperationContext，塞入 CacheOperationContexts
                // 執(zhí)行重載的 execute()
                return execute(invoker, method,
                     new CacheOperationContexts(operations, method, args, target, targetClass));
            }
        }
    }
    return invoker.invoke();
}

// --------------------------------- CacheAspectSupport -----------------------------------
private Object execute(CacheOperationInvoker invoker, 
                       Method method, 
                       CacheOperationContexts contexts) {
    // 1. 如果方法需要 sync 的話，此處在執(zhí)行 cache.get() 時(shí)會(huì)加鎖
    // 我們可以先不看此處內(nèi)部邏輯
    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, handleSynchronizedGet(invoker, key, cache));
            }
            catch (Cache.ValueRetrievalException ex) {
                ReflectionUtils.rethrowRuntimeException(ex.getCause());
            }
        }
        else {
            return invokeOperation(invoker);
        }
    }
    // 2. 執(zhí)行早期的 CacheEvict
    // 如果 @CacheEvict 的 beforeInvocation 屬性是 true 的話（默認(rèn)是 false）
    // 會(huì)在方法執(zhí)行前就執(zhí)行 CacheEvict
    processCacheEvicts(contexts.get(CacheEvictOperation.class), true,
                       CacheOperationExpressionEvaluator.NO_RESULT);
    // 3. 如果有 CacheableOperation 的話，也就是有 @Cacheable 注解的話
    // 先去緩存中取緩存值，并包裝為 Cache.ValueWrapper 對(duì)象
    // 	如果所有的 @Cacheable 都沒有緩存值，cacheHit 將為 null
    // 	反過(guò)來(lái)說(shuō)，但凡有一個(gè) @Cacheable 有緩存值，cacheHit 將不為 null
    Cache.ValueWrapper cacheHit = findCachedItem(contexts.get(CacheableOperation.class));
    // 4. 創(chuàng)建一個(gè) List<CachePutRequest> 集合
    // 如果 cacheHit == null，此時(shí)需要把所有 @Cacheable 中對(duì)應(yīng) key 都執(zhí)行 CachePut 操作
    // 所以這里會(huì)收集 CacheableOperation，并作為 CachePutOperation 塞入到 List<CachePutRequest> 中
    List<CachePutRequest> cachePutRequests = new ArrayList<>();
    if (cacheHit == null) {
        collectPutRequests(contexts.get(CacheableOperation.class),
                           CacheOperationExpressionEvaluator.NO_RESULT, cachePutRequests);
    }
    Object cacheValue;
    Object returnValue;
    if (cacheHit != null && !hasCachePut(contexts)) {
        // 5.1 如果緩存中的值不為空，且沒有 @CachePut
        // 顯然返回值就是 cacheValue，并做一定的包裝
        cacheValue = cacheHit.get();
        returnValue = wrapCacheValue(method, cacheValue);
    }
    else {
        // 5.2 其他情況，緩存中的值為空 || 有 @CachePut
        // 執(zhí)行目標(biāo)方法，返回值作為新的 cacheValue，并做一定的包裝
        // 這里執(zhí)行目標(biāo)方法時(shí)可能會(huì)出現(xiàn)異常，出現(xiàn)異常的情況下就不會(huì)執(zhí)行 CachePut 和 CacheEvict 操作了！??！
        returnValue = invokeOperation(invoker);
        cacheValue = unwrapReturnValue(returnValue);
    }
    // 6. 收集顯式聲明的 CachePutOperation，也就是有顯式聲明的 @CachePut
    collectPutRequests(contexts.get(CachePutOperation.class), cacheValue, cachePutRequests);
    // 7. 執(zhí)行 Cache.put()，處理 CachePut 和沒有緩存命中的 Cacheable 
    for (CachePutRequest cachePutRequest : cachePutRequests) {
        cachePutRequest.apply(cacheValue);
    }
    // 8. 處理 @CacheEvict
    // @CacheEvict 的 beforeInvocation 為 false 時(shí)，在目標(biāo)方法執(zhí)行完才執(zhí)行 CacheEvict
    processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue);
    // 返回值
    return returnValue;
}

// --------------------------------- CacheAspectSupport -----------------------------------
private void processCacheEvicts(Collection<CacheOperationContext> contexts, 
    boolean beforeInvocation, Object result) {
    for (CacheOperationContext context : contexts) {
        CacheEvictOperation operation = (CacheEvictOperation) context.metadata.operation;
        if (beforeInvocation == operation.isBeforeInvocation() 
            && isConditionPassing(context, result)) {
            performCacheEvict(context, operation, result);
        }
    }
}
// --------------------------------- CacheAspectSupport -----------------------------------
private void performCacheEvict(CacheOperationContext context, 
    CacheEvictOperation operation, Object result) {
    Object key = null;
    // 1. 針對(duì)每個(gè) @CacheEvict 注解中的每個(gè) cache 都執(zhí)行處理
    for (Cache cache : context.getCaches()) {
        if (operation.isCacheWide()) {
            logInvalidating(context, operation, null);
            doClear(cache, operation.isBeforeInvocation());
        }
        else {
            if (key == null) {
                // 2. 生成 cacheKey
                key = generateKey(context, result);
            }
            logInvalidating(context, operation, key);
            // 3. 執(zhí)行 doEvict()
            doEvict(cache, key, operation.isBeforeInvocation());
        }
    }
}

// --------------------------------- CacheAspectSupport -----------------------------------
private Cache.ValueWrapper findCachedItem(Collection<CacheOperationContext> contexts) {
    Object result = CacheOperationExpressionEvaluator.NO_RESULT;
    // 1. 遍歷所有的 CacheOperationContext
    for (CacheOperationContext context : contexts) {
        if (isConditionPassing(context, result)) {
            Object key = generateKey(context, result);
            // 2. 如果命中了一個(gè) @Cacheable 緩存，直接返回緩存值
            Cache.ValueWrapper cached = findInCaches(context, key);
            if (cached != null) {
                return cached;
            }
            else {
                if (logger.isTraceEnabled()) {
                    logger.trace("No cache entry for key in cache(s) " + context.getCacheNames());
                }
            }
        }
    }
    // 3. 都沒命中，返回 null
    return null;
}
// --------------------------------- CacheAspectSupport -----------------------------------
private Cache.ValueWrapper findInCaches(CacheOperationContext context, Object key) {
    // 遍歷 @Cacheable 中所有的 cache
    // 有一個(gè) cache 有緩存值就返回該緩存值
    for (Cache cache : context.getCaches()) {
        Cache.ValueWrapper wrapper = doGet(cache, key);
        if (wrapper != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Cache entry for key found in cache '" + cache.getName());
            }
            return wrapper;
        }
    }
    return null;
}

public void apply(@Nullable Object result) {
    if (this.context.canPutToCache(result)) {
        // 遍歷 @CachePut 中所有的 cache，執(zhí)行 doPut()
        for (Cache cache : this.context.getCaches()) {
            doPut(cache, this.key, result);
        }
    }
}

// result == null 的話不進(jìn)行緩存
@Cacheable(cacheNames = "demoCache", key = "#id",unless = "#result == null")

@CachePut(cacheNames = "demoCache", key = "#id") // 不同的注解可以標(biāo)注多個(gè)
//@Cacheable(cacheNames = "demoCache", key = "#id") // 相同注解標(biāo)注兩個(gè)是不行的 因?yàn)樗⒉皇茾Repeatable的
@Cacheable(cacheNames = "demoCache", key = "#id")
@Override
public Object getFromDB(Integer id) {
    System.out.println("模擬去db查詢~~~" + id);
    return "hello cache...";
}