<dependencies>
    <!-- 使用 jedis 客戶端添加以下依賴 -->
    <dependency>
        <groupId>com.alicp.jetcache</groupId>
        <artifactId>jetcache-starter-redis</artifactId>
        <version>${version}</version>
    </dependency>
    <!-- 使用 lettuce 客戶端添加以下依賴 -->
    <dependency>
        <groupId>com.alicp.jetcache</groupId>
        <artifactId>jetcache-starter-redis-lettuce</artifactId>
        <version>${version}</version>
    </dependency>
</dependencies>

jetcache:
  statIntervalMinutes: 60
  areaInCacheName: false
  penetrationProtect: false
  enableMethodCache: true
  hiddenPackages: com.xxx.xxx,com.xxx.xxx
  local:
    default:
      type: caffeine # 支持的類型：linkedhashmap、caffeine
      limit: 100
      keyConvertor: fastjson # 支持的類型：fastjson，可自定義轉(zhuǎn)換器函數(shù)
      expireAfterWriteInMillis: 600000
      expireAfterAccessInMillis: 300000 
  remote:
    default:
      type: redis.lettuce # 支持的類型：redis、redis.lettuce
      keyPrefix: '系統(tǒng)簡稱:所屬名字:'
      keyConvertor: fastjson
      valueEncoder: java # 支持的類型：kryo、java，可自定義編碼器
      valueDecoder: java # 支持的類型：kryo、java，可自定義解碼器
      expireAfterWriteInMillis: 3600000
      #readFrom: slavePreferred # 優(yōu)先從Slave節(jié)點中讀取
      uri: redis-sentinel://host1:26379,host2:26379,host3:26379/?sentinelMasterId=mymaster # 哨兵模式
      #uri: redis://127.0.0.1:6379/ # 單節(jié)點模式
      #mode: masterslave # 設(shè)置為主從模式
      #uri: # 集群模式
      #- redis://127.0.0.1:7000
      #- redis://127.0.0.1:7001
      #- redis://127.0.0.1:7002
    example:
      keyPrefix: '系統(tǒng)簡稱:所屬名字:'
      type: redis
      keyConvertor: fastjson
      valueEncoder: java
      valueDecoder: java
      expireAfterWriteInMillis: 3600000
      poolConfig:
        minIdle: 10
        maxIdle: 20
        maxTotal: 50
      #password: xxx # 連接密碼
      #timeout: 2000 # 連接的超時時間，讀取數(shù)據(jù)的超時時間
      #database: 0 # 連接的數(shù)據(jù)庫
      #clientName: null # 客戶端名稱
      #ssl: 是否使用SSL
      host: ${redis.host}
      port: ${redis.port}
      #sentinel: host1:26379,host2:26379,host3:26379 # 哨兵模式
      #masterName: mymaster

/**
 * 啟動類
 */
@SpringBootApplication
@EnableCreateCacheAnnotation
@EnableMethodCache(basePackages = "com.xxx.xxx")
public class Application {
    public static void main(String[] args){
        SpringApplication.run(Application.class, args);
    }
}
/**
 * 接口
 */
public interface JetCacheExampleService {
    
    User getValue(long userId);
    
    void updateValue(User  user);
    
    void deleteValue(User  user);
}
/**
 * 實現(xiàn)類
 */
@Service
public class JetCacheExampleServiceImpl implements JetCacheExampleService {
    
    @CreateCache(name = "JetCacheExampleServiceImpl.exampleCache" , localLimit = 50 ,cacheType = CacheType.LOCAL)
    @CachePenetrationProtect
    private Cache<Long, User> exampleCache;
    
    @Override
    @Cached(name = "JetCacheExampleService.getValue", expire = 3600 * 6, localLimit = 50, cacheType = CacheType.BOTH)
    @CacheRefresh(refresh = 3600, stopRefreshAfterLastAccess = 3600 * 2)
    @CachePenetrationProtect
    public User getValue(long userId){
        String result = new User();
        // ... 處理邏輯
        return result;
    }
    
    @Override
    @CacheUpdate(name = "JetCacheExampleService.getValue", key="#user.userId", value="#user")
    public void updateValue(User user){
        // 處理邏輯
    }
    
    @Override
    @CacheInvalidate(name = "JetCacheExampleService.getValue", key="#user.userId")
    public void deleteValue(User user){
        // 處理邏輯
    }
    
}

@Service
public class JetCacheExampleServiceImpl implements JetCacheExampleService {
    
	@CreateCache(name = "JetCacheExampleServiceImpl.exampleCache" , localLimit = 50 ,cacheType = CacheType.LOCAL)
	private Cache<Long, User> exampleCache;
	@PostConstruct
	public exampleCacheInit(){
    	RefreshPolicy policy = RefreshPolicy.newPolicy(60, TimeUnit.MINUTES)
                	.stopRefreshAfterLastAccess(120, TimeUnit.MINUTES);
        exampleCache.config().setLoader(this::loadFromDatabase);
        exampleCache.config().setRefreshPolicy(policy);
	}
}

public interface Cache<K, V> extends Closeable {
    Logger logger = LoggerFactory.getLogger(Cache.class);
    //-----------------------------JSR 107 style API------------------------------------------------
    default V get(K key) throws CacheInvokeException {
        CacheGetResult<V> result = GET(key);
        if (result.isSuccess()) {
            return result.getValue();
        } else {
            return null;
        }
    }
    default Map<K, V> getAll(Set<? extends K> keys) throws CacheInvokeException {
        MultiGetResult<K, V> cacheGetResults = GET_ALL(keys);
        return cacheGetResults.unwrapValues();
    }
    default void put(K key, V value) {
        PUT(key, value);
    }
    default void putAll(Map<? extends K, ? extends V> map) {
        PUT_ALL(map);
    }
    default boolean putIfAbsent(K key, V value) { // 多級緩存MultiLevelCache不支持此方法
        CacheResult result = PUT_IF_ABSENT(key, value, config().getExpireAfterWriteInMillis(), TimeUnit.MILLISECONDS);
        return result.getResultCode() == CacheResultCode.SUCCESS;
    }
    default boolean remove(K key) {
        return REMOVE(key).isSuccess();
    }
    default void removeAll(Set<? extends K> keys) {
        REMOVE_ALL(keys);
    }
    <T> T unwrap(Class<T> clazz);
    @Override
    default void close() {
    }
    //--------------------------JetCache API---------------------------------------------
    CacheConfig<K, V> config();
    default AutoReleaseLock tryLock(K key, long expire, TimeUnit timeUnit) {
        if (key == null) {
            return null;
        }
        // 隨機(jī)生成一個值
        final String uuid = UUID.randomUUID().toString();
        // 過期時間
        final long expireTimestamp = System.currentTimeMillis() + timeUnit.toMillis(expire);
        final CacheConfig config = config();
        AutoReleaseLock lock = () -> { // 創(chuàng)建一把會自動釋放資源的鎖，實現(xiàn)其 close() 方法
            int unlockCount = 0;
            while (unlockCount++ < config.getTryLockUnlockCount()) {
                if(System.currentTimeMillis() < expireTimestamp) { // 這把鎖還沒有過期，則刪除
                    // 刪除對應(yīng)的 Key 值
                    // 出現(xiàn)的結(jié)果：成功，失敗，Key 不存在
                    CacheResult unlockResult = REMOVE(key);
                    if (unlockResult.getResultCode() == CacheResultCode.FAIL
                            || unlockResult.getResultCode() == CacheResultCode.PART_SUCCESS) {
                        // 刪除對應(yīng)的 Key 值過程中出現(xiàn)了異常，則重試
                        logger.info("[tryLock] [{} of {}] [{}] unlock failed. Key={}, msg = {}",
                                unlockCount, config.getTryLockUnlockCount(), uuid, key, unlockResult.getMessage());
                        // retry
                    } else if (unlockResult.isSuccess()) { // 釋放成功
                        logger.debug("[tryLock] [{} of {}] [{}] successfully release the lock. Key={}",
                                unlockCount, config.getTryLockUnlockCount(), uuid, key);
                        return;
                    } else { // 鎖已經(jīng)被釋放了
                        logger.warn("[tryLock] [{} of {}] [{}] unexpected unlock result: Key={}, result={}",
                                unlockCount, config.getTryLockUnlockCount(), uuid, key, unlockResult.getResultCode());
                        return;
                    }
                } else { // 該鎖已失效
                    logger.info("[tryLock] [{} of {}] [{}] lock already expired: Key={}",
                            unlockCount, config.getTryLockUnlockCount(), uuid, key);
                    return;
                }
            }
        };
        int lockCount = 0;
        Cache cache = this;
        while (lockCount++ < config.getTryLockLockCount()) {
            // 往 Redis（或者本地） 中存放 Key 值（_#RL#結(jié)尾的Key）
            // 返回的結(jié)果：成功、已存在、失敗
            CacheResult lockResult = cache.PUT_IF_ABSENT(key, uuid, expire, timeUnit);
            if (lockResult.isSuccess()) { // 成功獲取到鎖
                logger.debug("[tryLock] [{} of {}] [{}] successfully get a lock. Key={}",
                        lockCount, config.getTryLockLockCount(), uuid, key);
                return lock;
            } else if (lockResult.getResultCode() == CacheResultCode.FAIL || lockResult.getResultCode() == CacheResultCode.PART_SUCCESS) {
                logger.info("[tryLock] [{} of {}] [{}] cache access failed during get lock, will inquiry {} times. Key={}, msg={}",
                        lockCount, config.getTryLockLockCount(), uuid,
                        config.getTryLockInquiryCount(), key, lockResult.getMessage());
                // 嘗試獲取鎖的過程中失敗了，也就是往 Redis 中存放 Key 值出現(xiàn)異常
                // 這個時候可能 Key 值已經(jīng)存儲了，但是由于其他原因?qū)е路祷氐慕Y(jié)果表示執(zhí)行失敗
                int inquiryCount = 0;
                while (inquiryCount++ < config.getTryLockInquiryCount()) {
                    CacheGetResult inquiryResult = cache.GET(key);
                    if (inquiryResult.isSuccess()) {
                        if (uuid.equals(inquiryResult.getValue())) {
                            logger.debug("[tryLock] [{} of {}] [{}] successfully get a lock after inquiry. Key={}",
                                    inquiryCount, config.getTryLockInquiryCount(), uuid, key);
                            return lock;
                        } else {
                            logger.debug("[tryLock] [{} of {}] [{}] not the owner of the lock, return null. Key={}",
                                    inquiryCount, config.getTryLockInquiryCount(), uuid, key);
                            return null;
                        }
                    } else {
                        logger.info("[tryLock] [{} of {}] [{}] inquiry failed. Key={}, msg={}",
                                inquiryCount, config.getTryLockInquiryCount(), uuid, key, inquiryResult.getMessage());
                        // retry inquiry
                    }
                }
            } else { // 已存在表示該鎖被其他人占有
                // others holds the lock
                logger.debug("[tryLock] [{} of {}] [{}] others holds the lock, return null. Key={}",
                        lockCount, config.getTryLockLockCount(), uuid, key);
                return null;
            }
        }
        logger.debug("[tryLock] [{}] return null after {} attempts. Key={}", uuid, config.getTryLockLockCount(), key);
        return null;
    }
    default boolean tryLockAndRun(K key, long expire, TimeUnit timeUnit, Runnable action){
        // Release the lock use Java 7 try-with-resources.
        try (AutoReleaseLock lock = tryLock(key, expire, timeUnit)) { // 嘗試獲取鎖
            if (lock != null) { // 獲取到鎖則執(zhí)行下面的任務(wù)
                action.run();
                return true;
            } else {
                return false;
            }
            // 執(zhí)行完鎖的操作后會進(jìn)行資源釋放，調(diào)用 AutoCloseable 的 close() 方法
        }
    }
    CacheGetResult<V> GET(K key);
    MultiGetResult<K, V> GET_ALL(Set<? extends K> keys);
    default V computeIfAbsent(K key, Function<K, V> loader) {
        return computeIfAbsent(key, loader, config().isCacheNullValue());
    }
    V computeIfAbsent(K key, Function<K, V> loader, boolean cacheNullWhenLoaderReturnNull);
    V computeIfAbsent(K key, Function<K, V> loader, boolean cacheNullWhenLoaderReturnNull, long expireAfterWrite, TimeUnit timeUnit);
    default void put(K key, V value, long expireAfterWrite, TimeUnit timeUnit) {
        PUT(key, value, expireAfterWrite, timeUnit);
    }
    default CacheResult PUT(K key, V value) {
        if (key == null) {
            return CacheResult.FAIL_ILLEGAL_ARGUMENT;
        }
        return PUT(key, value, config().getExpireAfterWriteInMillis(), TimeUnit.MILLISECONDS);
    }
    CacheResult PUT(K key, V value, long expireAfterWrite, TimeUnit timeUnit);
    default void putAll(Map<? extends K, ? extends V> map, long expireAfterWrite, TimeUnit timeUnit) {
        PUT_ALL(map, expireAfterWrite, timeUnit);
    }
    default CacheResult PUT_ALL(Map<? extends K, ? extends V> map) {
        if (map == null) {
            return CacheResult.FAIL_ILLEGAL_ARGUMENT;
        }
        return PUT_ALL(map, config().getExpireAfterWriteInMillis(), TimeUnit.MILLISECONDS);
    }
    CacheResult PUT_ALL(Map<? extends K, ? extends V> map, long expireAfterWrite, TimeUnit timeUnit);
    CacheResult REMOVE(K key);
    CacheResult REMOVE_ALL(Set<? extends K> keys);
    CacheResult PUT_IF_ABSENT(K key, V value, long expireAfterWrite, TimeUnit timeUnit);
}

