1
<dependency>
2
    <groupId>javax.activation</groupId>
3
    <artifactId>activation</artifactId>
4
    <version>1.1.1</version>
5
</dependency>
6
<dependency>
7
    <groupId>javax.mail</groupId>
8
    <artifactId>mail</artifactId>
9
    <version>1.4.7</version>
10
</dependency>
11
<dependency>
12
    <groupId>org.apache.commons</groupId>
13
    <artifactId>commons-email</artifactId>
14
    <version>1.4</version>
15
</dependency>

1
public class MailUtils {
2

3
    public static void sendTestMail(String email, String code) throws MessagingException {
4
        Properties props = new Properties();
5
        props.put("mail.smtp.auth", "true");
6
        props.put("mail.smtp.host", "smtp.qq.com");
7
        props.put("mail.smtp.port", "587");
8
        props.put("mail.user", "你的邮箱@qq.com");
9
        props.put("mail.password", "你的SMTP授权码");
10

11
        Authenticator authenticator = new Authenticator() {
12
            @Override
13
            protected PasswordAuthentication getPasswordAuthentication() {
14
                String userName = props.getProperty("mail.user");
15
                String password = props.getProperty("mail.password");
16
                return new PasswordAuthentication(userName, password);
17
            }
18
        };
19

20
        Session mailSession = Session.getInstance(props, authenticator);
21
        MimeMessage message = new MimeMessage(mailSession);
22
        message.setFrom(new InternetAddress(props.getProperty("mail.user")));
23
        message.setRecipient(Message.RecipientType.TO, new InternetAddress(email));
24
        message.setSubject("登录验证码");
25
        message.setContent("验证码为：" + code + "（有效期一分钟）", "text/html;charset=UTF-8");
26
        Transport.send(message);
27
    }
28

29
    public static String achieveCode() {
30
        String[] beforeShuffle = new String[]{
31
                "2", "3", "4", "5", "6", "7", "8", "9",
32
                "A", "B", "C", "D", "E", "F", "G", "H",
33
                "I", "J", "K", "L", "M", "N", "O", "P",
34
                "Q", "R", "S", "T", "U", "V", "W", "X",
35
                "Y", "Z", "a", "b", "c", "d", "e", "f",
36
                "g", "h", "i", "j", "k", "l", "m", "n",
37
                "o", "p", "q", "r", "s", "t", "u", "v",
38
                "w", "x", "y", "z"
39
        };
40
        List<String> list = Arrays.asList(beforeShuffle);
41
        Collections.shuffle(list);
42
        StringBuilder sb = new StringBuilder();
43
        for (String s : list) {
44
            sb.append(s);
45
        }
46
        return sb.substring(3, 8);
47
    }
48
}

1
@PostMapping("/login")
2
public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session) {
3
    String phone = loginForm.getPhone();
4
    String code = loginForm.getCode();
5
    Object cacheCode = session.getAttribute(phone);
6

7
    if (RegexUtils.isEmailInvalid(phone)) {
8
        return Result.fail("邮箱格式不正确！！");
9
    }
10

11
    if (code == null || cacheCode == null || !cacheCode.toString().equals(code)) {
12
        return Result.fail("验证码不一致！！");
13
    }
14

15
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
16
    queryWrapper.eq(User::getPhone, phone);
17
    User user = userService.getOne(queryWrapper);
18

19
    if (user == null) {
20
        user = createUserWithPhone(phone);
21
    }
22

23
    session.setAttribute("user", user);
24
    return Result.ok();
25
}

1
public class LoginInterceptor implements HandlerInterceptor {
2

3
    @Override
4
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
5
        HttpSession session = request.getSession();
6
        User user = (User) session.getAttribute("user");
7
        if (user == null) {
8
            response.setStatus(401);
9
            return false;
10
        }
11
        UserHolder.saveUser(user);
12
        return true;
13
    }
14

15
    @Override
16
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
17
        UserHolder.removeUser();
18
    }
19
}

