1
@Override
2
    public Result sendCode(String phone, HttpSession session) {
3
        // 1. Validate phone number
4
        if (RegexUtils.isPhoneInvalid(phone)) {
5
            // 2. If not valid, return error
6
            return Result.fail("手机号格式错误！");
7
        }
8
        // 3. Valid, generate verification code
9
        String code = RandomUtil.randomNumbers(6);
10

11
        // 4. Save verification code to session
12
        session.setAttribute("code",code);
13
        // 5. Send verification code
14
        log.debug("发送短信验证码成功，验证码：{}", code);
15
        // Return ok
16
        return Result.ok();
17
    }

1
@Override
2
    public Result login(LoginFormDTO loginForm, HttpSession session) {
3
        // 1. Validate phone number
4
        String phone = loginForm.getPhone();
5
        if (RegexUtils.isPhoneInvalid(phone)) {
6
            // 2. If not valid, return error
7
            return Result.fail("手机号格式错误！");
8
        }
9
        // 3. Validate verification code
10
        Object cacheCode = session.getAttribute("code");
11
        String code = loginForm.getCode();
12
        if(cacheCode == null || !cacheCode.toString().equals(code)){
13
             // 3. Not match, error
14
            return Result.fail("验证码错误");
15
        }
16
        // Match, query user by phone
17
        User user = query().eq("phone", phone).one();
18

19
        // 5. Check if user exists
20
        if(user == null){
21
            // If not, create
22
            user =  createUserWithPhone(phone);
23
        }
24
        // 7. Save user info to session
25
        session.setAttribute("user",user);
26

27
        return Result.ok();
28
    }

1
public class LoginInterceptor implements HandlerInterceptor {
2

3
    @Override
4
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
5
       //1. Get session
6
        HttpSession session = request.getSession();
7
        //2. Get user from session
8
        Object user = session.getAttribute("user");
9
        //3. Check if user exists
10
        if(user == null){
11
              //4. Not exist, intercept, return 401
12
              response.setStatus(401);
13
              return false;
14
        }
15
        //5. Exists, save user info to ThreadLocal
16
        UserHolder.saveUser((User)user);
17
        //6. Let it pass
18
        return true;
19
    }
20
}

1
@Configuration
2
public class MvcConfig implements WebMvcConfigurer {
3

4
    @Resource
5
    private StringRedisTemplate stringRedisTemplate;
6

7
    @Override
8
    public void addInterceptors(InterceptorRegistry registry) {
9
        // Login interceptor
10
        registry.addInterceptor(new LoginInterceptor())
11
                .excludePathPatterns(
12
                        "/shop/**",
13
                        "/voucher/**",
14
                        "/shop-type/**",
15
                        "/upload/**",
16
                        "/blog/hot",
17
                        "/user/code",
18
                        "/user/login"
19
                ).order(1);
20
        // Token refresh interceptor
21
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
22
    }
23
}

1
//7. Save user info to session
2
session.setAttribute("user", BeanUtils.copyProperties(user,UserDTO.class));
3

4
//5. If exists, save user info to ThreadLocal
5
UserHolder.saveUser((UserDTO) user);

1
@Override
2
public Result login(LoginFormDTO loginForm, HttpSession session) {
3
    // 1. Validate phone number
4
    String phone = loginForm.getPhone();
5
    if (RegexUtils.isPhoneInvalid(phone)) {
6
        // 2. If not valid, return error
7
        return Result.fail("手机号格式错误！");
8
    }
9
    // 3. Retrieve verification code from Redis and validate
10
    String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
11
    String code = loginForm.getCode();
12
    if (cacheCode == null || !cacheCode.equals(code)) {
13
        // Inconsistent, error
14
        return Result.fail("验证码错误");
15
    }
16

17
    // 4. Consistent, query user by phone
18
    User user = query().eq("phone", phone).one();
19

20
    // 5. Check if user exists
21
    if (user == null) {
22
        // 6. Not exist, create new user and save
23
        user = createUserWithPhone(phone);
24
    }
25

26
    // 7. Save user info to Redis
27
    // 7.1 Generate a random token as login token
28
    String token = UUID.randomUUID().toString(true);
29
    // 7.2 Convert User to HashMap for storage
30
    UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
31
    Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
32
            CopyOptions.create()
33
                    .setIgnoreNullValue(true)
34
                    .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
35
    // 7.3 Store
36
    String tokenKey = LOGIN_USER_KEY + token;
37
    stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
38
    // 7.4 Set token TTL
39
    stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);
