缓存详解-在java项目中使用缓存

一、概述

在java项目中经常有使用缓存的场景，这时候如何使用缓存就很重要了，本篇文章言简意赅，带你读透缓存

二、java常用的缓存

在java项目中经常使用到的缓存主要分为两个种类
1、内存类
java中的Map、List等容器实现类可以用来作为本地缓存。
一些本地缓存框架，类似ehcache，guava中实现的缓存。
2、中间件类
redis、memcache等等

三、使用缓存将会面临的一些问题

穿透

指的是一种攻击，恶意访问一个不存在的key导致请求到数据库上
防范：对空值也缓存。并对数据库查询加锁，限制同时访问数据库的线程数

雪崩

指的在某一段时间缓存集中失效会造成雪崩，主要的解决方案有：
1.分散缓存的过期时间
2.限流

击穿

和雪崩有些类似，指的是某几个热点key失效的时候瞬间大量并发查询缓存后的存储层，导致存储层堵塞或者宕机。和雪崩的区别在于雪崩是很多key，而击穿集中在几个key

总结

其实知道了这些可能出现的问题，就有很多种办法可以去避免这些可能出现的问题。其实在缓存失效的时候不一定所有的请求都要去查存储层，可以加某些限制，让少部分请求去查询存储层，大部分请求等待缓存。这样可以保证系统的稳定性

三、缓存淘汰策略

如果是使用了缓存，那就涉及到缓存淘汰的策略，最常用的就是ttl过期时间淘汰。同时也有一些其他的的淘汰策略可以适用于各种场景。

缓存淘汰

一般来说使用过期时间设置缓存有很大的限制，一般会有一些缓存淘汰算法来淘汰缓存。

缓存淘汰算法

LRU

简单的来说就是以下三步

新数据插入到链表头部；
每当缓存命中（即缓存数据被访问），则将数据移到链表头部；
当链表满的时候，将链表尾部的数据丢弃。

FIFO

直接用一个队列实现，最早加入的最早淘汰，如果当前数据已经加入过，则不操作队列

LFU

侧重访问频率，实现的重点在于如何写compare函数来比较两个数据的频率高低，从而进行排序，末尾淘汰。

其他的淘汰算法

还有一些其他的淘汰算法：

2Q（Two Queues）：同时采用 FIFO 和 LRU 两个队列，首次访问数据时加入到 FIFO 队列中，如果数据在 FIFO 队列移除之前被再次访问，数据会被移动到 LRU 队列中。
LRU-K ：是一种 LRU 算法的增强版，在 LRU 维护队列的基础上，再添加一个队列维护数据访问的次数，由原来访问 1 次会被添加到缓存中，改为访问 K 次才会被加入到缓存中。
ARC：在IBM Almaden研究中心开发，这个缓存算法同时跟踪记录LFU和LRU，以及驱逐缓存条目，来获得可用缓存的最佳使用。

常见缓存的缓存淘汰策略实现

Ehcache 中的缓存淘汰

Ehcache 提供了 3 种淘汰机制（驱逐策略），分别是 LRU（默认），LFU，FIFO。但是 Ehcache 的淘汰却不是给予全局的策略，执行步骤如下：

判断是否超过最大容量限制
在缓存中随机取出不超过 30 个元素作为样本
根据淘汰策略确定需要淘汰的元素
在缓存中移除元素

redis 中的缓存淘汰

在 redis 中可以配置 6 中淘汰机制：

noeviction：不删除策略, 达到最大内存限制时, 如果需要更多内存, 直接返回错误信息。
allkeys-lru：所有 key 通用，优先删除最近最少使用 (LRU) 的 key。
volatile-lru：只限于设置了 expire 的部分; 优先删除最近最少使用 (LRU) 的 key。
allkeys-random：所有 key 通用; 随机删除一部分 key。
volatile-random：只限于设置了 expire 的部分; 随机删除一部分 key。
volatile-ttl：只限于设置了 expire 的部分; 优先删除剩余时间 (time to live,TTL)

Guava 中的缓存淘汰

Guava 在维护缓存数据的同时，还维护了 WirteQueue 和 AccessQueue，分别用来记录写入的记录和访问的记录。总体来说有 4 种淘汰策略：

Size-base Eviction：基于使用量的淘汰策略。
Timed Eviction：基于时间驱逐，提供了根据访问时间（expireAfterAccess）和根据写入时间（expireAfterWrite）。
Reference-based Eviction：基于引用驱逐（通过 java 的软、弱引用实现）。
Explicit Removals：显示移除。

在Spring项目中优雅的实现缓存

在以MVC分层的spring项目中经常会有对service层或者是dao层做缓存的需求。比较优雅的实现方式是使用aop切面去解决。而在Spring中，已经对缓存切面有实现。可以通过使用@Cacheable注解修饰需要缓存的方法来实现切面缓存

在Springboot中，可以通过实现cacheManager来实现@Cacheable的底层。这里展示一种使用redis和ehcache的一种实现。（网上有很多种实现，选择喜欢的一种风格即可）
1、在启动类加上@EnableCaching注解开启缓存支持
2、编写config类，代码如下

import com.google.common.collect.ImmutableMap;
import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.Resource;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;

import java.time.Duration;
import java.util.Map;

/**
 * @author QiuPengJun
 * @version 1.0
 * @date 2020/7/29 15:57
 */
@Configuration
@EnableCaching
@EnableConfigurationProperties(CacheProperties.class)
public class CacheManagerConfiguration {
    private final CacheProperties cacheProperties;
    public CacheManagerConfiguration(CacheProperties cacheProperties)    {
        this.cacheProperties = cacheProperties;
    }
    public interface CacheManagerNames {
        String REDIS_CACHE_MANAGER = "redisCacheManager";
        String EHCACHE_CACHE_MANAGER = "ehCacheManager";
    }