1
@PostMapping("/code")
2
public Result sendCode(@RequestParam("phone") String phone) throws MessagingException {
3
    if (RegexUtils.isEmailInvalid(phone)) {
4
        return Result.fail("邮箱格式不正确");
5
    }
6
    String code = MailUtils.achieveCode();
7
    stringRedisTemplate.opsForValue().set(
8
            LOGIN_CODE_KEY + phone,
9
            code,
10
            LOGIN_CODE_TTL,
11
            TimeUnit.MINUTES
12
    );
13
    log.info("发送登录验证码：{}", code);
14
    return Result.ok();
15
}

1
@PostMapping("/login")
2
public Result login(@RequestBody LoginFormDTO loginForm) {
3
    String phone = loginForm.getPhone();
4
    String code = loginForm.getCode();
5

6
    String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
7

8
    if (RegexUtils.isEmailInvalid(phone)) {
9
        return Result.fail("邮箱格式不正确！！");
10
    }
11

12
    if (code == null || cacheCode == null || !cacheCode.equals(code)) {
13
        return Result.fail("验证码不一致！！");
14
    }
15

16
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
17
    queryWrapper.eq(User::getPhone, phone);
18
    User user = userService.getOne(queryWrapper);
19

20
    if (user == null) {
21
        user = createUserWithPhone(phone);
22
    }
23

24
    String token = UUID.randomUUID().toString();
25
    UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
26

27
    Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
28
            CopyOptions.create()
29
                    .setIgnoreNullValue(true)
30
                    .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
31

32
    String tokenKey = LOGIN_USER_KEY + token;
33
    stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
34
    stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);
35
    stringRedisTemplate.delete(LOGIN_CODE_KEY + phone);
36

37
    return Result.ok(token);
38
}

1
public class RefreshTokenInterceptor implements HandlerInterceptor {
2

3
    private final StringRedisTemplate stringRedisTemplate;
4

5
    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
6
        this.stringRedisTemplate = stringRedisTemplate;
7
    }
8

9
    @Override
10
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
11
        String token = request.getHeader("authorization");
12
        if (StrUtil.isBlank(token)) {
13
            return true;
14
        }
15

16
        String key = RedisConstants.LOGIN_USER_KEY + token;
17
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
18
        if (userMap.isEmpty()) {
19
            return true;
20
        }
21

22
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
23
        UserHolder.saveUser(userDTO);
24
        stringRedisTemplate.expire(key, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
25
        return true;
26
    }
27

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

1
public class LoginInterceptor implements HandlerInterceptor {
2

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

12
    @Override
13
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
14
        UserHolder.removeUser();
15
    }
16
}

1
@Configuration
2
public class MvcConfig implements WebMvcConfigurer {
3

4
    @Autowired
5
    private 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
                        "/shop-type/**",
16
                        "/upload/**",
17
                        "/voucher/**"
18
                ).order(1);
19

20
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).order(0);
21
    }
22
}

1
@Override
2
public Result queryById(Long id) {
3
    String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
4

5
    if (StrUtil.isNotBlank(shopJson)) {
6
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
7
        return Result.ok(shop);
8
    }
9

10
    Shop shop = getById(id);
11
    if (shop == null) {
12
        return Result.fail("店铺不存在！！");
13
    }
14

15
    String jsonStr = JSONUtil.toJsonStr(shop);
16
    stringRedisTemplate.opsForValue().set(
17
            CACHE_SHOP_KEY + id,
18
            jsonStr,
19
            CACHE_SHOP_TTL,
20
            TimeUnit.MINUTES
21
    );
22

23
    return Result.ok(shop);
24
}

