0%

基本框架增加优惠券业务

一、秒杀业务note重点

I 短信登录

1.1 Redis替换Session的具体细节和操作流程

1.存储短信验证码时,key-value分别是phone和code,均为String类型(唯一性、方便携带),存储User对象时,采用hash类型(json格式数据)

2.存储用户数据/需要返回给前端时,用phone作key不合适,暴露隐私,在后台生成一个随机串token(利用令牌技术)设置过期时间,完成识别认证

3.利用UUID随机生成token,将User对象转为Map(定制 beanToMap 转换行为),将每个字段的值转换为 String 类型,存储后返回token

1.2 状态登录刷新解决方案

设置两个拦截器,第一个拦截器拦截所有路径(拦截而不处理return true),仅用于刷新token时间,同时将前来认证/访问的User放入ThreadLocal(利用UserHolder,自定义的工具类,存放读取线程池的信息);

第二个拦截器做真正的拦截功能,拦截所有需要登录才能访问的路径,随后注册配置两个拦截器,注意先执行第一个拦截器,配置order

II 商户查询缓存

2.1 缓存更新策略、双写一致

原本的添加缓存的机制为,提交商铺id、查询缓存、命中返回商铺信息,未命中去数据库查(数据库不存在该商铺返回404)、存在该商铺写入Redis,返回商铺信息

内存数据有限宝贵,不可以redis插入太多数据,适当更新机制:

内存淘汰:自动进行,redis内存达到设定的max-memery的时候,会自动触发淘汰机制,淘汰掉一些不重要的数据(可以自己设置策略方式)

超时剔除:给redis设置了过期时间ttl之后,redis会将超时的数据进行删除

主动更新:手动调用方法把缓存删掉,通常用于解决缓存和数据库不一致问题

低一致性需求:内存淘汰

高一致性需求:主动更新为主、超时为辅

解决一致性问题

数据库数据域发生变化后,缓存数据没有同步,产生一致性问题

解决方式:主动更新,实现方案:

Cache Aside Pattern 缓存调用者在更新完数据库后去更新缓存,称之为双写方案(主要采用)

利用缓存服务:

Read/Write Through Pattern : 由系统本身完成,数据库与缓存的问题交由系统本身去处理,调用者无需关心一致性

Write Behind Caching Pattern :调用者只操作缓存,其他线程去异步处理数据库,实现最终一致

双写一致方案

采用双写一致方案,明确操作内容:

1.每次更新动作是直接删除缓存,而非更新

2.缓存与数据库的操作的同时成功或失败,采用一个事务

3.先操作数据库,再删除缓存,why:

  • 方案一:两个线程并发来访问时,线程1先来,删除缓存还没来得及更新数据库;此时线程2查询缓存数据并不存在,故查询旧数据库获取旧数据写入缓存;线程1再执行更新数据库动作时,造成数据库和缓存不一致
  • 方案二:当缓存失效时(时间等各原因),线程1查发现没有,查数据库旧数据,此时线程2先更新数据库改为新数据,然后删除缓存(本来就是空)相当于没删,此时线程1来写缓存,写的是旧数据(但发生的概率较小,先更新数据库)

1653323595206

住:写缓存是ums级别的,但数据库操作比写缓存时间多很多

实现:

查询操作:在ShopServiceImpl的queryById方法中:设置redis缓存时添加过期时间

修改确保双写一致操作:在update方法中,先更新数据库再删除缓存

2.2 缓存穿透问题

缓存穿透是指客户端恶意请求数据在缓存中和数据库中都不存在,这些请求都会打到数据库。

解决方案:

  • 缓存空对象:访问数据库也不存在的数据时,把这个数据存入到redis中,给null,下次来访问直接返回个null
    • 实现简单,额外内存消耗,缓存中需要存储 带TTL的null,短期不一致(后来此字段出现了)
  • 布隆过滤:在客户端访问到达redis前,设置布隆过滤器,哈希思想,通过一个庞大的二进制数组,判断当前这个要查询的这个数据是否存在(存在放行,不存在拒绝)
    • 内存占用较少,没有多余key,实现复杂,误判可能

主动解决方案:

  • 增强id的复杂度
  • 避免被猜测id规律
  • 做好数据的基础格式校验
  • 加强用户权限校验
  • 做好热点参数的限流

缓存空对象解决

原本:发现这个数据在mysql中不存在,直接就返回404

现在:会把这个数据写入到Redis中,并且将value设置为"",再次查询时,判断value为null,则为之前写的空数据,直接返回;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
     // 1、从redis中查询商铺缓存
String shopJson = stringRedisTemplate.opsForValue().get("key");
// 2、判断是否存在
if (StrUtil.isNotBlank(shopJson)) {
// 存在,直接返回
return JSONUtil.toBean(shopJson, Shop.class);
}
//判断命中的值是否是空值,说明此时shopJson有值,但是为blank(上一步没判断出来的),是奇怪的
if (shopJson != null) {
//返回一个错误信息
return null;
}
// 5.不存在,采用缓存空对象解决
if(shop == null){
//将空值写入redis
stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
//返回错误信息
return null;
}


2.3 缓存击穿问题

缓存击穿问题也叫热点Key问题,某个被高并发访问并且缓存重建业务较复杂的key突然失效了,无数的请求访问会在瞬间给数据库带来巨大的冲击。

线程1查询缓存,未命中,去查询数据库然后重建缓存数据(耗费时间较长),在此过程中,若干线程执行同线程1的操作,同时在访问数据库执行重建操作;

解决方案:

互斥锁

锁能实现互斥性,第一个查询未命中的线程在重建的时候获得锁的资源,其他之后的线程来没有锁的资源,无法访问到数据库,只能休眠等待(定期回到查询缓存步骤),直到线程1释放锁。

  • 让查询的性能从并行变成了串行,只能一个线程在操作,其他在休眠,效率低;死锁风险
  • 实现简单,无额外内存消耗
  • 牺牲可用性,保证一致性

实现思路:

1653357860001

核心思路:

  • 获取锁的方式:利用redis的setnx方法(redis中如果没有这个key,则插入成功,返回1/true,如果存在这个key,则插入失败)
  • 利用key-"1",setIfAbsent方法,如果存在这个资源则不会操作,成功插入key的线程认为获得了锁;删除这个key-value即代表释放锁
1
2
3
4
5
6
7
8
9
10
11
12
13
String lockKey = "lock:shop:" + id;
boolean isLock = tryLock(lockKey);
// 4.2 判断否获取成功
if(!isLock){
//4.3 失败,则休眠重试
Thread.sleep(50);
return queryWithMutex(id);
}
//4.4 成功,根据id查询数据库
shop = getById(id);
......
// 释放互斥锁
unlock(lockKey);

逻辑过期

逻辑过期:为key-value不设置实际的TTL,存储他们的时候采用一个expireTime字段,每次都需要判断value中的过期时间是否满足,如果没有过期,则直接返回redis中的数据,如果过期,则当前线程直接返回过期数据,同时开启一个独立线程,独立线程去获取锁重构数据,重构完成后释放互斥锁。

  • 线程读取过程中不需要等待,性能好,有一个额外的线程持有锁去进行重构数据
  • 不保证一致性,有额外的内存消耗,且实现复杂
  • 牺牲一致性,提高性能

实现思路:

1653360308731

核心思路:

现在redis中存储的数据的value需要带上过期时间,采用组合方式,对原来代码没有侵入性:

新定义一个实体类:

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

修改ShopServiceImpl代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// 2.判断是否存在
if (StrUtil.isBlank(json)) {
// 3.存在,直接返回
return null;
}
// 4.命中,需要先把json反序列化为对象
RedisData redisData = JSONUtil.toBean(json, RedisData.class);
Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
LocalDateTime expireTime = redisData.getExpireTime();
// 5.判断是否过期
if(expireTime.isAfter(LocalDateTime.now())) {
// 5.1.未过期,直接返回店铺信息
return shop;
}
// 5.2.已过期,需要缓存重建,开启新线程获取互斥锁重建
String lockKey = LOCK_SHOP_KEY + id;
boolean isLock = tryLock(lockKey);
// 6.2.判断是否获取锁成功
if (isLock){
CACHE_REBUILD_EXECUTOR.submit( ()->{

try{
//重建缓存
this.saveShop2Redis(id,20L);
}catch (Exception e){
throw new RuntimeException(e);
}finally {
unlock(lockKey);
}
});
}
// 6.4.返回过期的商铺信息
return shop;

2.4 缓存雪崩问题

缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机,导致大量请求到达数据库,带来巨大压力。(服务器本身的问题)

解决方案:

  • 给不同的Key的TTL添加随机值(避免TTL一起到期)
  • 利用Redis集群提高服务的可用性(Redis哨兵机制)
  • 给缓存业务添加降级限流策略
  • 给业务添加多级缓存(不仅在service缓存,nginx也可以缓存,数据库等)

2.5 封装Redis工具类

泛型是 Java 中引入的一种 参数化类型,让类、接口和方法可以使用 不确定的数据类型,泛型可以实现:代码重用、类型安全、增强可读性

泛型通常通过 <T>、<R> 等尖括号包裹的字母表示,其中:

  • T:表示类型(Type)。
  • R:表示返回类型(Return)。
  • ID:可以表示输入的参数类型(例如 ID)

基于StringRedisTemplate封装一个缓存工具类,满足下列需求:

  • 方法1:将任意Java对象序列化为json并存储在string类型的key中,并且可以设置TTL过期时间

  • 方法2:将任意Java对象序列化为json并存储在string类型的key中,并且可以设置逻辑过期时间,用于处理缓存击穿问题

  • 方法3:根据指定的key查询缓存,并反序列化为指定类型,利用缓存空值的方式解决缓存穿透问题

  • 方法4:根据指定的key查询缓存,并反序列化为指定类型,需要利用逻辑过期解决缓存击穿问题

  • 方法5:根据指定的key查询缓存,并反序列化为指定类型,需要利用互斥锁解决缓存击穿问题