public abstract class AbstractCache<K, V> implements Cache<K, V> {
    /**
     * 當(dāng)緩存未命中時，并發(fā)情況同一個Key是否只允許一個線程去加載，其他線程等待結(jié)果（可以設(shè)置timeout，超時則自己加載并直接返回）
     * 如果是的話則由獲取到Key對應(yīng)的 LoaderLock.signal（采用了 CountDownLatch）的線程進(jìn)行加載
     * loaderMap臨時保存 Key 對應(yīng)的 LoaderLock 對象
     */
    private volatile ConcurrentHashMap<Object, LoaderLock> loaderMap;
    ConcurrentHashMap<Object, LoaderLock> initOrGetLoaderMap() {
        if (loaderMap == null) {
            synchronized (this) {
                if (loaderMap == null) {
                    loaderMap = new ConcurrentHashMap<>();
                }
            }
        }
        return loaderMap;
    }
    @Override
    public final V computeIfAbsent(K key, Function<K, V> loader, boolean cacheNullWhenLoaderReturnNull) {
        return computeIfAbsentImpl(key, loader, cacheNullWhenLoaderReturnNull,
                0, null, this);
    }
    @Override
    public final V computeIfAbsent(K key, Function<K, V> loader, boolean cacheNullWhenLoaderReturnNull,
                                   long expireAfterWrite, TimeUnit timeUnit) {
        return computeIfAbsentImpl(key, loader, cacheNullWhenLoaderReturnNull,
                expireAfterWrite, timeUnit, this);
    }
    private static <K, V> boolean needUpdate(V loadedValue, boolean cacheNullWhenLoaderReturnNull, Function<K, V> loader) {
        if (loadedValue == null && !cacheNullWhenLoaderReturnNull) {
            return false;
        }
        if (loader instanceof CacheLoader && ((CacheLoader<K, V>) loader).vetoCacheUpdate()) {
            return false;
        }
        return true;
    }
    static <K, V> V computeIfAbsentImpl(K key, Function<K, V> loader, boolean cacheNullWhenLoaderReturnNull,
                                               long expireAfterWrite, TimeUnit timeUnit, Cache<K, V> cache) {
    	// 獲取內(nèi)部的 Cache 對象
        AbstractCache<K, V> abstractCache = CacheUtil.getAbstractCache(cache);
        // 封裝 loader 函數(shù)成一個 ProxyLoader 對象，主要在重新加載緩存后發(fā)出一個 CacheLoadEvent 到 CacheMonitor
        CacheLoader<K, V> newLoader = CacheUtil.createProxyLoader(cache, loader, abstractCache::notify);
        CacheGetResult<V> r;
        if (cache instanceof RefreshCache) { // 該緩存實例需要刷新
            RefreshCache<K, V> refreshCache = ((RefreshCache<K, V>) cache);
            /*
             * 從緩存中獲取數(shù)據(jù)
             * 如果是多級緩存（先從本地緩存獲取，獲取不到則從遠(yuǎn)程緩存獲?。?
             * 如果緩存數(shù)據(jù)是從遠(yuǎn)程緩存獲取到的數(shù)據(jù)則會更新至本地緩存，并且如果本地緩存沒有設(shè)置 localExpire 則使用遠(yuǎn)程緩存的到期時間作為自己的到期時間
             * 我一般不設(shè)置 localExpire ，因為可能導(dǎo)致本地緩存的有效時間比遠(yuǎn)程緩存的有效時間更長
             * 如果設(shè)置 localExpire 了記得設(shè)置 expireAfterAccessInMillis
             */
            r = refreshCache.GET(key);
            // 添加/更新當(dāng)前 RefreshCache 的刷新緩存任務(wù)，存放于 RefreshCache 的 taskMap 中
            refreshCache.addOrUpdateRefreshTask(key, newLoader);
        } else {
            // 從緩存中獲取數(shù)據(jù)
            r = cache.GET(key);
        }
        if (r.isSuccess()) { // 緩存命中
            return r.getValue();
        } else { // 緩存未命中
            // 創(chuàng)建當(dāng)緩存未命中去更新緩存的函數(shù)
            Consumer<V> cacheUpdater = (loadedValue) -> {
                if(needUpdate(loadedValue, cacheNullWhenLoaderReturnNull, newLoader)) {
                    /*
                     * 未在緩存注解中配置 key 的生成方式則默認(rèn)取入?yún)⒆鳛榫彺?key
                     * 在進(jìn)入當(dāng)前方法時是否可以考慮為 key 創(chuàng)建一個副本？？？？
                     * 因為緩存未命中然后通過 loader 重新加載方法時，如果方法內(nèi)部對入?yún)⑦M(jìn)行了修改，那么生成的緩存 key 也會被修改
                     * 從而導(dǎo)致相同的 key 進(jìn)入該方法時一直與緩存中的 key 不相同，一直出現(xiàn)緩存未命中
                     */
                    if (timeUnit != null) {
                        cache.PUT(key, loadedValue, expireAfterWrite, timeUnit).waitForResult();
                    } else {
                        cache.PUT(key, loadedValue).waitForResult();
                    }
                }
            };
            V loadedValue;
            if (cache.config().isCachePenetrationProtect()) { // 添加了 @CachePenetrationProtect 注解
            	// 一個JVM只允許一個線程執(zhí)行
                loadedValue = synchronizedLoad(cache.config(), abstractCache, key, newLoader, cacheUpdater);
            } else {
            	// 執(zhí)行方法
                loadedValue = newLoader.apply(key);
                // 將新的結(jié)果異步緩存
                cacheUpdater.accept(loadedValue);
            }
            return loadedValue;
        }
    }
    static <K, V> V synchronizedLoad(CacheConfig config, AbstractCache<K,V> abstractCache,
                                     K key, Function<K, V> newLoader, Consumer<V> cacheUpdater) {
        ConcurrentHashMap<Object, LoaderLock> loaderMap = abstractCache.initOrGetLoaderMap();
        Object lockKey = buildLoaderLockKey(abstractCache, key);
        while (true) {
            // 為什么加一個 create[] 數(shù)組 疑問？？
            boolean create[] = new boolean[1];
            LoaderLock ll = loaderMap.computeIfAbsent(lockKey, (unusedKey) -> {
                create[0] = true;
                LoaderLock loaderLock = new LoaderLock();
                loaderLock.signal = new CountDownLatch(1);
                loaderLock.loaderThread = Thread.currentThread();
                return loaderLock;
            });
            if (create[0] || ll.loaderThread == Thread.currentThread()) {
                try {
                    // 加載該 Key 實例的方法
                    V loadedValue = newLoader.apply(key);
                    ll.success = true;
                    ll.value = loadedValue;
                    // 將重新加載的數(shù)據(jù)更新至緩存
                    cacheUpdater.accept(loadedValue);
                    return loadedValue;
                } finally {
                    // 標(biāo)記已完成
                    ll.signal.countDown();
                    if (create[0]) {
                        loaderMap.remove(lockKey);
                    }
                }
            } else { // 等待其他線程加載，如果出現(xiàn)異?；蛘叱瑫r則自己加載返回數(shù)據(jù)，但是不更新緩存
                try {
                    Duration timeout = config.getPenetrationProtectTimeout();
                    if (timeout == null) {
                        ll.signal.await();
                    } else {
                        boolean ok = ll.signal.await(timeout.toMillis(), TimeUnit.MILLISECONDS);
                        if(!ok) {
                            logger.info("loader wait timeout:" + timeout);
                            return newLoader.apply(key);
                        }
                    }
                } catch (InterruptedException e) {
                    logger.warn("loader wait interrupted");
                    return newLoader.apply(key);
                }
                if (ll.success) {
                    return (V) ll.value;
                } else {
                    continue;
                }
            }
        }
    }
    private static Object buildLoaderLockKey(Cache c, Object key) {
        if (c instanceof AbstractEmbeddedCache) {
            return ((AbstractEmbeddedCache) c).buildKey(key);
        } else if (c instanceof AbstractExternalCache) {
            byte bytes[] = ((AbstractExternalCache) c).buildKey(key);
            return ByteBuffer.wrap(bytes);
        } else if (c instanceof MultiLevelCache) {
            c = ((MultiLevelCache) c).caches()[0];
            return buildLoaderLockKey(c, key);
        } else if(c instanceof ProxyCache) {
            c = ((ProxyCache) c).getTargetCache();
            return buildLoaderLockKey(c, key);
        } else {
            throw new CacheException("impossible");
        }
    }
    /**
     * 重新加載數(shù)據(jù)鎖
     */
    static class LoaderLock {
        /**
         * 柵欄
         */
        CountDownLatch signal;
        /**
         * 持有的線程
         */
        Thread loaderThread;
        /**
         * 是否加載成功
         */
        boolean success;
        /**
         * 加載出來的數(shù)據(jù)
         */，
        Object value;
    }
}

public abstract class AbstractEmbeddedCache<K, V> extends AbstractCache<K, V> {
    protected EmbeddedCacheConfig<K, V> config;
    /**
     * 本地緩存的 Map
     */
    protected InnerMap innerMap;
    protected abstract InnerMap createAreaCache();
    public AbstractEmbeddedCache(EmbeddedCacheConfig<K, V> config) {
        this.config = config;
        innerMap = createAreaCache();
    }
    @Override
    public CacheConfig<K, V> config() {
        return config;
    }
    public Object buildKey(K key) {
        Object newKey = key;
        Function<K, Object> keyConvertor = config.getKeyConvertor();
        if (keyConvertor != null) {
            newKey = keyConvertor.apply(key);
        }
        return newKey;
    }
    @Override
    protected CacheGetResult<V> do_GET(K key) {
        Object newKey = buildKey(key);
        CacheValueHolder<V> holder = (CacheValueHolder<V>) innerMap.getValue(newKey);
        return parseHolderResult(holder);
    }
    protected CacheGetResult<V> parseHolderResult(CacheValueHolder<V> holder) {
        long now = System.currentTimeMillis();
        if (holder == null) {
            return CacheGetResult.NOT_EXISTS_WITHOUT_MSG;
        } else if (now >= holder.getExpireTime()) {
            return CacheGetResult.EXPIRED_WITHOUT_MSG;
        } else {
            synchronized (holder) {
                long accessTime = holder.getAccessTime();
                if (config.isExpireAfterAccess()) {
                    long expireAfterAccess = config.getExpireAfterAccessInMillis();
                    if (now >= accessTime + expireAfterAccess) {
                        return CacheGetResult.EXPIRED_WITHOUT_MSG;
                    }
                }
                // 設(shè)置該緩存數(shù)據(jù)的最后一次訪問時間
                holder.setAccessTime(now);
            }
            return new CacheGetResult(CacheResultCode.SUCCESS, null, holder);
        }
    }
    @Override
    protected MultiGetResult<K, V> do_GET_ALL(Set<? extends K> keys) {
        ArrayList<K> keyList = new ArrayList<K>(keys.size());
        ArrayList<Object> newKeyList = new ArrayList<Object>(keys.size());
        keys.stream().forEach((k) -> {
            Object newKey = buildKey(k);
            keyList.add(k);
            newKeyList.add(newKey);
        });
        Map<Object, CacheValueHolder<V>> innerResultMap = innerMap.getAllValues(newKeyList);
        Map<K, CacheGetResult<V>> resultMap = new HashMap<>();
        for (int i = 0; i < keyList.size(); i++) {
            K key = keyList.get(i);
            Object newKey = newKeyList.get(i);
            CacheValueHolder<V> holder = innerResultMap.get(newKey);
            resultMap.put(key, parseHolderResult(holder));
        }
        MultiGetResult<K, V> result = new MultiGetResult<>(CacheResultCode.SUCCESS, null, resultMap);
        return result;
    }
    @Override
    protected CacheResult do_PUT(K key, V value, long expireAfterWrite, TimeUnit timeUnit) {
        CacheValueHolder<V> cacheObject = new CacheValueHolder(value ,timeUnit.toMillis(expireAfterWrite));
        innerMap.putValue(buildKey(key), cacheObject);
        return CacheResult.SUCCESS_WITHOUT_MSG;
    }
    @Override
    protected CacheResult do_PUT_ALL(Map<? extends K, ? extends V> map, long expireAfterWrite, TimeUnit timeUnit) {
        HashMap newKeyMap = new HashMap();
        for (Map.Entry<? extends K, ? extends V> en : map.entrySet()) {
            CacheValueHolder<V> cacheObject = new CacheValueHolder(en.getValue(), timeUnit.toMillis(expireAfterWrite));
            newKeyMap.put(buildKey(en.getKey()), cacheObject);
        }
        innerMap.putAllValues(newKeyMap);
        final HashMap resultMap = new HashMap();
        map.keySet().forEach((k) -> resultMap.put(k, CacheResultCode.SUCCESS));
        return CacheResult.SUCCESS_WITHOUT_MSG;
    }
    @Override
    protected CacheResult do_REMOVE(K key) {
        innerMap.removeValue(buildKey(key));
        return CacheResult.SUCCESS_WITHOUT_MSG;
    }
    @Override
    protected CacheResult do_REMOVE_ALL(Set<? extends K> keys) {
        Set newKeys = keys.stream().map((key) -> buildKey(key)).collect(Collectors.toSet());
        innerMap.removeAllValues(newKeys);
        final HashMap resultMap = new HashMap();
        keys.forEach((k) -> resultMap.put(k, CacheResultCode.SUCCESS));
        return CacheResult.SUCCESS_WITHOUT_MSG;
    }
    @Override
    protected CacheResult do_PUT_IF_ABSENT(K key, V value, long expireAfterWrite, TimeUnit timeUnit) {
        CacheValueHolder<V> cacheObject = new CacheValueHolder(value, timeUnit.toMillis(expireAfterWrite));
        if (innerMap.putIfAbsentValue(buildKey(key), cacheObject)) {
            return CacheResult.SUCCESS_WITHOUT_MSG;
        } else {
            return CacheResult.EXISTS_WITHOUT_MSG;
        }
    }
}