1
@Override
2
public Result queryById(Long id) {
3
    String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
4

5
    if (StrUtil.isNotBlank(shopJson)) {
6
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
7
        return Result.ok(shop);
8
    }
9

10
    if (shopJson != null) {
11
        return Result.fail("店铺不存在！！");
12
    }
13

14
    Shop shop = getById(id);
15

16
    if (shop == null) {
17
        stringRedisTemplate.opsForValue().set(
18
                CACHE_SHOP_KEY + id,
19
                "",
20
                CACHE_NULL_TTL,
21
                TimeUnit.MINUTES
22
        );
23
        return Result.fail("店铺不存在！！");
24
    }
25

26
    String jsonStr = JSONUtil.toJsonStr(shop);
27
    stringRedisTemplate.opsForValue().set(
28
            CACHE_SHOP_KEY + id,
29
            jsonStr,
30
            CACHE_SHOP_TTL,
31
            TimeUnit.MINUTES
32
    );
33

34
    return Result.ok(shop);
35
}

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

5
    private final StringRedisTemplate stringRedisTemplate;
6
    private static final ExecutorService CACHE_REBUILD_EXECUTOR =
7
            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 timeUnit) {
14
        stringRedisTemplate.opsForValue().set(
15
                key,
16
                JSONUtil.toJsonStr(value),
17
                time,
18
                timeUnit
19
        );
20
    }
21

22
    public void setWithLogicExpire(String key, Object value, Long time, TimeUnit timeUnit) {
23
        RedisData<Object> redisData = new RedisData<>();
24
        redisData.setData(value);
25
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(time)));
26
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
27
    }
28

29
    public <R, ID> R queryWithPassThrough(
30
            String keyPrefix,
31
            ID id,
32
            Class<R> type,
33
            Function<ID, R> dbFallback,
34
            Long time,
35
            TimeUnit timeUnit
36
    ) {
37
        String key = keyPrefix + id;
38
        String json = stringRedisTemplate.opsForValue().get(key);
39

40
        if (StrUtil.isNotBlank(json)) {
41
            return JSONUtil.toBean(json, type);
42
        }
43

44
        if (json != null) {
45
            return null;
46
        }
47

48
        R r = dbFallback.apply(id);
49

50
        if (r == null) {
51
            stringRedisTemplate.opsForValue().set(
52
                    key,
53
                    "",
54
                    CACHE_NULL_TTL,
55
                    TimeUnit.MINUTES
56
            );
57
            return null;
58
        }
59

60
        this.set(key, r, time, timeUnit);
61
        return r;
62
    }
63

64
    public <R, ID> R queryWithMutex(
65
            String keyPrefix,
66
            ID id,
67
            Class<R> type,
68
            Function<ID, R> dbFallback,
69
            Long time,
70
            TimeUnit timeUnit
71
    ) {
72
        String key = keyPrefix + id;
73
        String json = stringRedisTemplate.opsForValue().get(key);
74

75
        if (StrUtil.isNotBlank(json)) {
76
            return JSONUtil.toBean(json, type);
77
        }
78

79
        if (json != null) {
80
            return null;
81
        }
82

83
        R r = null;
84
        String lockKey = LOCK_SHOP_KEY + id;
85

86
        try {
87
            boolean flag = tryLock(lockKey);
88
            if (!flag) {
89
                Thread.sleep(50);
90
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, timeUnit);
91
            }
92

93
            r = dbFallback.apply(id);
94

95
            if (r == null) {
96
                stringRedisTemplate.opsForValue().set(
97
                        key,
98
                        "",
99
                        CACHE_NULL_TTL,
100
                        TimeUnit.MINUTES
101
                );
102
                return null;
103
            }
104

105
            this.set(key, r, time, timeUnit);
106
        } catch (InterruptedException e) {
107
            throw new RuntimeException(e);
108
        } finally {
109
            unlock(lockKey);
110
        }
111

112
        return r;
113
    }
114

