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

布鸽不鸽 Lv4
  2023-06-26 09:34:01 2023-06-26 09:34:01 创建   2023-06-28 10:01:38 2023-06-28 10:01:38 更新    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:38
  • 链接: https://xuedongyun.cn//post/39214/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
推荐阅读
Redis实战系列（1）：短信登录 Redis实战系列（1）：短信登录 Redis实战系列（4）：分布式锁 Redis实战系列（4）：分布式锁 JUC系列：（四）内存 JUC系列：（四）内存
推荐阅读
Redis实战系列（1）：短信登录 Redis实战系列（1）：短信登录 Redis实战系列（4）：分布式锁 Redis实战系列（4）：分布式锁
评论
目录
Redis实战系列（2）：商户查询缓存
  1. 前言
  2. 添加缓存
  3. 缓存更新策略
  4. 缓存穿透问题
  5. 缓存雪崩问题
  6. 缓存击穿问题
    1. 使用互斥锁
    2. 使用逻辑过期
  7. 封装Redis工具类
    1. 存储到缓存，设置过期
    2. 存储到缓存，逻辑过期
    3. 缓存null（缓存穿透）
    4. 互斥锁（缓存击穿）
    5. 逻辑超时（缓存击穿）