<dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>20.0</version>
        </dependency>

Cache<String, Object> cache = CacheBuilder.newBuilder().build();
cache.put("aaa", 156484);

        Cache<String, Object> cache = CacheBuilder.newBuilder()
                .initialCapacity(5)
                .maximumSize(10)
                .expireAfterWrite(10, TimeUnit.MINUTES).build();
		cache.put("154", "djawbdawd");

        RemovalListener<String, String> listener = new RemovalListener<String, Object>() {
            public void onRemoval(RemovalNotification<String, String> notification) {
            // notification.getKey();  // 當(dāng)前刪除對(duì)象的 key
            // notification.getValue();  // 當(dāng)前刪除對(duì)象的 value
            }
        };
        Cache<String, Object> cache = CacheBuilder.newBuilder()
                .maximumSize(5)
                // 添加移除監(jiān)聽器
                .removalListener(listener) 
                .build();

Cache<String, Object> cache = CacheBuilder.newBuilder()
                .initialCapacity(5)
                .maximumSize(10)
                .expireAfterWrite(10, TimeUnit.MINUTES).build();
        cache.put("154", "djawbdawd");
        try {
            cache.get("aaa", new Callable<Object>() {
                @Override
                public Object call() throws Exception {
                    // 具體如何獲取
                    // 方法的返回值即為 當(dāng)前key 對(duì)應(yīng)的value 并將會(huì)加入到緩存中
                    return null;
                }
            });
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        Cache<String, Object> cache = CacheBuilder.newBuilder()
                .initialCapacity(5)
                .maximumSize(10)
                .recordStats()
                .expireAfterWrite(10, TimeUnit.MINUTES).build();
        cache.put("154", "djawbdawd");
        try {
            cache.get("aaa", new Callable<Object>() {
                @Override
                public Object call() throws Exception {
                    // .......
                    return null;
                }
            });
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        cache.stats();

CacheLoader<String, String> loader = new CacheLoader<>() {
		// 加載沒有的數(shù)據(jù)的方法
            public String load(String key) throws Exception {
            // .............
                return null;
            }
        };
        LoadingCache<String, String> loadingCache = CacheBuilder.newBuilder()
                .maximumSize(5)
                .build(loader);

LoadingCache<String, Object> infoItemCache = CacheBuilder.newBuilder()
		.initialCapacity(5)
		.maximumSize(10)
		.expireAfterAccess(3, TimeUnit.MINUTES).build(new CacheLoader<String, Object>() {
                    // 使用 LoadingCache 重寫加載方法, 重寫后當(dāng)無法從緩存中獲取到key 對(duì)應(yīng)的值時(shí)將執(zhí)行重寫的load 方法，且返回值將成為入?yún)ey 對(duì)應(yīng)的Value并存儲(chǔ)
                    @Override
                    public Object load(String s) throws Exception {
                        // ............
                        return null;
                    }
                });

import com.dtdream.dthink.dtalent.dmall.dataresource.catalog.model.metadata.MetadataBlock;
import com.dtdream.dthink.dtalent.dmall.dataresource.catalog.service.catalog.ICatalogTemplateService;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class MyCache {
    /**
     * 初始化緩存容量大小
     */
    private static final int INITIAL_CAPACITY = 5;
    /**
     * 緩存中可包含最大 entry 數(shù)量，超過數(shù)量限制后淘汰 entry,接近最大值時(shí)淘汰不常用數(shù)據(jù)，設(shè)置為 0 時(shí)為不使用緩存的場(chǎng)景，用于測(cè)試數(shù)據(jù)加載
     */
    private static final long MAXIMUM_SIZE = 10;
    /**
     * 放入緩存后指定時(shí)間內(nèi)沒有被訪問將過期
     */
    private static final long EXPIRE_AFTER_ACCESS = 5;
    /**
     * cache 子接口, 緩存對(duì)象
     */
    private static LoadingCache<String, Object> infoItemCache;
    // 初始化緩存對(duì)象
    static {
        infoItemCache = CacheBuilder.newBuilder().initialCapacity(INITIAL_CAPACITY).maximumSize(MAXIMUM_SIZE)
                .expireAfterAccess(EXPIRE_AFTER_ACCESS, TimeUnit.MINUTES).build(new CacheLoader<String, Object>() {
                    // 使用 LoadingCache 重寫加載方法, 重寫后當(dāng)無法從緩存中獲取到key 對(duì)應(yīng)的值時(shí)將執(zhí)行重寫的load 方法，且返回值將成為入?yún)ey 對(duì)應(yīng)的Value并存儲(chǔ)
                    @Override
                    public Object load(String s) throws Exception {
                        // ...............
                        return null;
                    }
                });
    }
    /**
     * 從緩存中獲取數(shù)據(jù)，若不存在則重新查詢
     * @return
     */
    public static Object getFromCache(String key) throws ExecutionException {
        Object data = infoItemCache.get(key);
        return data;
    }
}