"automatic loading of entries into the cache"

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>29.0-jre</version>
</dependency>

private static List<String> rpcCall(String cityId) {
    // 模仿從數(shù)據(jù)庫中取數(shù)據(jù)
    try {
        switch (cityId) {
            case "0101":
	            System.out.println("load cityId:" + cityId);
                return ImmutableList.of("上海", "北京", "廣州", "深圳");
        }
    } catch (Exception e) {
        // 記日志
    }
    return Collections.EMPTY_LIST;
}

//創(chuàng)建一個LoadingCache，并可以進(jìn)行一些簡單的緩存配置
private static LoadingCache<String, Optional<List<String>> > loadingCache = CacheBuilder.newBuilder()
    //配置最大容量為100，基于容量進(jìn)行回收
    .maximumSize(100)
    //配置寫入后多久使緩存過期-下文會講述
    .expireAfterWrite(3, TimeUnit.SECONDS)
    //配置寫入后多久刷新緩存-下文會講述
    .refreshAfterWrite(3, TimeUnit.SECONDS)
    //key使用弱引用-WeakReference
    .weakKeys()
    //當(dāng)Entry被移除時的監(jiān)聽器-下文會講述
    .removalListener(notification -> System.out.println("notification=" + notification))
    //創(chuàng)建一個CacheLoader，重寫load方法，以實現(xiàn)"當(dāng)get時緩存不存在，則load，放到緩存并返回的效果
    .build(new CacheLoader<String, Optional<List<String>>>() {
        //重點，自動寫緩存數(shù)據(jù)的方法，必須要實現(xiàn)
        @Override
        public Optional<List<String>> load(String cityId) throws Exception {
            return Optional.ofNullable(rpcCall(cityId));
        }
        //異步刷新緩存-下文會講述
        @Override
        public ListenableFuture<Optional<List<String>>> reload(String cityId, Optional<List<String>> oldValue) throws Exception {
            return super.reload(cityId, oldValue);
        }
    });

// 測試
public static void main(String[] args) {

    try {
        System.out.println("load from cache once : " + loadingCache.get("0101").orElse(Lists.newArrayList()));
        Thread.sleep(4000);
        System.out.println("load from cache two : " + loadingCache.get("0101").orElse(Lists.newArrayList()));
        Thread.sleep(2000);
        System.out.println("load from cache three : " + loadingCache.get("0101").orElse(Lists.newArrayList()));
        Thread.sleep(2000);
        System.out.println("load not exist key from cache : " + loadingCache.get("0103").orElse(Lists.newArrayList()));

    } catch (ExecutionException | InterruptedException e) {
        //記錄日志
    }
}

//創(chuàng)建一個callableCache，并可以進(jìn)行一些簡單的緩存配置
private static Cache<String, Optional<List<String>>> callableCache = CacheBuilder.newBuilder()
    //最大容量為100（基于容量進(jìn)行回收）
    .maximumSize(100)
    //配置寫入后多久使緩存過期-下文會講述
    .expireAfterWrite(3, TimeUnit.SECONDS)
    //key使用弱引用-WeakReference
    .weakKeys()
    //當(dāng)Entry被移除時的監(jiān)聽器
    .removalListener(notification -> System.out.println("notification=" + notification))
    //不指定CacheLoader
    .build();

// 測試
public static void main(String[] args) {
    try {
        System.out.println("load from callableCache once : " + callableCache.get("0101", () -> Optional.ofNullable(rpcCall("0101"))).orElse(Lists.newArrayList()));
        Thread.sleep(4000);
        System.out.println("load from callableCache two : " + callableCache.get("0101", () -> Optional.ofNullable(rpcCall("0101"))).orElse(Lists.newArrayList()));
        Thread.sleep(2000);
        System.out.println("load from callableCache three : " + callableCache.get("0101", () -> Optional.ofNullable(rpcCall("0101"))).orElse(Lists.newArrayList()));
        Thread.sleep(2000);
        System.out.println("load not exist key from callableCache : " + callableCache.get("0103", () -> Optional.ofNullable(rpcCall("0103"))).orElse(Lists.newArrayList()));
    } catch (ExecutionException | InterruptedException e) {
        //記錄日志
    }
}