115
    public <R, ID> R queryWithLogicalExpire(
116
            String keyPrefix,
117
            ID id,
118
            Class<R> type,
119
            Function<ID, R> dbFallback,
120
            Long time,
121
            TimeUnit timeUnit
122
    ) {
123
        String key = keyPrefix + id;
124
        String json = stringRedisTemplate.opsForValue().get(key);
125

126
        if (StrUtil.isBlank(json)) {
127
            return null;
128
        }
129

130
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
131
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
132
        LocalDateTime expireTime = redisData.getExpireTime();
133

134
        if (expireTime.isAfter(LocalDateTime.now())) {
135
            return r;
136
        }
137

138
        String lockKey = LOCK_SHOP_KEY + id;
139
        boolean flag = tryLock(lockKey);
140

141
        if (flag) {
142
            CACHE_REBUILD_EXECUTOR.submit(() -> {
143
                try {
144
                    R tmp = dbFallback.apply(id);
145
                    this.setWithLogicExpire(key, tmp, time, timeUnit);
146
                } catch (Exception e) {
147
                    throw new RuntimeException(e);
148
                } finally {
149
                    unlock(lockKey);
150
                }
151
            });
152
        }
153

154
        return r;
155
    }
156

157
    private boolean tryLock(String key) {
158
        Boolean flag = stringRedisTemplate.opsForValue()
159
                .setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
160
        return BooleanUtil.isTrue(flag);
161
    }
162

163
    private void unlock(String key) {
164
        stringRedisTemplate.delete(key);
165
    }
166
}

1
@Component
2
public class RedisIdWorker {
3

4
    @Autowired
5
    private StringRedisTemplate stringRedisTemplate;
6

7
    public static final Long BEGIN_TIMESTAMP = 1640995200L;
8
    public static final Long COUNT_BIT = 32L;
9

10
    public long nextId(String keyPrefix) {
11
        LocalDateTime now = LocalDateTime.now();
12
        long currentSecond = now.toEpochSecond(ZoneOffset.UTC);
13
        long timeStamp = currentSecond - BEGIN_TIMESTAMP;
14

15
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
16
        long count = stringRedisTemplate.opsForValue()
17
                .increment("inc:" + keyPrefix + ":" + date);
18

19
        return timeStamp << COUNT_BIT | count;
20
    }
21
}

1
@Override
2
@Transactional
3
public void addSeckillVoucher(Voucher voucher) {
4
    save(voucher);
5

6
    SeckillVoucher seckillVoucher = new SeckillVoucher();
7
    seckillVoucher.setVoucherId(voucher.getId());
8
    seckillVoucher.setStock(voucher.getStock());
9
    seckillVoucher.setBeginTime(voucher.getBeginTime());
10
    seckillVoucher.setEndTime(voucher.getEndTime());
11
    seckillVoucherService.save(seckillVoucher);
12

13
    stringRedisTemplate.opsForValue().set(
14
            SECKILL_STOCK_KEY + voucher.getId(),
15
            voucher.getStock().toString()
16
    );
17
}

1
@Override
2
public Result seckillVoucher(Long voucherId) {
3
    LambdaQueryWrapper<SeckillVoucher> queryWrapper = new LambdaQueryWrapper<>();
4
    queryWrapper.eq(SeckillVoucher::getVoucherId, voucherId);
5
    SeckillVoucher seckillVoucher = seckillVoucherService.getOne(queryWrapper);
6

7
    if (LocalDateTime.now().isBefore(seckillVoucher.getBeginTime())) {
8
        return Result.fail("秒杀还未开始，请耐心等待");
9
    }
10

11
    if (LocalDateTime.now().isAfter(seckillVoucher.getEndTime())) {
12
        return Result.fail("秒杀已经结束！");
13
    }
14

15
    if (seckillVoucher.getStock() < 1) {
16
        return Result.fail("优惠券已被抢光了哦");
17
    }
18

19
    boolean success = seckillVoucherService.update()
20
            .setSql("stock = stock - 1")
21
            .eq("voucher_id", voucherId)
22
            .gt("stock", 0)
23
            .update();
24

25
    if (!success) {
26
        return Result.fail("库存不足");
27
    }
28

29
    VoucherOrder voucherOrder = new VoucherOrder();
30
    long orderId = redisIdWorker.nextId("order");
31
    Long userId = UserHolder.getUser().getId();
32

33
    voucherOrder.setId(orderId);
34
    voucherOrder.setUserId(userId);
35
    voucherOrder.setVoucherId(voucherId);
36

37
    save(voucherOrder);
38

39
    return Result.ok(orderId);
40
}