缓存穿透、缓存击穿和缓存雪崩实践

@Cacheable(value = "people", key = "#person.id", depict = "用户信息缓存",
        firstCache = @FirstCache(expireTime = 10, timeUnit = TimeUnit.MINUTES),
        secondaryCache = @SecondaryCache(expireTime = 10, timeUnit = TimeUnit.HOURS,
                isAllowNullValue = true, magnification = 10))
public Person findOne(Person person) {
    Person p = personRepository.findOne(Example.of(person));
    logger.info("为id、key为:" + p.getId() + "数据做了缓存");
    return p;
}

private <T> T executeCacheMethod(RedisCacheKey redisCacheKey, Callable<T> valueLoader) {
    Lock redisLock = new Lock(redisTemplate, redisCacheKey.getKey() + "_sync_lock");
    // 同一个线程循环20次查询缓存，每次等待20毫秒，如果还是没有数据直接去执行被缓存的方法
    for (int i = 0; i < RETRY_COUNT; i++) {
        try {
            // 先取缓存，如果有直接返回，没有再去做拿锁操作
            Object result = redisTemplate.opsForValue().get(redisCacheKey.getKey());
            if (result != null) {
                logger.debug("redis缓存 key= {} 获取到锁后查询查询缓存命中，不需要执行被缓存的方法", redisCacheKey.getKey());
                return (T) fromStoreValue(result);
            }


            // 获取分布式锁去后台查询数据
            if (redisLock.lock()) {
                T t = loaderAndPutValue(redisCacheKey, valueLoader, true);
                logger.debug("redis缓存 key= {} 从数据库获取数据完毕，唤醒所有等待线程", redisCacheKey.getKey());
                // 唤醒线程
                container.signalAll(redisCacheKey.getKey());
                return t;
            }
            // 线程等待
            logger.debug("redis缓存 key= {} 从数据库获取数据未获取到锁，进入等待状态，等待{}毫秒", redisCacheKey.getKey(), WAIT_TIME);
            container.await(redisCacheKey.getKey(), WAIT_TIME);
        } catch (Exception e) {
            container.signalAll(redisCacheKey.getKey());
            throw new LoaderCacheValueException(redisCacheKey.getKey(), e);
        } finally {
            redisLock.unlock();
        }
    }
    logger.debug("redis缓存 key={} 等待{}次，共{}毫秒，任未获取到缓存，直接去执行被缓存的方法", redisCacheKey.getKey(), RETRY_COUNT, RETRY_COUNT * WAIT_TIME, WAIT_TIME);
    return loaderAndPutValue(redisCacheKey, valueLoader, true);
}

@Cacheable(value = "people", key = "#person.id", depict = "用户信息缓存",
        firstCache = @FirstCache(expireTime = 10, timeUnit = TimeUnit.MINUTES),
        secondaryCache = @SecondaryCache(expireTime = 10, preloadTime = 2,timeUnit = TimeUnit.HOURS,))
public Person findOne(Person person) {
    Person p = personRepository.findOne(Example.of(person));
    logger.info("为id、key为:" + p.getId() + "数据做了缓存");
    return p;
}

/**
 * 刷新缓存数据
 */
private <T> void refreshCache(RedisCacheKey redisCacheKey, Callable<T> valueLoader, Object result) {
    Long ttl = redisTemplate.getExpire(redisCacheKey.getKey());
    Long preload = preloadTime;
    // 允许缓存NULL值，则自动刷新时间也要除以倍数
    boolean flag = isAllowNullValues() && (result instanceof NullValue || result == null);
    if (flag) {
        preload = preload / getMagnification();
    }
    if (null != ttl && ttl > 0 && TimeUnit.SECONDS.toMillis(ttl) <= preload) {
        // 判断是否需要强制刷新在开启刷新线程
        if (!getForceRefresh()) {
            logger.debug("redis缓存 key={} 软刷新缓存模式", redisCacheKey.getKey());
            softRefresh(redisCacheKey);
        } else {
            logger.debug("redis缓存 key={} 强刷新缓存模式", redisCacheKey.getKey());
            forceRefresh(redisCacheKey, valueLoader);
        }
    }

/**
 * 硬刷新（执行被缓存的方法）
 *
 * @param redisCacheKey {@link RedisCacheKey}
 * @param valueLoader   数据加载器
 */
private <T> void forceRefresh(RedisCacheKey redisCacheKey, Callable<T> valueLoader) {
    // 尽量少的去开启线程，因为线程池是有限的
    ThreadTaskUtils.run(() -> {
        // 加一个分布式锁，只放一个请求去刷新缓存
        Lock redisLock = new Lock(redisTemplate, redisCacheKey.getKey() + "_lock");
        try {
            if (redisLock.lock()) {
                // 获取锁之后再判断一下过期时间，看是否需要加载数据
                Long ttl = redisTemplate.getExpire(redisCacheKey.getKey());
                if (null != ttl && ttl > 0 && TimeUnit.SECONDS.toMillis(ttl) <= preloadTime) {
                    // 加载数据并放到缓存
                    loaderAndPutValue(redisCacheKey, valueLoader, false);
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            redisLock.unlock();
        }
    });
}