1
@Service
2
@Slf4j
3
public class UserInfoServiceImpl extends ServiceImpl<UserInfoMapper, UserInfo> implements IUserInfoService {
4

5
    @Override
6
    public Result sendCode(String phone, HttpSession session) {
7
        if (RegexUtils.isPhoneInvalid(phone)) {
8
            return Result.fail("手机号格式错误");
9
        }
10
        // 生成验证码
11
        String code = RandomUtil.randomNumbers(6);
12
        // 保存验证码
13
        session.setAttribute("code", code);
14
        // 发送验证码
15
        log.info("发送的验证码：{}", code);
16
        return Result.ok();
17
    }
18
}

1
    @Override
2
    public Result login(LoginFormDTO loginForm, HttpSession session) {
3
        String code = loginForm.getCode();
4
        String phone = loginForm.getPhone();
5
        if (RegexUtils.isPhoneInvalid(phone)) {
6
            return Result.fail("手机号格式错误");
7
        }
8
        if (RegexUtils.isCodeInvalid(code)) {
9
            return Result.fail("手机号格式错误");
10
        }
11
        // 根据手机查用户
12
        Object cacheCode = session.getAttribute("code");
13
        if (cacheCode == null) {
14
            return Result.fail("请填写验证码");
15
        }
16
        if (!cacheCode.equals(code)) {
17
            return Result.fail("验证码错误");
18
        }
19
        // 用户是否存在
20
        User user = lambdaQuery().eq(User::getPhone, phone).one();
21
        // 不存在，注册
22
        if (user == null) {
23
            user = User.builder()
24
                    .phone(phone)
25
                    .nickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(6))
26
                    .build();
27
            save(user);
28
        }
29
        // 存在，写到session
30
        session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));
31
        return Result.ok();
32
    }

1
public class LoginInterceptor implements HandlerInterceptor {
2

3

4
    @Override
5
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
6
        HttpSession session = request.getSession();
7
        Object user = session.getAttribute("user");
8
        if (ObjectUtil.isEmpty(user)) {
9
            response.setStatus(401);
10
            return false;
11
        }
12
        // 保存threadLocal
13
        UserHolder.saveUser((UserDTO) user);
14
        return true;
15
    }
16

17
    @Override
18
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
19
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
20
    }
21

22
    @Override
23
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
24
        UserHolder.removeUser();
25
    }
26
}

1
@Configuration
2
public class MvcConfig implements WebMvcConfigurer {
3

4
    @Override
5
    public void addInterceptors(InterceptorRegistry registry) {
6
        registry.addInterceptor(new LoginInterceptor())
7
                .excludePathPatterns(
8
                        "/user/code",
9
                        "/user/login",
10
                        "/blog/hot",
11
                        "/shop/**",
12
                        "/shot-type/**",
13
                        "/voucher/**"
14
                );
15
    }
16
}

1
    private final RedisTemplate<String, Object> redisTemplate;
2

3

4
    @Override
5
    public Result sendCode(String phone, HttpSession session) {
6
        if (RegexUtils.isPhoneInvalid(phone)) {
7
            return Result.fail("手机号格式错误");
8
        }
9
        // 生成验证码
10
        String code = RandomUtil.randomNumbers(6);
11
        // 保存到redis
12
        redisTemplate.opsForValue().set(RedisConstants.LOGIN_CODE_KEY + phone, code, RedisConstants.LOGIN_CODE_TTL, TimeUnit.MINUTES);
13

14
        // 发送验证码
15
        log.info("发送的验证码：{}", code);
16
        return Result.ok();
17
    }

1
    @Override
2
    public Result login(LoginFormDTO loginForm, HttpSession session) {
3
        String code = loginForm.getCode();
4
        String phone = loginForm.getPhone();
5
        if (RegexUtils.isPhoneInvalid(phone)) {
6
            return Result.fail("手机号格式错误");
7
        }
8
        if (RegexUtils.isCodeInvalid(code)) {
9
            return Result.fail("手机号格式错误");
10
        }
11
        // 根据手机查用户
12
        String cacheCode = (String) redisTemplate.opsForValue().get(RedisConstants.LOGIN_CODE_KEY + phone);
13
        if (cacheCode == null) {
14
            return Result.fail("请填写验证码");
15
        }
16
        if (!cacheCode.equals(code)) {
17
            return Result.fail("验证码错误");
18
        }
19
        // 用户是否存在
20
        User user = lambdaQuery().eq(User::getPhone, phone).one();
21
        // 不存在，注册
22
        if (user == null) {
23
            user = User.builder()
24
                    .phone(phone)
25
                    .nickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(6))
26
                    .build();
27
            save(user);
28
        }