    @Bean(name = CacheManagerNames.REDIS_CACHE_MANAGER)
    public RedisCacheManager redisCacheManager(RedisConnectionFactory factory) {
        Map<String, RedisCacheConfiguration> expires = ImmutableMap.<String, RedisCacheConfiguration>builder()
                .put("15sCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(
                        Duration.ofMillis(15000)
                ))
                .put("30sCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(
                        Duration.ofMillis(30000)
                ))
                .put("60sCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(
                        Duration.ofMillis(60000)
                ))
                .put("120sCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(
                        Duration.ofMillis(120000)
                ))
                .build();


        return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(factory)
                .withInitialCacheConfigurations(expires)
                .build();
    }

    @Bean(name = CacheManagerNames.EHCACHE_CACHE_MANAGER)
    @Primary
    public EhCacheCacheManager ehCacheManager() {
        Resource resource = this.cacheProperties.getEhcache().getConfig();
        resource = this.cacheProperties.resolveConfigLocation(resource);
        EhCacheCacheManager ehCacheManager = new EhCacheCacheManager(
                EhCacheManagerUtils.buildCacheManager(resource)
        );
        ehCacheManager.afterPropertiesSet();
        return ehCacheManager;
    }
}

从代码可看到，redis缓存方面，代码配置了15s,30s,60s,120s的过期时间的缓存实现，可以根据需要配置不同的过期时间，然后通过CacheName来区分，也就是代码里的15sCache、30sCache这种。
而ehcache则直接读取了配置文件，这部分下面会讲到
3、编写配置文件

spring:
  application:
    name: authority-management
  redis:
    host: 58.215.52.151
    port: 4041
    lettuce:
      pool:
        max-active: 8
        max-wait: 200
        max-idle: 8
        min-idle: 2
    timeout: 2000
  cache:
    ehcache:
      config: classpath:ehcache.xml
    type: EHCACHE
server:
  port: 8920

我把我demo项目的配置文件直接贴出来了，其中先是配置了redis的ip端口并配置lettuce线程池参数，然后配置ehcache的配置文件路径，ehcache配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false" monitoring="autodetect"
         dynamicConfig="true">

    <diskStore path="java.io.tmpdir/ehcache"/>

    <defaultCache
            maxElementsInMemory="50000"
            eternal="false"
            timeToIdleSeconds="3600"
            timeToLiveSeconds="3600"
            overflowToDisk="true"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
    />

  <cache name="ehCacheTest"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="3600"
           overflowToDisk="false"
           memoryStoreEvictionPolicy="LRU"
           statistics="true">
    </cache>
</ehcache>

可以看到除了默认配置外，还加了一个名为ehCacheTest的缓存配置，使用了LRU的缓存淘汰算法。其他的参数可以参考官网解释，这里不做多描述。可以配置多个不同名字的缓存来适用各种场景

4、在代码中使用@Cacheable注解来使用缓存

import com.example.ehcache.bootdemo.config.CacheManagerConfiguration;
import com.example.ehcache.bootdemo.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

/**
 * @author QiuPengJun
 * @version 1.0
 * @date 2020/7/29 16:23
 */
@Component
public class TestServiceImpl implements TestService {
    public static final String TEST_TWO ="testTwo";
    @Autowired
    TestService testService;

    /**
     * 用redis做方法級別緩存
     * @param key 入參
     * @return 模拟数据库查询结果
     */
    @Cacheable(key = "#key", cacheNames = "120cache",
            cacheManager = CacheManagerConfiguration.CacheManagerNames.REDIS_CACHE_MANAGER)
    @Override
    public String testRedis(String key) {
        System.out.println("redis没有数据,到数据库查询");
        return "testRedis";
    }

    /**
     * 用ehcache做方法級別緩存,内部调用使用redis做缓存的方法，实现二级缓存
     * @param key 入參
     * @return 模拟数据库查询结果
     */
    @Cacheable(key = "#key", cacheNames = "ehCacheTest",
            cacheManager = CacheManagerConfiguration.CacheManagerNames.EHCACHE_CACHE_MANAGER)
    @Override
    public String testTwo(String key) {
        System.out.println("Ehcache 没有数据，到redis查询");
        return testService.testRedis(key);
    }

    @Cacheable(key = "#key", cacheNames = "ehCacheTest",
            cacheManager = CacheManagerConfiguration.CacheManagerNames.EHCACHE_CACHE_MANAGER)
    @Override
    public String testEhcache(String key) {
        System.out.println("ehcache没有数据,到数据库查询");
        return "testEhcache";
    }

}

以上代码仅用于测试，如果是写业务需要更加严谨
可以看到上面代码使用了 @Cacheable的三个字段，key:表示存储在缓存的key，这里需要谨慎设置，cacheNames：就是上文经常提到的缓存名，用来区分不同配置的缓存，cacheManager ：通过config我们配置了两个选择，可以选redis或者ehcache；
代码彩蛋：可以看到这个类使用Autowire注入了自己，然后再testTwo方法中调用了注入类的testRedis方法，实现了一个ehcache+redis的二级缓存。为什么注入自己?这里不多描述，可以百度搜索同一个类里@Cacheable缓存不起作用。当然本人不推荐这种写法，很容易哪天就自己坑自己。

二级缓存推荐的实现

上文已经提到了二级缓存的实现，并且给出了简单的示例(反面示例)，笔者推荐一下两种实现方式
1、使用两个类去做二级缓存，比如在service做一层缓存，在dao做一层缓存，或者再service层做两层缓存。用@Cacheable来实现
2、自己定义注解和切面，一键实现二级缓存。这样来说更加灵活。（网上有实现的示例）