将逻辑进行封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
@Slf4j
@Component
public class CacheClient {

private final StringRedisTemplate stringRedisTemplate;
// 设置十个线程
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

public CacheClient(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
// 方法1:设置过期时间
public void set(String key, Object value, Long time, TimeUnit unit) {
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
}
// 方法2:设置逻辑过期时间
public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
// 设置逻辑过期
RedisData redisData = new RedisData();
redisData.setData(value);
redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
// 写入Redis
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}
// 方法3,利用泛型手段,不局限于Shop类型
public <R,ID> R queryWithPassThrough(
String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
String key = keyPrefix + id;
// 1.从redis查询商铺缓存
String json = stringRedisTemplate.opsForValue().get(key);
// 2.判断是否存在
if (StrUtil.isNotBlank(json)) {
// 3.存在,直接返回
// type 用来帮助框架或工具进行对象的反序列化,即将字符串或JSON 转换为具体的对象类型R(type告诉方法:把 JSON 转换成 R 类型的对象)
return JSONUtil.toBean(json, type);
}
// 判断命中的是否是空值
if (json != null) {
// 返回一个错误信息
return null;
}

// 4.不存在,根据id查询数据库
// 接受参数 ID 并返回 R 类型的函数
R r = dbFallback.apply(id);
// 5.不存在,返回错误
if (r == null) {
// 将空值写入redis
stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
// 返回错误信息
return null;
}
// 6.存在,写入redis
this.set(key, r, time, unit);
return r;
}
// 方法4:利用逻辑过期解决缓存击穿问题
public <R, ID> R queryWithLogicalExpire(
String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
String key = keyPrefix + id;
// 1.从redis查询商铺缓存
String json = stringRedisTemplate.opsForValue().get(key);
// 2.判断是否存在
if (StrUtil.isBlank(json)) {
// 3.存在,直接返回
return null;
}
// 4.命中,需要先把json反序列化为对象
RedisData redisData = JSONUtil.toBean(json, RedisData.class);
R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
LocalDateTime expireTime = redisData.getExpireTime();
// 5.判断是否过期
if(expireTime.isAfter(LocalDateTime.now())) {
// 5.1.未过期,直接返回店铺信息
return r;
}
// 5.2.已过期,需要缓存重建
// 6.缓存重建
// 6.1.获取互斥锁
String lockKey = LOCK_SHOP_KEY + id;
boolean isLock = tryLock(lockKey);
// 6.2.判断是否获取锁成功
if (isLock){
// 6.3.成功,开启独立线程,实现缓存重建
CACHE_REBUILD_EXECUTOR.submit(() -> {
try {
// 查询数据库
R newR = dbFallback.apply(id);
// 重建缓存
this.setWithLogicalExpire(key, newR, time, unit);
} catch (Exception e) {
throw new RuntimeException(e);
}finally {
// 释放锁
unlock(lockKey);
}
});
}
// 6.4.返回过期的商铺信息
return r;
}
// 方法5:利用互斥锁解决缓存击穿
public <R, ID> R queryWithMutex(
String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
String key = keyPrefix + id;
// 1.从redis查询商铺缓存
String shopJson = stringRedisTemplate.opsForValue().get(key);
// 2.判断是否存在
if (StrUtil.isNotBlank(shopJson)) {
// 3.存在,直接返回
return JSONUtil.toBean(shopJson, type);
}
// 判断命中的是否是空值
if (shopJson != null) {
// 返回一个错误信息
return null;
}

// 4.实现缓存重建
// 4.1.获取互斥锁
String lockKey = LOCK_SHOP_KEY + id;
R r = null;
try {
boolean isLock = tryLock(lockKey);
// 4.2.判断是否获取成功
if (!isLock) {
// 4.3.获取锁失败,休眠并重试
Thread.sleep(50);
return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
}
// 4.4.获取锁成功,根据id查询数据库
r = dbFallback.apply(id);
// 5.不存在,返回错误
if (r == null) {
// 将空值写入redis
stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
// 返回错误信息
return null;
}
// 6.存在,写入redis
this.set(key, r, time, unit);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}finally {
// 7.释放锁
unlock(lockKey);
}
// 8.返回
return r;
}
// 获得锁和释放锁
private boolean tryLock(String key) {
Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
return BooleanUtil.isTrue(flag);
}

private void unlock(String key) {
stringRedisTemplate.delete(key);
}
}

在ShopServiceImpl 中直接调方法Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);

III 优惠券秒杀

3.1 全局唯一ID

当用户抢购时,就会生成订单并保存到tb_voucher_order这张表中,而订单表如果使用数据库自增ID就存在一些问题:

  • id的规律性太明显
  • 受单表数据量的限制

全局ID生成器:为了增加ID的安全性,我们可以不直接使用Redis自增的数值,而是拼接一些其它信息:

1653363172079

永远为0

时间戳:31bit,以秒为单位,可以使用69年

序列号:32bit,秒内的计数器,支持每秒产生2^32个不同ID

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
// 1.生成时间戳
LocalDateTime now = LocalDateTime.now();
long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
long timestamp = nowSecond - BEGIN_TIMESTAMP;

// 2.生成序列号
// 2.1.获取当前日期,精确到天
String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
// 2.2.自增长
long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);

// 3.拼接并返回,右移后 或 count,比加效率高
return timestamp << COUNT_BITS | count;

3.2 秒杀下单超卖问题

数据库信息:

tb_voucher:优惠券的基本信息,优惠金额、使用规则等 tb_seckill_voucher:优惠券的库存、开始抢购时间,结束抢购时间。特价优惠券才需要填写这些信息

tb_order_voucher:订单表,在用户每次特价优惠券秒杀成功后,都会创建订单,在此表增加一项秒杀订单信息(订单id、用户id、代金券id)

秒杀下单思考:下单时需要判断两点:

  • 秒杀是否开始或结束,如果尚未开始或已经结束则无法下单
  • 库存是否充足,不足则无法下单

超卖问题:线程1过来查询库存,判断库存大于1,正准备去扣减库存,还没扣;此时线程2也去查询库存,发现数量也大于1,那么这两个线程都会去扣减库存,最终多个线程相当于一起去扣减库存,此时就会出现库存的超卖问题。(优惠券库存变为负数,订单表条目超过库存数量),超卖问题是典型的多线程安全问题

解决方案就是加锁:

  • 悲观锁:认为线程安全很重要,操作数据前必须先获得锁,确保数据的串行化执行,比如syn,和lock都是悲观锁的代表,同时,悲观锁中又可以再细分为公平锁,非公平锁,可重入锁,等等

  • 乐观锁:认为线程安全问题不一定会发生,因此不直接加锁。会有一个版本号version,每次操作数据会对版本号+1,再提交回数据时,会去校验是否比之前的版本大1 ,如果大1 ,则进行操作成功(如果大了其他,或version不对应了,证明数据被修改过)。乐观锁还有一些变种的处理方式比如cas

自旋操作(spin lock):如果一个线程正在尝试获取某个资源,但该资源当前被其他线程占用,它就会不断重复检查该资源的状态,直到资源可用

CAS(Compare-and-Swap)操作:一种常用的原子操作,主要用于解决多线程中的竞争条件,原子性保证了在多线程环境下的操作是线程安全

乐观锁解决超卖问题

实现时,是由seckillVouncher方法的最后,若库存充足则扣减库存,调用createVoucherOrder方法

VoucherOrderServiceImpl 在扣减库存时,createVoucherOrder函数中扣减部分改为:

1
2
3
boolean success = seckillVoucherService.update()
.setSql("stock= stock -1") //set stock = stock -1
.eq("voucher_id", voucherId).eq("stock",voucher.getStock()).update(); // where id = ? and stock = ?

以上逻辑的核心含义是:只要扣减库存时的库存和之前我查询到的库存是一样的,就意味着没有人在中间修改过库存;

但是以上这种方式通过测试发现会有很多失败的情况,原因:使用乐观锁过程中假设100个线程同时都拿到了100的库存,然后大家一起去进行扣减,但是100个人中只有1个人能扣减成功,其他的人在处理时,他们在扣减时,库存已经被修改过了,所以此时其他线程都会失败,导致商品虽然不会超卖,但也很多没卖出去,操作失败率高。

改成stock大于0

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

3.3 优惠券秒杀——一人一单问题——逐步加锁

现在的情况是一个人可以无限制的抢这个优惠卷(黄牛),要求同一个优惠券,一个用户只能下一单

实现思路:

1653371854389

在优惠券订单实现类的createVoucherOrder方法中,增加一人一单逻辑:函数上需要增加@Transactional事务注解(查询订单、扣减库存和创建订单一致性)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 5.一人一单逻辑
// 5.1.用户id
Long userId = UserHolder.getUser().getId();
int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
// 5.2.判断是否存在
if (count > 0) {
// 用户已经购买过了
return Result.fail("用户已经购买过一次!");
}
// 订单表中不存在的用户可以购买
//6.扣减库存
boolean success = seckillVoucherService.update()
.setSql("stock= stock -1")
.eq("voucher_id", voucherId).update();
if (!success) {
//扣减库存
return Result.fail("库存不足!");
}
//7.创建订单
VoucherOrder voucherOrder = new VoucherOrder();
// 7.1.订单id
long orderId = redisIdWorker.nextId("order");
voucherOrder.setId(orderId);

voucherOrder.setUserId(userId);
// 7.3.代金券id
voucherOrder.setVoucherId(voucherId);
save(voucherOrder);

return Result.ok(orderId);

存在问题:同一个用户id的多个线程并发过来,第一次购买,查询数据库,都不存在订单,都可以走到第六步购买;

针对这个问题,我们还是需要加锁,但是乐观锁比较适合更新数据(不同线程带来不同版本,解决超卖),而现在是插入数据(不同线程同时插入),所以我们需要使用悲观锁操作

  1. 封装了一个createVoucherOrder方法,在方法上增加synchronized锁,当前锁是this,当前对象,此方法实现查询订单,扣减库存,创建订单,返回结果

    1. 问题:锁的范围过大,任何用户来了都得等锁,而非是同一用户,粒度太粗了
    2. 在使用锁过程中,控制锁粒度 是一个非常重要的事情,因为如果锁的粒度太大,会导致每个线程进来都会锁住
  2. 加锁的时候按照用户ID来加,同一用户加一把锁,不同用户不同锁,获取到代码,然后synchronized(userId.toString().intern()){剩下代码},toString每次都是一个全新字符串,返回字符串的规范表示:从常量池中拿到数据,只按值判断;此时在方法内部加锁

    1. 问题:在方法内部加锁,在执行完逻辑代码,理论上锁已经释放了,其他线程可以进来,但是又有@transactional事务逻辑,若未提交事务时,其他线程面对的数据库还是之前的,仍然可以进来,产生订单安全问题
    2. 事务没提交而锁已经释放
  3. 故应该加在整个函数的外面,锁住整个函数:在seckillVoucher方法中,添加以下逻辑,先获取ID,然后锁住要返回的函数(创建订单),函数执行完,事务一定已经提交,数据库已经更新,释放的锁才能被其他进程正确使用。保证事务特效同时也控制了锁的粒度;

    1653373434815

    问题:调用的方法,其实是this.的方式调用的,事务想要生效,还得利用代理来生效

  4. Spring事务失效:事务是创建一个代理对象,对代理对象事务一致性操作;但是this.的方式调用的是非代理对象,目标对象;

    1. 需要拿到代理对象:

      1653383810643
  5. 需要引入asproxy依赖,加@Enable...注解设置为true才能生效

    ​ 还需要去掉sekillVouncher方法上面的注解

3.4 分布式集群环境的并发问题

通过加锁可以解决在单机情况下的一人一单安全问题,但是在集群模式下就不行了。

1、我们将服务启动两份,端口分别为8081和8082:

1653373887844

2、然后修改nginx的conf目录下的nginx.conf文件,配置反向代理和负载均衡:

1653373908620

有关锁失效原因分析

由于现在我们部署了多个tomcat,每个tomcat都有一个属于自己的jvm,同一JVM内部锁维护锁监视器对象(user_id),利用同一常量池的id是可以实现互斥,但此时服务器JVM不一样时,又有两个线程但是却不是同一个锁监视器,故线程1和线程3就可以是同一个用户

1653374044740

故要使用跨集群的锁——分布式锁

3.5 分布式锁——simpleLock(自己实现)

分布式锁需要满足:多进程可见、互斥、高可用、高并发(高性能)、安全性

分布式锁:满足分布式系统或集群模式下多进程可见并且互斥的锁,原本一个JVM一个锁监视器,现在统一用一个锁监视器了

常见分布式锁:

Mysql:本身互斥锁机制,性能一般;Redis:常见方式,setnx方法,插入Key成功则成功获得锁,后续的人无法成功插入这个数据;Zookeeper:利用节点有序性和唯一性实现互斥

Redis实现:

获取锁:互斥(一次只能一个获取)、非阻塞(尝试一次、成功true,失败false,无法再重试)

释放锁:手动释放、超时释放(超时时间)

3.5.1 核心思路与基本实现

setNx 方法:有多个线程进入时,第一个线程进入时,setnx key value,其中key是携带用户id信息的,可以创建成功,即获取了锁,返回1,去执行业务,后删除锁delete key实现退出锁逻辑;其他线程无法再设置这个key,执行返回0,需要等待一定时间后重试setnx。

  • 加锁逻辑

utils下增加:接口:ILock

实现两个方法boolean tryLock(传入锁持有时间,过期自动释放)和void unlock()

utils下增加:SimpleRedisLock实现ILock

有参构造,传入name和redistemplate实例化对象,

tryLock:获取线程标识,利用setnx方法进行加锁,同时增加过期时间,防止死锁,此方法可以保证加锁和增加过期时间具有原子性(setnx expire 一起执行)