29
        // 生成token （可换jwt）
30
        String token = UUID.randomUUID().toString(true);
31
        // 写到redis
32
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
33
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO);
34
        String tokenKey = RedisConstants.LOGIN_USER_KEY + token;
35
        redisTemplate.opsForHash().putAll(tokenKey, userMap);
36
        redisTemplate.expire(tokenKey, 30, TimeUnit.MINUTES);
37
        // 返回token
38
        return Result.ok(token);
39
    }

1
@RequiredArgsConstructor
2
public class LoginInterceptor implements HandlerInterceptor {
3

4
    private final StringRedisTemplate stringRedisTemplate;
5

6
    @Override
7
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
8
        String token = request.getHeader("authorization");
9
        if (StrUtil.isBlank(token)) {
10
            response.setStatus(401);
11
            return false;
12
        }
13
        // 基于ToKEN获取redis中的用户
14
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY + token);
15
        if (userMap.isEmpty()) {
16
            response.setStatus(401);
17
            return false;
18
        }
19
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
20
        // 刷新token有效期 (token续期)
21
        stringRedisTemplate.expire(LOGIN_USER_KEY + token, 30, TimeUnit.MINUTES);
22
        // 保存threadLocal
23
        UserHolder.saveUser(userDTO);
24
        return true;
25
    }
26

27
    @Override
28
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
29
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
30
    }
31

32
    @Override
33
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
34
        UserHolder.removeUser();
35
    }
36
}

1
@Configuration
2
@RequiredArgsConstructor
3
public class MvcConfig implements WebMvcConfigurer {
4

5
    private final StringRedisTemplate stringRedisTemplate;
6

7
    @Override
8
    public void addInterceptors(InterceptorRegistry registry) {
9
        registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
10
                .excludePathPatterns(
11
                        "/user/code",
12
                        "/user/login",
13
                        "/blog/hot",
14
                        "/shop/**",
15
                        "/shot-type/**",
16
                        "/voucher/**"
17
                );
18
    }
19
}

1
@RequiredArgsConstructor
2
public class RefreshInterceptor implements HandlerInterceptor {
3

4
    private final StringRedisTemplate stringRedisTemplate;
5

6
    @Override
7
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
8
        String token = request.getHeader("authorization");
9
        if (StrUtil.isBlank(token)) {
10
            return true;
11
        }
12
        // 基于ToKEN获取redis中的用户
13
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY + token);
14
        if (userMap.isEmpty()) {
15
            return true;
16
        }
17
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
18
        // 刷新token有效期 (token续期)
19
        stringRedisTemplate.expire(LOGIN_USER_KEY + token, 30, TimeUnit.MINUTES);
20
        // 保存threadLocal
21
        UserHolder.saveUser(userDTO);
22
        return true;
23
    }
24

25
    @Override
26
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
27
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
28
    }
29

30
    @Override
31
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
32
        UserHolder.removeUser();
33
    }
34
}

1
public class LoginInterceptor implements HandlerInterceptor {
2

3

4
    @Override
5
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
6
        UserDTO user = UserHolder.getUser();
7
        if (user == null) {
8
            response.setStatus(401);
9
            return false;
10
        }
11
        return true;
12
    }
13

14
    @Override
15
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
16
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
17
    }
18

19
    @Override
20
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
21
        UserHolder.removeUser();
22
    }
23
}

1
@Configuration
2
@RequiredArgsConstructor
3
public class MvcConfig implements WebMvcConfigurer {
4

5
    private final StringRedisTemplate stringRedisTemplate;
6

7
    @Override
8
    public void addInterceptors(InterceptorRegistry registry) {
9
        registry.addInterceptor(new LoginInterceptor())
10
                .excludePathPatterns(
11
                        "/user/code",
12
                        "/user/login",
13
                        "/blog/hot",
14
                        "/shop/**",
15
                        "/shot-type/**",
16
                        "/voucher/**"
17
                ).order(1);
18
        registry.addInterceptor(new RefreshInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);   // 先执行
19
    }
20
}

