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

一、概述

二、java常用的缓存

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

穿透

雪崩

击穿

总结

三、缓存淘汰策略

缓存淘汰

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

二级缓存推荐的实现

一、概述

在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)@Primarypublic 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-managementredis:host: 58.215.52.151port: 4041lettuce:pool:max-active: 8max-wait: 200max-idle: 8min-idle: 2timeout: 2000cache:ehcache:config: classpath:ehcache.xmltype: 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"/><defaultCachemaxElementsInMemory="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";@AutowiredTestService testService;/*** 用redis做方法級別緩存* @param key 入參* @return 模拟数据库查询结果*/@Cacheable(key = "#key", cacheNames = "120cache",cacheManager = CacheManagerConfiguration.CacheManagerNames.REDIS_CACHE_MANAGER)@Overridepublic 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)@Overridepublic String testTwo(String key) {System.out.println("Ehcache 没有数据，到redis查询");return testService.testRedis(key);}@Cacheable(key = "#key", cacheNames = "ehCacheTest",cacheManager = CacheManagerConfiguration.CacheManagerNames.EHCACHE_CACHE_MANAGER)@Overridepublic 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、自己定义注解和切面，一键实现二级缓存。这样来说更加灵活。(网上有实现的示例)