1
2
3
4
5
6
7
8
9
10
private static final String KEY_PREFIX="lock:"
@Override
public boolean tryLock(long timeoutSec) {
// 获取线程标示
String threadId = Thread.currentThread().getId()
// 获取锁
Boolean success = stringRedisTemplate.opsForValue()
.setIfAbsent(KEY_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
return Boolean.TRUE.equals(success);
}
  • 释放锁逻辑:

直接删除stringRedisTemplate.delete(KEY_PREFIX + name);

  • 设计完工具方法后,修改vouncherOrderService实现类的seckillVoncher方法:

在发现库存充足后,此时不需要在proxy.createVoucherOrder外部利用synchronized上锁了(用分布式锁了,更高级,不需要刚才实现的防止一人一单的方法了)但是:分布式锁确保了同一时间只有一个用户能执行 createVoucherOrder 方法,而事务管理确保了方法执行过程中的一致性和原子性,所以此时仍需要代理对象

在判断库存后面上锁:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 4.判断库存是否充足
if (voucher.getStock() < 1) {
// 库存不足
return Result.fail("库存不足!");
}
Long userId = UserHolder.getUser().getId();
// 创建锁对象(新增代码)
SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
// 获取锁对象,加锁1200秒
boolean isLock = lock.tryLock(1200);
// 加锁失败:证明同一用户正在下单了
if (!isLock) {
return Result.fail("不允许重复下单");
}
try {
//获取代理对象(事务):执行查询订单、扣减库存、创建订单
IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
return proxy.createVoucherOrder(voucherId);
} finally {
//释放锁
lock.unlock();
}

3.5.2 误删问题

问题:我们设置了锁的自动过期时间,若持有锁的线程1在锁的内部出现了阻塞,导致他的锁自动释放,被其他线程获取;但线程1本身并不知晓,阻塞结束后继续执行本身逻辑,完成逻辑后删除锁(释放锁),此时删除的是属于线程2刚才获取的锁,这就是误删别人锁的情况;

解决方案:每个线程释放锁的时候,去判断一下当前这把锁是否属于自己,属于自己则可以释放,是属于自己,证明已经被释放了,此时不删除锁。

1653385920025

实现方案:集群的模式下,直接利用threadID,不同JVM可能相同,因此在获取锁时存入线程标示(可以用该线程UUID + 线程ID),此时再拼接同一JVM的不同线程ID

UUID:全局唯一的标识符,区分不同的 JVM 实例

修改tryLock和unLock代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 当前JVM的唯一标识
private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
@Override
public boolean tryLock(long timeoutSec) {
// 获取线程标示
String threadId = ID_PREFIX + Thread.currentThread().getId();
// 获取锁
Boolean success = stringRedisTemplate.opsForValue()
.setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
return Boolean.TRUE.equals(success);
}

public void unlock() {
// 获取线程标示
String threadId = ID_PREFIX + Thread.currentThread().getId();
// 获取锁中的标示
String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
// 判断标示是否一致
if(threadId.equals(id)) {
// 释放锁
stringRedisTemplate.delete(KEY_PREFIX + name);
}
}

3.5.3 原子性问题——Lua脚本

误删问题2:阻塞发生在线程判断标识一致和释放锁之间:线程1持有锁后执行业务逻辑,结束后他准备删除锁,此时发生阻塞,线程1锁在阻塞过程中到期已经自动释放。此时线程2进来,线程1阻塞完后会删除当前线程2获取的锁(因为他刚刚判断了锁是自己的,但是没来得及删),这就是删锁时的原子性问题。

本质:线程1的拿锁,比锁,删锁,并不是原子性

1653387764938

Redis提供了Lua脚本功能,在一个脚本中编写多条Redis命令,确保多条命令执行时的原子性。

重点介绍Lua脚本中Redis提供的调用函数,语法如下:

1
redis.call('命令名称', 'key', '其它参数', ...)

例如,我们要执行set name jack,则脚本是这样:

1
2
# 执行 set name jack
redis.call('set', 'name', 'jack')

例如,我们要先执行set name Rose,再执行get name,则脚本如下:

1
2
3
4
5
6
# 先执行 set name jack
redis.call('set', 'name', 'Rose')
# 再执行 get name
local name = redis.call('get', 'name')
# 返回
return name

写好脚本以后,需要用Redis命令来调用脚本

脚本中的key、value不想写死,可以作为参数传递。key类型参数会放入KEYS数组,其它参数会放入ARGV数组,在脚本中可以从KEYS和ARGV数组获取这些参数:

1653392438917

之前释放锁的业务流程是这样的:

1.获取锁的唯一线程标识

2.比较是否和当前线程标识一致

3.一致则删除;不一致则直接over

Lua脚本实现:

线程标识是key-value中的value即UUID+线程标识,key是userID

1
2
3
4
5
6
7
8
9
-- 这里的 KEYS[1] 就是锁的key,这里的ARGV[1] 就是当前线程标示
-- 获取锁中的标示,判断是否与当前线程标示一致
-- 利用redis.call('GET', KEYS[1])先取Key(拼接lock:(order:userId传入))对应的value(锁的线程标识),与当前线程标识比较
if (redis.call('GET', KEYS[1]) == ARGV[1]) then
-- 一致,则删除锁
return redis.call('DEL', KEYS[1])
end
-- 不一致,则直接返回
return 0

在Java代码中调用Lua脚本:

RedisTemplate中,可以利用execute方法去执行lua脚本,参数对应关系就如下图股

1653393304844

Java代码

static 的作用是确保指示 Lua 脚本 的变量UNLOCK_SCRIPT 只被加载和初始化一次

静态代码块,它会在 类加载时自动执行,且只执行一次。它用于初始化静态变量 UNLOCK_SCRIPT,在静态代码块中被初始化为一个新的 DefaultRedisScript 对象,并且设置了 Lua 脚本的路径(unlock.lua)以及脚本的执行结果类型(Long.class)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// UNLOCK_SCRIPT是一个静态变量,它被声明为 static,它属于类本身,而不是类的实例,无论你创建多少个该类的实例,UNLOCK_SCRIPT 始终只有一个实例,UNLOCK_SCRIPT 只在类加载时初始化一次,且所有实例共享同一个对象,避免了重复的初始化操作(节省资源)
// final 关键字保证了 UNLOCK_SCRIPT 一旦被赋值就无法再改变它指向的对象。
private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
static {
UNLOCK_SCRIPT = new DefaultRedisScript<>();
UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
UNLOCK_SCRIPT.setResultType(Long.class);
}

public void unlock() {
// 释放锁的时候判断和删除一起做
// 调用lua脚本
stringRedisTemplate.execute(
UNLOCK_SCRIPT,
Collections.singletonList(KEY_PREFIX + name), //(脚本中的参数KEYS[1])
ID_PREFIX + Thread.currentThread().getId()); // (脚本中的参数ARGV[1])
}

小结:添加过期时间,防止死锁问题的发生,但可能出现到期以后误删别人锁的问题,开始是利用删之前对比锁标识和自己标识,但可能出现原子性问题也会误删,通过lua表达式来解决这个问题。

基于setnx分布式锁实现存在问题:

重入问题:获得锁的线程可以再次进入到相同的锁的代码块中,可重入锁的意义在于防止死锁,如A方法获得锁,调用B方法,而B方法也需要锁,则B在等待A释放,A调用的B未执行A没法释放,此时发生死锁;synchronized和Lock锁都是可重入的。

不可重试:目前的分布式中只能尝试一次,我们认为合理的情况是:当线程在获得锁失败后,他应该能再次尝试获得锁。

超时释放:加锁时增加了过期时间,这样的我们可以防止死锁,但是如果卡顿的时间超长,自己锁已经释放,存在安全问题;利用redission也可以实现到期续约,不会误删别人的锁;

主从一致性: 如果Redis提供了主从集群,当我们向集群写数据时,主机需要异步的将数据同步给从机,而万一在同步过去之前,主机宕机了,就会出现死锁问题。

1653546070602

3.6 分布式锁——redisson

3.6.1 Redisson介绍与应用

Redisson在Redis的基础上实现的Java驻内存数据网格(In-Memory Data Grid),是一个 Java Redis 客户端,它封装了 Redis 的基本操作,并且提供了许多高层次的抽象。Redisson 的目标是简化与 Redis 的交互,同时提供一些高级功能,如分布式锁、分布式集合、分布式缓存。简言之:Redis的儿子(增强版),更高级,交互更方便

引入依赖,注册配置客户端

使用案例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Resource // 引入Redisson客户端实例
private RedissionClient redissonClient;
@Test
void testRedisson() throws Exception{
//获取锁(可重入),指定锁的名称
RLock lock = redissonClient.getLock("anyLock");
//尝试获取锁,参数分别是:获取锁的最大等待时间(期间会重试),锁自动释放时间,时间单位
boolean isLock = lock.tryLock(1,10,TimeUnit.SECONDS);
//判断获取锁成功
if(isLock){
try{
System.out.println("执行业务");
}finally{
//释放锁
lock.unlock();
}
}
}

在 VoucherOrderServiceImpl注入RedissonClient

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Resource
private RedissonClient redissonClient;
// 在seckillVoucher函数块中部分核心代码:
// 4.判断库存是否充足
if (voucher.getStock() < 1) {
// 库存不足
return Result.fail("库存不足!");
}
Long userId = UserHolder.getUser().getId();
// 创建锁对象 下面代码不用了,因为我们现在要使用Redisson提供的锁,不用自己创建的simple锁了
//SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
RLock lock = redissonClient.getLock("lock:order:" + userId); // 锁的名称即key
// 获取锁对象
boolean isLock = lock.tryLock();

//加锁失败
if (!isLock) {
return Result.fail("不允许重复下单");
}
try {
//获取代理对象(事务)
IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
return proxy.createVoucherOrder(voucherId);
} finally {
//释放锁
lock.unlock();
}

利用以上RedissonClient提供的锁我们即可实现Reddision锁,解决上述的四个问题,下面我们剖析一下Reddisson实现这些功能的原理

3.6.2 Reddisson可重入、可重试、超时释放原理

** 可重入**

Lock锁中,借助于底层的一个voaltile(关键字,修饰变量确保该变量的值对所有线程可见的)的一个state变量来记录重入的状态的,无人拥有此锁state = 0,每有一个人拥有state + 1;对于synchronized而言,他在c语言代码中会有一个count,原理和state类似,直到减少成0 时,表示当前这把锁没有被人持有;

在redission中,支持可重入锁:采用hash结构用来存储锁,其中key表示这把锁是否存在,field表示当前这把锁被哪个线程持有(线程标识),value代表重入次数。分析源码:trylock调用tryLockAsync,返回 tryAcquireOnceAsync,函数中调用tryLockInnerAsync,其中存在lua表达式:

1
2
3
4
5
6
7
8
9
10
11
12
13
"if (redis.call('exists', KEYS[1]) == 0) then " +
"redis.call('hset', KEYS[1], ARGV[2], 1); " +
"redis.call('pexpire', KEYS[1], ARGV[1]); " +
"return nil; " +
"end; " +

"if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
"redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
"redis.call('pexpire', KEYS[1], ARGV[1]); " +
"return nil; " +
"end; " +

"return redis.call('pttl', KEYS[1]);"

参数:

KEYS[1] : 锁名称

ARGV[1]: 锁失效时间

ARGV[2]: id + ":" + threadId; 锁的小key,标识当前锁的被哪个线程持有

  • 首先进行判断:exists 判断Redis数据库中是否存在 name:如果==0,就表示当前这把锁不存在,可以获取锁:

    redis.call('hset', KEYS[1], ARGV[2], 1);此时他就开始往redis里边去写数据 ,hash结构,锁名称通常是用户ID(KEYS[1])-线程标识符或 UUID(ARGV[2]),数字1代表当前线程已经获得锁;pexpire 命令为锁设置一个过期时间,单位是毫秒最后返回nil;

  • 如果这把锁已经存在,hexists 命令检查这把锁是否是属于自己,即对比当前线程标识符ID和锁的标识符(key对应的value),如果是自己的,hincrby将当前这个锁的value进行+1 ,然后再对其设置过期时间redis.call('pexpire', KEYS[1], ARGV[1]);返回nil

  • 如果以上两个条件都不满足,即当前锁已被其他线程或进程占用且无法重入,脚本返回当前锁的剩余有效时间(pttl 命令返回的是锁的过期时间,单位毫秒;

整体:加锁(无人获取)、重入锁(同一线程已经获取了锁,可以就行获取,重入增加次数,延长过期时间)、锁的过期(持锁线程在过期时间内没有释放锁,其他线程可以重新获取该锁。)

1653548087334

** 可重试**

** 实现思路:**

  • 获取锁:
image-20241210123703596

ttl表示获取已有锁的过期时间,null表示当前没有已存在的锁,即可以成功获取锁;否则判断剩余等待时间,如果等待时间小于0了,则证明已经不需要等了,直接返回;如果大于0(证明还需要接着等),此时利用Lock的Pubsub订阅锁并等待释放,定期判断等待时间若超时则取消订阅并返回false,否则尝试获取;

leaseTime是释放时间(有效期),如果过了有效期,则可以重新获取锁,返回true;

如果在有效期内,则开启看门狗机制,watchDog不停更新锁的有效期

  • 释放锁:
image-20241210123803989

unlock相对简单很多,执行释放脚本,释放成功发送释放消息publish,取消watchDog任务

** 超时释放**

renewExpiration此逻辑就是续约逻辑

分析lock()方法的源码解析

抢锁过程中,获得当前线程,通过tryAcquire进行抢锁,该抢锁逻辑和之前逻辑相同

1、先判断当前这把锁是否存在,如果不存在,插入一把锁,返回null

2、判断当前这把锁是否是属于当前线程,如果是,则返回null

3、锁存在且不是这个线程,开始抢锁(尝试获取锁),即上面的执行流程图;

所以如果返回是null,则代表着当前该线程已经抢锁完毕,或者可重入完毕;但是如果以上两个条件都不满足,则进入到第三个条件,返回的是锁的失效时间,此时有个while( true) 再次进行tryAcquire进行抢锁

1
2
3
4
5
6
long threadId = Thread.currentThread().getId();
Long ttl = tryAcquire(-1, leaseTime, unit, threadId);
// lock acquired
if (ttl == null) {
return;
}

接下来会有一个条件分支,因为lock方法有重载方法,一个是带参数则leaseTime是他本身,一个是不带参数默认传入leaseTime = -1;leaseTime时间内都会去抢锁,抢锁过程的逻辑与之前相同。

如果是没有传入时间,则此时也会进行抢锁, 而且抢锁时间是默认看门狗时间 commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout()

ttlRemainingFuture.onComplete((ttlRemaining, e) 这句话相当于对以上抢锁进行了监听,也就是说当上边抢锁完毕后,此方法会被调用,具体调用的逻辑就是去后台开启一个线程,进行续约逻辑,也就是看门狗线程,续约逻辑代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(waitTime,
commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(),
TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
if (e != null) {
return;
}

// lock acquired
if (ttlRemaining == null) {
scheduleExpirationRenewal(threadId);
}
});
return ttlRemainingFuture;

commandExecutor.getConnectionManager().newTimeout()方法:Method( new TimerTask() {},参数2 ,参数3 )

通过参数2,参数3 去描述什么时候去做参数1的事情,现在的情况是:10s之后去做参数一的事情

因为锁的失效时间是30s,当10s之后,此时这个timeTask 就触发了,他就去进行续约,把当前这把锁续约成30s,如果操作成功,那么此时就会递归调用自己,再重新设置一个timeTask(),于是再过10s后又再设置一个timerTask,完成不停的续约

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
private void renewExpiration() {
ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
if (ee == null) {
return;
}

Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
@Override
public void run(Timeout timeout) throws Exception {
ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());
if (ent == null) {
return;
}
Long threadId = ent.getFirstThreadId();
if (threadId == null) {
return;
}

RFuture<Boolean> future = renewExpirationAsync(threadId);
future.onComplete((res, e) -> {
if (e != null) {
log.error("Can't update lock " + getName() + " expiration", e);
return;
}

if (res) {
// reschedule itself
renewExpiration();
}
});
}
}, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);