1
    private final RedisTemplate<String, Object> redisTemplate;
2

3
    @Override
4
    public Result queryShopById(Long id) {
5
        String shopJson = (String) redisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
6
        if (StrUtil.isNotBlank(shopJson)) {
7
            Shop shop = JSON.parseObject(shopJson, Shop.class);
8
            return Result.ok(shop);
9
        }
10

11
        Shop shop = getById(id);
12
        if (ObjectUtil.isEmpty(shop)) {
13
            return Result.ok();
14
        }
15
        redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSON.toJSONString(shop));
16

17
        return Result.ok(shop);
18
    }

1
    private final RedisTemplate<String, Object> redisTemplate;
2

3
    @Override
4
    public Result queryTypeList() {
5
        List<Object> shopTypeListCache = redisTemplate.opsForList().range("cache:shopType", 0L, -1L);
6
        if (!shopTypeListCache.isEmpty()) {
7
            return Result.ok(shopTypeListCache);
8
        }
9
        List<ShopType> typeList = lambdaQuery()
10
                .orderByAsc(ShopType::getSort)
11
                .list();
12
        if (typeList.isEmpty()) {
13
            return Result.ok();
14
        }
15
        redisTemplate.opsForList().rightPushAll("cache:shopType", typeList.toArray());
16
        return Result.ok(typeList);
17
    }

1
redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSON.toJSONString(shop), 30L, TimeUnit.MINUTES);

1
    @Override
2
    @Transactional(rollbackFor = Exception.class)
3
    public Result updateShop(Shop shop) {
4
        Long id = shop.getId();
5
        if (id == null) {
6
            return Result.fail("id不能为空");
7
        }
8
        // 更新数据库
9
        updateById(shop);
10
        // 删除缓存
11
        redisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + id);
12
        return Result.ok();
13
    }

1
    private final RedisTemplate<String, Object> redisTemplate;
2

3
    @Override
4
    public Result queryShopById(Long id) {
5
        String shopJson = (String) redisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
6
        if (StrUtil.isNotBlank(shopJson)) {
7
            Shop shop = JSON.parseObject(shopJson, Shop.class);
8
            return Result.ok(shop);
9
        }
10
        // 命中的是否是空值
11
        if (shopJson != null) {
12
            return Result.fail("店铺不存在");
13
        }
14
        Shop shop = getById(id);
15
        if (ObjectUtil.isEmpty(shop)) {
16
            // 缓存空值到redis
17
            redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", 2L, TimeUnit.MINUTES);
18
            return Result.fail("店铺不存在");
19
        }
20
        redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSON.toJSONString(shop), 30L, TimeUnit.MINUTES);
21

22
        return Result.ok(shop);
23
    }

1
    @Override
2
    public Result queryShopById(Long id) {
3
        String shopJson = (String) redisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
4
        if (StrUtil.isNotBlank(shopJson)) {
5
            Shop shop = JSON.parseObject(shopJson, Shop.class);
6
            return Result.ok(shop);
7
        }
8
        // 命中的是否是空值
9
        if (shopJson != null) {
10
            return Result.fail("店铺不存在");
11
        }
12
        // 实现缓存重建
13
        // 获取互斥锁
14
        String lockKey = "lock:shop:" + id;
15
        boolean isLocked = tryLock(lockKey);
16
        // 是否获取成功
17
        if (!isLocked) {
18
            // 失败-休眠重试
19
            ThreadUtil.sleep(50);
20
            return queryShopById(id);  // 递归重试
21
        }
22
        // Double-Check：第二次检查缓存
23
        shopJson = (String) redisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
24
        if (StrUtil.isNotBlank(shopJson)) {
25
            Shop shop = JSON.parseObject(shopJson, Shop.class);
26
            return Result.ok(shop);
27
        }
28
        if (shopJson != null) {
29
            return Result.fail("店铺不存在");
30
        }
31
        // 缓存仍未命中，查数据库
32
        Shop shop = getById(id);
33
        if (ObjectUtil.isEmpty(shop)) {
34
            // 缓存空值到redis,防止穿透
35
            redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", 2L, TimeUnit.MINUTES);
36
            return Result.fail("店铺不存在");
37
        }
38
        redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSON.toJSONString(shop), 30L, TimeUnit.MINUTES);