public class LinkedHashMapCache<K, V> extends AbstractEmbeddedCache<K, V> {
    private static Logger logger = LoggerFactory.getLogger(LinkedHashMapCache.class);
    public LinkedHashMapCache(EmbeddedCacheConfig<K, V> config) {
        super(config);
        // 將緩存實例添加至 Cleaner
        addToCleaner();
    }
    protected void addToCleaner() {
        Cleaner.add(this);
    }
    @Override
    protected InnerMap createAreaCache() {
        return new LRUMap(config.getLimit(), this);
    }
    public void cleanExpiredEntry() {
        ((LRUMap) innerMap).cleanExpiredEntry();
    }
    /**
     * 用于本地緩存類型為 linkedhashmap 緩存實例存儲緩存數(shù)據(jù)
     */
    final class LRUMap extends LinkedHashMap implements InnerMap {
        /**
         * 允許的最大緩存數(shù)量
         */
        private final int max;
        /**
         * 緩存實例鎖
         */
        private Object lock;
        public LRUMap(int max, Object lock) {
            super((int) (max * 1.4f), 0.75f, true);
            this.max = max;
            this.lock = lock;
        }
        /**
         * 當(dāng)元素大于最大值時移除最老的元素
         *
         * @param eldest 最老的元素
         * @return 是否刪除
         */
        @Override
        protected boolean removeEldestEntry(Map.Entry eldest) {
            return size() > max;
        }
        /**
         * 清理過期的元素
         */
        void cleanExpiredEntry() {
            synchronized (lock) { // 占有當(dāng)前緩存實例這把鎖
                for (Iterator it = entrySet().iterator(); it.hasNext();) {
                    Map.Entry en = (Map.Entry) it.next();
                    Object value = en.getValue();
                    if (value != null && value instanceof CacheValueHolder) {
                        CacheValueHolder h = (CacheValueHolder) value;
                        /*
                         * 緩存的數(shù)據(jù)已經(jīng)失效了則刪除
                         * 為什么不對 expireAfterAccess 進(jìn)行判斷，取最小值，疑問？？？？
                         */
                        if (System.currentTimeMillis() >= h.getExpireTime()) {
                            it.remove();
                        }
                    } else {
                        // assert false
                        if (value == null) {
                            logger.error("key " + en.getKey() + " is null");
                        } else {
                            logger.error("value of key " + en.getKey() + " is not a CacheValueHolder. type=" + value.getClass());
                        }
                    }
                }
            }
        }
        @Override
        public Object getValue(Object key) {
            synchronized (lock) {
                return get(key);
            }
        }
        @Override
        public Map getAllValues(Collection keys) {
            Map values = new HashMap();
            synchronized (lock) {
                for (Object key : keys) {
                    Object v = get(key);
                    if (v != null) {
                        values.put(key, v);
                    }
                }
            }
            return values;
        }
        @Override
        public void putValue(Object key, Object value) {
            synchronized (lock) {
                put(key, value);
            }
        }
        @Override
        public void putAllValues(Map map) {
            synchronized (lock) {
                Set<Map.Entry> set = map.entrySet();
                for (Map.Entry en : set) {
                    put(en.getKey(), en.getValue());
                }
            }
        }
        @Override
        public boolean removeValue(Object key) {
            synchronized (lock) {
                return remove(key) != null;
            }
        }
        @Override
        public void removeAllValues(Collection keys) {
            synchronized (lock) {
                for (Object k : keys) {
                    remove(k);
                }
            }
        }
        @Override
        @SuppressWarnings("unchecked")
        public boolean putIfAbsentValue(Object key, Object value) {
            /*
             * 如果緩存 key 不存在，或者對應(yīng)的 value 已經(jīng)失效則放入，否則返回 false
             */
            synchronized (lock) {
                CacheValueHolder h = (CacheValueHolder) get(key);
                if (h == null || parseHolderResult(h).getResultCode() == CacheResultCode.EXPIRED) {
                    put(key, value);
                    return true;
                } else {
                    return false;
                }
            }
        }
    }
}

/**
 * 執(zhí)行任務(wù)：定時清理（每分鐘） LinkedHashMapCache 緩存實例中過期的緩存數(shù)據(jù)
 */
class Cleaner {
    /**
     * 存放弱引用對象，以防內(nèi)存溢出
     * 如果被弱引用的對象只被當(dāng)前弱引用對象關(guān)聯(lián)時，gc 時被弱引用的對象則會被回收（取決于被弱引用的對象是否還與其他強(qiáng)引用對象關(guān)聯(lián)）
     *
     * 個人理解：當(dāng)某個 LinkedHashMapCache 強(qiáng)引用對象沒有被其他對象（除了這里）引用時，我們應(yīng)該讓這個對象被回收，
     * 但是由于這里使用的也是強(qiáng)引用，這個對象被其他強(qiáng)引用對象關(guān)聯(lián)了，不可能被回收，存在內(nèi)存溢出的危險，
     * 所以這里使用了弱引用對象，如果被弱引用的對象沒有被其他對象（除了這里）引用時，這個對象會被回收
     *
     * 舉個例子：如果我們往一個 Map<Object, Object> 中存放一個key-value鍵值對
     * 假設(shè)對應(yīng)的鍵已經(jīng)不再使用被回收了，那我們無法再獲取到對應(yīng)的值，也無法被回收，占有一定的內(nèi)存，存在風(fēng)險
     */
    static LinkedList<WeakReference<LinkedHashMapCache>> linkedHashMapCaches = new LinkedList<>();
    static {
        // 創(chuàng)建一個線程池，1個核心線程
        ScheduledExecutorService executorService = JetCacheExecutor.defaultExecutor();
        // 起一個循環(huán)任務(wù)一直清理 linkedHashMapCaches 過期的數(shù)據(jù)（每隔60秒）
        executorService.scheduleWithFixedDelay(() -> run(), 60, 60, TimeUnit.SECONDS);
    }
    static void add(LinkedHashMapCache cache) {
        synchronized (linkedHashMapCaches) {
            // 創(chuàng)建一個弱引用對象，并添加到清理對象中
            linkedHashMapCaches.add(new WeakReference<>(cache));
        }
    }
    static void run() {
        synchronized (linkedHashMapCaches) {
            Iterator<WeakReference<LinkedHashMapCache>> it = linkedHashMapCaches.iterator();
            while (it.hasNext()) {
                WeakReference<LinkedHashMapCache> ref = it.next();
                // 獲取被弱引用的對象（強(qiáng)引用）
                LinkedHashMapCache c = ref.get();
                if (c == null) { // 表示被弱引用的對象被標(biāo)記成了垃圾，則移除
                    it.remove();
                } else {
                    c.cleanExpiredEntry();
                }
            }
        }
    }
}

public class CaffeineCache<K, V> extends AbstractEmbeddedCache<K, V> {
    /**
     * 緩存實例對象
     */
    private com.github.benmanes.caffeine.cache.Cache cache;
    public CaffeineCache(EmbeddedCacheConfig<K, V> config) {
        super(config);
    }
    /**
     * 初始化本地緩存的容器
     *
     * @return Map對象
     */
    @Override
    @SuppressWarnings("unchecked")
    protected InnerMap createAreaCache() {
        Caffeine<Object, Object> builder = Caffeine.newBuilder();
        // 設(shè)置緩存實例的最大緩存數(shù)量
        builder.maximumSize(config.getLimit());
        final boolean isExpireAfterAccess = config.isExpireAfterAccess();
        final long expireAfterAccess = config.getExpireAfterAccessInMillis();
        // 設(shè)置緩存實例的緩存數(shù)據(jù)的失效策略
        builder.expireAfter(new Expiry<Object, CacheValueHolder>() {
            /**
             * 獲取緩存的有效時間
             *
             * @param value 緩存數(shù)據(jù)
             * @return 有效時間
             */
            private long getRestTimeInNanos(CacheValueHolder value) {
                long now = System.currentTimeMillis();
                long ttl = value.getExpireTime() - now;
                /*
                 * 如果本地緩存設(shè)置了多長時間沒訪問緩存則失效
                 */
                if(isExpireAfterAccess){
                    // 設(shè)置緩存的失效時間
                    // 多長時間沒訪問緩存則失效 and 緩存的有效時長取 min
                    ttl = Math.min(ttl, expireAfterAccess);
                }
                return TimeUnit.MILLISECONDS.toNanos(ttl);
            }
            @Override
            public long expireAfterCreate(Object key, CacheValueHolder value, long currentTime) {
                return getRestTimeInNanos(value);
            }
            @Override
            public long expireAfterUpdate(Object key, CacheValueHolder value,
                                          long currentTime, long currentDuration) {
                return currentDuration;
            }
            @Override
            public long expireAfterRead(Object key, CacheValueHolder value,
                                        long currentTime, long currentDuration) {
                return getRestTimeInNanos(value);
            }
        });
        // 構(gòu)建 Cache 緩存實例
        cache = builder.build();
        return new InnerMap() {
            @Override
            public Object getValue(Object key) {
                return cache.getIfPresent(key);
            }
            @Override
            public Map getAllValues(Collection keys) {
                return cache.getAllPresent(keys);
            }
            @Override
            public void putValue(Object key, Object value) {
                cache.put(key, value);
            }
            @Override
            public void putAllValues(Map map) {
                cache.putAll(map);
            }
            @Override
            public boolean removeValue(Object key) {
                return cache.asMap().remove(key) != null;
            }
            @Override
            public void removeAllValues(Collection keys) {
                cache.invalidateAll(keys);
            }
            @Override
            public boolean putIfAbsentValue(Object key, Object value) {
                return cache.asMap().putIfAbsent(key, value) == null;
            }
        };
    }
}