ee.setTimeout(task);
}

3.6.3 MutiLock应用

利用redission锁可以实现上述的功能,但无法实现主从一致性

Redis集群中,主节点:存数据;从节点:读数据。主从同步时,数据会有一定延时,如主节点获取锁,写在主节点的数据还没来得及写从节点上,此时主机宕机,哨兵发现,选举一个slave变成新的master,而此时新的master中实际上并没有锁信息,此时锁信息就已经丢掉了,其他线程可以获得锁了。

1653553998403

解决方案:redission提出来了MutiLock锁,使用这把锁每个节点地位一致,加锁的逻辑需要写入到每一个主丛节点上,只有所有的服务器都写入成功,此时才是加锁成功;若一个节点挂了,其他乘虚而入的进程获得锁的时候,只要有一个节点的拿不到,就不算加锁成功。

1653554055048

MultiLock加锁原理:

1653553093967

设置多个锁的时候,redisson将多个锁加入一个集合中,(在总的加锁时间内,这个时间是用需要加锁的个数 * 1500ms)并且while循环不断尝试拿锁,假设这时间内,所有的锁都加锁成功, 那么此时才算是加锁成功,如果在4500ms有线程加锁失败,则会再次去进行重试。

测试:test类中配置RedisClient中若干个主从节点redisClient1/2/3,给他们获取对应的lock1/2/3,创建multiLock,lock = redissonClient1/2/3.getMultiLock(lock1,lock2,lock3)

小结:Redis解决四个问题

  1. 可重入问题:同一线程(不同函数)可以调用自己的锁,获取锁:利用hash结构记录线程标识和重入次数;释放:每释放一次,重入-1,减为0,真正释放锁
  2. 锁失败重试问题:失败后可以重试获取,而不是直接false,利用信号量和pubsub订阅(发布-订阅模式)功能实现等待、唤醒、获取锁失败的重试机制,也非无限制重试,有等待时间;
  3. 锁超时释放(续约)问题:利用watchDog,开启定时任务,每隔一段时间重新配置expire,重置超时时间
  4. 主从一致性问题:利用multipleLock,分布式锁实现

此时我们便利用Redis解决四个问题:可重入问题、可重试、超时释放、主从一致性;至此,项目秒杀优惠券业务完成一人一单的优化,但是性能还可以做一定的优化

IV 秒杀优化

回顾一下购买优惠券下单流程:

用户发起请求,此时会请求nginx,nginx会访问到tomcat,而tomcat中的程序,会进行串行操作,分成如下几个步骤:

1、查询优惠卷

2、判断秒杀库存是否足够

3、查询订单

4、校验是否是一人一单

5、扣减库存

6、创建订单

其中,查询优惠券、查询订单、扣减库存和创建订单都是对数据库的直接操作,且在一个线程内串行执行,效率较低;需要异步执行加速

4.1 异步秒杀

4.1.1 思路

  1. 将耗时比较短的逻辑判断放入到redis中,判断是否库存足够及一人一单,快速的逻辑判断后,将下单信息存入消息队列,然后直接给用户返回成功;
  2. 再在后台开一个线程,后台线程从队列取出下单信息,去执行和数据库相关逻辑;

两大问题:

  • redis中去快速库存判断和校验一人一单
  • 由于校验和tomct下单是两个线程,如何知道到底是哪个单,以及最后是否成功

解决方案:库存判断利用key-value中的value,一人一单通过set集合区分该用户是否下过单;在redis操作完之后,我们会将一些信息(订单id)返回给前端,同时也会把这些信息丢到异步queue中去,后续操作中,可以通过这个id来查询我们tomcat中的下单逻辑是否完成了。

1653561657295

整体:用户下单->判断库存充足(不足结束)-> 校验一人一单(不是结束)-> 完成下单,扣除Redis库存,此后将用户id和优惠卷信息存入到redis(Lua 脚本实现原子性库存充足和校验需要原子性操作,否则超卖和重复下单)-> 对Redis操作完毕返回值(0代表成功,1代表超卖,-1代表重复下单)-> 成功即将刚才存入的信息放入queue,利用新线程异步下单

前端可以通过返回的订单id来判断是否下单成功,整体流程类似于饭店接单,服务员先接单给个小票(告诉顾客已经完成),同时告诉厨师可以炒了,厨师异步操作

1653562234886

4.1.2 Redis实现资格判断

实现资格判断时,核心在于:管理端保存优惠券到Redis,用户端下单的时候基于Lua脚本判断库存容量和一人一单、成功下单后将优惠券id和用户id封装后存入阻塞队列、开启线程任务不断从阻塞队列中获取信息实现异步下单,共四步任务,实现代码如下:

用户购买进入Vounchercontroller:

1
2
3
4
5
@PostMapping("seckill")
public Result addSeckillVoucher(@RequestBody Voucher voucher) {
voucherService.addSeckillVoucher(voucher);
return Result.ok(voucher.getId());
}

管理端增加优惠卷的时候,调用VoucherService接口,实现类VoucherServiceImpl中,实现保存优惠券到Redis:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override
@Transactional
public void addSeckillVoucher(Voucher voucher) {
// 保存优惠券
save(voucher);
// 保存秒杀信息
SeckillVoucher seckillVoucher = new SeckillVoucher();
seckillVoucher.setVoucherId(voucher.getId());
seckillVoucher.setStock(voucher.getStock());
seckillVoucher.setBeginTime(voucher.getBeginTime());
seckillVoucher.setEndTime(voucher.getEndTime());
seckillVoucherService.save(seckillVoucher);
// 保存秒杀库存到Redis中
//SECKILL_STOCK_KEY 这个变量定义在RedisConstans中
//private static final String SECKILL_STOCK_KEY ="seckill:stock:"
stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());
}

用户端下单购买优惠券的时候,会进入VouncherOrdercontroller:

1
2
3
4
@PostMapping("seckill/{id}")
public Result seckillVoucher(@PathVariable("id") Long voucherId) {
return voucherOrderService.seckillVoucher(voucherId);
}

传入优惠券ID,在VoucherOrderServiceImpl中,我们实现第二步:基于Lua脚本判断库存容量和一人一单

再次修改seckillVouncher代码:此时创建订单和判断是否下单成功是异步操作,Redis 操作和库存更新、订单创建是分离的,createVoucherOrder 方法已经独立,不依赖代理对象的事务支持或锁逻辑;故

  1. createVouncher方法不需要再通过代理对象调用,去掉proxy
  2. 此外,现在去掉了@Transactional,将分布式锁直接加在了createVouncher上,通过 Redis 校验和分布式锁减少了对事务的依赖

其实在Redis中我们已经判断一人一单和超卖问题了,因而无需在此时加锁再次判断,但为了以防万一,代码健壮性~,再次加锁再次判断一遍超卖和;

修改代码后,seckillVouncher仅用来对接用户:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 创建1024*1024的阻塞队列,ArrayBlockingQueue 是 Java 中的一个阻塞队列实现,基于 数组 实现
private BlockingQueue<VoucherOrder> orderTasks =new ArrayBlockingQueue<>(1024 * 1024);
@Override
public Result seckillVoucher(Long voucherId) {
//获取用户
Long userId = UserHolder.getUser().getId();
long orderId = redisIdWorker.nextId("order");
// 1.执行lua脚本
Long result = stringRedisTemplate.execute(
SECKILL_SCRIPT,
Collections.emptyList(),
voucherId.toString(), userId.toString(), String.valueOf(orderId)
);
int r = result.intValue();
// 2.判断结果是否为0
if (r != 0) {
// 2.1.不为0 ,代表没有购买资格
return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
}
// 2.2.为0 ,有购买资格,把下单信息保存到阻塞队列
VoucherOrder voucherOrder = new VoucherOrder();
// 2.3.订单id
long orderId = redisIdWorker.nextId("order");
voucherOrder.setId(orderId);
// 2.4.用户id
voucherOrder.setUserId(userId);
// 2.5.代金券id
voucherOrder.setVoucherId(voucherId);
// 2.6.放入阻塞队列
orderTasks.add(voucherOrder);

// 3.返回订单id
return Result.ok(orderId);
}