39
        // 释放互斥锁
40
        unLock(lockKey);
41
        return Result.ok(shop);
42
    }
43

44

45
    private boolean tryLock(String key) {
46
        // 只有当 key 不存在时，才会设置 value，并返回 true; 如果 key 已经存在，则不会进行任何修改，并返回 false。
47
        Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, "1", 10L, TimeUnit.SECONDS);
48
        return BooleanUtil.isTrue(flag);    // isTrue:只有当flag是true才是true，flag为false和null都返回false(避免拆箱操作报空指针)
49
    }
50

51
    private void unLock(String key) {
52
        redisTemplate.delete(key);
53
    }

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

1
@SpringBootTest
2
class HmDianPingApplicationTests {
3

4
    @Autowired
5
    private ShopServiceImpl shopService;
6

7
    @Test
8
    void saveToRedis() {
9
        shopService.saveShopToRedis(1L, 10L);
10
    }
11
}

1
    public void saveShopToRedis(Long id, Long expireSeconds) {
2
        // 查询店铺数据
3
        Shop shop = getById(id);
4
        // 封装逻辑过期
5
        RedisData redisData = RedisData.builder()
6
                .data(shop)
7
                .expireTime(LocalDateTime.now().plusSeconds(expireSeconds))
8
                .build();
9
        // 写入redis
10
        redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
11
    }

1
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
2

3

4
 @Override
5
    public Result queryShopById(Long id) {
6
        String shopJson = (String) redisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
7
        if (StrUtil.isBlank(shopJson)) {
8
            return Result.fail("不存在");
9
        }
10
        // 命中需要判断过期时间
11
        RedisData redisData = JSON.parseObject(shopJson, RedisData.class);
12
        Shop shop = JSON.parseObject(JSON.toJSONString(redisData.getData()), Shop.class);
13
        LocalDateTime expireTime = redisData.getExpireTime();
14

15
        if (expireTime.isAfter(LocalDateTime.now())) {
16
            // 未过期 返回店铺信息
17
            return Result.ok(shop);
18
        }
19
        // 过期-重建缓存
20
        // 获取互斥锁
21
        String lockKey = "lock:shop:" + id;
22
        boolean isLocked = tryLock(lockKey);
23
        // 是否获取成功
24
        if (isLocked) {
25
            // 再次检测redis缓存是否过期，做DoubleCheck
26
            String doubleCheckCacheStr = (String) redisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
27
            RedisData parsed = JSON.parseObject(doubleCheckCacheStr, RedisData.class);
28
            Shop shopObj = JSON.parseObject(JSON.toJSONString(parsed.getData()), Shop.class);
29
            LocalDateTime newExpireTime = parsed.getExpireTime();
30
            // 缓存未过期（已经有线程重建完成了），则返回数据
31
            if (newExpireTime.isAfter(LocalDateTime.now())) {
32
                return Result.ok(shopObj);
33
            }
34
            // 缓存仍过期 （还没有其他的线程重建缓存），创建独立线程，重建缓存
35
            CACHE_REBUILD_EXECUTOR.submit(() -> {
36
                saveShopToRedis(id, 20000L);
37
                // 释放锁
38
                unLock(lockKey);
39
            });
40
        }
41
        // 返回过期的商铺信息
42
        return Result.ok(shop);
43
    }
44

45
    private boolean tryLock(String key) {
46
        // 只有当 key 不存在时，才会设置 value，并返回 true; 如果 key 已经存在，则不会进行任何修改，并返回 false。
47
        Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, "1", 10L, TimeUnit.SECONDS);
48
        return BooleanUtil.isTrue(flag);    // isTrue:只有当flag是true才是true，flag为false和null都返回false(避免拆箱操作报空指针)
49
    }
50

51
    private void unLock(String key) {
52
        redisTemplate.delete(key);
53
    }
