Redis实战系列（2）：商户查询缓存

布鸽不鸽 Lv4
  2023-06-26 09:34:01 2023-06-26 09:34:01 创建   2023-06-28 10:01:37 2023-06-28 10:01:37 更新    2.5k 字  10 分钟  

前言

本系列为Redis实战系列，旨在通过实际场景学习Redis相关使用方法。本系列项目使用spring-boot-starter-data-redis（SpringDataRedis）来操作Redis。

原文地址：https://xuedongyun.cn/post/44039/

添加缓存

  • 查询数据前先查询缓存
    • 如果缓存有，直接返回
    • 如果缓存无，查询数据库，再存入redis中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Service
public class ShopService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    public Result queryById(Long shopId) {
        String key = "cache:shop:" + shopId;
        String shopJson = stringRedisTemplate.opsForValue().get(key);

        // 缓存中有直接返回
        if (shopJson != null) {
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }

        // 缓存中无，需要去数据库查询
        Shop shop = new Shop(1001L, "KaKaShop");

        // 查不到，返回错误
        if (shop == null) {
            return Result.fail("店铺不存在");
        }

        // 存在，写入Redis中
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));

        return Result.ok(shop);
    }
}

缓存更新策略

三种缓存更新策略

  • 内存淘汰：Redis自动进行，当redis内存达到设定的max-memory时，自动触发淘汰机制，淘汰掉一些不重要的数据（可以自行设置）

  • 超时删除：给Redis中的变量设置ttl，超时的数据自动删除

  • 主动更新：手动调用方法把缓存删除，用于解决缓存和数据库不一致问题

业务场景：

  • 低一致性需求：使用内存淘汰机制
  • 高一致性需求：主动更新，并以超时删除作为兜底方案（本案例使用此方案）

在本实例的场景中，如果有人修改了数据库，会导致数据库和缓存不一致。因此需要操作缓存，那么应该更新缓存还是删除缓存？

  • 更新缓存：每次修改数据库都更新缓存，无效写操作过多
  • 删除缓存：跟新数据库时，让缓存失效，查询时再写入缓存（更优）

那么，应该先更新数据库还是先删除缓存？（考虑这两个操作之间可能会有新的操作）

  • 先删除缓存：在还未来得及更新数据库时，可能会有新的请求读取了数据库并写入到缓存中，出现不一致的情况
  • 先更新数据库：能够保证数据一致性

1653323595206

总结：我们应该先更新数据库，再删除缓存

修改一：读取数据库，并写入Redis时，设置超时时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public Result queryById(Long shopId) {
    String key = "cache:shop:" + shopId;
    String shopJson = stringRedisTemplate.opsForValue().get(key);

    // 缓存中有直接返回
    if (shopJson != null) {
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }

    // 缓存中无，需要去数据库查询
    Shop shop = new Shop(1001L, "KaKaShop");

    // 查不到，返回错误
    if (shop == null) {
        return Result.fail("店铺不存在");
    }

    // 存在，写入Redis中，设置超时时间
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), 30L, TimeUnit.MINUTES);

    return Result.ok(shop);
}

修改二：更新数据后，把缓存中的数据删掉

1
2
3
4
5
6
7
8
9
public Result update(Shop shop) {
    // 更新数据库
    System.out.println("模拟更新数据库");

    // 删除缓存
    Long shopId = shop.getShopId();
    stringRedisTemplate.delete("cache:shop:" + shopId);
    return Result.ok();
}

缓存穿透问题

缓存穿透：请求的数据在数据库和缓存中都不存在，每次请求都会打到数据库中

解决方案：

  • 缓存空对象：简单方便。但会有额外内存消耗，且会造成数据短期不一致。
  • 布隆过滤：内存占用少。但实现复杂，存在误判，且无法删除元素。

更改思路（使用缓存空对象）：

  • 以前：查询数据时，如果数据库中不存在，返回查询失败
  • 现在：查询数据时，如果数据库中不存在，依然写入Redis缓存null值，返回查询失败

1653326156516

缓存雪崩问题

缓存雪崩：指同一时间大量缓存的key同时失效，或Redis宕机，导致大量请求到达数据库，带来压力

解决方案：

  • 给不同key的TTL添加随机值
  • 利用Redis集群提高服务可用性
  • 给业务添加降级限流策略（微服务相关）
  • 给业务添加多级缓存（请求到达浏览器，nginx可以做缓存，未命中找Redis，再未命中找JVM，最后到数据库……）

缓存击穿问题

缓存击穿：指一个key失效了，在高并发的情况下，会有大量的请求都访问数据库（因为都暂时从缓存中读不到），带来冲击