执行的Lua脚本实现判断库存容量和一人一单:

完整lua表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
-- 1.参数列表
-- 1.1.优惠券id
local voucherId = ARGV[1]
-- 1.2.用户id
local userId = ARGV[2]
-- 1.3.订单id
local orderId = ARGV[3]

-- 2.数据key
-- 2.1.库存key
local stockKey = 'seckill:stock:' .. voucherId
-- 2.2.订单key
local orderKey = 'seckill:order:' .. voucherId

-- 3.脚本业务
-- 3.1.判断库存是否充足 get stockKey
if(tonumber(redis.call('get', stockKey)) <= 0) then
-- 3.2.库存不足,返回1
return 1
end
-- 3.2.判断用户是否下单 SISMEMBER orderKey userId
if(redis.call('sismember', orderKey, userId) == 1) then
-- 3.3.存在,说明是重复下单,返回2
return 2
end
-- 3.4.扣库存 incrby stockKey -1
redis.call('incrby', stockKey, -1)
-- 3.5.下单(保存用户)sadd orderKey userId
redis.call('sadd', orderKey, userId)
-- 3.6.发送消息到队列中, XADD stream.orders * k1 v1 k2 v2 ...
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
return 0

seckill执行完以后,若可以创建订单,则开启另一个线程调用createVouncherOrder用来实现真正创建订单:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
private void createVoucherOrder(VoucherOrder voucherOrder) {
Long userId = voucherOrder.getUserId();
Long voucherId = voucherOrder.getVoucherId();
// 创建锁对象
RLock redisLock = redissonClient.getLock("lock:order:" + userId);
// 尝试获取锁
boolean isLock = redisLock.tryLock();
// 判断
if (!isLock) {
// 获取锁失败,直接返回失败或者重试
log.error("不允许重复下单!");
return;
}

try {
// 5.1.查询订单
int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
// 5.2.判断是否存在
if (count > 0) {
// 用户已经购买过了
log.error("不允许重复下单!");
return;
}

// 6.扣减库存
boolean success = seckillVoucherService.update()
.setSql("stock = stock - 1") // set stock = stock - 1
.eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
.update();
if (!success) {
// 扣减失败
log.error("库存不足!");
return;
}

// 7.创建订单
save(voucherOrder);
} finally {
// 释放锁
redisLock.unlock();
}
}

同步下单:判断有没有资格,执行业务加各种锁,业务执行完耗时较久

异步下单:业务分成两部分,一部分是Redis进行抢购资格的判断(如果有资格,则立即下单成功);耗时较久的下单部分(操作数据库)异步完成,放入阻塞队列

故接下来利用阻塞队列实现异步下单:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//异步处理线程池
private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

//在类初始化之后执行,因为当这个类初始化好了之后,随时都是有可能要执行的
@PostConstruct
private void init() {
SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}
// 用于线程池处理的任务
// 当初始化完毕后,就会去从对列中去拿信息
private class VoucherOrderHandler implements Runnable{

@Override
public void run() {
while (true){
try {
// 1.获取队列中的订单信息
VoucherOrder voucherOrder = orderTasks.take();
// 2.创建订单
createVouncherOrder(voucherOrder);
} catch (Exception e) {
log.error("处理订单异常", e);
}
}
}

线程池(SECKILL_ORDER_EXECUTOR):

  • 创建了一个单线程的线程池(Executors.newSingleThreadExecutor()),用于异步处理订单。
  • orderTasks 是一个阻塞队列,用于存储待处理的订单
  • 利用 @PostConstruct 注解,在 Spring 容器初始化该类后便会执行init方法, 调用submit方法将 VoucherOrderHandler 任务提交到线程池
  • VoucherOrderHandler 任务的核心逻辑:
    • while (true):保证线程池中的线程 持续运行,不停从队列中获取订单进行处理。
    • orderTasks.take():
      • 这是从阻塞队列中获取订单的逻辑,如果队列为空,take() 方法会阻塞线程,直到队列中有新的订单加入(实现高效的任务调度)。
    • createVoucherOrder(voucherOrder):取到订单后,调用 createVoucherOrder 方法完成实际的订单创建操作。

4.2 Redis消息队列

4.2.1 消息队列三种类型介绍

消息队列是JVM以外独立服务,解决内存问题;存入磁盘,且需要消费者确认,不然一直投递到消费者。

1653574849336

基于List结构模拟消息队列:Redis的list数据结构是一个双向链表,很容易模拟出队列效果

优点:

  • 利用Redis存储,不受限于JVM内存上限,基于Redis的持久化机制,数据安全性有保证
  • 可以满足消息有序性

缺点:

  • 无法避免消息丢失(从队列中取走未消费,想去再取发现没了)
  • 只支持单消费者

基于PubSub的消息队列:PubSub(发布订阅)是Redis2.0版本引入的消息传递模型,消费者可以订阅一个或多个channel,生产者向对应channel发送消息后,所有订阅者都能收到相关消息。

优点:

  • 采用发布订阅模型,支持多生产、多消费

缺点:

  • 不支持数据持久化(更像是一个通道,未被订阅则消失)
  • 无法避免消息丢失
  • 消息堆积有上限,超出时数据丢失(不在内存保存,数据在消费者有个缓存区域,做处理,处理较慢时空间超过则丢失)

基于Stream的消息队列:Redis 5.0 引入的一种新数据类型,可以实现一个功能非常完善的消息队列

4.2.2 基于Stream的消息队列实现

在业务开发中,我们可以循环的调用XREAD阻塞方式来查询最新消息,从而实现持续监听队列的效果,STREAM类型消息队列的XREAD命令特点:

  • 消息可回溯
  • 一个消息可以被多个消费者读取
  • 可以阻塞读取
  • 有消息漏读的风险

漏读:如果我们处理一条消息的过程中,又有超过1条以上的消息到达队列,则下次获取时也只能获取到最新的一条,会出现漏读消息的问题

解决方案:利用消费者组

消费者组(Consumer Group):将多个消费者划分到一个组中,监听同一个队列;可以进行消息分流,队列中的消息会分流给组内的不同消费者(组内消费者竞争)、消息标识,消费者组会维护一个标示,记录最后一个被处理的消息,哪怕消费者宕机重启,还会从标示之后读取消息。确保每一个消息都会被消费、消息确认,消费者获取消息后,消息处于pending状态,并存入一个pending-list。当处理完成后需要通过XACK来确认消息,标记消息为已处理,才会从pending-list移除。

创建消费者组: 1653577984924 key:队列名称 groupName:消费者组名称 ID:起始ID标示,$代表队列中最后一个消息,0则代表队列中第一个消息 MKSTREAM:队列不存在时自动创建队列

小结:

1653578560691

修改lua表达式,新增3.6 ,将消息发送到队列中,队列名称为stream.orders

1656082824939

修改VouncherOrderServiceImpl代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
private class VoucherOrderHandler implements Runnable {

@Override
public void run() {
while (true) {
try {
// 1.获取消息队列中的订单信息 XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS s1 >
List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
Consumer.from("g1", "c1"),
StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
StreamOffset.create("stream.orders", ReadOffset.lastConsumed())
);
// 2.判断订单信息是否为空
if (list == null || list.isEmpty()) {
// 如果为null,说明没有消息,继续下一次循环
continue;
}
// 解析数据
MapRecord<String, Object, Object> record = list.get(0);
Map<Object, Object> value = record.getValue();
VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
// 3.创建订单
createVoucherOrder(voucherOrder);
// 4.确认消息 XACK
stringRedisTemplate.opsForStream().acknowledge("s1", "g1", record.getId());
} catch (Exception e) {
log.error("处理订单异常", e);
//处理异常消息
handlePendingList();
}
}
}

其中 handlePendingList即用来处理异常订单,即没有被ACK标记已经处理的订单:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 private void handlePendingList() {
while (true) {
try {
// 1.获取pending-list中的订单信息 XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS s1 0
List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
Consumer.from("g1", "c1"),
StreamReadOptions.empty().count(1),
StreamOffset.create("stream.orders", ReadOffset.from("0"))
);
// 2.判断订单信息是否为空
if (list == null || list.isEmpty()) {
// 如果为null,说明没有异常消息,结束循环
break;
}
// 解析数据
MapRecord<String, Object, Object> record = list.get(0);
Map<Object, Object> value = record.getValue();
VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
// 3.创建订单
createVoucherOrder(voucherOrder);
// 4.确认消息 XACK
stringRedisTemplate.opsForStream().acknowledge("s1", "g1", record.getId());
} catch (Exception e) {
log.error("处理pendding订单异常", e);
try{
Thread.sleep(20);
}catch(Exception e){
e.printStackTrace();
}
}
}
}
}

至此,我们对于优惠券秒杀业务已经全部完成!下面是利用一些现成的mq,比如(kafka,rabbitmq)来实现消息队列,见五、RabbitMQ篇

二、新增业务数据库准备

涉及到优惠券秒杀业务的数据库有:

管理端表 employee :已经存在,实现增删优惠券

用户表 user: 已经存在,实现抢购秒杀优惠券

优惠券表voucher包括:优惠券标题、副标题、使用规则、支付金额、抵扣金额、劵类型、优惠券状态、创建时间和更新时间,实现记录优惠券信息

优惠券订单表voucher_order包括:下单用户的ID、购买优惠券ID、支付方式、订单状态、下单时间、支付时间、核销时间、退款时间、更新时间,实现记录用户抢购的优惠券订单,普通券没库存

秒杀券表voucher_seckill包括:关联的优惠券ID(主键)、库存、创建时间、生效时间、失效时间、更新时间、外键关联秒杀优惠券表,与优惠券是一对一关系

接口设计和实体类设计

管理端操作优惠券:实现如下功能

路径:http://localhost:8080/admin/voucher

  1. 添加普通券:路径不变、POST方式(传入VoucherDTO对象)、返回优惠券ID
  2. 添加秒杀券:路径:/seckill、Post方式(传入VoucherDTO对象,其中额外包括秒杀属性)、返回优惠券ID
  3. 分页查询优惠券列表:路径:/list、Get方式(传入VoucherPageQueryDTO),返回VoucherVO对象(包含voucher中部分属性:优惠券标题、副标题、使用规则、支付金额、抵扣金额、劵类型、优惠券状态)
  4. 下架优惠券,路径:/delete/{id}、DELETE方式,返回无,直接按照id删除对应优惠券

实体类:

public class Voucher :包含属性同数据库属性

public class VouncherSeckill:仅含秒杀券的属性

public class VouncherDTO:普通券表 + 秒杀券表的额外属性,去掉创建和更新时间

客户端:

查询优惠券,路径同前面

购买优惠券:路径http://localhost:8080/user/voucher/{id}、POST请求路径参数传入购买的用户券ID、返回购买的优惠券ID或购买失败信息;

public class VouncherOrder:与订单表对应

代码框架与实现思路

管理端(小):

controller层做接受信息,调用voucherService实现业务逻辑,在service中调用mapper实现数据库操作

  • 添加普通券:利用MybatisPlus在Service中直接实现save()

  • 添加秒杀券:调用service实现类,先利用mp添加优惠券,再保存秒杀信息,利用mp添加秒杀券

  • 查询优惠券订单:调用service的Query方法,利用mp自定义实体类实现

分页查询,利用插件设置分页参数,自动加入Limit语句(创建一个 Page 对象,这个 Page 对象用于 MyBatis Plus 的分页查询,它会自动计算 SQL 查询的分页偏移量 LIMIT),同时传入wrapper设置查询条件(注意if条件判断,如果没有就不加这个查询条件),返回Page<Voucher> 对象,它包含了查询结果和分页信息,再转换为voucherVO传给前端