40

41
    // 8. Return token
42
    return Result.ok(token);
43
}

1
public class RefreshTokenInterceptor implements HandlerInterceptor {
2

3
    private 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) throws Exception {
11
        // 1. Get token from request header
12
        String token = request.getHeader("authorization");
13
        if (StrUtil.isBlank(token)) {
14
            return true;
15
        }
16
        // 2. Get user from Redis by token
17
        String key  = LOGIN_USER_KEY + token;
18
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
19
        // 3. Check existence
20
        if (userMap.isEmpty()) {
21
            return true;
22
        }
23
        // 5. Convert hash to UserDTO
24
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
25
        // 6. Save user to ThreadLocal
26
        UserHolder.saveUser(userDTO);
27
        // 7. Refresh token TTL
28
        stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.MINUTES);
29
        // 8. Pass
30
        return true;
31
    }
32

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

1
public class LoginInterceptor implements HandlerInterceptor {
2

3
    @Override
4
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
5
        // 1. Check if needs to intercept (is there a user in ThreadLocal)
6
        if (UserHolder.getUser() == null) {
7
            // Not present, intercept, set status
8
            response.setStatus(401);
9
            // Intercept
10
            return false;
11
        }
12
        // 2. Present, pass
13
        return true;
14
    }
15
}

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

6
    if(StrUtil.isNotBlank(shopJson)) {
7
        Shop shop = JSONUtil.toBean(shopJson,Shop.class);
8
        return Result.ok(shop);
9
    }
10
    Shop shop = getById(id);
11
    if(shop == null) {
12
        return Result.fail("店铺不存在!");
13
    }
14
    stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),
15
            RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
16

17
    return Result.ok(shop);
18
}

1
// Query add expiration
2
stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),
3
        RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
4

5
// Add update method
6
@Override
7
@Transactional
8
public Result update(Shop shop) {
9
    Long id = shop.getId();
10
    if (id == null) {
11
        return Result.fail("店铺id不能为空");
12
    }
13
    updateById(shop);
14

15
    stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + id);
16
    return Result.ok();
17

18
}

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

6
    if(StrUtil.isNotBlank(shopJson)) {
7
        Shop shop = JSONUtil.toBean(shopJson,Shop.class);
8
        return Result.ok(shop);
9
    }
10
    // Check if cached null
11
    if(shopJson != null) {
12
        return Result.fail("店铺信息不存在");
13
    }
14

15
    Shop shop = getById(id);
16
    if(shop == null) {
17
        // Write a null to cache
18
        stringRedisTemplate.opsForValue().set(key,"",
19
                RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
20
        return Result.fail("店铺不存在!");
21
    }
22
    stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),
23
            RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
24

25
    return Result.ok(shop);
26
}

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
        // set logical expiration
19
        RedisData redisData = new RedisData();
20
        redisData.setData(value);
21
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
22
        // write to 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. query Redis
30
        String json = stringRedisTemplate.opsForValue().get(key);
31
        // 2. check
32
        if (StrUtil.isNotBlank(json)) {
33
            // 3. exists, return
34
            return JSONUtil.toBean(json, type);
35
        }
36
        // check if empty value
37
        if (json != null) {
38
            // return null
39
            return null;
40
        }
41

42
        // 4. not exist, query DB
43
        R r = dbFallback.apply(id);
44
        // 5. not exist
45
        if (r == null) {
46
            // cache null
47
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
48
            return null;
49
        }
50
        // 6. exist, write to Redis
51
        this.set(key, r, time, unit);
52
        return r;
53
    }
54

55
    public <R, ID> R queryWithLogicalExpire(
56
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
57
        String key = keyPrefix + id;
58
        // 1. query cache
59
        String json = stringRedisTemplate.opsForValue().get(key);
60
        // 2. check
61
        if (StrUtil.isBlank(json)) {
62
            return null;
63
        }
64
        // 4. hit, deserialize
65
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
66
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
67
        LocalDateTime expireTime = redisData.getExpireTime();
68
        // 5. check expiration
69
        if(expireTime.isAfter(LocalDateTime.now())) {
70
            return r;
71
        }
72
        // 6. expired: rebuild
73
        String lockKey = LOCK_SHOP_KEY + id;
74
        boolean isLock = tryLock(lockKey);
75
        if (isLock){
76
            CACHE_REBUILD_EXECUTOR.submit(() -> {
77
                try {
78
                    R newR = dbFallback.apply(id);
79
                    this.setWithLogicalExpire(key, newR, time, unit);
80
                } catch (Exception e) {
81
                    throw new RuntimeException(e);
82
                }finally {
83
                    unlock(lockKey);
84
                }
85
            });
86
        }
87
        return r;
88
    }