解决方案：

  • 互斥锁
  • 逻辑过期

使用互斥锁

如果从缓存中没有查询到数据，需要不停尝试获取互斥锁。直到获取到锁为止，才能重新进行查询。

1
2
3
4
5
6
7
8
private boolean tryLock(String key) {
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
    return BooleanUtil.isTrue(flag);
}

private void unlock(String key) {
    stringRedisTemplate.delete(key);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public Result queryById(Long shopId) {
    String key = "cache:shop:" + shopId;
    String shopJson = stringRedisTemplate.opsForValue().get(key);

    // 缓存中有直接返回
    if (shopJson != null) {
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }

    // 需要互斥锁才能查询数据库
    String lockKey = "lock:shop:" + shopId;
    try {
        // 获取锁
        boolean isLock = tryLock(lockKey);
        if (!isLock) {
            Thread.sleep(50);
            return queryById(shopId);
        }

        // 缓存中无，去数据库查询
        Shop shop = new Shop(1001L, "KaKaShop");
        // 查不到，返回错误
        if (shop == null) {
            return Result.fail("店铺不存在");
        }

        // 存在，写入Redis中，设置超时时间
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), 30L, TimeUnit.MINUTES);
		
        return Result.ok(shop);

    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        // 释放锁
        unlock(lockKey);
    }
}

使用逻辑过期

  • 需要进行缓存预热，提前将数据加入到Redis中

  • 查询Redis时，如果没有命中，直接返回空，不查询数据库

  • 一旦命中，将value取出，判断value中的过期时间是否满足。如果没有过期，则直接返回数据

  • 如果过期，开启独立线程后直接返回数据。独立线程能获取互斥锁，才去重构数据，重构完成后释放互斥锁

新建一个实体类，用来存储数据以及过期时间

1
2
3
4
5
@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

在ShopService中封装一个方法（测试的时候，缓存预热用）

1
2
3
4
5
6
7
8
9
10
11
public void saveShop2Redis(Long shopId, Long expireSeconds) {
    // 从数据库中查询shop（模拟）
    Shop shop = new Shop(shopId, "testShop");

    // 写入数据到Redis
    RedisData redisData = new RedisData();
    redisData.setData(shop);
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));

    stringRedisTemplate.opsForValue().set("cache:shop:" + shopId, JSONUtil.toJsonStr(redisData));
}

在测试类中预热一下

1
2
3
4
5
6
7
@Test
void testSaveShop() {
    shopService.saveShop2Redis(1L, 10L);
    shopService.saveShop2Redis(2L, 10L);
    shopService.saveShop2Redis(3L, 10L);
    shopService.saveShop2Redis(4L, 10L);
}

核心业务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public Result queryById(Long shopId) {
    String key = "cache:shop:" + shopId;
    String json = stringRedisTemplate.opsForValue().get(key);

    // 不存在直接返回null
    if (Strings.isBlank(json)) {
        return Result.ok(null);
    }

    // 命中，需要先把json反序列化为对象
    RedisData redisData = JSONUtil.toBean(json, RedisData.class);
    Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();

    // 判断是否过期，未过期直接返回
    if (expireTime.isAfter(LocalDateTime.now())) {
        return Result.ok(shop);
    }

    // 过期则重建缓存
    String lockKey = "lock:shop:" + shopId;
    boolean isLock = tryLock(lockKey);
    if (isLock) {
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            try {
                // 重建缓存
                this.saveShop2Redis(shopId, 10L);
            } catch (Exception e) {
                throw new RuntimeException();
            } finally {
                // 释放锁
                unlock(lockKey);
            }
        });
    }

    // 返回过期的商铺信息
    return Result.ok(shop);
}

封装Redis工具类

针对上述问题，我们可以发现，其实很多业务的逻辑都是相似的。因此其实可以封装一个工具类来处理

  • 方法1：将任意Java对象序列化为json，存储在String类型的key中，设置TTL
  • 方法2：将任意Java对象序列化为json，存储在String类型的key中，设置逻辑过期时间
  • 方法3：根据key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
  • 方法4：根据key查询缓存，并反序列化为指定类型，利用互斥锁的方式解决缓存击穿问题
  • 方法5：根据key查询缓存，并反序列化为指定类型，利用逻辑过期的方式解决缓存击穿问题

创建此工具类

1
2
3
4
5
6
7
8
@Component
public class RedisClient {

    @Resource
    private StringRedisTemplate stringRedisTemplate;
    
    public static final ExecutorService  CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
}

存储到缓存，设置过期

实现方法1：存储到缓存，并设置过期时间

1
2
3
public void set(String key, Object value, Long time, TimeUnit unit) {
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
}

