一、概述
在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 expires = ImmutableMap.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配置文件如下:
可以看到除了默认配置外,还加了一个名为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、自己定义注解和切面,一键实现二级缓存。这样来说更加灵活。(网上有实现的示例)