89

90
    public <R, ID> R queryWithMutex(
91
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
92
        String key = keyPrefix + id;
93
        // 1. query Redis
94
        String shopJson = stringRedisTemplate.opsForValue().get(key);
95
        // 2. check
96
        if (StrUtil.isNotBlank(shopJson)) {
97
            // 3. exists
98
            return JSONUtil.toBean(shopJson, type);
99
        }
100
        // check if empty
101
        if (shopJson != null) {
102
            return null;
103
        }
104

105
        // 4. rebuild
106
        String lockKey = LOCK_SHOP_KEY + id;
107
        R r = null;
108
        try {
109
            boolean isLock = tryLock(lockKey);
110
            if (!isLock) {
111
                Thread.sleep(50);
112
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
113
            }
114
            r = dbFallback.apply(id);
115
            if (r == null) {
116
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
117
                return null;
118
            }
119
            this.set(key, r, time, unit);
120
        } catch (InterruptedException e) {
121
            throw new RuntimeException(e);
122
        }finally {
123
            unlock(lockKey);
124
        }
125
        return r;
126
    }
127

128
    private boolean tryLock(String key) {
129
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
130
        return BooleanUtil.isTrue(flag);
131
    }
132

133
    private void unlock(String key) {
134
        stringRedisTemplate.delete(key);
135
    }
136
}

1
@Component
2
public class RedisIdWorker {
3
    /**
4
     * Starting timestamp
5
     */
6
    private static final long BEGIN_TIMESTAMP = 1640995200L;
7
    /**
8
     * Bits for the sequence
9
     */
10
    private static final int COUNT_BITS = 32;
11

12
    private StringRedisTemplate stringRedisTemplate;
13

14
    public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
15
        this.stringRedisTemplate = stringRedisTemplate;
16
    }
17

18
    public long nextId(String keyPrefix) {
19
        // 1. Generate timestamp
20
        LocalDateTime now = LocalDateTime.now();
21
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
22
        long timestamp = nowSecond - BEGIN_TIMESTAMP;
23

24
        // 2. Generate sequence
25
        // 2.1. Get current date, daily granularity
26
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
27
        // 2.2. Auto-increment
28
        long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);
29

30
        // 3. Assemble and return
31
        return timestamp << COUNT_BITS | count;
32
    }
33
}

1
@Override
2
@Transactional
3
public void addSeckillVoucher(Voucher voucher) {
4
    // Save voucher
5
    save(voucher);
6
    // Save seckill info
7
    SeckillVoucher seckillVoucher = new SeckillVoucher();
8
    seckillVoucher.setVoucherId(voucher.getId());
9
    seckillVoucher.setStock(voucher.getStock());
10
    seckillVoucher.setBeginTime(voucher.getBeginTime());
11
    seckillVoucher.setEndTime(voucher.getEndTime());
12
    seckillVoucherService.save(seckillVoucher);
13
    // Save stock to Redis
14
    stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());
15
}

1
@Override
2
public Result seckillVoucher(Long voucherId) {
3
    // 1. Query voucher
4
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
5
    // 2. Check if seckill started
6
    if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
7
        // Not started yet
8
        return Result.fail("秒杀尚未开始！");
9
    }
10
    // 3. Check if seckill ended
11
    if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
12
        // Already ended
13
        return Result.fail("秒杀已经结束！");
14
    }
15
    // 4. Check stock
16
    if (voucher.getStock() < 1) {
17
        // Out of stock
18
        return Result.fail("库存不足！");
19
    }
20
    //5, Deduct stock
21
    boolean success = seckillVoucherService.update()
22
            .setSql("stock= stock -1")
23
            .eq("voucher_id", voucherId).update();
24
    if (!success) {
25
        // Deduction failed
26
        return Result.fail("库存不足！");
27
    }
28
    //6. Create order
29
    VoucherOrder voucherOrder = new VoucherOrder();
30
    // 6.1 Order ID
31
    long orderId = redisIdWorker.nextId("order");
32
    voucherOrder.setId(orderId);
33
    // 6.2 User ID
34
    Long userId = UserHolder.getUser().getId();
35
    voucherOrder.setUserId(userId);
36
    // 6.3 Voucher ID
