黑马点评上

1
//拦截器登录校验
2
public class RefreshTokenInterceptor implements HandlerInterceptor {
3
    //引入Redis因为此为自定义工具类不受Spring监管不能用@Resourse利用构造方法
4
    private StringRedisTemplate stringRedisTemplate;
5
public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate){
6
    this.stringRedisTemplate=stringRedisTemplate;
7

8
}
9
   //alter+insert实现controller方法前执行
10
    @Override
11
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
12
//获取请求头的token
13
        String token =request.getHeader("authorization");
14
        //判断用户是否存在
15
        if(token == null){
16
            return true;
17
        }
18
//        基于Redis获取用户(获取全部key和value)
19
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash()
20
                .entries(RedisConstants.LOGIN_USER_KEY + token);
21
        //判断用户是否存在
22
        if(userMap.isEmpty()){
23
            return true;
24
        }
25
        //将查到的Hash数据转成USERDTO对象‘
26
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
27
        //存在，把用户信息存入threadlocal
28
        //session利用beanutil属性拷贝去除敏感信息，转成UserDTO类
29
        UserHolder.saveUser(userDTO);
30
        //刷新token时间
31
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
32
        //放行
33
        return true;
34
    }
35
//方法后执行
36
    @Override
37
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
38
        UserHolder.removeUser();
39
    }
40
}

1
@Configuration
2
public class Mvcconfig implements WebMvcConfigurer {
3
    @Resource
4
    private StringRedisTemplate stringRedisTemplate;
5
    @Override
6
    public void addInterceptors(InterceptorRegistry registry) {
7
    //token刷新拦截器（第一个拦截器）利用oder字段指定
8
      registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
9
    }
10

11
      registry.addInterceptor(new LoginInterceptor())
12
              .excludePathPatterns(
13
                      "/shop/**",
14
                      "/voucher/**",
15
                      "/shop-type/**",
16
                      "/upload/**",
17
                      "/blog/hot",
18
                      "/user/code",
19
                      "/user/login"
20
              ).order(1);
21

22

23

24
}

1
public class LoginInterceptor implements HandlerInterceptor {
2

3
    @Override
4
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
5
        // 1.判断是否需要拦截（ThreadLocal中是否有用户）
6
        if (UserHolder.getUser() == null) {
7
            // 没有，需要拦截，设置状态码
8
            response.setStatus(401);
9
            // 拦截
10
            return false;
11
        }
12
        // 有用户，则放行
13
        return true;
14
    }
15
}

1
@Service
2
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
3
    @Resource
4
    private StringRedisTemplate stringRedisTemplate;
5
//  //  根据id查询商铺信息
6
    @Override
7
    public Result queryById(Long id) {
8
        //商品的key
9
        String key =CACHE_SHOP_KEY+id;
10
        //先从Redis中查询缓存
11
String shopJson= stringRedisTemplate.opsForValue().get(key);
12

13
        //判断缓存是否存在
14
        if(StrUtil.isNotBlank(shopJson)){
15
           // 存在
16
           Shop shop =JSONUtil.toBean(shopJson,Shop.class);
17
           return   Result.ok(shop) ;
18
        }
19
        //不存在查询数据库
20
       Shop shop= getById(id);
21
        if (shop==null){
22
            return Result.fail("店铺不存在");
23
        }
24
        //存在写入redis
25
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop));
26
        return Result.ok(shop);
27

28
    }
29
}

1
    //更新店铺信息
2
    //原子性同时删除数据库和缓存
3
    @Transactional
4
    @Override
5
    public Result update(Shop shop) {
6
        Long id = shop.getId();
7
        if(id==null){
8
            return Result.fail("店铺id不能为空");
9
        }
10
        //更新数据库
11
        updateById(shop);
12
//        删除缓存
13
         stringRedisTemplate.delete(CACHE_SHOP_KEY+id);
14
         return Result.ok();
15
    }

1
@Configuration
2
public class CacheConfig {
3
    @Bean
4
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
5
        // 创建ObjectMapper用于处理序列化和反序列化
6
        ObjectMapper objectMapper = new ObjectMapper();
7
        // 注册JavaTimeModule以支持Java 8日期时间类型
8
        objectMapper.registerModule(new JavaTimeModule());
9
        // 禁用将日期序列化为时间戳格式，保持可读性
10
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
11
        // 启用默认的多态类型信息处理，以便在反序列化时保留类型信息
12
        objectMapper.activateDefaultTyping(
13
                objectMapper.getPolymorphicTypeValidator(),
14
                ObjectMapper.DefaultTyping.NON_FINAL,
15
                JsonTypeInfo.As.PROPERTY
16
        );
17
        // 创建通用的Jackson2 JSON Redis序列化器
18
        GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer(objectMapper);
19

20
// 定义默认的缓存配置，设置缓存条目过期时间为10分钟，并使用定义好的序列化器 。
21
        RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
22
                .entryTtl(Duration.ofMinutes(10))
23
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer));
24
        // 创建缓存配置映射，允许为不同的缓存名称定义不同的配置
25
Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
26
        // 为店铺缓存设置单独的过期时间（1小时）
27
        cacheConfigurations.put(CACHE_SHOP_KEY, defaultConfig.entryTtl(Duration.ofDays(1)));
28
        // 构建RedisCacheManager实例，使用默认配置和自定义的缓存配置初始化
29

30

31
        return RedisCacheManager.builder(connectionFactory)
32
                .cacheDefaults(defaultConfig)
33
   .withInitialCacheConfigurations(cacheConfigurations)
34
                .build();
35
    }
36
}