54

55
    public void saveShopToRedis(Long id, Long expireSeconds) {
56
        // 查询店铺数据
57
        Shop shop = getById(id);
58
        // 封装逻辑过期
59
        RedisData redisData = RedisData.builder()
60
                .data(shop)
61
                .expireTime(LocalDateTime.now().plusSeconds(expireSeconds))
62
                .build();
63
        // 写入redis
64
        redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
65
    }

1
package com.hmdp.utils;
2

3
import cn.hutool.core.util.BooleanUtil;
4
import cn.hutool.core.util.StrUtil;
5
import cn.hutool.json.JSONObject;
6
import cn.hutool.json.JSONUtil;
7
import org.springframework.data.redis.core.StringRedisTemplate;
8
import org.springframework.stereotype.Component;
9

10
import java.time.LocalDateTime;
11
import java.util.concurrent.ExecutorService;
12
import java.util.concurrent.Executors;
13
import java.util.concurrent.TimeUnit;
14
import java.util.function.Function;
15

16

17
/**
18
 * @ClassName CacheClient
19
 * @Description 缓存工具类
20
 * @Author zzy
21
 */
22
@Component
23
public class CacheClient {
24

25
    //存入Reids中的空值的过期时间
26
    public static final Long CACHE_NULL_TTL = 2L;
27
    //存入Reids中的空值的过期时间的时间类型
28
    public static final TimeUnit CACHE_NULL_TIME_UNIT = TimeUnit.MINUTES;
29
    //互斥锁对应的key
30
    public static final String LOCK_KEY = "lock:";
31
    //获取互斥锁失败后的等待时间（单位毫秒）
32
    public static final Long SPIN_WAIT_MILLISECOND = 50L;
33

34
    //使用构造函数注入StringRedisTemplate
35
    private final StringRedisTemplate stringRedisTemplate;
36

37
    public CacheClient(StringRedisTemplate stringRedisTemplate) {
38
        this.stringRedisTemplate = stringRedisTemplate;
39
    }
40

41
    //创建拥有十个线程的线程池，用来重建缓存，避免经常创建销毁线程
42
    private final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
43

44
    /**
45
     * 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
46
     *
47
     * @param key      String类型的Key
48
     * @param value    任意类型的对象
49
     * @param time     过期时间
50
     * @param timeUnit 时间单位
51
     */
52
    public void set(String key, Object value, Long time, TimeUnit timeUnit) {
53
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, timeUnit);
54
    }
55

56
    /**
57
     * 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
58
     *
59
     * @param key      String类型的Key
60
     * @param value    任意类型的对象
61
     * @param time     逻辑过期时间
62
     * @param timeUnit 时间单位
63
     */
64
    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit timeUnit) {
65
        //设置逻辑过期时间
66
        RedisData redisData = new RedisData();
67
        redisData.setData(value);
68
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(time)));
69
        //写入Redis
70
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
71
    }
72

73
    /**
74
     * 据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
75
     *
76
     * @param keyPrefix  key的前缀
77
     * @param id         id
78
     * @param type       需要返回的对象的Class类型
79
     * @param dbFallback 根据id进行数据库查询的函数
80
     * @param time       过期时间
81
     * @param timeUnit   时间单位
82
     * @param <R>        需要返回的对象类型的泛型
83
     * @param <ID>       id的泛型
84
     * @return
85
     */
86
    public <R, ID> R queryWithPassThrough(String keyPrefix,
87
                                          ID id,
88
                                          Class<R> type,
89
                                          Function<ID, R> dbFallback,
90
                                          Long time,
91
                                          TimeUnit timeUnit) {
92
        //1、从redis中根据id查询商铺
93
        String key = keyPrefix + id;
94
        String json = stringRedisTemplate.opsForValue().get(key);
95
        //2、判断是否存在记录
96
        if (StrUtil.isNotBlank(json)) {
97
            //存在，返回数据
98
            R r = JSONUtil.toBean(json, type);
99
            return r;
100
        }
101

102
        //3、判断记录是否为空值
103
        if (json != null) {
104
            return null;
105
        }
106

107
        //4、查询数据库
108
        R r = dbFallback.apply(id);
109
        //5、数据库是否存在记录
110
        if (r == null) {
111
            //6、不存在，将空值写入redis
112
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, CACHE_NULL_TIME_UNIT);
113
            return null;
114
        }
