用guava快速打造两级缓存能力

　　首先，咱们都有一共识，即可以使用缓存来提升系统的访问速度！

　　现如今，分布式缓存这么强大，所以，大部分时候，我们可能都不会去关注本地缓存了！

　　而在一起高并发的场景，如果我们一味使用nosql式的缓存，如 redis, 那么也是好的吧！

　　但是有个问题我们得考虑下： redis 这样的缓存是快，但是它总有自己的瓶颈吧，如果什么东西我们都往里面存储，则在高并发场景下，应用瓶颈将受限于其缓存瓶颈吧！

　　所以，针对这种问题，在一些场景下，咱们可以使用本地缓存来存储一些数据，从而避免每次都将请求击穿到 redis 层面！

　　本文考虑的是使用 本地缓存 作为二级缓存存在，而非直接的充当缓存工具！　　

而使用本地缓存，则有几个讲究：

　　1. 缓存一致性问题;
　　2. 并发安全问题;

　　所谓缓存一致性问题，就是本地缓存，是否和redis等缓存中间件的数据保持一致，如果不一致的表现超过了可接受的程度，则要这访问速度也就没啥意义了！

　　所谓并发安全问题，即是，当使用本地缓存时，本地的缓存访问线程安全性问题，如果出现错乱情况，则严重了！

使用本地缓存，有什么好处？

　　1. 减少访问远程缓存的网络io,速度自然是要提升的;
　　2. 减少远程缓存的并发请求，从而表现出更大的并发处理能力;

本地缓存，都有什么应用场景？

　　1. 单机部署的应用咱们就不说了;
　　2. 读多写少的场景;(这也缓存的应用场景)
　　3. 可以容忍一定时间内的缓存不一致; (因涉及的本地缓存，分布式机器结果必可能不一致)
　　4. 应用对缓存的请求量非常大的场景; (如果直接打到redis缓存, 则redis压力巨大, 且应用响应速度将变慢)

　　所以，如果自己存在这样的使用场景，不防也考虑下，如何使用这本地缓存，来提升响应速度吧！

如果要求自己来实现这两级缓存功能，我想应该也是不能的！只要解决掉两个问题即可:

　　1. 缓存过期策略;
　　2. 缓存安全性;

其中一最简单直接的方式，就是使用一个定时刷新缓存的线程，在时间节点到达后，将缓存删除即可; 另一个安全问题，则可以使用 synchronized 或 并发包下的锁工具来实现即可。

　　但是真正做起来，可能不一定会简单，这也不是咱们想特别考虑的。

　　咱们主要看下 guava 是如何来解决这种问题的？以其思路来开拓自己的设想！

如何 guava 来作为我们的二级缓存？

　　1. 首先，咱们得引入 guava 的依赖

        <dependency>
            <groupId>com.google.guavagroupId>
            <artifactId>guavaartifactId>
            <version>18.0version>
        dependency>

　　2. 创建guava缓存;

 　　首先，创建的guava缓存实例，应是全局共用的，否则就失去了缓存的意义;

　　其次，一些过期参数，应支持配置化；

　　例子如下：

@Component
@Slf4j
public class LocalEnhancedCacheHolder {

    @Value("${guava.cache.max.size}")
    private Integer maxCacheSize;

    @Value("${guava.cache.timeout}")
    private Integer guavaCacheTimeout;

    /**
     * 字符串类型取值, k->v 只支持字符串存取，避免复杂化
     */
    private LoadingCache stringDbCacheContainer;

    /**
     * hash 数据缓存, 展示使用多key 作为 guava 的缓存key
     */
    private LoadingCachebyte[]> hashDbCacheContainer;

    @Resource
    private RedisTemplate redisTemplate;

    /**
     * 值为空 字符串标识
     */
    public static final String EMPTY_VALUE_STRING = "";

    /**
     * 值为空 字节标识
     */
    public static final byte[] EMPTY_VALUE_BYTES = new byte[0];