传给前端时需要:new 一个PageResult对象

page.getTotal():获取分页结果的总记录数。

page.getRecords():获取分页后的数据记录(即 VoucherVO 对象的列表)。

  • 删除优惠券:通过路径参数传入删除的券ID,判断券是否是秒杀券类型,如果是还要删除秒杀券表中的信息;

客户端(大):

实现查询优惠券,分页查询,用redis实现,解决缓存击穿/穿透问题

购买时按照note中的逻辑实现:

建立User的Controller,Service,重点是serviceImpl

主要流程:

本质上是用户下单,减少库存,创建订单表

1.乐观锁解决超卖问题

2.redisson分布式锁解决集群模式下一人一单问题

3.秒杀优化中实现异步秒杀(Redis解决前面两个问题,多线程消息队列对接数据库操作)

实现思路(逻辑):

Controller传入下单ID,orderService调用下单方法

下单方法实现:

  1. 创建订单全局唯一ID
  2. 执行lua脚本,全程在redis实现:判断库存是否充足(解决超卖)、判断用户是否下单(一人一单)、扣库存,下单(保存用户ID到redis),发送下单消息到消息队列
  3. 返回Lua脚本执行结果(1库存不足,2不能重复下单,0成功),成功直接返回订单全局唯一ID(返回给用户认为已经下单)

异步下单:

  • 在下单方法的所在类初始化完成即会创建一个单线程的线程池,提交任务;
  • 新定义任务类,不断地从消息队列取订单消息(利用GROUP),如果为null(没有消息时),继续下一次循环;取到消息后解析数据,调用创建订单函数创建订单,发送ACK确认消息,代表取到消息了;一旦发送堵塞等某些异常消息,有未确认消息线程进入 Pending List,系统定期处理(与上面的一样的处理方式)
  • 在创建订单部分,再次加锁(双重保证一人一单问题)

实现了一个基于 Redis 和 Spring 的高性能秒杀系统,采用 Redis 的 Lua 脚本进行秒杀资格的快速校验,包括库存扣减和防止重复下单,同时将秒杀成功的订单数据写入 Redis Stream 队列。后台通过线程池异步监听队列,从 Stream 中消费订单数据并创建订单,保证主线程的响应速度。订单创建中使用 分布式锁(Redisson 实现)确保同一用户不会重复下单,并安全扣减库存。系统还实现了异常处理机制,通过 Pending List 确保未确认的订单消息不会丢失,从而实现了高并发场景下的订单创建、一人一单、库存安全以及消息可靠性保障的完整流程。

秒杀总结流程图

前置:1. 生成全局唯一ID 2.编写Lua脚本内容 3.创建常量,以及线程池

  1. 用户发起秒杀请求 → 执行 Redis Lua 脚本:
    • 库存扣减,创建订单到消息队列
    • 数据写入 Redis Stream 队列。
  2. 后台线程不断监听 Redis Stream:
    • 读取订单消息 → 解析数据 → 执行订单逻辑 → 确认消息。
  3. 异常处理机制:
    • 未确认消息进入 Pending List,系统定期处理。

三、实现过程中遇到的Q&A

  1. mapper中方法对应的xml映射文件报错
image-20241213182608385

在升级为mp后,xml映射文件中的parameterType和resultType报错,传统的 MyBatis 配置中,如果 parameterType 和 resultType 中只写类名,MyBatis 会假定你的类在 typeAliasesPackage 配置中定义的包路径下;在 MyBatis-Plus 中,通常鼓励开发者使用注解而不是 XML 映射。MyBatis-Plus 并不会自动假设类的路径,因为它简化了传统的 XML 映射配置,所以现在需要加上全部路径的类名

2.请求路径正确,代码正确,如果发送没有反应,就检查@Requestbody是否添加(json格式数据接收时),如果也没问题,检查实体类和发送的json数据是否有不一样的地方,大多是类型不一样的时候(如BigDecimal需要带小数),测试的数据必须一点点排查

3.在批量删除时,也想利用save方法直接实现类似新增的一样,直接构建wrapper条件,不去调用其他的service/mapper,但是报错:

image-20241214171044538

只能调用相对应的mapper进行,如果用Db去实现就会报错,db无法找到实体类对应的数据库表

4.分页查询mp版本与jsql不兼容,手动再引入

image-20241214174058272

JSqlParser 在 MyBatis-Plus 分页中的作用:分页操作中,JSqlParser 是由 MyBatis-Plus 的 PaginationInnerInterceptor 使用的,它的主要作用是 解析原始 SQL 并在其基础上自动添加分页逻辑。

5.设置用户端查询时,利用cacheclient的quryByID函数进行查询,改装函数,改进:1.缓存穿透和缓存击穿同时实现 2.解决第一次查询为null的问题

在缓存击穿的逻辑上增加穿透的实现,利用互斥锁,获得锁的线程去重建缓存数据,其开启一个新线程去重建数据,可以最多等待0.5秒获取新数据,其他没获得锁的线程返回旧的信息

6.TODO:当前缓存查询只能通过ID查询缓存并解决缓存击穿,不能通过其他属性类,且是按照ID,没法返回List(不确定)

7.添加优惠券到数据库的时候,会添加秒杀券到redis,虽然voucherSeckill.getStock()是一个Integer对象,但因为 RedisTemplate 的序列化方式存入Redis变成了乱码,导致在lua脚本无法识别数字

解决办法:

无效尝试:在存储库存值时将 Integer 显式转换为字符串存储,还是有乱码只是少了点;

有效方案:使用 StringRedisTemplate 来简化处理,@Autowired注入,然后利用其来保证存储正确数据;

stringRedisTemplate.opsForValue().set("seckill:stock:" + voucherSeckill.getVoucherId(), voucherSeckill.getStock().toString());

确保在 Lua 脚本中将 Redis 中存储的字符串值通过 tonumber() 转换为数字。

8.执行Lua脚本,始终返回1,代表库存不足,没找到原因

在Lua中添加调试信息:

1
2
3
4
5
6
7
local stock = redis.call('get', stockKey)
redis.call('set', 'debug:stockKey_check', 'StockKey is: ' .. stockKey)
if (stock == false or tonumber(stock) <= 0) then
-- 3.2 库存不存在或不足则返回1
redis.call('set', 'debug:stock_check', 'Stock is: ' .. tostring(tonumber(stock)))
return 1
end

发现stockKey的名称为乱码:seckill:stock:�� t 10,遂检查代码,发现执行脚本时也是redisTemplate,于是把所有的redisTemplate全部换成StringRedisTemplate

最终测试:

image-20241216210259589
image-20241216222127491

最终结果:只有一个线程可以同时下单成功

四、Mybatis-plus学习总结

配置mp:

引入依赖:

1
2
3
4
5
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.3.1</version>
</dependency>

配置:

application.yml:

1
2
3
4
5
spring:
mybatis-plus:
mapper-locations: ${sky.mybatis-plus.mapper-locations} # 如果使用 XML 映射文件
configuration:
log-impl: ${sky.mybatis-plus.configuration.log-impl} # 开启 SQL 日志

配置实体类的别名扫描包:(一般都会默认配好):

1
2
3
4
5
6
mybatis-plus:
type-aliases-package: com.itheima.mp.domain.po
global-config:
db-config:
id-type: auto # 全局id类型为自增长
mapper-locations: "classpath*:/mapper/**/*.xml" # Mapper.xml文件地址,当前这个是默认值。

为了简化单表CRUD,MybatisPlus提供了一个基础的BaseMapper接口,其中已经实现了单表的CRUD,因此自定义的Mapper只要实现了这个BaseMapper,就无需自己实现单表CRUD了。

1
2
3
4
5
6
7
8
package com.sky.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sky.entity.User;
// 泛型中的User就是与数据库对应的实体对象PO.
public interface VoucherMapper extends BaseMapper<User> {
}

MybatisPlus就是根据PO实体的信息来推断出表的信息,从而生成SQL的。默认情况下:

  • MybatisPlus会把PO实体的类名驼峰转下划线作为表名
  • MybatisPlus会把PO实体的所有变量名驼峰转下划线作为表的字段名,并根据变量类型推断字段类型
  • MybatisPlus会把名为id的字段作为主键

至此我们已经配置好MP:1.引入pom文件,配置xml信息 2.实现BaseMapper

基本的增删改查CRUD

1
2
3
4
5
6
7
8
9
  @Autowired
private UserMapper userMapper;
void method (){
userMapper.insert(user);
User user = userMapper.selectById(5L);
List<User> users = userMapper.selectBatchIds(List.of(1L, 2L, 3L, 4L, 5L));
userMapper.updateById(user);
userMapper.deleteById(5L);
}

常见注解:

@TableName:用在实体类上,数据库注解,标识实体类对应的数据库表

属性:value(表名)、schema(schema如sky-take-out(.表))

@TableId:用在实体类的主键字段,主键注解,标识实体类中的主键字段、

属性:value(表名)和type(主键类型)

@TableField:普通字段注解,一般不用

核心用法

Where条件

因此BaseMapper中提供的相关方法除了以id作为where条件以外,还支持更加复杂的where条件,参数中的Wrapper就是条件构造的抽象类

即wrapper是用来实现where条件的

一般常用的有四种:

QueryWrapper:修改、删除、查询,都可以使用QueryWrapper来构建查询条件

1
2
3
4
5
6
7
// 1.构建查询条件 where name like "%o%" AND balance >= 1000
QueryWrapper<User> wrapper = new QueryWrapper<User>()
.select("id", "username", "info", "balance")
.like("username", "o")
.ge("balance", 1000);
// 2.查询数据
List<User> users = userMapper.selectList(wrapper);

UpdateWrapper:SET的赋值结果是基于字段现有值的,需要利用UpdateWrapper的setSql功能

1
2
3
4
5
6
7
8
9
10
11
@Test
void testUpdateWrapper() {
List<Long> ids = List.of(1L, 2L, 4L);
// 1.生成SQL
UpdateWrapper<User> wrapper = new UpdateWrapper<User>()
.setSql("balance = balance - 200") // SET balance = balance - 200
.in("id", ids); // WHERE id in (1, 2, 4)
// 2.更新,注意第一个参数可以给null,也就是不填更新字段和数据,
// 而是基于UpdateWrapper中的setSQL来更新
userMapper.update(null, wrapper);
}

对于前两种Wrapper写死了构造条件的字段值,下面利用Lambda的Wrapper更为常用(基于变量的gettter方法结合反射技术。因此我们只要将条件对应的字段的getter方法传递给MybatisPlus,它就能计算出对应的变量名了)

LambdaQueryWrapper/LambdaUpdateWrapper:

1
2
3
4
5
6
7
8
9
10
11
12
@Test
void testLambdaQueryWrapper() {
// 1.构建条件 WHERE username LIKE "%o%" AND balance >= 1000
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.lambda()
.select(User::getId, User::getUsername, User::getInfo, User::getBalance)
.like(User::getUsername, "o") //利用这种方式获取数据库的信息,后面的是传入的参数信息
.ge(User::getBalance, 1000);
// 2.查询
List<User> users = userMapper.selectList(wrapper);
users.forEach(System.out::println);
}

自定义SQL

在上面的测试案例中,SQL语句写在了Service层,是不可以的,现在要写到Mapper,自定义SQL:

1
2
3
4
5
6
7
8
9
@Test
void testCustomWrapper() {
// 1.准备自定义查询条件
List<Long> ids = List.of(1L, 2L, 4L);
QueryWrapper<User> wrapper = new QueryWrapper<User>().in("id", ids);

// 2.调用mapper的自定义方法,直接传递Wrapper
userMapper.deductBalanceByIds(200, wrapper);
}

然后在UserMapper中自定义SQL:

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.itheima.mp.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itheima.mp.domain.po.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
import org.apache.ibatis.annotations.Param;