115
        //7、存在，保存数据到redis，返回数据
116
        this.set(key, r, time, timeUnit);
117
        return r;
118
    }
119

120

121
    /**
122
     * 根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
123
     *
124
     * @param keyPrefix  key的前缀
125
     * @param id         id
126
     * @param type       需要返回对象的Class类型
127
     * @param dbFallback 根据id查询数据库
128
     * @param time       逻辑过期时间
129
     * @param timeUnit   时间单位
130
     * @param <R>        需要返回的对象类型的泛型
131
     * @param <ID>       id的泛型
132
     * @return
133
     */
134
    public <R, ID> R queryWithLogicalExpire(String keyPrefix,
135
                                            ID id,
136
                                            Class<R> type,
137
                                            Function<ID, R> dbFallback,
138
                                            Long time,
139
                                            TimeUnit timeUnit) {
140
        //1、从redis中根据id查询商铺
141
        String key = keyPrefix + id;
142
        String json = stringRedisTemplate.opsForValue().get(key);
143
        //2、缓存未命中，返回空数据
144
        if (StrUtil.isBlank(json)) {
145
            return null;
146
        }
147
        //3、缓存命中
148
        RedisData cacheData = JSONUtil.toBean(json, RedisData.class);
149
        LocalDateTime expireTime = cacheData.getExpireTime();
150
        R r = JSONUtil.toBean((JSONObject) cacheData.getData(), type);
151

152
        //3.1、判断缓存是否过期
153
        if (expireTime.isAfter(LocalDateTime.now())) {
154
            //3.2、缓存未过期，直接返回数据
155
            return r;
156
        }
157

158
        //4、缓存过期，需要进行缓存重建
159
        //4.1、尝试获取互斥锁
160
        String lockKey = LOCK_KEY + id;
161
        boolean isLock = tryLock(lockKey);
162
        //4.2、互斥锁获取成功
163
        if (isLock) {
164
            //4.3、再次检测redis缓存是否过期，做DoubleCheck
165
            String doubleCheckCacheStr = stringRedisTemplate.opsForValue().get(key);
166
            RedisData redisData = JSONUtil.toBean(doubleCheckCacheStr, RedisData.class);
167
            LocalDateTime newExpireTime = redisData.getExpireTime();
168
            R newR = JSONUtil.toBean((JSONObject) redisData.getData(), type);
169
            //4.3、缓存未过期（已经有线程重建完成了），则返回数据
170
            if (newExpireTime.isAfter(LocalDateTime.now())) {
171
                return newR;
172
            }
173
            //4.4 缓存仍过期 （还没有其他的线程重建缓存），创建独立线程，重建缓存
174
            //将重建工作交给线程池完成
175
            CACHE_REBUILD_EXECUTOR.submit(() -> {
176
                try {
177
                    //查询数据库
178
                    R dbR = dbFallback.apply(id);
179
                    //重建缓存
180
                    this.setWithLogicalExpire(key, dbR, time, timeUnit);
181
                } catch (Exception e) {
182
                    throw new RuntimeException(e);
183
                } finally {
184
                    //4.5释放锁
185
                    unlock(lockKey);
186
                }
187
            });
188
        }
189
        //5、返回过期的商铺信息
190
        return r;
191
    }
192

193
    /**
194
     * 根据指定的key查询缓存，并反序列化为指定类型，利用互斥锁解决缓存击穿问题
195
     *
196
     * @param keyPrefix  key的前缀
197
     * @param id         id
198
     * @param type       需要返回对象的Class类型
199
     * @param dbFallback 根据id查询数据库
200
     * @param time       过期时间
201
     * @param timeUnit   时间单位
202
     * @param <R>        需要返回的对象类型的泛型
203
     * @param <ID>       id的泛型
204
     * @return
205
     */
