黑马点评上

1
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {//发送验证码
2
   //引入redis配置类
3
    @Resource
4
    private StringRedisTemplate stringRedisTemplate;
5
    @Override
6
    public Result sendCode(String phone, HttpSession session) {
7
        //校验手机号的有效性借助
8
        if(RegexUtils.isPhoneInvalid(phone)){
9
            //如果不符合，返回错误信息
10
            return Result.fail("手机号格式错误");
11
        }
12
        //符合生成6位数验证吗
13
        String code  = RandomUtil.randomNumbers(6);
14
        //将验证码存入session
15
        //转换成存入redis,s数据共享  以手机号作为key  工具类定义过期时间
16
        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY +phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);
17
        //发送验证码
18
         log.debug("发送验证码成功，验证码为:{}",code);
19
        return Result.ok();
20
    }

1
//登录注册功能
2
    @Override
3
    public Result login(LoginFormDTO loginForm, HttpSession session) {
4
        String phone=loginForm.getPhone();
5
        //校验手机号
6
        if(RegexUtils.isPhoneInvalid(phone)){
7
            //如果不符合，返回错误信息
8
            return Result.fail("手机号格式错误");
9
        }
10
        //校验验证码
11
        //获取Redis中的key
12
        String cacheCode= stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
13
        String code =loginForm.getCode();//请求验证码
14
        if(cacheCode == null|| !cacheCode.equals(code)){
15
            //不一致返回
16
            return Result.fail("验证码错误");
17
        }
18
       // 一致的话根据手机号查询用户select* from tb_user where phone =?
19
        User user= query().eq("phone",phone).one();
20
        //用户是否存在
21
        if(user==null){
22
//            不存在向数据库插入新用户并保存
23
            user=createUserWithPhone(phone);
24
        }
25

26

27
        //   保存用户信息到Redis
28
        //1.生成随机生成token,作为登录令牌
29
        String token = UUID.randomUUID().toString(true);
30
        //2.将User对象转成HashMap存储
31
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
32
        //解决user中的id无法转换成string，要求类型都为String
33
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
34
                CopyOptions.create()
35
                        .setIgnoreNullValue(true)
36
                        .setFieldValueEditor((fieldName, fieldValue) ->        fieldValue.toString()));
37
        //3.存储到redis
38
        String tokenKey=LOGIN_USER_KEY+token;
39
        stringRedisTemplate.opsForHash().putAll(tokenKey,userMap);
40
        //4.设置token有效期
41
        stringRedisTemplate.expire(tokenKey,LOGIN_USER_TTL,TimeUnit.MINUTES);
42
        return Result.ok(token);
43
    }
44

45
    //创建用户对象插入数据
46
    private User createUserWithPhone(String phone){
47
        User user=new User();
48
        user.setPhone(phone);
49
        user.setNickName(USER_NICK_NAME_PREFIX+RandomUtil.randomString(10));
50
        //保存用户
51
        save(user);
52
        return user;
53
    }
54
}

1
//拦截器登录校验
2
public class LoginInterceptor implements HandlerInterceptor {
3
    //引入Redis因为此为自定义工具类不受Spring监管不能用@Resourse利用构造方法
4
    private StringRedisTemplate stringRedisTemplate;
5
public LoginInterceptor(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
            //不存在，拦截返回401状态码
17
            response.setStatus(401);
18
            return false;
19
        }
20
//        基于Redis获取用户(获取全部key和value)
21
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash()
22
                .entries(RedisConstants.LOGIN_USER_KEY + token);
23
        //判断用户是否存在
24
        if(userMap.isEmpty()){
25
            //不存在拦截401状态码
26
            response.setStatus(401);
27
            return false;
28
        }
29
        //将查到的Hash数据转成USERDTO对象‘
30
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
31
        //存在，把用户信息存入threadlocal
32
        //session利用beanutil属性拷贝去除敏感信息，转成UserDTO类
33
        UserHolder.saveUser(userDTO);
34
        //刷新token时间
35
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
36
        //放行
37
        return true;
38
    }

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
      registry.addInterceptor(new LoginInterceptor())
8
              .excludePathPatterns(
9
                      "/shop/**",
10
                      "/voucher/**",
11
                      "/shop-type/**",
12
                      "/upload/**",
13
                      "/blog/hot",
14
                      "/user/code",
15
                      "/user/login"
16
              ).order(1);
17

18
//token刷新拦截器
19
      registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
20
    }
21

22
}

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
        String key =CACHE_SHOP_KEY+id;
9
        //先从Redis中查询缓存
10
        String shopJson= stringRedisTemplate.opsForValue().get(key);
11
        //判断是否存在
12
        if(StrUtil.isNotBlank(shopJson)){
13
           // 存在
14
           Shop shop =JSONUtil.toBean(shopJson,Shop.class);
15
           return   Result.ok(shop) ;
16
        }
17
        //不存在查询数据库
18
       Shop shop= getById(id);
19
        if (shop==null){
20
            return Result.fail("店铺不存在");
21
        }
22
        //存在写入redis
23
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop));
24
        return Result.ok(shop);
25

26
    }
27
}

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
    }