public class MultiLevelCache<K, V> extends AbstractCache<K, V> {
    private Cache[] caches;
    private MultiLevelCacheConfig<K, V> config;
    @SuppressWarnings("unchecked")
    @Deprecated
    public MultiLevelCache(Cache... caches) throws CacheConfigException {
        this.caches = caches;
        checkCaches();
        CacheConfig lastConfig = caches[caches.length - 1].config();
        config = new MultiLevelCacheConfig<>();
        config.setCaches(Arrays.asList(caches));
        config.setExpireAfterWriteInMillis(lastConfig.getExpireAfterWriteInMillis());
        config.setCacheNullValue(lastConfig.isCacheNullValue());
    }
    @SuppressWarnings("unchecked")
    public MultiLevelCache(MultiLevelCacheConfig<K, V> cacheConfig) throws CacheConfigException {
        this.config = cacheConfig;
        this.caches = cacheConfig.getCaches().toArray(new Cache[]{});
        checkCaches();
    }
    private void checkCaches() {
        if (caches == null || caches.length == 0) {
            throw new IllegalArgumentException();
        }
        for (Cache c : caches) {
            if (c.config().getLoader() != null) {
                throw new CacheConfigException("Loader on sub cache is not allowed, set the loader into MultiLevelCache.");
            }
        }
    }
    public Cache[] caches() {
        return caches;
    }
    @Override
    public MultiLevelCacheConfig<K, V> config() {
        return config;
    }
    @Override
    public CacheResult PUT(K key, V value) {
        if (config.isUseExpireOfSubCache()) { // 本地緩存使用自己的失效時間
            // 設(shè)置了TimeUnit為null，本地緩存則使用自己的到期時間
            return PUT(key, value, 0, null);
        } else {
            return PUT(key, value, config().getExpireAfterWriteInMillis(), TimeUnit.MILLISECONDS);
        }
    }
    @Override
    public CacheResult PUT_ALL(Map<? extends K, ? extends V> map) {
        if (config.isUseExpireOfSubCache()) {
            return PUT_ALL(map, 0, null);
        } else {
            return PUT_ALL(map, config().getExpireAfterWriteInMillis(), TimeUnit.MILLISECONDS);
        }
    }
    @Override
    protected CacheGetResult<V> do_GET(K key) {
    	// 遍歷多級緩存（遠(yuǎn)程緩存排在后面）
        for (int i = 0; i < caches.length; i++) {
            Cache cache = caches[i];
            CacheGetResult result = cache.GET(key);
            if (result.isSuccess()) {
                CacheValueHolder<V> holder = unwrapHolder(result.getHolder());
                /*
                 * 這個遍歷是從低層的緩存開始獲取，獲取成功則將該值設(shè)置到更低層的緩存中
                 * 情景：
                 * 本地沒有獲取到緩存，遠(yuǎn)程獲取到了緩存，這里會將遠(yuǎn)程的緩存數(shù)據(jù)設(shè)置到本地中，
                 * 這樣下次請求則直接從本次獲取，減少了遠(yuǎn)程獲取的時間
                 */
                checkResultAndFillUpperCache(key, i, holder);
                return new CacheGetResult(CacheResultCode.SUCCESS, null, holder);
            }
        }
        return CacheGetResult.NOT_EXISTS_WITHOUT_MSG;
    }
    private CacheValueHolder<V> unwrapHolder(CacheValueHolder<V> h) {
        // if @Cached or @CacheCache change type from REMOTE to BOTH (or from BOTH to REMOTE),
        // during the dev/publish process, the value type which different application server put into cache server will be different
        // (CacheValueHolder<V> and CacheValueHolder<CacheValueHolder<V>>, respectively).
        // So we need correct the problem at here and in CacheGetResult.
        Objects.requireNonNull(h);
        if (h.getValue() instanceof CacheValueHolder) {
            return (CacheValueHolder<V>) h.getValue();
        } else {
            return h;
        }
    }
    private void checkResultAndFillUpperCache(K key, int i, CacheValueHolder<V> h) {
        Objects.requireNonNull(h);
        long currentExpire = h.getExpireTime();
        long now = System.currentTimeMillis();
        if (now <= currentExpire) {
            if(config.isUseExpireOfSubCache()){ // 如果使用本地自己的緩存過期時間
                // 使用本地緩存自己的過期時間
                PUT_caches(i, key, h.getValue(), 0, null);
            } else { // 使用遠(yuǎn)程緩存的過期時間
                long restTtl = currentExpire - now;
                if (restTtl > 0) { // 遠(yuǎn)程緩存數(shù)據(jù)還未失效，則重新設(shè)置本地的緩存
                    PUT_caches(i, key, h.getValue(), restTtl, TimeUnit.MILLISECONDS);
                }
            }
        }
    }
    @Override
    protected MultiGetResult<K, V> do_GET_ALL(Set<? extends K> keys) {
        HashMap<K, CacheGetResult<V>> resultMap = new HashMap<>();
        Set<K> restKeys = new HashSet<>(keys);
        for (int i = 0; i < caches.length; i++) {
            if (restKeys.size() == 0) {
                break;
            }
            Cache<K, CacheValueHolder<V>> c = caches[i];
            MultiGetResult<K, CacheValueHolder<V>> allResult = c.GET_ALL(restKeys);
            if (allResult.isSuccess() && allResult.getValues() != null) {
                for (Map.Entry<K, CacheGetResult<CacheValueHolder<V>>> en : allResult.getValues().entrySet()) {
                    K key = en.getKey();
                    CacheGetResult result = en.getValue();
                    if (result.isSuccess()) {
                        CacheValueHolder<V> holder = unwrapHolder(result.getHolder());
                        checkResultAndFillUpperCache(key, i, holder);
                        resultMap.put(key, new CacheGetResult(CacheResultCode.SUCCESS, null, holder));
                        restKeys.remove(key);
                    }
                }
            }
        }
        for (K k : restKeys) {
            resultMap.put(k, CacheGetResult.NOT_EXISTS_WITHOUT_MSG);
        }
        return new MultiGetResult<>(CacheResultCode.SUCCESS, null, resultMap);
    }
    @Override
    protected CacheResult do_PUT(K key, V value, long expireAfterWrite, TimeUnit timeUnit) {
        return PUT_caches(caches.length, key, value, expireAfterWrite, timeUnit);
    }
    @Override
    protected CacheResult do_PUT_ALL(Map<? extends K, ? extends V> map, long expireAfterWrite, TimeUnit timeUnit) {
        CompletableFuture<ResultData> future = CompletableFuture.completedFuture(null);
        for (Cache c : caches) {
            CacheResult r;
            if(timeUnit == null) {
                r = c.PUT_ALL(map);
            } else {
                r = c.PUT_ALL(map, expireAfterWrite, timeUnit);
            }
            future = combine(future, r);
        }
        return new CacheResult(future);
    }
    private CacheResult PUT_caches(int lastIndex, K key, V value, long expire, TimeUnit timeUnit) {
        CompletableFuture<ResultData> future = CompletableFuture.completedFuture(null);
        for (int i = 0; i < lastIndex; i++) {
            Cache cache = caches[i];
            CacheResult r;
            if (timeUnit == null) { // 表示本地緩存使用自己過期時間
                r = cache.PUT(key, value);
            } else {
                r = cache.PUT(key, value, expire, timeUnit);
            }
            // 將多個 PUT 操作放在一條鏈上
            future = combine(future, r);
        }
        return new CacheResult(future);
    }
    private CompletableFuture<ResultData> combine(CompletableFuture<ResultData> future, CacheResult result) {
        return future.thenCombine(result.future(), (d1, d2) -> {
            if (d1 == null) {
                return d2;
            }
            if (d1.getResultCode() != d2.getResultCode()) {
                return new ResultData(CacheResultCode.PART_SUCCESS, null, null);
            }
            return d1;
        });
    }
    @Override
    protected CacheResult do_REMOVE(K key) {
        CompletableFuture<ResultData> future = CompletableFuture.completedFuture(null);
        for (Cache cache : caches) {
            CacheResult r = cache.REMOVE(key);
            future = combine(future, r);
        }
        return new CacheResult(future);
    }
    @Override
    protected CacheResult do_REMOVE_ALL(Set<? extends K> keys) {
        CompletableFuture<ResultData> future = CompletableFuture.completedFuture(null);
        for (Cache cache : caches) {
            CacheResult r = cache.REMOVE_ALL(keys);
            future = combine(future, r);
        }
        return new CacheResult(future);
    }
    @Override
    public <T> T unwrap(Class<T> clazz) {
        Objects.requireNonNull(clazz);
        for (Cache cache : caches) {
            try {
                T obj = (T) cache.unwrap(clazz);
                if (obj != null) {
                    return obj;
                }
            } catch (IllegalArgumentException e) {
                // ignore
            }
        }
        throw new IllegalArgumentException(clazz.getName());
    }
    @Override
    public AutoReleaseLock tryLock(K key, long expire, TimeUnit timeUnit) {
        if (key == null) {
            return null;
        }
        return caches[caches.length - 1].tryLock(key, expire, timeUnit);
    }
    @Override
    public boolean putIfAbsent(K key, V value) {
        throw new UnsupportedOperationException("putIfAbsent is not supported by MultiLevelCache");
    }
    @Override
    protected CacheResult do_PUT_IF_ABSENT(K key, V value, long expireAfterWrite, TimeUnit timeUnit) {
        throw new UnsupportedOperationException("PUT_IF_ABSENT is not supported by MultiLevelCache");
    }
    @Override
    public void close() {
        for (Cache c : caches) {
            c.close();
        }
    }
}

public class RefreshCache<K, V> extends LoadingCache<K, V> {
    
    protected CacheConfig<K, V> config;
    
    /**
	 * 用于保存刷新任務(wù)
	 */
	private ConcurrentHashMap<Object, RefreshTask> taskMap = new ConcurrentHashMap<>();
    
    protected void addOrUpdateRefreshTask(K key, CacheLoader<K, V> loader) {
		// 獲取緩存刷新策略
		RefreshPolicy refreshPolicy = config.getRefreshPolicy();
		if (refreshPolicy == null) { // 沒有則不進(jìn)行刷新
			return;
		}
		// 獲取刷新時間間隔
		long refreshMillis = refreshPolicy.getRefreshMillis();
		if (refreshMillis > 0) {
			// 獲取線程任務(wù)的ID
			Object taskId = getTaskId(key);
			// 獲取對應(yīng)的RefreshTask，不存在則創(chuàng)建一個
			RefreshTask refreshTask = taskMap.computeIfAbsent(taskId, tid -> {
				logger.debug("add refresh task. interval={},  key={}", refreshMillis, key);
				RefreshTask task = new RefreshTask(taskId, key, loader);
				task.lastAccessTime = System.currentTimeMillis();
				/*
				 * 獲取 ScheduledExecutorService 周期/延遲線程池，10個核心線程，創(chuàng)建的線程都是守護(hù)線程
				 * scheduleWithFixedDelay(Runnable command, long initialDelay, long period, TimeUnit unit)
				 * 運行的任務(wù)task、多久延遲后開始執(zhí)行、后續(xù)執(zhí)行的周期間隔多長，時間單位
				 * 通過其創(chuàng)建一個循環(huán)任務(wù)，用于刷新緩存數(shù)據(jù)
				 */
				ScheduledFuture<?> future = JetCacheExecutor.heavyIOExecutor().scheduleWithFixedDelay(task,
						refreshMillis, refreshMillis, TimeUnit.MILLISECONDS);
				task.future = future;
				return task;
			});
			// 設(shè)置最后一次訪問時間
			refreshTask.lastAccessTime = System.currentTimeMillis();
		}
	}
}

public class RefreshCache<K, V> extends LoadingCache<K, V> {
    
    protected Cache concreteCache() {
		Cache c = getTargetCache();
		while (true) {
			if (c instanceof ProxyCache) {
				c = ((ProxyCache) c).getTargetCache();
			} else if (c instanceof MultiLevelCache) {
				Cache[] caches = ((MultiLevelCache) c).caches();
				// 如果是兩級緩存則返回遠(yuǎn)程緩存
				c = caches[caches.length - 1];
			} else {
				return c;
			}
		}
	}
    
    class RefreshTask implements Runnable {
		/**
		 * 唯一標(biāo)志符，也就是Key轉(zhuǎn)換后的值
		 */
		private Object taskId;
		/**
		 * 緩存的Key
		 */
		private K key;
		/**
		 * 執(zhí)行方法的CacheLoader對象
		 */
		private CacheLoader<K, V> loader;
		/**
		 * 最后一次訪問時間
		 */
		private long lastAccessTime;
		/**
		 * 該 Task 的執(zhí)行策略
		 */
		private ScheduledFuture future;
		RefreshTask(Object taskId, K key, CacheLoader<K, V> loader) {
			this.taskId = taskId;
			this.key = key;
			this.loader = loader;
		}
		private void cancel() {
			logger.debug("cancel refresh: {}", key);
			// 嘗試中斷當(dāng)前任務(wù)
			future.cancel(false);
			// 從任務(wù)列表中刪除
			taskMap.remove(taskId);
		}
		/**
		 * 重新加載數(shù)據(jù)
		 *
		 * @throws Throwable 異常
		 */
		private void load() throws Throwable {
			CacheLoader<K, V> l = loader == null ? config.getLoader() : loader;
			if (l != null) {
				// 封裝 CacheLoader 成 ProxyLoader，加載后會發(fā)起 Load 事件
				l = CacheUtil.createProxyLoader(cache, l, eventConsumer);
				// 加載
				V v = l.load(key);
				if (needUpdate(v, l)) {
					// 將重新加載的數(shù)據(jù)放入緩存
					cache.PUT(key, v);
				}
			}
		}
		/**
		 * 遠(yuǎn)程加載數(shù)據(jù)
		 *
		 * @param concreteCache 緩存對象
		 * @param currentTime   當(dāng)前時間
		 * @throws Throwable 異常
		 */
		private void externalLoad(final Cache concreteCache, final long currentTime) throws Throwable {
			// 獲取 Key 轉(zhuǎn)換后的值
			byte[] newKey = ((AbstractExternalCache) concreteCache).buildKey(key);
			// 創(chuàng)建分布式鎖對應(yīng)的Key
			byte[] lockKey = combine(newKey, "_#RL#".getBytes());
			// 分布式鎖的存在時間
			long loadTimeOut = RefreshCache.this.config.getRefreshPolicy().getRefreshLockTimeoutMillis();
			// 刷新間隔
			long refreshMillis = config.getRefreshPolicy().getRefreshMillis();
			// Key對應(yīng)的時間戳Key（用于存放上次刷新時間）
			byte[] timestampKey = combine(newKey, "_#TS#".getBytes());
			// AbstractExternalCache buildKey method will not convert byte[]
			// 獲取Key上一次刷新時間
			CacheGetResult refreshTimeResult = concreteCache.GET(timestampKey);
			boolean shouldLoad = false; // 是否需要重新加載
			if (refreshTimeResult.isSuccess()) {
				// 當(dāng)前時間與上一次刷新的時間間隔是否大于或等于刷新間隔
				shouldLoad = currentTime >= Long.parseLong(refreshTimeResult.getValue().toString()) + refreshMillis;
			} else if (refreshTimeResult.getResultCode() == CacheResultCode.NOT_EXISTS) { // 無緩存
				shouldLoad = true;
			}
			if (!shouldLoad) {
				if (multiLevelCache) {
					// 將頂層的緩存數(shù)據(jù)更新至低層的緩存中，例如將遠(yuǎn)程的緩存數(shù)據(jù)放入本地緩存
					// 因為如果是多級緩存，創(chuàng)建刷新任務(wù)后，我們只需更新遠(yuǎn)程的緩存，然后從遠(yuǎn)程緩存獲取緩存數(shù)據(jù)更新低層的緩存，保證緩存一致
					refreshUpperCaches(key);
				}
				return;
			}
			// 重新加載
			Runnable r = () -> {
				try {
					load();
					// AbstractExternalCache buildKey method will not convert byte[]
					// 保存一個key-value至redis，其中的信息為該value的生成時間，刷新緩存
					concreteCache.put(timestampKey, String.valueOf(System.currentTimeMillis()));
				} catch (Throwable e) {
					throw new CacheException("refresh error", e);
				}
			};
			// AbstractExternalCache buildKey method will not convert byte[]
			// 分布式緩存沒有一個全局分配的功能，這里嘗試獲取一把非嚴(yán)格的分布式鎖，獲取鎖的超時時間默認(rèn)60秒，也就是獲取到這把鎖最多可以擁有60秒
			// 只有獲取Key對應(yīng)的這把分布式鎖，才執(zhí)行重新加載的操作
			boolean lockSuccess = concreteCache.tryLockAndRun(lockKey, loadTimeOut, TimeUnit.MILLISECONDS, r);
			if (!lockSuccess && multiLevelCache) { // 沒有獲取到鎖并且是多級緩存
				// 這個時候應(yīng)該有其他實例在刷新緩存，所以這里設(shè)置過一會直接獲取遠(yuǎn)程的緩存數(shù)據(jù)更新到本地
				// 創(chuàng)建一個延遲任務(wù)（1/5刷新間隔后），將最頂層的緩存數(shù)據(jù)更新至每一層
				JetCacheExecutor.heavyIOExecutor().schedule(() -> refreshUpperCaches(key), (long) (0.2 * refreshMillis),
						TimeUnit.MILLISECONDS);
			}
		}
		private void refreshUpperCaches(K key) {
			MultiLevelCache<K, V> targetCache = (MultiLevelCache<K, V>) getTargetCache();
			Cache[] caches = targetCache.caches();
			int len = caches.length;
			// 獲取多級緩存中頂層的緩存數(shù)據(jù)
			CacheGetResult cacheGetResult = caches[len - 1].GET(key);
			if (!cacheGetResult.isSuccess()) {
				return;
			}
			// 將緩存數(shù)據(jù)重新放入低層緩存
			for (int i = 0; i < len - 1; i++) {
				caches[i].PUT(key, cacheGetResult.getValue());
			}
		}
		/**
		 * 刷新任務(wù)的具體執(zhí)行
		 */
		@Override
		public void run() {
			try {
				if (config.getRefreshPolicy() == null || (loader == null && !hasLoader())) {
					// 取消執(zhí)行
					cancel();
					return;
				}
				long now = System.currentTimeMillis();
				long stopRefreshAfterLastAccessMillis = config.getRefreshPolicy().getStopRefreshAfterLastAccessMillis();
				if (stopRefreshAfterLastAccessMillis > 0) {
					// 最后一次訪問到現(xiàn)在時間的間隔超過了設(shè)置的 stopRefreshAfterLastAccessMillis，則取消當(dāng)前任務(wù)執(zhí)行
					if (lastAccessTime + stopRefreshAfterLastAccessMillis < now) {
						logger.debug("cancel refresh: {}", key);
						cancel();
						return;
					}
				}
				logger.debug("refresh key: {}", key);
				// 獲取緩存實例對象，如果是多層則返回頂層，也就是遠(yuǎn)程緩存
				Cache concreteCache = concreteCache();
				if (concreteCache instanceof AbstractExternalCache) { // 遠(yuǎn)程緩存刷新
					externalLoad(concreteCache, now);
				} else { // 本地緩存刷新
					load();
				}
			} catch (Throwable e) {
				logger.error("refresh error: key=" + key, e);
			}
		}
	}
}

