一、Redis缓存
Redis是一个高性能的键值对存储数据库,也是一个基于内存的数据结构存储系统,同时也支持持久化数据存储。Redis提供了丰富的数据结构,包括字符串、哈希、列表、集合、有序集合等。在缓存方面,Redis最大的优点就是支持数据的持久化存储,同时也具有很好的性能和扩展性。
二、缓存穿透
缓存穿透 :缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在,这样缓存永远不会生效,由于缓存中没有数据,请求会直接穿透到数据库中,从而引起数据库的压力过大,严重影响系统的性能。解决缓存穿透的常用方法有两种。
2.1、布隆过滤器
布隆过滤器是一种高效的数据结构,可以判断一个元素是否存在于一个集合中,同时也可以减轻数据库的压力。在使用布隆过滤器的时候,首先将所有的数据hash到一个位图中,如果查询的数据在位图中不存在,那么直接返回不存在,从而避免了对数据库的查询操作。
- 优点:内存占用较少,没有多余key
- 缺点:
- 实现复杂
- 存在误判可能
在SpringBoot中,我们可以使用Guava提供的布隆过滤器实现缓存穿透的解决方案。例如:
@Bean
public BloomFilter bloomFilter() {
return BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 100000, 0.001);
}
@Override
public User getUserById(String id) {
// 先从布隆过滤器中查询是否存在
if (!bloomFilter.mightContain(id)) {
return null;
}
// 如果存在,则查询Redis中的缓存数据
User user = redisTemplate.opsForValue().get(id);
if (user == null) {
// 如果Redis中不存在,则查询数据库
user = userDao.getUserById(id);
if (user != null) {
// 将数据缓存到Redis中
redisTemplate.opsForValue().set(id, user);
} else {
// 如果数据库中也不存在,则将该id加入到布隆过滤器中
bloomFilter.put(id);
}
}
return user;
}
在上面的代码中,首先通过布隆过滤器判断请求的数据是否存在于集合中,如果不存在,则直接返回null,从而避免了对数据库的查询操作。
2.2、空对象缓存
另外一种解决缓存穿透的方法是采用空对象缓存的方式,即当查询的数据不存在时,将一个空对象缓存到Redis中。这样下次查询同样不存在的数据时,就可以直接从Redis中获取到一个空对象,从而避免了对数据库的查询操作。
- 优点:实现简单,维护方便
- 缺点:
- 额外的内存消耗
- 可能造成短期的不一致
在SpringBoot中,我们可以通过设置Redis缓存的过期时间来实现空对象缓存的解决方案。例如:
@Override
public User getUserById(String id) {
User user = redisTemplate.opsForValue().get(id);
if (user == null) {
// 如果Redis中不存在,则查询数据库
user = userDao.getUserById(id);
if (user != null) {
// 将数据缓存到Redis中
redisTemplate.opsForValue().set(id, user);
} else {
// 如果数据库中也不存在,则将一个空对象缓存到Redis中,设置过期时间防止缓存雪崩
redisTemplate.opsForValue().set(id, new User(), 5, TimeUnit.MINUTES);
}
}
return user;
}
在上面的代码中,当查询的数据不存在时,我们将一个空对象缓存到Redis中,并设置了5分钟的过期时间。这样即使缓存中的数据被清空了,也不会引起数据库的压力过大,从而避免了缓存穿透。
三、缓存击穿
缓存击穿是指一个非常热点的数据在缓存中过期之后,正好在这个时间段内有大量的请求访问该数据,这些请求会直接穿透到数据库中,从而引起数据库的压力过大,严重影响系统的性能。解决缓存击穿的常用方法有两种。
3.1、设置热点数据永不过期
一种解决缓存击穿的方法是将热点数据设置为永不过期,从而避免缓存失效的问题。但是这种方法存在一个缺点,就是热点数据可能会被修改,如果不及时更新缓存,可能会导致缓存中的数据与实际数据不一致。
在SpringBoot中,我们可以通过设置Redis缓存的过期时间来实现设置热点数据永不过期的解决方案。例如:
@Override
public User getHotUserById(String id) {
User user = redisTemplate.opsForValue().get(id);
if (user == null) {
// 如果Redis中不存在,则查询数据库
user = userDao.getHotUserById(id);
if (user != null) {
// 将数据缓存到Redis中,设置过期时间为1小时
redisTemplate.opsForValue().set(id, user, 1, TimeUnit.HOURS);
}
}
return user;
}
在上面的代码中,我们将热点数据的过期时间设置为1小时,从而避免了缓存击穿的问题。但是这种方法存在一个缺点,就是如果在1小时内热点数据被修改了,缓存中的数据就会失效,需要重新查询数据库。
3.2.使用互斥锁
只有一个请求可以获取到互斥锁,然后到DB中将数据查询并返回到Redis,之后所有请求就可以从Redis中得到响应。【缺点:所有线程的请求需要一同等待】
使用setnx作为Redis中的锁。
- Redis中查询缓存
- 存在且不为空值,直接返回
- 为空值(比如“”、0等特殊值),返回失败结果
- 不存在,获取锁
- 获取锁失败,等待重试
- 获取成功,查找MySQL
- 不存在,Redis存入空值
- 存在,写入Redis
- 释放锁,返回结果
/**
* 根据id查找商户,先到redis中找,再到MySQL中找
* @param id
* @return
*/
@Override
public Result queryShopById(Long id) {
// 用String形式存储JSON
String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
// 如果查询结果不为null,直接返回
if (StrUtil.isNotBlank(shopJson)) {
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return Result.ok(shop);
}
// 否则Redis中查询结果为空,判断是否为“”
if (shopJson != null) {
return Result.fail("店铺不存在,请确认id是否正确");
}
// 尝试获取锁,
// 如果没有得到锁,Sleep一段时间
if (!tryLock(LOCK_SHOP_KEY + id)) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 从开始重试
return queryShopById(id);
}
// 获得了锁,从MySQl中查找
Shop shop = this.getById(id);
// 模拟重建的延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 不在MySQL中
if (shop == null) {
// 将空值写入Redis
stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
// 释放锁
unLock(LOCK_SHOP_KEY + id);
return Result.fail("店铺不存在,请确认id是否正确");
}
else {
// 在MySQL中,存入redis
stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
// 释放锁
unLock(LOCK_SHOP_KEY + id);
return Result.ok(shop);
}
}
public boolean tryLock(String key) {
// 尝试获取锁,set成功返回true,否则返回false
Boolean getLock = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
// 避免getLock为null,使用工具类
return BooleanUtil.isTrue(getLock);
}
public void unLock(String key) {
stringRedisTemplate.delete(key);
}
四、缓存雪崩
缓存雪崩是指当缓存中的大量数据在同一时间失效,导致大量请求直接访问数据库,从而引起数据库的压力过大,严重影响系统的性能。解决缓存雪崩的常用方法有:
4.1 缓存数据的随机过期时间
一种解决缓存雪崩的方法是在缓存数据的过期时间上增加随机因素,从而避免大量数据在同一时间失效的情况。在SpringBoot中,我们可以通过设置Redis缓存的过期时间和一个随机值来实现这个解决方案。例如:
@Override
public List<User> getUserList() {
List<User> userList = redisTemplate.opsForValue().get("userList");
if (userList == null) {
// 如果Redis中不存在,则查询数据库
userList = userDao.getUserList();
if (userList != null && userList.size() > 0) {
// 将数据缓存到Redis中,并增加随机的过期时间
int random = new Random().nextInt(600) + 600;
redisTemplate.opsForValue().set("userList", userList, random, TimeUnit.SECONDS);
}
}
return userList;
}
在上面的代码中,我们先在缓存中查询数据,如果不存在,则去数据库中查询,并将数据缓存到Redis中,并增加随机的过期时间。这样即使大量数据在同一时间失效,也不会全部直接访问数据库,从而避免了缓存雪崩的问题。
4.2 使用分布式锁
第二种解决缓存雪崩的方法是使用分布式锁,从而避免大量请求同时访问数据库的情况。在SpringBoot中,我们可以通过Redisson来实现分布式锁的解决方案。例如:
@Override
public List<User> getUserList() {
List<User> userList = redisTemplate.opsForValue().get("userList");
if (userList == null) {
// 如果Redis中不存在,则尝试获取分布式锁
RLock lock = redissonClient.getLock("userListLock");
try {
// 尝试加锁,并设置锁的过期时间为5秒
boolean success = lock.tryLock(5, TimeUnit.SECONDS);
if (success) {
// 如果获取到了锁,则查询数据库并将数据缓存到Redis中
userList = userDao.getUserList();
if (userList != null && userList.size() > 0) {
redisTemplate.opsForValue().set("userList", userList, 1, TimeUnit.HOURS);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放锁
lock.unlock
}
} return userList;
}
在上面的代码中,我们先在缓存中查询数据,如果不存在,则尝试获取分布式锁,如果获取到了锁,则查询数据库并将数据缓存到Redis中。如果没有获取到锁,则等待一段时间再尝试获取锁,这样即使大量请求同时访问系统,也能够保证只有一个请求去查询数据库并缓存数据,从而避免了缓存雪崩的问题。