public interface UserMapper extends BaseMapper<User> {
// 下面的${ew.customSqlSegment}是固定写法
@Select("UPDATE user SET balance = balance - #{money} ${ew.customSqlSegment}")
void deductBalanceByIds(@Param("money") int money, @Param("ew") QueryWrapper<User> wrapper);
}

UPDATE user SET balance = balance - #{money}:更新 user 表中的 balance 字段,扣除指定金额,#{money} 是一个 MyBatis 的占位符,表示将方法参数 money 的值传入。而${ew.customSqlSegment}则表示将 QueryWrapper<User> 类型的参数 ew 中的 customSqlSegment 内容插入到 SQL 语句中。customSqlSegment 是 QueryWrapper 对象中一个特殊的属性,它允许我们在查询条件中动态地插入额外的 SQL 片段(例如 WHERE 子句)。利用${}而不是#{},因为#{}是参数替换,${}是字符串拼接

QueryWrapper<User> 中的泛型是 User, QueryWrapper 基于User实体类构建 User 表的 SQL 条件

MyBatisPlus不支持多表查询,我们可以利用Wrapper中自定义条件结合自定义SQL来实现多表查询的效果:

1
2
3
4
5
6
7
8
9
10
11
12
@Test
void testCustomJoinWrapper() {
// 1.准备自定义查询条件
QueryWrapper<User> wrapper = new QueryWrapper<User>()
.in("u.id", List.of(1L, 2L, 4L))
.eq("a.city", "北京");

// 2.调用mapper的自定义方法
List<User> users = userMapper.queryUserByWrapper(wrapper);

users.forEach(System.out::println);
}

然后在UserMapper中自定义方法:

1
2
@Select("SELECT u.* FROM user u INNER JOIN address a ON u.id = a.user_id ${ew.customSqlSegment}")
List<User> queryUserByWrapper(@Param("ew")QueryWrapper<User> wrapper);

当然,也可以在UserMapper.xml中写SQL:

1
2
3
<select id="queryUserByIdAndAddr" resultType="com.itheima.mp.domain.po.User">
SELECT * FROM user u INNER JOIN address a ON u.id = a.user_id ${ew.customSqlSegment}
</select>

Service接口

基本用法

MybatisPlus不仅提供了BaseMapper,还提供了通用的Service接口及默认实现,封装了一些常用的service模板方法

Service中经常需要定义与业务有关的自定义方法,因此我们不能直接使用IService,而是自定义Service接口,然后继承IService以拓展方法

自定义IUserService接口继承IService

1
2
3
4
5
6
7
8
package com.itheima.mp.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.itheima.mp.domain.po.User;

public interface IUserService extends IService<User> {
// 拓展自定义方法
}

然后,编写UserServiceImpl类,继承ServiceImpl,实现UserService:

1
2
3
4
5
6
7
8
9
10
11
package com.itheima.mp.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.itheima.mp.domain.po.User;
import com.itheima.mp.domain.po.service.IUserService;
import com.itheima.mp.mapper.UserMapper;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
}

ServiceImpl 是 MyBatis-Plus 提供的一个基类,它是一个通用的服务类实现,封装了很多常见的 CRUD 操作。ServiceImpl 实现了 IService 接口,并且提供了 IService 中定义的方法的默认实现

有了Service接口,可以直接在Controller中操作到数据库

编写Controller层代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Api(tags = "用户管理接口")
@RequiredArgsConstructor
@RestController
@RequestMapping("users")
public class UserController {
private final IUserService userService;

@PostMapping
@ApiOperation("新增用户")
public void saveUser(@RequestBody UserFormDTO userFormDTO){
// 1.转换DTO为PO
User user = BeanUtil.copyProperties(userFormDTO, User.class);
// 2.新增
userService.save(user);
}

@DeleteMapping("/{id}")
@ApiOperation("删除用户")
public void removeUserById(@PathVariable("id") Long userId){
userService.removeById(userId);
}

@GetMapping("/{id}")
@ApiOperation("根据id查询用户")
public UserVO queryUserById(@PathVariable("id") Long userId){
// 1.查询用户
User user = userService.getById(userId);
// 2.处理vo
return BeanUtil.copyProperties(user, UserVO.class);
}

@GetMapping
@ApiOperation("根据id集合查询用户")
public List<UserVO> queryUserByIds(@RequestParam("ids") List<Long> ids){
// 1.查询用户
List<User> users = userService.listByIds(ids);
// 2.处理vo
return BeanUtil.copyToList(users, UserVO.class);
}
}

@RequiredArgsConstructor 是 Lombok 提供的一个注解,它会自动生成一个构造函数,该构造函数包含所有 final 或 @NonNull 注解标注的字段。代码中的作用是自动为 userService 字段生成一个构造函数,以便在类初始化时注入依赖。(@RequiredArgsConstructor,不需要手动写构造函数,只需要标注 final 字段,它会自动完成依赖注入的工作,就不用@Autowired了)

上面的例子非常方便的实现了在Controller层的简单CRUD,但是业务逻辑代码就需要在Service层再写了

如:根据id扣减用户余额

需要先判断用户状态,然后判断余额,最后扣减

首先在UserController中定义一个方法:

1
2
3
4
5
@PutMapping("{id}/deduction/{money}")
@ApiOperation("扣减用户余额")
public void deductBalance(@PathVariable("id") Long id, @PathVariable("money")Integer money){
userService.deductBalance(id, money);
}

然后是UserService接口:

1
2
3
4
5
6
7
8
package com.itheima.mp.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.itheima.mp.domain.po.User;

public interface IUserService extends IService<User> {
void deductBalance(Long id, Integer money);
}

最后是UserServiceImpl实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
@Override
public void deductBalance(Long id, Integer money) {
// 1.查询用户
User user = getById(id);
// 2.判断用户状态
if (user == null || user.getStatus() == 2) {
throw new RuntimeException("用户状态异常");
}
// 3.判断用户余额
if (user.getBalance() < money) {
throw new RuntimeException("用户余额不足");
}
// 4.扣减余额 baseMapper是父接口
baseMapper.deductMoneyById(id, money);
}
}

最后是mapper:

1
2
@Update("UPDATE user SET balance = balance - #{money} WHERE id = #{id}")
void deductMoneyById(@Param("id") Long id, @Param("money") Integer money);

Lambda功能简化

IService中还提供了Lambda功能来简化我们的复杂查询及更新功能

接下来我们在UserController中定义一个controller方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@GetMapping("/list")
@ApiOperation("根据id集合查询用户")
public List<UserVO> queryUsers(UserQuery query){
// 1.组织条件
String username = query.getName();
Integer status = query.getStatus();
Integer minBalance = query.getMinBalance();
Integer maxBalance = query.getMaxBalance();
LambdaQueryWrapper<User> wrapper = new QueryWrapper<User>().lambda()
.like(username != null, User::getUsername, username)
.eq(status != null, User::getStatus, status)
.ge(minBalance != null, User::getBalance, minBalance)
.le(maxBalance != null, User::getBalance, maxBalance);
// 2.查询用户
List<User> users = userService.list(wrapper);
// 3.处理vo
return BeanUtil.copyToList(users, UserVO.class);
}

在组织查询条件的时候,我们加入了 username != null 这样的参数,意思就是当条件成立时才会添加这个查询条件,类似Mybatis的mapper.xml文件中的<if>标签。这样就实现了动态查询条件效果了

进一步地,Service中对LambdaQueryWrapper和LambdaUpdateWrapper的用法进一步做了简化。我们无需自己通过new的方式来创建Wrapper

基于Lambda查询:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@GetMapping("/list")
@ApiOperation("根据id集合查询用户")
public List<UserVO> queryUsers(UserQuery query){
// 1.组织条件
String username = query.getName();
Integer status = query.getStatus();
Integer minBalance = query.getMinBalance();
Integer maxBalance = query.getMaxBalance();
// 2.查询用户
List<User> users = userService.lambdaQuery()
.like(username != null, User::getUsername, username)
.eq(status != null, User::getStatus, status)
.ge(minBalance != null, User::getBalance, minBalance)
.le(maxBalance != null, User::getBalance, maxBalance)
.list();
// 3.处理vo
return BeanUtil.copyToList(users, UserVO.class);
}

可以发现lambdaQuery方法中除了可以构建条件,还需要在链式编程的最后添加一个list(),这是在告诉MP我们的调用结果需要是一个list集合。这里不仅可以用list(),可选的方法有:

  • .one():最多1个结果
  • .list():返回集合结果
  • .count():返回计数结果

同理:IService中的lambdaUpdate方法可以非常方便的实现复杂更新业务

实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Override
@Transactional
public void deductBalance(Long id, Integer money) {
// 1.查询用户
User user = getById(id);
// 2.校验用户状态
if (user == null || user.getStatus() == 2) {
throw new RuntimeException("用户状态异常!");
}
// 3.校验余额是否充足
if (user.getBalance() < money) {
throw new RuntimeException("用户余额不足!");
}
// 4.扣减余额 update tb_user set balance = balance - ?
int remainBalance = user.getBalance() - money;
lambdaUpdate()
.set(User::getBalance, remainBalance) // 更新余额
.set(remainBalance == 0, User::getStatus, 2) // 动态判断,是否更新status
.eq(User::getId, id)
.eq(User::getBalance, user.getBalance()) // 乐观锁
.update();
}

但是存在ABA问题:ABA 问题通常指的是在并发环境中,某个值在某个时刻从 A 变成了 B,然后又变回 A,外部系统无法检测到这个值曾经经历过变化,但实际上它已经发生了变化。这个问题常见于基于版本号或时间戳的乐观锁机制中。例如,乐观锁使用的是 eq(User::getBalance, user.getBalance()),这意味着在更新余额时,系统会校验当前数据库中的余额是否与用户获取的余额相同。如果中间有其他线程修改了余额,但最终余额恢复到原值,则当前线程会错误地认为数据没有变化,导致错误的更新操作,所以用version比较好

1
2
3
4
5
6
7
8
lambdaUpdate()
.set(User::getBalance, remainBalance)
.set(remainBalance == 0, User::getStatus, 2)
.eq(User::getId, id)
.eq(User::getBalance, user.getBalance()) // 乐观锁
.eq(User::getVersion, user.getVersion()) // 校验版本号
.update();

IService中的批量新增功能

我们尝试逐条插入数据,发现时间非常慢,后调用mp的批量插入,发现效率也不高:

1
2
3
4
5
6
7
8
9
10
11
12
for (int i = 1; i <= 100000; i++) {
userService.save(buildUser(i));
}
// 和
for (int i = 1; i <= 100000; i++) {
list.add(buildUser(i));
// 每1000条批量插入一次
if (i % 1000 == 0) {
userService.saveBatch(list);
list.clear();
}
}

查看MP部分源码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Transactional(rollbackFor = Exception.class)
@Override
public boolean saveBatch(Collection<T> entityList, int batchSize) {
String sqlStatement = getSqlStatement(SqlMethod.INSERT_ONE);
return executeBatch(entityList, batchSize, (sqlSession, entity) -> sqlSession.insert(sqlStatement, entity));
}
// ...SqlHelper
public static <E> boolean executeBatch(Class<?> entityClass, Log log, Collection<E> list, int batchSize, BiConsumer<SqlSession, E> consumer) {
Assert.isFalse(batchSize < 1, "batchSize must not be less than one");
return !CollectionUtils.isEmpty(list) && executeBatch(entityClass, log, sqlSession -> {
int size = list.size();
int idxLimit = Math.min(batchSize, size);
int i = 1;
for (E element : list) {
consumer.accept(sqlSession, element);
if (i == idxLimit) {
sqlSession.flushStatements();
idxLimit = Math.min(idxLimit + batchSize, size);
}
i++;
}
});
}

可以发现其实MybatisPlus的批处理是基于PrepareStatement的预编译模式,然后批量提交,最终在数据库执行时还是会有多条insert语句,逐条插入数据。SQL类似这样:

1
2
3
4
Preparing: INSERT INTO user ( username, password, phone, info, balance, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ?, ? )
Parameters: user_1, 123, 18688190001, "", 2000, 2023-07-01, 2023-07-01
Parameters: user_2, 123, 18688190002, "", 2000, 2023-07-01, 2023-07-01
Parameters: user_3, 123, 18688190003, "", 2000, 2023-07-01, 2023-07-01

为了提高性能,我们希望插入语句是这样:

1
2
3
4
5
6
INSERT INTO user ( username, password, phone, info, balance, create_time, update_time )
VALUES
(user_1, 123, 18688190001, "", 2000, 2023-07-01, 2023-07-01),
(user_2, 123, 18688190002, "", 2000, 2023-07-01, 2023-07-01),
(user_3, 123, 18688190003, "", 2000, 2023-07-01, 2023-07-01),
(user_4, 123, 18688190004, "", 2000, 2023-07-01, 2023-07-01);

修改项目中的application.yml文件,在jdbc的url后面添加参数&rewriteBatchedStatements=true:即开启重写批处理的statement语句

1
2
3
4
5
6
spring:
datasource:
url: jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: MySQL123

可以大大提高效率啦~

其他功能

MyBatisPlus插件:直接配置数据库,然后code generator即可

Service之间相互调用可能会出现循环依赖问题(在插入订单Service中,还需要调用插入订单详情的Service,maybe死锁,互相等待对方注入),MybatisPlus提供一个静态工具类:Db,其中的一些静态方法与IService中方法签名基本一致,也可以帮助我们实现CRUD功能。

改造原本的UserVO:新增地址属性,List列表类型为AddressVO

@ApiModelProperty("收货地址列表")

private List<AddressV0>addresses:首先在IUserService中定义方法:

1
2
3
4
5
6
7
8
9
10
11
package com.itheima.mp.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.itheima.mp.domain.po.User;
import com.itheima.mp.domain.vo.UserVO;

public interface IUserService extends IService<User> {
void deduct(Long id, Integer money);

UserVO queryUserAndAddressById(Long userId);
}

然后,在UserServiceImpl中实现该方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Override
public UserVO queryUserAndAddressById(Long userId) {
// 1.查询用户
User user = getById(userId);
if (user == null) {
return null;
}
// 2.查询收货地址
List<Address> addresses = Db.lambdaQuery(Address.class)
.eq(Address::getUserId, userId)
.list();
// 3.处理vo
UserVO userVO = BeanUtil.copyProperties(user, UserVO.class);
userVO.setAddresses(BeanUtil.copyToList(addresses, AddressVO.class));
return userVO;
}

在查询地址时,我们采用了Db的静态方法,因此避免了注入AddressService,减少了循环依赖的风险。

分页查询

在config中添加配置类

其代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.sky.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MybatisConfig {

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
// 初始化核心插件
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 添加分页插件
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
return interceptor;
}
}

// 真正查询代码
// 1.分页查询,new Page()的两个参数分别是:页码、每页大小
Page<User> p = userService.page(new Page<>(2, 2));
// 2.总条数
System.out.println("total = " + p.getTotal());
// 3.总页数
System.out.println("pages = " + p.getPages());
// 4.数据
List<User> records = p.getRecords();
records.forEach(System.out::println);

五、RabbitMQ学习总结

5.1 RabbitMQ基础知识学习

1. RabbitMQ 配置:定义交换机、队列和路由键

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
java复制代码public class RabbitMqConfig {

// 定义交换机
public static final String EXCHANGE = "voucher_exchange";
// 定义队列
public static final String QUEUE = "voucher_order_queue";
// 定义路由
public static final String ROUTING_KEY = "voucher.order";

@Bean
public Exchange exchange() {
return ExchangeBuilder.directExchange(EXCHANGE).durable(true).build();
}

@Bean
public Queue queue() {
return QueueBuilder.durable(QUEUE).build(); //队列持久化
}

@Bean
public Binding binding() {
return BindingBuilder.bind(queue()).to(exchange()).with(ROUTING_KEY).noargs();
}
}

1.1 交换机(Exchange)

  • Exchange 是 RabbitMQ 中的一个核心概念,负责接收生产者发送的消息,并根据路由规则将消息分发到不同的队列。
  • 这里定义了一个名为 voucher_exchange 的 direct exchange,它将根据路由键将消息定向到具体的队列。
  • 使用 durable(true) 表示交换机是持久化的,意味着即使 RabbitMQ 重启,交换机也不会丢失。

1.2 队列(Queue)

  • Queue 是消息的存储容器,消费者会从队列中获取消息进行处理。
  • 这里定义了一个名为 voucher_order_queue 的队列,并且通过 durable(true) 设置队列持久化,确保消息在队列重启后不会丢失。

1.3 路由(Routing Key)和绑定(Binding)

  • Routing Key 是一种路由机制,用于决定消息应发送到哪个队列。voucher.order 是一个简单的字符串,用来与交换机的绑定进行匹配。
  • Binding 将交换机和队列通过路由键绑定起来。BindingBuilder.bind(queue()).to(exchange()).with(ROUTING_KEY).noargs() 表示将 voucher_order_queue 队列与 voucher_exchange 交换机通过路由键 voucher.order 进行绑定。

5.2 MQ实现消息队列

1. RabbitMQ 配置:定义交换机、队列和路由键

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class RabbitMqConfig {

// 定义交换机
public static final String EXCHANGE = "voucher_exchange";
// 定义队列
public static final String QUEUE = "voucher_order_queue";
// 定义路由
public static final String ROUTING_KEY = "voucher.order";

@Bean
public Exchange exchange() {
return ExchangeBuilder.directExchange(EXCHANGE).durable(true).build();
}

@Bean
public Queue queue() {
return QueueBuilder.durable(QUEUE).build(); //队列持久化
}

@Bean
public Binding binding() {
return BindingBuilder.bind(queue()).to(exchange()).with(ROUTING_KEY).noargs();
}
}

1.1 交换机(Exchange)

  • Exchange 是 RabbitMQ 中的一个核心概念,负责接收生产者发送的消息,并根据路由规则将消息分发到不同的队列。
  • 这里定义了一个名为 voucher_exchange 的 direct exchange,它将根据路由键将消息定向到具体的队列。
  • 使用 durable(true) 表示交换机是持久化的,意味着即使 RabbitMQ 重启,交换机也不会丢失。

1.2 队列(Queue)

  • Queue 是消息的存储容器,消费者会从队列中获取消息进行处理。
  • 这里定义了一个名为 voucher_order_queue 的队列,并且通过 durable(true) 设置队列持久化,确保消息在队列重启后不会丢失。

1.3 路由(Routing Key)和绑定(Binding)

  • Routing Key 是一种路由机制,用于决定消息应发送到哪个队列。voucher.order 是一个简单的字符串,用来与交换机的绑定进行匹配。
  • Binding 将交换机和队列通过路由键绑定起来。BindingBuilder.bind(queue()).to(exchange()).with(ROUTING_KEY).noargs() 表示将 voucher_order_queue 队列与 voucher_exchange 交换机通过路由键 voucher.order 进行绑定。

在 RabbitMQ 中,消息的路由是由交换机(Exchange)和路由键(Routing Key)来控制的,发送者并不需要直接指定消息发送到具体的队列,而是通过交换机将消息发送到队列,当消息发送到 voucher_exchange 交换机时,交换机会根据绑定的路由规则将消息分发到相应的队列即配置类中的:

1
2
3
4
@Bean
public Binding binding() {
return BindingBuilder.bind(queue()).to(exchange()).with(ROUTING_KEY).noargs();
}

将 voucher_order_queue 队列绑定到 voucher_exchange 交换机,并使用路由键 voucher.order

此外,RabbitMQ 允许将同一条消息发送到多个队列,这是通过交换机的绑定关系来实现的,即创建两个queue,两个binding即可,如果不关心路由键,而是想把消息广播到多个队列,可以使用 fanout 类型的交换机;fanout 交换机会将所有消息广播到绑定到该交换机的所有队列,无论路由键是什么。

2. 发送消息到 RabbitMQ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
java复制代码public Result purchase(Long voucherId) {
Long userId = 1010108L;
long orderId = redisIdWorker.nextId("order");

Long result = stringRedisTemplate.execute(SECKILL_SCRIPT, Collections.emptyList(),
voucherId.toString(), userId.toString(), String.valueOf(orderId));

int r = result.intValue();
if (r == 1) {
return Result.error("库存不足");
} else if (r == 2) {
return Result.error("同一用户不能重复下单");
}

// 创建订单对象
VoucherOrder voucherOrder = VoucherOrder.builder().userId(userId).voucherId(voucherId).id(orderId).build();

// 发送消息到 RabbitMQ 队列
amqpTemplate.convertAndSend(RabbitMqConfig.EXCHANGE, RabbitMqConfig.ROUTING_KEY, voucherOrder);

return Result.success("下单成功,订单号:" + orderId);
}

2.1 消息发送

  • 代码中通过 amqpTemplate.convertAndSend() 发送消息。amqpTemplate 是 Spring 提供的消息发送模板,它可以简化与 RabbitMQ 的交互。
  • convertAndSend 方法将消息发送到指定的交换机、路由键和消息体。这里发送的是一个 voucherOrder 对象,表示用户下单的请求。
  • RabbitMqConfig.EXCHANGE:交换机的名称,确保消息发送到正确的交换机。
  • RabbitMqConfig.ROUTING_KEY:路由键,用于确定消息应该被路由到哪个队列。
  • 消息体是 voucherOrder 对象,它封装了用户 ID、优惠券 ID 和订单 ID。

3. 消费消息并处理订单

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
java复制代码@RabbitListener(queues = RabbitMqConfig.QUEUE)
public void processOrder(VoucherOrder voucherOrder, Channel channel, Message message) {
// 处理订单逻辑,创建订单并扣减库存
Long userId = voucherOrder.getUserId();
Long voucherId = voucherOrder.getVoucherId();

try {
// 创建锁对象,防止重复下单
RLock redisLock = redissonClient.getLock("lock:order" + userId);
boolean isLock = redisLock.tryLock();

// 锁获取失败直接确认,不需要重新入队
if (!isLock) {
log.info("不允许重复下单");
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
return;
}

try {
// 查询订单是否已经存在
long count = voucherOrderService.query().eq("user_id", userId).eq("voucher_id", voucherId).count();
if (count > 0) {
log.info("不允许重复下单");
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
return;
}

// 扣减库存
boolean success = seckillVoucherService.update().setSql("stock = stock - 1")
.eq("voucher_id", voucherId).gt("stock", 0).update();
if (!success) {
log.info("库存不足");
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
return;
}

// 创建订单
voucherOrderService.save(voucherOrder);
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);

} finally {
redisLock.unlock();
}
} catch (Exception e) {
log.error("处理订单失败", e);

// 异常时,发送 nack,重新入队重试
try {
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
} catch (Exception ex) {
log.error("确认消息失败", ex);
}
}
}

3.1 消费者(Consumer)

  • @RabbitListener 注解用于声明该方法是一个消息监听器,它会自动从指定的队列(voucher_order_queue)接收消息。消费者监听该队列并处理队列中的消息。

3.2 锁机制

  • 使用 Redisson 分布式锁 (RLock) 防止同一用户重复下单。当获取到锁时,处理业务逻辑;如果获取锁失败(表示当前请求正在被其他线程处理),则直接返回,并且确认消息(channel.basicAck()),确保该消息不再被消费。

3.3 消息确认(Acknowledgment)

  • channel.basicAck():手动确认消息。当消息成功处理时(比如订单创建成功),通过 basicAck 确认消息已处理,RabbitMQ 会将其从队列中移除。
  • channel.basicNack():如果处理失败(比如扣减库存失败,或者发生异常),使用 basicNack 将消息重新入队,以便重试。requeue=true 表示消息重新进入队列,待下次消费。

3.4 异常处理

  • 如果在处理订单的过程中发生异常,basicNack 会重新将消息放回队列,并且设置 requeue=true,使得消息可以重新被消费。