public abstract class AbstractCacheAutoInit implements InitializingBean {
    @Autowired
    protected ConfigurableEnvironment environment;
    @Autowired
    protected AutoConfigureBeans autoConfigureBeans;
    @Autowired
    protected ConfigProvider configProvider;
    protected String[] typeNames;
    private boolean inited = false;
    public AbstractCacheAutoInit(String... cacheTypes) {
        Objects.requireNonNull(cacheTypes,"cacheTypes can't be null");
        Assert.isTrue(cacheTypes.length > 0, "cacheTypes length is 0");
        this.typeNames = cacheTypes;
    }
    /**
     * 初始化方法
     */
    @Override
    public void afterPropertiesSet() {
        if (!inited) {
            synchronized (this) {
                if (!inited) {
                    // 這里我們有兩個指定前綴 'jetcache.local' 'jetcache.remote'
                    process("jetcache.local.", autoConfigureBeans.getLocalCacheBuilders(), true);
                    process("jetcache.remote.", autoConfigureBeans.getRemoteCacheBuilders(), false);
                    inited = true;
                }
            }
        }
    }
    private void process(String prefix, Map cacheBuilders, boolean local) {
        // 創(chuàng)建一個配置對象（本地或者遠(yuǎn)程）
        ConfigTree resolver = new ConfigTree(environment, prefix);
        // 獲取本地或者遠(yuǎn)程的配置項
        Map<String, Object> m = resolver.getProperties();
        // 獲取本地或者遠(yuǎn)程的 area ，這里我一般只有默認(rèn)的 default
        Set<String> cacheAreaNames = resolver.directChildrenKeys();
        for (String cacheArea : cacheAreaNames) {
            // 獲取本地或者遠(yuǎn)程存儲類型，例如 caffeine，redis.lettuce
            final Object configType = m.get(cacheArea + ".type");
            // 緩存類型是否和當(dāng)前 CacheAutoInit 的某一個 typeName 匹配（不同的 CacheAutoInit 會設(shè)置一個或者多個 typename）
            boolean match = Arrays.stream(typeNames).anyMatch((tn) -> tn.equals(configType));
            /*
             * 因為有很多 CacheAutoInit 繼承者，都會執(zhí)行這個方法，不同的繼承者解析不同的配置
             * 例如 CaffeineAutoConfiguration 只解析 jetcache.local.default.type=caffeine 即可
             * RedisLettuceAutoInit 只解析 jetcache.remote.default.type=redis.lettuce 即可
             */
            if (!match) {
                continue;
            }
            // 獲取本地或者遠(yuǎn)程的 area 的子配置項
            ConfigTree ct = resolver.subTree(cacheArea + ".");
            logger.info("init cache area {} , type= {}", cacheArea, typeNames[0]);
            // 根據(jù)配置信息構(gòu)建本地或者遠(yuǎn)程緩存的 CacheBuilder 構(gòu)造器
            CacheBuilder c = initCache(ct, local ? "local." + cacheArea : "remote." + cacheArea);
            // 將 CacheBuilder 構(gòu)造器存放至 AutoConfigureBeans
            cacheBuilders.put(cacheArea, c);
        }
    }
    /**
     * 設(shè)置公共的配置到 CacheBuilder 構(gòu)造器中
     *
     * @param builder 構(gòu)造器
     * @param ct      配置信息
     */
    protected void parseGeneralConfig(CacheBuilder builder, ConfigTree ct) {
        AbstractCacheBuilder acb = (AbstractCacheBuilder) builder;
        // 設(shè)置 Key 的轉(zhuǎn)換函數(shù)
        acb.keyConvertor(configProvider.parseKeyConvertor(ct.getProperty("keyConvertor")));
        // 設(shè)置超時時間
        String expireAfterWriteInMillis = ct.getProperty("expireAfterWriteInMillis");
        if (expireAfterWriteInMillis == null) {
            // compatible with 2.1 兼容老版本
            expireAfterWriteInMillis = ct.getProperty("defaultExpireInMillis");
        }
        if (expireAfterWriteInMillis != null) {
            acb.setExpireAfterWriteInMillis(Long.parseLong(expireAfterWriteInMillis));
        }
        // 多長時間沒有訪問就讓緩存失效，0表示不使用該功能（注意：只支持本地緩存）
        String expireAfterAccessInMillis = ct.getProperty("expireAfterAccessInMillis");
        if (expireAfterAccessInMillis != null) {
            acb.setExpireAfterAccessInMillis(Long.parseLong(expireAfterAccessInMillis));
        }
    }
    /**
     * 初始化 CacheBuilder 構(gòu)造器交由子類去實現(xiàn)
     *
     * @param ct                  配置信息
     * @param cacheAreaWithPrefix 配置前綴
     * @return CacheBuilder 構(gòu)造器
     */
    protected abstract CacheBuilder initCache(ConfigTree ct, String cacheAreaWithPrefix);
}

public abstract class EmbeddedCacheAutoInit extends AbstractCacheAutoInit {
    public EmbeddedCacheAutoInit(String... cacheTypes) {
        super(cacheTypes);
    }
    @Override
    protected void parseGeneralConfig(CacheBuilder builder, ConfigTree ct) {
        super.parseGeneralConfig(builder, ct);
        EmbeddedCacheBuilder ecb = (EmbeddedCacheBuilder) builder;
        // 設(shè)置本地緩存每個緩存實例的緩存數(shù)量個數(shù)限制（默認(rèn)100）
        ecb.limit(Integer.parseInt(ct.getProperty("limit", String.valueOf(CacheConsts.DEFAULT_LOCAL_LIMIT))));
    }
}

@Component
@Conditional(LinkedHashMapAutoConfiguration.LinkedHashMapCondition.class)
public class LinkedHashMapAutoConfiguration extends EmbeddedCacheAutoInit {
    public LinkedHashMapAutoConfiguration() {
        super("linkedhashmap");
    }
    @Override
    protected CacheBuilder initCache(ConfigTree ct, String cacheAreaWithPrefix) {
        // 創(chuàng)建一個 LinkedHashMapCacheBuilder 構(gòu)造器
        LinkedHashMapCacheBuilder builder = LinkedHashMapCacheBuilder.createLinkedHashMapCacheBuilder();
        // 解析相關(guān)配置至 LinkedHashMapCacheBuilder 的 CacheConfig 中
        parseGeneralConfig(builder, ct);
        return builder;
    }
    public static class LinkedHashMapCondition extends JetCacheCondition {
        // 配置了緩存類型為 linkedhashmap 當(dāng)前類才會被注入 Spring 容器
        public LinkedHashMapCondition() {
            super("linkedhashmap");
        }
    }
}

@Component
@Conditional(CaffeineAutoConfiguration.CaffeineCondition.class)
public class CaffeineAutoConfiguration extends EmbeddedCacheAutoInit {
    public CaffeineAutoConfiguration() {
        super("caffeine");
    }
    @Override
    protected CacheBuilder initCache(ConfigTree ct, String cacheAreaWithPrefix) {
        // 創(chuàng)建一個 CaffeineCacheBuilder 構(gòu)造器
        CaffeineCacheBuilder builder = CaffeineCacheBuilder.createCaffeineCacheBuilder();
        // 解析相關(guān)配置至 CaffeineCacheBuilder 的 CacheConfig 中
        parseGeneralConfig(builder, ct);
        return builder;
    }
    public static class CaffeineCondition extends JetCacheCondition {
        // 配置了緩存類型為 caffeine 當(dāng)前類才會被注入 Spring 容器
        public CaffeineCondition() {
            super("caffeine");
        }
    }
}

public abstract class ExternalCacheAutoInit extends AbstractCacheAutoInit {
    public ExternalCacheAutoInit(String... cacheTypes) {
        super(cacheTypes);
    }
    /**
     * 設(shè)置遠(yuǎn)程緩存 CacheBuilder 構(gòu)造器的相關(guān)配置
     *
     * @param builder 構(gòu)造器
     * @param ct      配置信息
     */
    @Override
    protected void parseGeneralConfig(CacheBuilder builder, ConfigTree ct) {
        super.parseGeneralConfig(builder, ct);
        ExternalCacheBuilder ecb = (ExternalCacheBuilder) builder;
        // 設(shè)置遠(yuǎn)程緩存 key 的前綴
        ecb.setKeyPrefix(ct.getProperty("keyPrefix"));
        /*
         * 根據(jù)配置創(chuàng)建緩存數(shù)據(jù)的編碼函數(shù)和解碼函數(shù)
         */
        ecb.setValueEncoder(configProvider.parseValueEncoder(ct.getProperty("valueEncoder", CacheConsts.DEFAULT_SERIAL_POLICY)));
        ecb.setValueDecoder(configProvider.parseValueDecoder(ct.getProperty("valueDecoder", CacheConsts.DEFAULT_SERIAL_POLICY)));
    }
}

@Configuration
@Conditional(RedisAutoConfiguration.RedisCondition.class)
public class RedisAutoConfiguration {
    public static final String AUTO_INIT_BEAN_NAME = "redisAutoInit";
    @Bean(name = AUTO_INIT_BEAN_NAME)
    public RedisAutoInit redisAutoInit() {
        return new RedisAutoInit();
    }
    public static class RedisCondition extends JetCacheCondition {
        // 配置了緩存類型為 redis 當(dāng)前類才會被注入 Spring 容器
        public RedisCondition() {
            super("redis");
        }
    }
    public static class RedisAutoInit extends ExternalCacheAutoInit {
        public RedisAutoInit() {
            // 設(shè)置緩存類型
            super("redis");
        }
        @Autowired
        private AutoConfigureBeans autoConfigureBeans;
        @Override
        protected CacheBuilder initCache(ConfigTree ct, String cacheAreaWithPrefix) {
            Pool jedisPool = parsePool(ct);
            Pool[] slavesPool = null;
            int[] slavesPoolWeights = null;
            // 是否只從 Redis 的從節(jié)點讀取數(shù)據(jù)
            boolean readFromSlave = Boolean.parseBoolean(ct.getProperty("readFromSlave", "False"));
            // 獲取從節(jié)點的配置信息
            ConfigTree slaves = ct.subTree("slaves.");
            Set<String> slaveNames = slaves.directChildrenKeys();
            // 依次創(chuàng)建每個從節(jié)點的連接池
            if (slaveNames.size() > 0) {
                slavesPool = new Pool[slaveNames.size()];
                slavesPoolWeights = new int[slaveNames.size()];
                int i = 0;
                for (String slaveName: slaveNames) {
                    ConfigTree slaveConfig = slaves.subTree(slaveName + ".");
                    slavesPool[i] = parsePool(slaveConfig);
                    slavesPoolWeights[i] = Integer.parseInt(slaveConfig.getProperty("weight","100"));
                    i++;
                }
            }
            // 創(chuàng)建一個 RedisCacheBuilder 構(gòu)造器
            ExternalCacheBuilder externalCacheBuilder = RedisCacheBuilder.createRedisCacheBuilder()
                    .jedisPool(jedisPool)
                    .readFromSlave(readFromSlave)
                    .jedisSlavePools(slavesPool)
                    .slaveReadWeights(slavesPoolWeights);
            // 解析相關(guān)配置至 RedisCacheBuilder 的 CacheConfig 中
            parseGeneralConfig(externalCacheBuilder, ct);
            // eg: "jedisPool.remote.default"
            autoConfigureBeans.getCustomContainer().put("jedisPool." + cacheAreaWithPrefix, jedisPool);
            return externalCacheBuilder;
        }
        /**
         * 創(chuàng)建 Redis 連接池
         *
         * @param ct 配置信息
         * @return 連接池
         */
        private Pool<Jedis> parsePool(ConfigTree ct) {
            // 創(chuàng)建連接池配置對象
            GenericObjectPoolConfig poolConfig = parsePoolConfig(ct);
            String host = ct.getProperty("host", (String) null);
            int port = Integer.parseInt(ct.getProperty("port", "0"));
            int timeout = Integer.parseInt(ct.getProperty("timeout", String.valueOf(Protocol.DEFAULT_TIMEOUT)));
            String password = ct.getProperty("password", (String) null);
            int database = Integer.parseInt(ct.getProperty("database", String.valueOf(Protocol.DEFAULT_DATABASE)));
            String clientName = ct.getProperty("clientName", (String) null);
            boolean ssl = Boolean.parseBoolean(ct.getProperty("ssl", "false"));
            String masterName = ct.getProperty("masterName", (String) null);
            String sentinels = ct.getProperty("sentinels", (String) null);//ip1:port,ip2:port
            Pool<Jedis> jedisPool;
            if (sentinels == null) {
                Objects.requireNonNull(host, "host/port or sentinels/masterName is required");
                if (port == 0) {
                    throw new IllegalStateException("host/port or sentinels/masterName is required");
                }
                // 創(chuàng)建一個 Jedis 連接池
                jedisPool = new JedisPool(poolConfig, host, port, timeout, password, database, clientName, ssl);
            } else {
                Objects.requireNonNull(masterName, "host/port or sentinels/masterName is required");
                String[] strings = sentinels.split(",");
                HashSet<String> sentinelsSet = new HashSet<>();
                for (String s : strings) {
                    if (s != null && !s.trim().equals("")) {
                        sentinelsSet.add(s.trim());
                    }
                }
                // 創(chuàng)建一個 Jedis Sentine 連接池
                jedisPool = new JedisSentinelPool(masterName, sentinelsSet, poolConfig, timeout, password, database, clientName);
            }
            return jedisPool;
        }
    }
}