37
    voucherOrder.setVoucherId(voucherId);
38
    save(voucherOrder);
39

40
    return Result.ok(orderId);
41
}

1
boolean success = seckillVoucherService.update()
2
    .setSql("stock= stock -1")
3
    .eq("voucher_id", voucherId)
4
    .gt("stock",0)
5
    .update(); //where id = ? and stock > 0

1
// 5. One person, one order logic
2
// 5.1. User ID
3
Long userId = UserHolder.getUser().getId();
4
int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
5
// 5.2. Check existence
6
if (count > 0) {
7
    // User has already purchased
8
    return Result.fail("用户已经购买过一次！");
9
}

1
<!-- maven -->
2
<dependency>
3
    <groupId>org.aspectj</groupId>
4
    <artifactId>aspectjweaver</artifactId>
5
</dependency>
6

7
// Service
8
synchronized(userId.toString().intern()) {
9
    // Get proxy object (transaction)
10
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
11
    return proxy.createVoucherOrder(voucherId);
12
}
13

14
@Transactional
15
public Result createVoucherOrder(Long voucherId) {
16
    // 5. One person, one order logic
17
    // 5.1. User ID
18
    Long userId = UserHolder.getUser().getId();
19

20
    int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
21
    // 5.2. Check existence
22
    if (count > 0) {
23
        // User has already purchased
24
        return Result.fail("用户已经购买过一次！");
25
    }
26

27
    //5, Deduct stock
28
    boolean success = seckillVoucherService.update()
29
            .setSql("stock= stock -1")
30
            .eq("voucher_id", voucherId)
31
            .gt("stock",0)
32
            .update(); //where id = ? and stock > 0
33
    if (!success) {
34
        // Deduction failed
35
        return Result.fail("库存不足！");
36
    }
37
    //6. Create order
38
    VoucherOrder voucherOrder = new VoucherOrder();
39
    // 6.1: Order ID
40
    long orderId = redisIdWorker.nextId("order");
41
    voucherOrder.setId(orderId);
42
    // 6.2: User ID
43
    voucherOrder.setUserId(userId);
44
    // 6.3: Voucher ID
45
    voucherOrder.setVoucherId(voucherId);
46
    save(voucherOrder);
47
    return Result.ok(orderId);
48

49
}

1
XGROUP CREATE stream.orders g1 0 MKSTREAM # Create message queue

1
private class VoucherOrderHandler implements Runnable {
2

3
    @Override
4
    public void run() {
5
        while (true) {
6
            try {
7
                // 1. Fetch order info from stream
8
                List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
9
                    Consumer.from("g1", "c1"),
10
                    StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
11
                    StreamOffset.create("stream.orders", ReadOffset.lastConsumed())
12
                );
13
                // 2. Check if there is data
14
                if (list == null || list.isEmpty()) {
15
                    // No messages
16
                    continue;
17
                }
18
                // Parse data
19
                MapRecord<String, Object, Object> record = list.get(0);
20
                Map<Object, Object> value = record.getValue();
21
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
22
                // 3. Create order
23
                createVoucherOrder(voucherOrder);
24
                // 4. Acknowledge
25
                stringRedisTemplate.opsForStream().acknowledge("s1", "g1", record.getId());
26
            } catch (Exception e) {
27
                log.error("处理订单异常", e);
28
                // Handle exceptional messages
29
                handlePendingList();
30
            }
31
        }
32
    }
33

34
    private void handlePendingList() {
35
        while (true) {
36
            try {
37
                // 1. Get pending list
38
                List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
39
                    Consumer.from("g1", "c1"),
40
                    StreamReadOptions.empty().count(1),
41
                    StreamOffset.create("stream.orders", ReadOffset.from("0"))
42
                );
43
                // 2. Check
44
                if (list == null || list.isEmpty()) {
45
                    break;
46
                }
47
                // Parse
48
                MapRecord<String, Object, Object> record = list.get(0);
49
                Map<Object, Object> value = record.getValue();
50
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
51
                // 3. Create order
52
                createVoucherOrder(voucherOrder);
53
                // 4. Acknowledge
54
                stringRedisTemplate.opsForStream().acknowledge("s1", "g1", record.getId());
55
            } catch (Exception e) {
56
                log.error("处理pendding订单异常", e);
57
                try{
58
                    Thread.sleep(20);
59
                }catch(Exception e){
60
                    e.printStackTrace();
61
                }
62
            }
63
        }
64
    }
65
}