    @PostConstruct
    public void init() {

        Integer dbCount = 2;

        stringDbCacheContainer = CacheBuilder.newBuilder()
                .expireAfterWrite(guavaCacheTimeout, TimeUnit.SECONDS)
                .maximumSize(maxCacheSize)
                .build(new CacheLoader() {
                    @Override
                    public String load(String key) throws Exception {
                        log.info("【缓存】从redis获取配置:{}", key);
                        String value = redisTemplate.get(key);
                        return StringUtils.defaultIfBlank(value, EMPTY_VALUE_STRING);
                    }
                });

        hashDbCacheContainer = CacheBuilder.newBuilder()
                .expireAfterWrite(guavaCacheTimeout, TimeUnit.SECONDS)
                .maximumSize(maxCacheSize / dbCount)
                .build(new CacheLoaderbyte[]>() {
                    @Override
                    public byte[] load(HashDbItemEntry keyHolder) throws Exception {
                        log.info("【缓存】从redis获取配置:{}", keyHolder);
                        byte[] valueBytes = redisTemplate.hgetValue(
                                                keyHolder.getBucketKey(), keyHolder.getSlotKey());
                        if(valueBytes == null) {
                            valueBytes = EMPTY_VALUE_BYTES;
                        }
                        return valueBytes;
                    }
                });
    }