@Configuration
@Conditional(RedisLettuceAutoConfiguration.RedisLettuceCondition.class)
public class RedisLettuceAutoConfiguration {
    public static final String AUTO_INIT_BEAN_NAME = "redisLettuceAutoInit";
    /**
     * 注入 spring 容器的條件
     */
    public static class RedisLettuceCondition extends JetCacheCondition {
        // 配置了緩存類型為 redis.lettuce 當(dāng)前類才會被注入 Spring 容器
        public RedisLettuceCondition() {
            super("redis.lettuce");
        }
    }
    @Bean(name = {AUTO_INIT_BEAN_NAME})
    public RedisLettuceAutoInit redisLettuceAutoInit() {
        return new RedisLettuceAutoInit();
    }
    public static class RedisLettuceAutoInit extends ExternalCacheAutoInit {
        public RedisLettuceAutoInit() {
            // 設(shè)置緩存類型
            super("redis.lettuce");
        }
        /**
         * 初始化 RedisLettuceCacheBuilder 構(gòu)造器
         *
         * @param ct                  配置信息
         * @param cacheAreaWithPrefix 配置前綴
         * @return 構(gòu)造器
         */
        @Override
        protected CacheBuilder initCache(ConfigTree ct, String cacheAreaWithPrefix) {
            Map<String, Object> map = ct.subTree("uri"/*there is no dot*/).getProperties();
            // 數(shù)據(jù)節(jié)點偏好設(shè)置
            String readFromStr = ct.getProperty("readFrom");
            // 集群模式
            String mode = ct.getProperty("mode");
            // 異步獲取結(jié)果的超時時間，默認(rèn)1s
            long asyncResultTimeoutInMillis = Long.parseLong(
                    ct.getProperty("asyncResultTimeoutInMillis", Long.toString(CacheConsts.ASYNC_RESULT_TIMEOUT.toMillis())));
            ReadFrom readFrom = null;
            if (readFromStr != null) {
                /*
                 * MASTER：只從Master節(jié)點中讀取。
                 * MASTER_PREFERRED：優(yōu)先從Master節(jié)點中讀取。
                 * SLAVE_PREFERRED：優(yōu)先從Slave節(jié)點中讀取。
                 * SLAVE：只從Slave節(jié)點中讀取。
                 * NEAREST：使用最近一次連接的Redis實例讀取。
                 */
                readFrom = ReadFrom.valueOf(readFromStr.trim());
            }
            AbstractRedisClient client;
            StatefulConnection connection = null;
            if (map == null || map.size() == 0) {
                throw new CacheConfigException("lettuce uri is required");
            } else {
                // 創(chuàng)建對應(yīng)的 RedisURI
                List<RedisURI> uriList = map.values().stream().map((k) -> RedisURI.create(URI.create(k.toString())))
                        .collect(Collectors.toList());
                if (uriList.size() == 1) { // 只有一個 URI，集群模式只給一個域名怎么辦 TODO 疑問？？
                    RedisURI uri = uriList.get(0);
                    if (readFrom == null) {
                        // 創(chuàng)建一個 Redis 客戶端
                        client = RedisClient.create(uri);
                        // 設(shè)置失去連接時的行為，拒絕命令，默認(rèn)為 DEFAULT
                        ((RedisClient) client).setOptions(ClientOptions.builder().
                                disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS).build());
                    } else {
                        // 創(chuàng)建一個 Redis 客戶端
                        client = RedisClient.create();
                        ((RedisClient) client).setOptions(ClientOptions.builder().
                                disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS).build());
                        // 創(chuàng)建一個安全連接并設(shè)置數(shù)據(jù)節(jié)點偏好
                        StatefulRedisMasterSlaveConnection c = MasterSlave.connect(
                                (RedisClient) client, new JetCacheCodec(), uri);
                        c.setReadFrom(readFrom);
                        connection = c;
                    }
                } else { // 多個 URI，集群模式
                    if (mode != null && mode.equalsIgnoreCase("MasterSlave")) {
                        client = RedisClient.create();
                        ((RedisClient) client).setOptions(ClientOptions.builder().
                                disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS).build());
                        StatefulRedisMasterSlaveConnection c = MasterSlave.connect(
                                (RedisClient) client, new JetCacheCodec(), uriList);
                        if (readFrom != null) {
                            c.setReadFrom(readFrom);
                        }
                        connection = c;
                    } else {
                        // 創(chuàng)建一個 Redis 客戶端
                        client = RedisClusterClient.create(uriList);
                        ((RedisClusterClient) client).setOptions(ClusterClientOptions.builder().
                                disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS).build());
                        if (readFrom != null) {
                            StatefulRedisClusterConnection c = ((RedisClusterClient) client).connect(new JetCacheCodec());
                            c.setReadFrom(readFrom);
                            connection = c;
                        }
                    }
                }
            }
            // 創(chuàng)建一個 RedisLettuceCacheBuilder 構(gòu)造器
            ExternalCacheBuilder externalCacheBuilder = RedisLettuceCacheBuilder.createRedisLettuceCacheBuilder()
                    .connection(connection)
                    .redisClient(client)
                    .asyncResultTimeoutInMillis(asyncResultTimeoutInMillis);
            // 解析相關(guān)配置至 RedisLettuceCacheBuilder 的 CacheConfig 中
            parseGeneralConfig(externalCacheBuilder, ct);
            // eg: "remote.default.client"
            autoConfigureBeans.getCustomContainer().put(cacheAreaWithPrefix + ".client", client);
            // 開始將 Redis 客戶端和安全連接保存至 LettuceConnectionManager 管理器中
            LettuceConnectionManager m = LettuceConnectionManager.defaultManager();
            // 初始化 Lettuce 連接 Redis
            m.init(client, connection);
            // 初始化 Redis 連接的相關(guān)信息保存至 LettuceObjects 中，并將相關(guān)信息保存至 AutoConfigureBeans.customContainer
            autoConfigureBeans.getCustomContainer().put(cacheAreaWithPrefix + ".connection", m.connection(client));
            autoConfigureBeans.getCustomContainer().put(cacheAreaWithPrefix + ".commands", m.commands(client));
            autoConfigureBeans.getCustomContainer().put(cacheAreaWithPrefix + ".asyncCommands", m.asyncCommands(client));
            autoConfigureBeans.getCustomContainer().put(cacheAreaWithPrefix + ".reactiveCommands", m.reactiveCommands(client));
            return externalCacheBuilder;
        }
    }
}

/**
 * 該 Bean 將會被 Spring 容器注入，依次注入下面幾個 Bean
 * SpringConfigProvider -> AutoConfigureBeans -> BeanDependencyManager(為 GlobalCacheConfig 添加 CacheAutoInit 依賴) -> GlobalCacheConfig
 * 由此會完成初始化配置操作，緩存實例構(gòu)造器 CacheBuilder 也會被注入容器
 *
 * Created on 2016/11/17.
 *
 * @author <a href="mailto:areyouok@gmail.com">huangli</a>
 */
@Configuration
@ConditionalOnClass(GlobalCacheConfig.class)
@ConditionalOnMissingBean(GlobalCacheConfig.class)
@EnableConfigurationProperties(JetCacheProperties.class)
@Import({RedisAutoConfiguration.class,
        CaffeineAutoConfiguration.class,
        MockRemoteCacheAutoConfiguration.class,
        LinkedHashMapAutoConfiguration.class,
        RedisLettuceAutoConfiguration.class,
        RedisSpringDataAutoConfiguration.class})
public class JetCacheAutoConfiguration {
    public static final String GLOBAL_CACHE_CONFIG_NAME = "globalCacheConfig";
    private SpringConfigProvider _springConfigProvider = new SpringConfigProvider();
    private AutoConfigureBeans _autoConfigureBeans = new AutoConfigureBeans();
    private GlobalCacheConfig _globalCacheConfig;
    @Bean
    @ConditionalOnMissingBean
    public SpringConfigProvider springConfigProvider() {
        return _springConfigProvider;
    }
    @Bean
    public AutoConfigureBeans autoConfigureBeans() {
        return _autoConfigureBeans;
    }
    @Bean
    public static BeanDependencyManager beanDependencyManager(){
        return new BeanDependencyManager();
    }
    @Bean(name = GLOBAL_CACHE_CONFIG_NAME)
    public GlobalCacheConfig globalCacheConfig(SpringConfigProvider configProvider,
                                                            AutoConfigureBeans autoConfigureBeans,
                                                            JetCacheProperties props) {
        if (_globalCacheConfig != null) {
            return _globalCacheConfig;
        }
        _globalCacheConfig = new GlobalCacheConfig();
        _globalCacheConfig.setHiddenPackages(props.getHiddenPackages());
        _globalCacheConfig.setStatIntervalMinutes(props.getStatIntervalMinutes());
        _globalCacheConfig.setAreaInCacheName(props.isAreaInCacheName());
        _globalCacheConfig.setPenetrationProtect(props.isPenetrationProtect());
        _globalCacheConfig.setEnableMethodCache(props.isEnableMethodCache());
        _globalCacheConfig.setLocalCacheBuilders(autoConfigureBeans.getLocalCacheBuilders());
        _globalCacheConfig.setRemoteCacheBuilders(autoConfigureBeans.getRemoteCacheBuilders());
        return _globalCacheConfig;
    }
}

public abstract class AbstractCacheBuilder<T extends AbstractCacheBuilder<T>> implements CacheBuilder, Cloneable {
    /**
     * 該緩存實例的配置
     */
    protected CacheConfig config;
    /**
     * 創(chuàng)建緩存實例函數(shù)
     */
    private Function<CacheConfig, Cache> buildFunc;
    public abstract CacheConfig getConfig();
    protected T self() {
        return (T) this;
    }
    public T buildFunc(Function<CacheConfig, Cache> buildFunc) {
        this.buildFunc = buildFunc;
        return self();
    }
    protected void beforeBuild() {
    }
    @Deprecated
    public final <K, V> Cache<K, V> build() {
        return buildCache();
    }
    @Override
    public final <K, V> Cache<K, V> buildCache() {
        if (buildFunc == null) {
            throw new CacheConfigException("no buildFunc");
        }
        beforeBuild();
        // 克隆一份配置信息，因為這里獲取到的是全局配置信息，以防后續(xù)被修改
        CacheConfig c = getConfig().clone();
        // 通過構(gòu)建函數(shù)創(chuàng)建一個緩存實例
        Cache<K, V> cache = buildFunc.apply(c);
        /*
         * 目前發(fā)現(xiàn) c.getLoader() 都是 null，后續(xù)都會把 cache 封裝成 CacheHandlerRefreshCache
         * TODO 疑問？？？？
         */
        if (c.getLoader() != null) {
            if (c.getRefreshPolicy() == null) {
                cache = new LoadingCache<>(cache);
            } else {
                cache = new RefreshCache<>(cache);
            }
        }
        return cache;
    }
    @Override
    public Object clone() {
        AbstractCacheBuilder copy = null;
        try {
            copy = (AbstractCacheBuilder) super.clone();
            copy.config = getConfig().clone();
            return copy;
        } catch (CloneNotSupportedException e) {
            throw new CacheException(e);
        }
    }
}

// 設(shè)置構(gòu)建 CaffeineCache 緩存實例的函數(shù)
buildFunc((c) -> new CaffeineCache((EmbeddedCacheConfig) c));
// 進(jìn)入CaffeineCache的構(gòu)造器你就可以看到會根據(jù)配置完成緩存實例的初始化

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({CommonConfiguration.class, ConfigSelector.class})
public @interface EnableMethodCache {
    boolean proxyTargetClass() default false;
    AdviceMode mode() default AdviceMode.PROXY;
    int order() default Ordered.LOWEST_PRECEDENCE;
    String[] basePackages();
}