// 聲明一個CallableCache，不需要CacheLoader
private static  Cache<String, Optional<List<String>>> localCache = CacheBuilder
    .newBuilder()
    .maximumSize(100)
    .expireAfterAccess(10, TimeUnit.MINUTES)
    .removalListener(notification -> System.out.println("notification=" + notification))
    .build();


// 測試。使用時自主控制get、put等操作
public static void main(String[] args) {
    try {
        String cityId = "0101";

        Optional<List<String>> ifPresent1 = localCache.getIfPresent(cityId);
        System.out.println("load from localCache one : " + ifPresent1);
        // 做判空，不存在時手工獲取并put數(shù)據(jù)到localCache中
        if (ifPresent1 == null || ifPresent1.isPresent() || CollectionUtils.isEmpty(ifPresent1.get())) {
            List<String> stringList = rpcCall(cityId);
            if (CollectionUtils.isNotEmpty(stringList)) {
                localCache.put(cityId, Optional.ofNullable(stringList));
            }
        }
        Optional<List<String>> ifPresent2 = localCache.getIfPresent(cityId);
        System.out.println("load from localCache two : " + ifPresent2);

        // 失效某個key，或者loadingCache.invalidateAll() 方法
        localCache.invalidate(cityId);
        Optional<List<String>> ifPresent3 = localCache.getIfPresent(cityId);
        System.out.println("load from localCache three : " + ifPresent3);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
	// 緩存最多可以存儲1000個條目
    .maximumSize(1000) 
    .build();

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
	// 緩存最多可以存儲的總權(quán)重
    .maximumWeight(10000) 
    .weigher(new Weigher<KeyType, ValueType>() {
        public int weigh(KeyType key, ValueType value) {
            // 定義如何計算每個條目的權(quán)重
            return getSizeInBytes(key, value);
        }
    })
    .build();

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
    .expireAfterWrite(30, TimeUnit.MINUTES)
    .build();

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
    .expireAfterAccess(15, TimeUnit.MINUTES)
    .build();

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
    .weakKeys()
    .build();

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
    .softValues()
    .build();

cache.invalidate(key);

cache.invalidateAll(keys);

cache.invalidateAll();

// 移除單個條目
cache.asMap().remove(key);

// 批量移除條目
for (KeyType key : keys) {
    cache.asMap().remove(key);
}

// 移除滿足特定條件的條目
cache.asMap().entrySet().removeIf(entry -> entry.getValue().equals(someValue));

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
    .removalListener(new RemovalListener<KeyType, ValueType>() {
        @Override
        public void onRemoval(RemovalNotification<KeyType, ValueType> notification) {
            // 處理移除事件
        }
    })
    .build();

@Override
// 1、執(zhí)行LocalLoadingCache中的get方法
public V get(K key) throws ExecutionException {
  return localCache.getOrLoad(key);
}

// 2、執(zhí)行g(shù)et 或 load方法
V getOrLoad(K key) throws ExecutionException {
  return get(key, defaultLoader);
}

// 3、核心get方法  
V get(K key, CacheLoader<? super K, V> loader) throws ExecutionException {
  int hash = hash(checkNotNull(key));
  // segmentFor方法根據(jù)hash的高位從segments數(shù)組中取出相應(yīng)的segment實例，執(zhí)行segment實例的get方法
  return segmentFor(hash).get(key, hash, loader);
}

// 4、Segment中的get方法
V get(K key, int hash, CacheLoader<? super K, V> loader) throws ExecutionException {
    checkNotNull(key);
    checkNotNull(loader);
    try {
    	// 當(dāng)前Segment中存活的條目個數(shù)不為0
        if (count != 0) { // read-volatile
            // don't call getLiveEntry, which would ignore loading values
            // getEntry會校驗key，所以key為弱引用被回收的場景，取到的e是null。稍后展開介紹該方法
            LocalCache.ReferenceEntry<K, V> e = getEntry(key, hash);
            if (e != null) {
                long now = map.ticker.read();
                // 此處有個getLiveValue(),這個方法是拿到當(dāng)前存活有效的緩存值，稍后展開介紹該方法
                V value = getLiveValue(e, now);
                if (value != null) {
                	// 記錄該緩存被訪問了。此時expireAfterAccess相關(guān)的時間會被刷新
                    recordRead(e, now);
                    // 記錄緩存擊中
                    statsCounter.recordHits(1);
                    // 用來判斷是直接返回現(xiàn)有value，還是等待刷新
                    return scheduleRefresh(e, key, hash, value, now, loader);
                }
                LocalCache.ValueReference<K, V> valueReference = e.getValueReference();
                // 只有key存在，但是value不存在（被回收）、或緩存超時的情況會到達(dá)這里
	            // 如果已經(jīng)有線程在加載緩存了，后面的線程不會重復(fù)加載，而是等待加載的結(jié)果
                if (valueReference.isLoading()) {
                    return waitForLoadingValue(e, key, valueReference);
                }
            }
        }

        // at this point e is either null or expired;
        // 如果不存在或者過期，就通過loader方法進(jìn)行加載（該方法會對當(dāng)前整個Segment加鎖，直到從數(shù)據(jù)源加載數(shù)據(jù)，更新緩存）;
        // 走到這里的場景：
        // 1）segment為空
        // 2）key或value不存在（沒有緩存，或者弱引用、軟引用被回收），
        // 3）緩存超時（expireAfterAccess或expireAfterWrite觸發(fā)的）
        return lockedGetOrLoad(key, hash, loader);
    } catch (ExecutionException ee) {
        Throwable cause = ee.getCause();
        if (cause instanceof Error) {
            throw new ExecutionError((Error) cause);
        } else if (cause instanceof RuntimeException) {
            throw new UncheckedExecutionException(cause);
        }
        throw ee;
    } finally {
        postReadCleanup();
    }
}

    @Nullable
    ReferenceEntry<K, V> getEntry(Object key, int hash) {
      // getFirst用來根據(jù)hash獲取table中相應(yīng)位置的鏈表的頭元素
      for (ReferenceEntry<K, V> e = getFirst(hash); e != null; e = e.getNext()) {
        // hash不相等的，key肯定不相等。hash判等是int判等，比直接用key判等要快得多
        if (e.getHash() != hash) {
          continue;
        }
 
        K entryKey = e.getKey();
        // entryKey == null的情況，是key為軟引用或者弱引用，已經(jīng)被GC回收了。直接清理掉
        if (entryKey == null) {
        // 
          tryDrainReferenceQueues();
          continue;
        }
 
        if (map.keyEquivalence.equivalent(key, entryKey)) {
          return e;
        }
      }
 
      return null;
    }

V getLiveValue(LocalCache.ReferenceEntry<K, V> entry, long now) {
	// 軟引用或者弱引用的key被清理掉了
    if (entry.getKey() == null) {
    	// 清理非強引用的隊列
        tryDrainReferenceQueues();
        return null;
    }
    V value = entry.getValueReference().get();
    // 軟引用的value被清理掉了
    if (value == null) {
    	// 清理非強引用的隊列
        tryDrainReferenceQueues();
        return null;
    }
	// 在這里map.isExpired(entry, now)滿足條件執(zhí)行清除tryExpireEntries(now)
    if (map.isExpired(entry, now)) {
        tryExpireEntries(now);
        return null;
    }
    return value;
}

LoadingCache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
	// 在寫入后的10分鐘后自動刷新
    .refreshAfterWrite(10, TimeUnit.MINUTES) 
    .build(new CacheLoader<KeyType, ValueType>() {
        @Override
        public ValueType load(KeyType key) {
            // 緩存項不存在時加載數(shù)據(jù)的方法
            return loadData(key);
        }

        @Override
        public ListenableFuture<ValueType> reload(KeyType key, ValueType oldValue) throws Exception {
            // 異步刷新緩存項的方法
            // 使用ListenableFuture來異步執(zhí)行刷新操作
            return listeningExecutorService.submit(() -> loadData(key));
        }
    });