存储到缓存，逻辑过期

实现方法2：存储到缓存，并设置逻辑过期时间

1
2
3
4
5
6
public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
    RedisData redisData = new RedisData();
    redisData.setData(value);
    redisData.setExpireTime(LocalDateTime.now().plus(time, unit.toChronoUnit()));
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}

缓存null（缓存穿透）

实现方法3：使用key查询缓存，数据库中也没有则缓存null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public <R, ID> R queryWithPassThrough(String keyPrefix,
                                           ID id,
                                           Class<R> type,
                                           Function<ID, R> dbFallback,
                                           Long time,
                                           TimeUnit unit) {
    String key = keyPrefix + id;
    String json = stringRedisTemplate.opsForValue().get(key);

    // 缓存中有直接返回
    if (!Strings.isBlank(json)) {
        return JSONUtil.toBean(json, type);
    }

    // 如果命中的是空值，直接返回null
    if (json != null) {
        return null;
    }

    // 不存在，去数据库中拿
    R data = dbFallback.apply(id);
    // 若数据库中没有，缓存空值
    if (data == null) {
        this.set(key, "", time, unit);
        return null;
    }
    this.set(key, data, time, unit);

    return data;
}

互斥锁（缓存击穿）

实现方法4：使用互斥锁，解决缓存击穿问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public <R, ID> R queryWithMutex(String keyPrefix,
                                ID id, Class<R> type,
                                Function<ID, R> dbFallback,
                                Long time,
                                TimeUnit unit) {
    String key = keyPrefix + id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);

    // 缓存中有直接返回
    if (Strings.isNotBlank(shopJson)) {
        return JSONUtil.toBean(shopJson, type);
    }

    // 判断命中的是否是空值，是返回null
    if (shopJson != null) {
        return null;
    }

    // 4.1.获取互斥锁
    String lockKey = "lock:" + keyPrefix + id;
    R data;
    try {
        boolean isLock = tryLock(lockKey);
        if (!isLock) {
            // 获取锁失败，休眠并重试
            Thread.sleep(50);
            return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
        }
        // 获取锁成功，查询数据库
        data = dbFallback.apply(id);
        if (data == null) {
            set(key, "", time, unit);
            return null;
        }
        this.set(key, data, time, unit);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }finally {
        unlock(lockKey);
    }
    return data;
}

逻辑超时（缓存击穿）

实现方法5：使用逻辑超时，解决缓存击穿问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public <ID, R> R queryWithLogicalExpire(String keyPrefix,
                                    ID id,
                                    Class<R> type,
                                    Function<ID, R> dbFallback,
                                    Long time,
                                    TimeUnit unit) {
    String key = keyPrefix + id;
    String json = stringRedisTemplate.opsForValue().get(key);

    // 不存在直接返回null
    if (Strings.isBlank(json)) {
        return null;
    }

    // 命中，进行反序列化
    RedisData redisData = JSONUtil.toBean(json, RedisData.class);
    R data = JSONUtil.toBean((JSONObject) redisData.getData(), type);
    LocalDateTime expireTime = redisData.getExpireTime();

    // 未过期直接返回
    if (expireTime.isAfter(LocalDateTime.now())) {
        return data;
    }

    // 已过期需要缓存重建
    String lockKey = "lock:" + keyPrefix + id;
    boolean isLock = tryLock(lockKey);
    if (isLock) {
        CACHE_REBUILD_EXECUTOR.submit(()->{
            try {
                // 获取到锁的人才有资格，查询数据库，重建缓存
                R dbData = dbFallback.apply(id);
                this.setWithLogicalExpire(key, dbData, time, unit);
            } catch (Exception e) {
                throw new RuntimeException();
            } finally {
                unlock(lockKey);
            }
        });
    }

    return data;
}
  • 标题: Redis实战系列（2）：商户查询缓存
  • 作者: 布鸽不鸽
  • 创建于 : 2023-06-26 09:34:01
  • 更新于 : 2023-06-28 10:01:37
  • 链接: https://xuedongyun.cn//post/39214/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
评论
此页目录
Redis实战系列（2）：商户查询缓存
  1. 前言
  2. 添加缓存
  3. 缓存更新策略
  4. 缓存穿透问题
  5. 缓存雪崩问题
  6. 缓存击穿问题
    1. 使用互斥锁
    2. 使用逻辑过期
  7. 封装Redis工具类
    1. 存储到缓存，设置过期
    2. 存储到缓存，逻辑过期
    3. 缓存null（缓存穿透）
    4. 互斥锁（缓存击穿）
    5. 逻辑超时（缓存击穿）