Java guava框架LoadingCache及CacheBuilder本地小容量缓存框架总结

        <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();  // 当前删除对象的 key
            // notification.getValue();  // 当前删除对象的 value
            }
        };
        Cache<String, Object> cache = CacheBuilder.newBuilder()
                .maximumSize(5)
                // 添加移除监听器
                .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 {
                    // 具体如何获取
                    // 方法的返回值即为 当前key 对应的value 并将会加入到缓存中
                    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<>() {
		// 加载没有的数据的方法
            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 重写加载方法, 重写后当无法从缓存中获取到key 对应的值时将执行重写的load 方法，且返回值将成为入参key 对应的Value并存储
                    @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 数量，超过数量限制后淘汰 entry,接近最大值时淘汰不常用数据，设置为 0 时为不使用缓存的场景，用于测试数据加载
     */
    private static final long MAXIMUM_SIZE = 10;
    /**
     * 放入缓存后指定时间内没有被访问将过期
     */
    private static final long EXPIRE_AFTER_ACCESS = 5;
    /**
     * cache 子接口, 缓存对象
     */
    private static LoadingCache<String, Object> infoItemCache;
    // 初始化缓存对象
    static {
        infoItemCache = CacheBuilder.newBuilder().initialCapacity(INITIAL_CAPACITY).maximumSize(MAXIMUM_SIZE)
                .expireAfterAccess(EXPIRE_AFTER_ACCESS, TimeUnit.MINUTES).build(new CacheLoader<String, Object>() {
                    // 使用 LoadingCache 重写加载方法, 重写后当无法从缓存中获取到key 对应的值时将执行重写的load 方法，且返回值将成为入参key 对应的Value并存储
                    @Override
                    public Object load(String s) throws Exception {
                        // ...............
                        return null;
                    }
                });
    }
    /**
     * 从缓存中获取数据，若不存在则重新查询
     * @return
     */
    public static Object getFromCache(String key) throws ExecutionException {
        Object data = infoItemCache.get(key);
        return data;
    }
}