    /**
     * 获取k-v中的缓存值
     *
     * @param key 键
     * @return 缓存值，没有值时，返回 null
     */
    public String getCache(String key) {
        try {
            return stringDbCacheContainer.get(key);
        } catch (ExecutionException e) {
            log.error("【缓存】获取缓存异常:{}, ex:{}", key, e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 放入缓存，此处暂只实现为向redis写入值
     *
     * @param key 缓存key
     * @param value 缓存value
     */
    public void putCache(String key, String value) {
        redisTemplate.set(key, value, 0L);
    }

    /**
     * 放入缓存带超时时间设置，此处暂只实现为向redis写入值
     *
     * @param key 缓存key
     * @param value 缓存value
     * @param timeout 超时时间，单位 s
     */
    public void putCache(String key, String value, Long timeout) {
        redisTemplate.set(key, value, timeout);
    }

    /**
     * 删除单个kv缓存
     *
     * @param key 缓存键
     */
    public void removeCache(String key) {
        redisTemplate.remove(key);
    }

    /**
     * 批量删除单个kv缓存
     *
     * @param keyList 缓存键 列表，以 管道形式删除，性能更高
     */
    public void removeCache(Collection keyList) {
        redisTemplate.remove(keyList);
    }

    /**
     * 从hash数据库中获取缓存值
     *
     * @param bucketKey 桶key, 对应一系列值 k->v
     * @param slotKey 槽key, 对应具体的缓存值
     * @return 缓存值
     */
    public byte[] getCacheFromHash(String bucketKey, String slotKey) {
        HashDbItemEntry entry = new HashDbItemEntry(bucketKey, slotKey);
        try {
            return hashDbCacheContainer.get(entry);
        } catch (ExecutionException e) {
            log.error("【缓存】获取缓存异常:{}, ex:{}", entry, e);
            throw new RuntimeException(e);
        }
    }

    /**
     * hash 数据结构存储
     *
     *      value 暂不存储相应值，只做查询使用
     */
    class HashDbItemEntry {
        private String bucketKey;
        private String slotKey;
        private Object value;

        public HashDbItemEntry(String bucketKey, String slotKey) {
            this.bucketKey = bucketKey;
            this.slotKey = slotKey;
        }

        public String getBucketKey() {
            return bucketKey;
        }

        public String getSlotKey() {
            return slotKey;
        }

        public Object getValue() {
            return value;
        }

        // 必重写 equals & hashCode, 否则缓存将无法复用
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            HashDbItemEntry that = (HashDbItemEntry) o;
            return Objects.equals(bucketKey, that.bucketKey) &&
                    Objects.equals(slotKey, that.slotKey) &&
                    Objects.equals(value, that.value);
        }

        @Override
        public int hashCode() {
            return Objects.hash(bucketKey, slotKey, value);
        }

        @Override
        public String toString() {
                return "HashDbItemEntry{" +
                    "bucketKey='" + bucketKey + '\'' +
                    ", slotKey='" + slotKey + '\'' +
                    ", value=" + value +
                    '}';
        }
    }
}

　　如上例子，展示了两种缓存，一种是 简单的 string -> string 的缓存, 另一种是 (string, string) -> byte[] 的缓存; 不管怎么样，只是想说明，缓存的方式有多种！

　　我们就以简单的 string -> string 来说明吧！

        stringDbCacheContainer = CacheBuilder.newBuilder()
                .expireAfterWrite(guavaCacheTimeout, TimeUnit.SECONDS)
                .maximumSize(maxCacheSize)
                .build(new CacheLoader() {
                    @Override
                    public String load(String key) throws Exception {
                        log.info("【缓存】从redis获取配置:{}", key);
                        String value = redisTemplate.get(key);
                        return StringUtils.defaultIfBlank(value, EMPTY_VALUE_STRING);
                    }
                });

　　如上，咱们创建了一个缓存容器，它的最大容量是 maxCacheSize, 且每个key将在 guavaCacheTimeout 后过期, 过期后将从 redisTemplate 中获取数据！

　　如上，一个完整的 两级缓存组件就完成了，你大可以直接在项目进行相应的操作了！是不是很简单？

 

深入理解guava 二级缓存原理？

　　1. CacheBuilder 是如何创建的？

@GwtCompatible(emulated = true)
public final class CacheBuilder {
  private static final int DEFAULT_INITIAL_CAPACITY = 16;
  private static final int DEFAULT_CONCURRENCY_LEVEL = 4;
  private static final int DEFAULT_EXPIRATION_NANOS = 0;
  private static final int DEFAULT_REFRESH_NANOS = 0;

  static final Supplierextends StatsCounter> NULL_STATS_COUNTER = Suppliers.ofInstance(
      new StatsCounter() {
        @Override
        public void recordHits(int count) {}

        @Override
        public void recordMisses(int count) {}

        @Override
        public void recordLoadSuccess(long loadTime) {}

        @Override
        public void recordLoadException(long loadTime) {}

        @Override
        public void recordEviction() {}

        @Override
        public CacheStats snapshot() {
          return EMPTY_STATS;
        }
      });
  static final CacheStats EMPTY_STATS = new CacheStats(0, 0, 0, 0, 0, 0);

  static final Supplier CACHE_STATS_COUNTER =
      new Supplier() {
    @Override
    public StatsCounter get() {
      return new SimpleStatsCounter();
    }
  };

  enum NullListener implements RemovalListener {
    INSTANCE;

    @Override
    public void onRemoval(RemovalNotification notification) {}
  }

  enum OneWeigher implements Weigher {
    INSTANCE;

    @Override
    public int weigh(Object key, Object value) {
      return 1;
    }
  }

  static final Ticker NULL_TICKER = new Ticker() {
    @Override
    public long read() {
      return 0;
    }
  };

  private static final Logger logger = Logger.getLogger(CacheBuilder.class.getName());

  static final int UNSET_INT = -1;

  boolean strictParsing = true;

  int initialCapacity = UNSET_INT;
  int concurrencyLevel = UNSET_INT;
  long maximumSize = UNSET_INT;
  long maximumWeight = UNSET_INT;
  Weighersuper K, ? super V> weigher;

  Strength keyStrength;
  Strength valueStrength;

  long expireAfterWriteNanos = UNSET_INT;
  long expireAfterAccessNanos = UNSET_INT;
  long refreshNanos = UNSET_INT;

  Equivalence