1
@Slf4j
2
@Component
3
public class CacheClient {
4

5
    private final StringRedisTemplate stringRedisTemplate;
6

7
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
8

9
    public CacheClient(StringRedisTemplate stringRedisTemplate) {
10
        this.stringRedisTemplate = stringRedisTemplate;
11
    }
12

13
    public void set(String key, Object value, Long time, TimeUnit unit) {
14
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
15
    }
16

17
    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
18
        // 设置逻辑过期
19
        RedisData redisData = new RedisData();
20
        redisData.setData(value);
21
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
22
        // 写入Redis
23
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
24
    }
25

26
    public <R,ID> R queryWithPassThrough(
27
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
28
        String key = keyPrefix + id;
29
        // 1.从redis查询商铺缓存
30
        String json = stringRedisTemplate.opsForValue().get(key);
31
        // 2.判断是否存在
32
        if (StrUtil.isNotBlank(json)) {
33
            // 3.存在，直接返回
34
            return JSONUtil.toBean(json, type);
35
        }
36
        // 判断命中的是否是空值
37
        if (json != null) {
38
            // 返回一个错误信息
39
            return null;
40
        }
41

42
        // 4.不存在，根据id查询数据库
43
        R r = dbFallback.apply(id);
44
        // 5.不存在，返回错误
45
        if (r == null) {
46
            // 将空值写入redis
47
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
48
            // 返回错误信息
49
            return null;
50
        }
51
        // 6.存在，写入redis
52
        this.set(key, r, time, unit);
53
        return r;
54
    }
55

56
    public <R, ID> R queryWithLogicalExpire(
57
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
58
        String key = keyPrefix + id;
59
        // 1.从redis查询商铺缓存
60
        String json = stringRedisTemplate.opsForValue().get(key);
61
        // 2.判断是否存在
62
        if (StrUtil.isBlank(json)) {
63
            // 3.存在，直接返回
64
            return null;
65
        }
66
        // 4.命中，需要先把json反序列化为对象
67
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
68
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
69
        LocalDateTime expireTime = redisData.getExpireTime();
70
        // 5.判断是否过期
71
        if(expireTime.isAfter(LocalDateTime.now())) {
72
            // 5.1.未过期，直接返回店铺信息
73
            return r;
74
        }
75
        // 5.2.已过期，需要缓存重建
76
        // 6.缓存重建
77
        // 6.1.获取互斥锁
78
        String lockKey = LOCK_SHOP_KEY + id;
79
        boolean isLock = tryLock(lockKey);
80
        // 6.2.判断是否获取锁成功
81
        if (isLock){
82
            // 6.3.成功，开启独立线程，实现缓存重建
83
            CACHE_REBUILD_EXECUTOR.submit(() -> {
84
                try {
85
                    // 查询数据库
86
                    R newR = dbFallback.apply(id);
87
                    // 重建缓存
88
                    this.setWithLogicalExpire(key, newR, time, unit);
89
                } catch (Exception e) {
90
                    throw new RuntimeException(e);
91
                }finally {
92
                    // 释放锁
93
                    unlock(lockKey);
94
                }
95
            });
96
        }
97
        // 6.4.返回过期的商铺信息
98
        return r;
99
    }
100

101
    public <R, ID> R queryWithMutex(
102
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
103
        String key = keyPrefix + id;
104
        // 1.从redis查询商铺缓存
105
        String shopJson = stringRedisTemplate.opsForValue().get(key);
106
        // 2.判断是否存在
107
        if (StrUtil.isNotBlank(shopJson)) {
108
            // 3.存在，直接返回
109
            return JSONUtil.toBean(shopJson, type);
110
        }
111
        // 判断命中的是否是空值
112
        if (shopJson != null) {
113
            // 返回一个错误信息
114
            return null;
115
        }
116

117
        // 4.实现缓存重建
118
        // 4.1.获取互斥锁
119
        String lockKey = LOCK_SHOP_KEY + id;
120
        R r = null;
121
        try {
122
            boolean isLock = tryLock(lockKey);
123
            // 4.2.判断是否获取成功
124
            if (!isLock) {
125
                // 4.3.获取锁失败，休眠并重试
126
                Thread.sleep(50);
127
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
128
            }
129
            // 4.4.获取锁成功，根据id查询数据库
130
            r = dbFallback.apply(id);
131
            // 5.不存在，返回错误
132
            if (r == null) {
133
                // 将空值写入redis
134
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
135
                // 返回错误信息
136
                return null;
137
            }
138
            // 6.存在，写入redis
139
            this.set(key, r, time, unit);
140
        } catch (InterruptedException e) {
141
            throw new RuntimeException(e);
142
        }finally {
143
            // 7.释放锁
144
            unlock(lockKey);
145
        }
146
        // 8.返回
147
        return r;
148
    }
149

150
    private boolean tryLock(String key) {
151
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
152
        return BooleanUtil.isTrue(flag);
153
    }
154

155
    private void unlock(String key) {
156
        stringRedisTemplate.delete(key);
157
    }
158
}

1
@Resource
2
private CacheClient cacheClient;
3

4
 @Override
5
    public Result queryById(Long id) {
6
        // 解决缓存穿透
7
        Shop shop = cacheClient
8
                .queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
9

10
        // 互斥锁解决缓存击穿
11
        // Shop shop = cacheClient
12
        //         .queryWithMutex(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
13

14
        // 逻辑过期解决缓存击穿
15
        // Shop shop = cacheClient
16
        //         .queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, 20L, TimeUnit.SECONDS);
17

18
        if (shop == null) {
19
            return Result.fail("店铺不存在！");
20
        }
21
        // 7.返回
22
        return Result.ok(shop);
23
    }