206
    public <R, ID> R queryWithMutex(String keyPrefix,
207
                                    ID id,
208
                                    Class<R> type,
209
                                    Function<ID, R> dbFallback,
210
                                    Long time,
211
                                    TimeUnit timeUnit) {
212
        //1、从redis中根据id查询商铺
213
        String key = keyPrefix + id;
214
        String json = stringRedisTemplate.opsForValue().get(key);
215
        //2、判断是否存在记录
216
        if (StrUtil.isNotBlank(json)) {
217
            //存在，返回数据
218
            R r = JSONUtil.toBean(json, type);
219
            return r;
220
        }
221

222
        //3、判断记录是否为空值
223
        if (json != null) {
224
            return null;
225
        }
226

227
        //4、redis 查询结果为null缓存失效，尝试重建缓存
228
        String lockKey = LOCK_KEY + id;
229
        R dbR = null;
230
        try {
231
            //自旋等待，尝试获取互斥锁
232
            while (!tryLock(lockKey)) {
233
                Thread.sleep(SPIN_WAIT_MILLISECOND);
234
            }
235

236
            //4.2、获取锁成功,再次查询缓存
237
            String newJson = stringRedisTemplate.opsForValue().get(key);
238
            //缓存有效，直接返回
239
            if (StrUtil.isNotBlank(newJson)) {
240
                //存在，返回数据
241
                return JSONUtil.toBean(newJson, type);
242
            }
243

244
            //4.3、缓存无效，查询数据库重建缓存
245
            dbR = dbFallback.apply(id);
246
            //数据库是否存在记录
247
            if (dbR == null) {
248
                //不存在，将空值写入redis
249
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, CACHE_NULL_TIME_UNIT);
250
                return null;
251
            }
252
            //存在，保存数据到redis，返回数据
253
            this.set(key, dbR, time, timeUnit);
254
        } catch (InterruptedException e) {
255
            throw new RuntimeException(e);
256
        } finally {
257
            //5、释放锁
258
            unlock(lockKey);
259
        }
260
        //返回数据
261
        return dbR;
262
    }
263

264
    /**
265
     * 获取互斥锁，利用 setnx设置互斥锁，并设置锁的过期时间
266
     *
267
     * @param key
268
     * @return
269
     */
270
    public boolean tryLock(String key) {
271
        Boolean isLock = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
272
        return BooleanUtil.isTrue(isLock);
273
    }
274

275
    /**
276
     * 释放互斥锁
277
     *
278
     * @param key
279
     */
280
    public void unlock(String key) {
281
        stringRedisTemplate.delete(key);
282
    }
283
}

1
public Result queryShopById(Long id) {
2
        // 通过缓存空值，缓存穿透
3
//        Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY,
4
//                id, Shop.class,  this::getById, CACHE_SHOP_TTL,TimeUnit.MINUTES);
5

6
        // 互斥锁解决缓存击穿
7
//        Shop shop = cacheClient.queryWithMutex(CACHE_SHOP_KEY,id,Shop.class,
8
//                this::getById,CACHE_SHOP_TTL,TimeUnit.MINUTES);
9

10
        // 逻辑过期解决缓存击穿
11
        Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY,id,Shop.class,
12
                this::getById,10L,TimeUnit.SECONDS);
13

14
        if (shop == null) {
15
            return Result.fail("店铺不存在");
16
        }
17
        return Result.ok(shop);
18
    }

1
@Component
2
@RequiredArgsConstructor
3
public class RedisIdWorker {
4

5

6
    private final RedisTemplate<String, Object> redisTemplate;
7

8
    private static final long BEGIN_TIMESTAMP = 1640995200L;
9

10
    /**
11
     * 序列号位数
12
     */
13
    private static final int COUNT_BITS = 32;
14

15
    /**
16
     * 生成全局唯一ID
17
     *
18
     * @param keyPerfix 相关业务的ID前缀
19
     * @return
20
     */
21
    public long nextId(String keyPerfix) {
22
        // 生成时间戳
23
        LocalDateTime now = LocalDateTime.now();
24
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
25
        long timestamp = nowSecond - BEGIN_TIMESTAMP;
26
        // 生成序列号
27
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
28
        Long count = redisTemplate.opsForValue().increment("icr:" + keyPerfix + ":" + date); // redis自增长的值是有上限的，是2^64
29

30
        return timestamp << COUNT_BITS | count;
31
    }
32

33
}