@Configuration
public class JetCacheProxyConfiguration implements ImportAware, ApplicationContextAware {
    protected AnnotationAttributes enableMethodCache;
    private ApplicationContext applicationContext;
    @Override
    public void setImportMetadata(AnnotationMetadata importMetadata) {
        // 獲取 @EnableMethodCache 注解信息
        this.enableMethodCache = AnnotationAttributes.fromMap(
                importMetadata.getAnnotationAttributes(EnableMethodCache.class.getName(), false));
        if (this.enableMethodCache == null) {
            throw new IllegalArgumentException(
                    "@EnableMethodCache is not present on importing class " + importMetadata.getClassName());
        }
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
    @Bean(name = CacheAdvisor.CACHE_ADVISOR_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public CacheAdvisor jetcacheAdvisor(JetCacheInterceptor jetCacheInterceptor) {
        CacheAdvisor advisor = new CacheAdvisor();
        // bean的名稱：jetcache2.internalCacheAdvisor
        advisor.setAdviceBeanName(CacheAdvisor.CACHE_ADVISOR_BEAN_NAME);
        // 設(shè)置緩存攔截器為 JetCacheInterceptor
        advisor.setAdvice(jetCacheInterceptor);
        // 設(shè)置需要掃描的包
        advisor.setBasePackages(this.enableMethodCache.getStringArray("basePackages"));
        // 設(shè)置優(yōu)先級，默認(rèn) Integer 的最大值，最低優(yōu)先級
        advisor.setOrder(this.enableMethodCache.<Integer>getNumber("order"));
        return advisor;
    }
    /**
     * 注入一個 JetCacheInterceptor 攔截器，設(shè)置為框架內(nèi)部的角色
     *
     * @return JetCacheInterceptor
     */
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public JetCacheInterceptor jetCacheInterceptor() {
        return new JetCacheInterceptor();
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({CommonConfiguration.class, CreateCacheAnnotationBeanPostProcessor.class})
public @interface EnableCreateCacheAnnotation {
}

class LazyInitCache implements ProxyCache {
    /**
     * 是否初始化，用于懶加載
     */
    private boolean inited;
    /**
     * 緩存實例
     */
    private Cache cache;
    /**
     * 所處上下文
     */
    private ConfigurableListableBeanFactory beanFactory;
    /**
     * CreateCache 注解元信息
     */
    private CreateCache ann;
    /**
     * 字段
     */
    private Field field;
    /**
     * 刷新策略
     */
    private RefreshPolicy refreshPolicy;
    /**
     * 保護(hù)策略
     */
    private PenetrationProtectConfig protectConfig;
    public LazyInitCache(ConfigurableListableBeanFactory beanFactory, CreateCache ann, Field field) {
        this.beanFactory = beanFactory;
        this.ann = ann;
        this.field = field;
        CacheRefresh cr = field.getAnnotation(CacheRefresh.class);
        if (cr != null) {
            refreshPolicy = CacheConfigUtil.parseRefreshPolicy(cr);
        }
        CachePenetrationProtect penetrateProtect = field.getAnnotation(CachePenetrationProtect.class);
        if (penetrateProtect != null) {
            protectConfig = CacheConfigUtil.parsePenetrationProtectConfig(penetrateProtect);
        }
    }
    private void checkInit() {
        if (!inited) {
            synchronized (this) {
                if (!inited) {
                    init();
                    inited = true;
                }
            }
        }
    }
    /**
     * 獲取緩存實例，不存在則新建
     *
     * @return 緩存實例
     */
    @Override
    public Cache getTargetCache() {
        checkInit();
        return cache;
    }
    private void init() {
        if (inited) {
            throw new IllegalStateException();
        }
        // 從 spring 的容器中獲取全局緩存配置 GlobalCacheConfig 對象
        GlobalCacheConfig globalCacheConfig = beanFactory.getBean(GlobalCacheConfig.class);
        ConfigProvider configProvider = beanFactory.getBean(ConfigProvider.class);
        // 將注解信息封裝到 CachedAnnoConfig 對象中
        CachedAnnoConfig cac = new CachedAnnoConfig();
        cac.setArea(ann.area());
        cac.setName(ann.name());
        cac.setTimeUnit(ann.timeUnit());
        cac.setExpire(ann.expire());
        cac.setLocalExpire(ann.localExpire());
        cac.setCacheType(ann.cacheType());
        cac.setLocalLimit(ann.localLimit());
        cac.setSerialPolicy(ann.serialPolicy());
        cac.setKeyConvertor(ann.keyConvertor());
        cac.setRefreshPolicy(refreshPolicy);
        cac.setPenetrationProtectConfig(protectConfig);
        String cacheName = cac.getName();
        if (CacheConsts.isUndefined(cacheName)) {
            String[] hiddenPackages = globalCacheConfig.getHiddenPackages();
            CacheNameGenerator g = configProvider.createCacheNameGenerator(hiddenPackages);
            cacheName = g.generateCacheName(field);
        }
        // 從緩存實例管理器中獲取或者創(chuàng)建對應(yīng)的緩存實例
        cache = configProvider.getCacheContext().__createOrGetCache(cac, ann.area(), cacheName);
    }
}

public class ConfigProvider extends AbstractLifecycle {
    /**
     * 緩存的全局配置
     */
    @Resource
    protected GlobalCacheConfig globalCacheConfig;
    /**
     * 緩存實例管理器
     */
    protected SimpleCacheManager cacheManager;
    /**
     * 根據(jù)不同類型生成緩存數(shù)據(jù)轉(zhuǎn)換函數(shù)的轉(zhuǎn)換器
     */
    protected EncoderParser encoderParser;
    /**
     * 根據(jù)不同類型生成緩存 Key 轉(zhuǎn)換函數(shù)的轉(zhuǎn)換器
     */
    protected KeyConvertorParser keyConvertorParser;
    /**
     * 緩存監(jiān)控指標(biāo)管理器
     */
    protected CacheMonitorManager cacheMonitorManager;
    /**
     * 打印緩存各項指標(biāo)的函數(shù)
     */
    private Consumer<StatInfo> metricsCallback = new StatInfoLogger(false);
    /**
     * 緩存更新事件（REMOVE OR PUT）消息接收者，無實現(xiàn)類
     * 我們可以自己實現(xiàn) CacheMessagePublisher 用于統(tǒng)計一些緩存的命中信息
     */
    private CacheMessagePublisher cacheMessagePublisher;
    /**
     * 默認(rèn)的緩存監(jiān)控指標(biāo)管理器
     */
    private CacheMonitorManager defaultCacheMonitorManager = new DefaultCacheMonitorManager();
    /**
     * 緩存上下文
     */
    private CacheContext cacheContext;
    public ConfigProvider() {
        cacheManager = SimpleCacheManager.defaultManager;
        encoderParser = new DefaultEncoderParser();
        keyConvertorParser = new DefaultKeyConvertorParser();
        cacheMonitorManager = defaultCacheMonitorManager;
    }
    @Override
    public void doInit() {
        // 啟動緩存指標(biāo)監(jiān)控器，周期性打印各項指標(biāo)
        initDefaultCacheMonitorInstaller();
        // 初始化緩存上下文
        cacheContext = newContext();
    }
    protected void initDefaultCacheMonitorInstaller() {
        if (cacheMonitorManager == defaultCacheMonitorManager) {
            DefaultCacheMonitorManager installer = (DefaultCacheMonitorManager) cacheMonitorManager;
            installer.setGlobalCacheConfig(globalCacheConfig);
            installer.setMetricsCallback(metricsCallback);
            if (cacheMessagePublisher != null) {
                installer.setCacheMessagePublisher(cacheMessagePublisher);
            }
            // 啟動緩存指標(biāo)監(jiān)控器
            installer.init();
        }
    }
    @Override
    public void doShutdown() {
        shutdownDefaultCacheMonitorInstaller();
        cacheManager.rebuild();
    }
    protected void shutdownDefaultCacheMonitorInstaller() {
        if (cacheMonitorManager == defaultCacheMonitorManager) {
            ((DefaultCacheMonitorManager) cacheMonitorManager).shutdown();
        }
    }
    /**
     * 根據(jù)編碼類型通過緩存value轉(zhuǎn)換器生成編碼函數(shù)
     *
     * @param valueEncoder 編碼類型
     * @return 編碼函數(shù)
     */
    public Function<Object, byte[]> parseValueEncoder(String valueEncoder) {
        return encoderParser.parseEncoder(valueEncoder);
    }
    /**
     * 根據(jù)解碼類型通過緩存value轉(zhuǎn)換器生成解碼函數(shù)
     *
     * @param valueDecoder 解碼類型
     * @return 解碼函數(shù)
     */
    public Function<byte[], Object> parseValueDecoder(String valueDecoder) {
        return encoderParser.parseDecoder(valueDecoder);
    }
    /**
     * 根據(jù)轉(zhuǎn)換類型通過緩存key轉(zhuǎn)換器生成轉(zhuǎn)換函數(shù)
     *
     * @param convertor 轉(zhuǎn)換類型
     * @return 轉(zhuǎn)換函數(shù)
     */
    public Function<Object, Object> parseKeyConvertor(String convertor) {
        return keyConvertorParser.parseKeyConvertor(convertor);
    }
    public CacheNameGenerator createCacheNameGenerator(String[] hiddenPackages) {
        return new DefaultCacheNameGenerator(hiddenPackages);
    }
    protected CacheContext newContext() {
        return new CacheContext(this, globalCacheConfig);
    }
}

public class CacheContext {
    private static Logger logger = LoggerFactory.getLogger(CacheContext.class);
    private static ThreadLocal<CacheThreadLocal> cacheThreadLocal = new ThreadLocal<CacheThreadLocal>() {
        @Override
        protected CacheThreadLocal initialValue() {
            return new CacheThreadLocal();
        }
    };
    /**
     * JetCache 緩存的管理器（包含很多信息）
     */
    private ConfigProvider configProvider;
    /**
     * 緩存的全局配置
     */
    private GlobalCacheConfig globalCacheConfig;
    /**
     * 緩存實例管理器
     */
    protected SimpleCacheManager cacheManager;
    public CacheContext(ConfigProvider configProvider, GlobalCacheConfig globalCacheConfig) {
        this.globalCacheConfig = globalCacheConfig;
        this.configProvider = configProvider;
        cacheManager = configProvider.getCacheManager();
    }
    public CacheInvokeContext createCacheInvokeContext(ConfigMap configMap) {
    	// 創(chuàng)建一個本次調(diào)用的上下文
        CacheInvokeContext c = newCacheInvokeContext();
        // 添加一個函數(shù)，后續(xù)用于獲取緩存實例
        // 根據(jù)注解配置信息獲取緩存實例對象，不存在則創(chuàng)建并設(shè)置到緩存注解配置類中
        c.setCacheFunction((invokeContext, cacheAnnoConfig) -> {
            Cache cache = cacheAnnoConfig.getCache();
            if (cache == null) {
                if (cacheAnnoConfig instanceof CachedAnnoConfig) { // 緩存注解
                    // 根據(jù)配置創(chuàng)建一個緩存實例對象，通過 CacheBuilder
                    cache = createCacheByCachedConfig((CachedAnnoConfig) cacheAnnoConfig, invokeContext);
                } else if ((cacheAnnoConfig instanceof CacheInvalidateAnnoConfig) || (cacheAnnoConfig instanceof CacheUpdateAnnoConfig)) { // 更新/使失效緩存注解
                    CacheInvokeConfig cacheDefineConfig = configMap.getByCacheName(cacheAnnoConfig.getArea(), cacheAnnoConfig.getName());
                    if (cacheDefineConfig == null) {
                        String message = "can't find @Cached definition with area=" + cacheAnnoConfig.getArea()
                                + " name=" + cacheAnnoConfig.getName() +
                                ", specified in " + cacheAnnoConfig.getDefineMethod();
                        CacheConfigException e = new CacheConfigException(message);
                        logger.error("Cache operation aborted because can't find @Cached definition", e);
                        return null;
                    }
                    cache = createCacheByCachedConfig(cacheDefineConfig.getCachedAnnoConfig(), invokeContext);
                }
                cacheAnnoConfig.setCache(cache);
            }
            return cache;
        });
        return c;
    }
    private Cache createCacheByCachedConfig(CachedAnnoConfig ac, CacheInvokeContext invokeContext) {
    	// 緩存區(qū)域
        String area = ac.getArea();
        // 緩存實例名稱
        String cacheName = ac.getName();
        if (CacheConsts.isUndefined(cacheName)) { // 沒有定義緩存實例名稱
        	// 生成緩存實例名稱：類名+方法名+(參數(shù)類型)
            cacheName = configProvider.createCacheNameGenerator(invokeContext.getHiddenPackages())
                    .generateCacheName(invokeContext.getMethod(), invokeContext.getTargetObject());
        }
        // 創(chuàng)建緩存實例對象
        Cache cache = __createOrGetCache(ac, area, cacheName);
        return cache;
    }
    @Deprecated
    public <K, V> Cache<K, V> getCache(String cacheName) {
        return getCache(CacheConsts.DEFAULT_AREA, cacheName);
    }
    @Deprecated
    public <K, V> Cache<K, V> getCache(String area, String cacheName) {
        Cache cache = cacheManager.getCacheWithoutCreate(area, cacheName);
        return cache;
    }
    public Cache __createOrGetCache(CachedAnnoConfig cachedAnnoConfig, String area, String cacheName) {
    	// 緩存名稱拼接
        String fullCacheName = area + "_" + cacheName;
        // 從緩存實例管理器中根據(jù)緩存區(qū)域和緩存實例名稱獲取緩存實例
        Cache cache = cacheManager.getCacheWithoutCreate(area, cacheName);
        if (cache == null) {
            synchronized (this) { // 加鎖
                // 再次確認(rèn)
                cache = cacheManager.getCacheWithoutCreate(area, cacheName);
                if (cache == null) {
                    /*
                     * 緩存區(qū)域的名稱是否作為緩存 key 名稱前綴，默認(rèn)為 true ，我一般設(shè)置為 false
                     */
                    if (globalCacheConfig.isAreaInCacheName()) {
                        // for compatible reason, if we use default configuration, the prefix should same to that version <=2.4.3
                        cache = buildCache(cachedAnnoConfig, area, fullCacheName);
                    } else {
                        // 構(gòu)建一個緩存實例
                        cache = buildCache(cachedAnnoConfig, area, cacheName);
                    }
                    cacheManager.putCache(area, cacheName, cache);
                }
            }
        }
        return cache;
    }
    protected Cache buildCache(CachedAnnoConfig cachedAnnoConfig, String area, String cacheName) {
        Cache cache;
        if (cachedAnnoConfig.getCacheType() == CacheType.LOCAL) { // 本地緩存
            cache = buildLocal(cachedAnnoConfig, area);
        } else if (cachedAnnoConfig.getCacheType() == CacheType.REMOTE) { // 遠(yuǎn)程緩存
            cache = buildRemote(cachedAnnoConfig, area, cacheName);
        } else { // 兩級緩存
        	// 構(gòu)建本地緩存實例
            Cache local = buildLocal(cachedAnnoConfig, area);
            // 構(gòu)建遠(yuǎn)程緩存實例
            Cache remote = buildRemote(cachedAnnoConfig, area, cacheName);
            // 兩級緩存時是否單獨設(shè)置了本地緩存失效時間 localExpire
            boolean useExpireOfSubCache = cachedAnnoConfig.getLocalExpire() > 0;
            // 創(chuàng)建一個兩級緩存CacheBuilder
            cache = MultiLevelCacheBuilder.createMultiLevelCacheBuilder()
                    .expireAfterWrite(remote.config().getExpireAfterWriteInMillis(), TimeUnit.MILLISECONDS)
                    .addCache(local, remote)
                    .useExpireOfSubCache(useExpireOfSubCache)
                    .cacheNullValue(cachedAnnoConfig.isCacheNullValue())
                    .buildCache();
        }
        // 設(shè)置緩存刷新策略
        cache.config().setRefreshPolicy(cachedAnnoConfig.getRefreshPolicy());
        // 將 cache 封裝成 CacheHandlerRefreshCache，也就是 RefreshCache 類型
        // 后續(xù)添加刷新任務(wù)時會判斷是否為 RefreshCache 類型，然后決定是否執(zhí)行 addOrUpdateRefreshTask 方法，添加刷新任務(wù)，沒有刷新策略不會添加
        cache = new CacheHandler.CacheHandlerRefreshCache(cache);
        // 設(shè)置緩存未命中時，JVM是否只允許一個線程執(zhí)行方法，其他線程等待，全局配置默認(rèn)為false
        cache.config().setCachePenetrationProtect(globalCacheConfig.isPenetrationProtect());
        PenetrationProtectConfig protectConfig = cachedAnnoConfig.getPenetrationProtectConfig();
        if (protectConfig != null) { // 方法的@CachePenetrationProtect注解
            cache.config().setCachePenetrationProtect(protectConfig.isPenetrationProtect());
            cache.config().setPenetrationProtectTimeout(protectConfig.getPenetrationProtectTimeout());
        }
        if (configProvider.getCacheMonitorManager() != null) {
        	// 添加監(jiān)控統(tǒng)計配置
            configProvider.getCacheMonitorManager().addMonitors(area, cacheName, cache);
        }
        return cache;
    }
    protected Cache buildRemote(CachedAnnoConfig cachedAnnoConfig, String area, String cacheName) {
        // 獲取緩存區(qū)域?qū)?yīng)的 CacheBuilder 構(gòu)造器
        ExternalCacheBuilder cacheBuilder = (ExternalCacheBuilder) globalCacheConfig.getRemoteCacheBuilders().get(area);
        if (cacheBuilder == null) {
            throw new CacheConfigException("no remote cache builder: " + area);
        }
        // 克隆一個 CacheBuilder 構(gòu)造器，因為不同緩存實例有不同的配置
        cacheBuilder = (ExternalCacheBuilder) cacheBuilder.clone();
        if (cachedAnnoConfig.getExpire() > 0 ) {
        	// 設(shè)置失效時間
            cacheBuilder.expireAfterWrite(cachedAnnoConfig.getExpire(), cachedAnnoConfig.getTimeUnit());
        }
        // 設(shè)置緩存 key 的前綴
        if (cacheBuilder.getConfig().getKeyPrefix() != null) {
            // 配置文件中配置了 prefix，則設(shè)置為 prefix+cacheName
            cacheBuilder.setKeyPrefix(cacheBuilder.getConfig().getKeyPrefix() + cacheName);
        } else { // 設(shè)置為 cacheName
            cacheBuilder.setKeyPrefix(cacheName);
        }
        if (!CacheConsts.isUndefined(cachedAnnoConfig.getKeyConvertor())) { // 如果注解中設(shè)置了Key的轉(zhuǎn)換方式則替換，否則還是使用全局的
        	// 設(shè)置 key 的轉(zhuǎn)換器，只支持 FASTJSON
            cacheBuilder.setKeyConvertor(configProvider.parseKeyConvertor(cachedAnnoConfig.getKeyConvertor()));
        }
        if (!CacheConsts.isUndefined(cachedAnnoConfig.getSerialPolicy())) {
        	// 緩存數(shù)據(jù)保存至遠(yuǎn)程需要進(jìn)行編碼和解碼，所以這里設(shè)置其編碼和解碼方式，KRYO 和 JAVA 可選擇
            cacheBuilder.setValueEncoder(configProvider.parseValueEncoder(cachedAnnoConfig.getSerialPolicy()));
            cacheBuilder.setValueDecoder(configProvider.parseValueDecoder(cachedAnnoConfig.getSerialPolicy()));
        }
        // 設(shè)置是否緩存 null 值
        cacheBuilder.setCacheNullValue(cachedAnnoConfig.isCacheNullValue());
        return cacheBuilder.buildCache();
    }
    protected Cache buildLocal(CachedAnnoConfig cachedAnnoConfig, String area) {
    	// 獲取緩存區(qū)域?qū)?yīng)的 CacheBuilder 構(gòu)造器
        EmbeddedCacheBuilder cacheBuilder = (EmbeddedCacheBuilder) globalCacheConfig.getLocalCacheBuilders().get(area);
        if (cacheBuilder == null) {
            throw new CacheConfigException("no local cache builder: " + area);
        }
        // 克隆一個 CacheBuilder 構(gòu)造器，因為不同緩存實例有不同的配置
        cacheBuilder = (EmbeddedCacheBuilder) cacheBuilder.clone();
        if (cachedAnnoConfig.getLocalLimit() != CacheConsts.UNDEFINED_INT) {
            // 本地緩存數(shù)量限制
            cacheBuilder.setLimit(cachedAnnoConfig.getLocalLimit());
        }
        if (cachedAnnoConfig.getCacheType() == CacheType.BOTH && cachedAnnoConfig.getLocalExpire() > 0) {
        	// 設(shè)置本地緩存失效時間，前提是多級緩存，一般和遠(yuǎn)程緩存保持一致不設(shè)置
            cacheBuilder.expireAfterWrite(cachedAnnoConfig.getLocalExpire(), cachedAnnoConfig.getTimeUnit());
        } else if (cachedAnnoConfig.getExpire() > 0) {
        	// 設(shè)置失效時間
            cacheBuilder.expireAfterWrite(cachedAnnoConfig.getExpire(), cachedAnnoConfig.getTimeUnit());
        }
        if (!CacheConsts.isUndefined(cachedAnnoConfig.getKeyConvertor())) {
            cacheBuilder.setKeyConvertor(configProvider.parseKeyConvertor(cachedAnnoConfig.getKeyConvertor()));
        }
        // 設(shè)置是否緩存 null 值
        cacheBuilder.setCacheNullValue(cachedAnnoConfig.isCacheNullValue());
        // 構(gòu)建一個緩存實例
        return cacheBuilder.buildCache();
    }
    protected CacheInvokeContext newCacheInvokeContext() {
        return new CacheInvokeContext();
    }
}

public class JetCacheInterceptor implements MethodInterceptor, ApplicationContextAware {
    private static final Logger logger = LoggerFactory.getLogger(JetCacheInterceptor.class);
    /**
     * 緩存實例注解信息
     */
    @Autowired
    private ConfigMap cacheConfigMap;
    /**
     * Spring 上下文
     */
    private ApplicationContext applicationContext;
    /**
     * 緩存的全局配置
     */
    private GlobalCacheConfig globalCacheConfig;
    /**
     * JetCache 緩存的管理器（包含很多信息）
     */
    ConfigProvider configProvider;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
    @Override
    public Object invoke(final MethodInvocation invocation) throws Throwable {
        if (configProvider == null) {
            /**
             * 這里會獲取到 SpringConfigProvider 可查看 {@link com.alicp.jetcache.autoconfigure.JetCacheAutoConfiguration}
             */
            configProvider = applicationContext.getBean(ConfigProvider.class);
        }
        if (configProvider != null && globalCacheConfig == null) {
            globalCacheConfig = configProvider.getGlobalCacheConfig();
        }
        if (globalCacheConfig == null || !globalCacheConfig.isEnableMethodCache()) {
            return invocation.proceed();
        }
        // 獲取被攔截的方法
        Method method = invocation.getMethod();
        // 獲取被攔截的對象
        Object obj = invocation.getThis();
        CacheInvokeConfig cac = null;
        if (obj != null) {
        	// 獲取改方法的Key(方法所在類名+方法名+(參數(shù)類型)+方法返回類型+_被攔截的類名)
            String key = CachePointcut.getKey(method, obj.getClass());
            // 獲取該方法的緩存注解信息，在 Pointcut 中已經(jīng)對注解進(jìn)行解析并放入 ConfigMap 中
            cac  = cacheConfigMap.getByMethodInfo(key);
        }
        if(logger.isTraceEnabled()){
            logger.trace("JetCacheInterceptor invoke. foundJetCacheConfig={}, method={}.{}(), targetClass={}",
                    cac != null,
                    method.getDeclaringClass().getName(),
                    method.getName(),
                    invocation.getThis() == null ? null : invocation.getThis().getClass().getName());
        }
        // 無緩存相關(guān)注解配置信息表明無須緩存，直接執(zhí)行該方法
        if (cac == null || cac == CacheInvokeConfig.getNoCacheInvokeConfigInstance()) {
            return invocation.proceed();
        }
        // 為本次調(diào)用創(chuàng)建一個上下文對象，包含對應(yīng)的緩存實例
        CacheInvokeContext context = configProvider.getCacheContext().createCacheInvokeContext(cacheConfigMap);
        context.setTargetObject(invocation.getThis());
        context.setInvoker(invocation::proceed);
        context.setMethod(method);
        context.setArgs(invocation.getArguments());
        context.setCacheInvokeConfig(cac);
        context.setHiddenPackages(globalCacheConfig.getHiddenPackages());
        // 繼續(xù)往下執(zhí)行
        return CacheHandler.invoke(context);
    }
    public void setCacheConfigMap(ConfigMap cacheConfigMap) {
        this.cacheConfigMap = cacheConfigMap;
    }
}

public class CacheHandler implements InvocationHandler {
	public static Object invoke(CacheInvokeContext context) throws Throwable {
		if (context.getCacheInvokeConfig().isEnableCacheContext()) {
			try {
				CacheContextSupport._enable();
				return doInvoke(context);
			} finally {
				CacheContextSupport._disable();
			}
		} else {
			return doInvoke(context);
		}
	}
	private static Object doInvoke(CacheInvokeContext context) throws Throwable {
		// 獲取緩存實例配置
		CacheInvokeConfig cic = context.getCacheInvokeConfig();
		// 獲取注解配置信息
		CachedAnnoConfig cachedConfig = cic.getCachedAnnoConfig();
		if (cachedConfig != null && (cachedConfig.isEnabled() || CacheContextSupport._isEnabled())) {
			// 經(jīng)過緩存中獲取結(jié)果
			return invokeWithCached(context);
		} else if (cic.getInvalidateAnnoConfigs() != null || cic.getUpdateAnnoConfig() != null) {
			// 根據(jù)結(jié)果刪除或者更新緩存
			return invokeWithInvalidateOrUpdate(context);
		} else {
			// 執(zhí)行該方法
			return invokeOrigin(context);
		}
	}
	private static Object invokeWithCached(CacheInvokeContext context) throws Throwable {
		// 獲取本地調(diào)用的上下文
		CacheInvokeConfig cic = context.getCacheInvokeConfig();
		// 獲取注解配置信息
		CachedAnnoConfig cac = cic.getCachedAnnoConfig();
		// 獲取緩存實例對象（不存在則會創(chuàng)建并設(shè)置到 cac 中）
		// 可在 JetCacheInterceptor 創(chuàng)建本次調(diào)用的上下文時，調(diào)用 createCacheInvokeContext(cacheConfigMap) 方法中查看詳情
		Cache cache = context.getCacheFunction().apply(context, cac);
		if (cache == null) {
			logger.error("no cache with name: " + context.getMethod());
			// 無緩存實例對象，執(zhí)行原有方法
			return invokeOrigin(context);
		}
		// 生成緩存 Key 對象（注解中沒有配置的話就是入?yún)?，沒有入?yún)t為 "_$JETCACHE_NULL_KEY$_" ）
		Object key = ExpressionUtil.evalKey(context, cic.getCachedAnnoConfig());
		if (key == null) {
			 // 生成緩存 Key 失敗則執(zhí)行原方法，并記錄 CacheLoadEvent 事件
			return loadAndCount(context, cache, key);
		}
		/*
		 * 根據(jù)配置的 condition 來決定是否走緩存
		 * 緩存注解中沒有配置 condition 表示所有請求都走緩存
		 * 配置了 condition 表示滿足條件的才走緩存
		 */
		if (!ExpressionUtil.evalCondition(context, cic.getCachedAnnoConfig())) {
			// 不滿足 condition 則直接執(zhí)行原方法，并記錄 CacheLoadEvent 事件
			return loadAndCount(context, cache, key);
		}
		try {
			// 創(chuàng)建一個執(zhí)行原有方法的函數(shù)
			CacheLoader loader = new CacheLoader() {
				@Override
				public Object load(Object k) throws Throwable {
					Object result = invokeOrigin(context);
					context.setResult(result);
					return result;
				}
				@Override
				public boolean vetoCacheUpdate() {
					// 本次執(zhí)行原方法后是否需要更新緩存
					return !ExpressionUtil.evalPostCondition(context, cic.getCachedAnnoConfig());
				}
			};
			// 獲取結(jié)果
			Object result = cache.computeIfAbsent(key, loader);
			return result;
		} catch (CacheInvokeException e) {
			throw e.getCause();
		}
	}
	private static Object loadAndCount(CacheInvokeContext context, Cache cache, Object key) throws Throwable {
		long t = System.currentTimeMillis();
		Object v = null;
		boolean success = false;
		try {
			// 調(diào)用原有方法
			v = invokeOrigin(context);
			success = true;
		} finally {
			t = System.currentTimeMillis() - t;
			// 發(fā)送 CacheLoadEvent 事件
			CacheLoadEvent event = new CacheLoadEvent(cache, t, key, v, success);
			while (cache instanceof ProxyCache) {
				cache = ((ProxyCache) cache).getTargetCache();
			}
			if (cache instanceof AbstractCache) {
				((AbstractCache) cache).notify(event);
			}
		}
		return v;
	}
	private static Object invokeOrigin(CacheInvokeContext context) throws Throwable {
		// 執(zhí)行被攔截的方法
		return context.getInvoker().invoke();
	}
}