AllinToyou

这个屌丝很懒，什么也没留下！

热门标签

【Java项目推荐】值得写到简历上的项目--黑马点评_黑马点评项目简历怎么写

作者：AllinToyou | 2024-04-06 15:25:57

踩

黑马点评项目简历怎么写

前言

项目是b站黑马程序员的redis教程中的案例，建议所有java程序员做一下！

这篇博客会从最简单的实现优惠卷秒杀到加分布式锁、对秒杀优化、使用消息队列异步下单做详细介绍！

优惠券秒杀

实现优惠券秒杀下单

@Override
@Transactional
public Result seckillVoucher(Long voucherId) {
    /**
     * 秒杀基本实现一：
     *  1.查询优惠卷
     *  2.判断秒杀是否开始
     *  3.判断是否结束
     *  4.判断库存是否充足
     *  5.扣减库存
     *  6.创建订单
     */
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);

    if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
        //尚未开始
        return Result.fail("秒杀尚未开始!");
    }

    if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
        return Result.fail("秒杀已经结束!");
    }

    if (voucher.getStock() < 1) {
        return Result.fail("库存不足！");
    }

    boolean success = seckillVoucherService.update()
            .setSql("stock = stock - 1")
            .eq("voucher_id", voucherId).update();

    if (!success) {
        return Result.fail("库存不足！");
    }

    VoucherOrder voucherOrder = new VoucherOrder();
    long orderId = redisIdWorker.nextId("order");
    voucherOrder.setId(orderId);

    Long userId = UserHolder.getUser().getId();
    voucherOrder.setUserId(userId);

    voucherOrder.setVoucherId(voucherId);
    save(voucherOrder);

    return Result.ok(orderId);
}
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

超卖问题

超卖情况

加锁解决超卖问题

乐观锁

两种方式是心爱乐观锁：

版本号法
CAS法（Compare And swap）

实现方式:

每当数据做一次修改,版本号加1,所以判断一个数据有没有被修改过就看它的版本有没有变化过

CAS法:

Compare and Swap，即比较再交换。

也就是我不在判断库存有没有被修改过了，我每次都去比较看库存是否小于0

乐观锁解决超卖问题

乐观锁更新操作的时候使用

@Override
@Transactional
public Result seckillVoucher(Long voucherId) {  
	/**
     * 秒杀基本实现二：
     *  1.查询优惠卷
     *  2.判断秒杀是否开始
     *  3.判断是否结束
     *  4.判断库存是否充足
     *  5.扣减库存（乐观锁解决超卖问题）
     *  6.创建订单
     */
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);

    if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
        //尚未开始
        return Result.fail("秒杀尚未开始!");
    }

    if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
        return Result.fail("秒杀已经结束!");
    }

    if (voucher.getStock() < 1) {
        return Result.fail("库存不足！");
    }

    boolean success = seckillVoucherService.update()
            .setSql("stock = stock - 1")
            .eq("voucher_id", voucherId).gt("stock",0)
            .update();

    if (!success) {
        return Result.fail("库存不足！");
    }

    VoucherOrder voucherOrder = new VoucherOrder();
    long orderId = redisIdWorker.nextId("order");
    voucherOrder.setId(orderId);

    Long userId = UserHolder.getUser().getId();
    voucherOrder.setUserId(userId);

    voucherOrder.setVoucherId(voucherId);
    save(voucherOrder);

    return Result.ok(orderId);
}
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

一人一单

重复下单情况

解决思路

 		@Override
    public Result seckillVoucher(Long voucherId) {
      /**
       * 秒杀基本实现三：
       * 悲观锁实现一人一单
       */
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);

        if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
            //尚未开始
            return Result.fail("秒杀尚未开始!");
        }

        if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
            return Result.fail("秒杀已经结束!");
        }

        if (voucher.getStock() < 1) {
            return Result.fail("库存不足！");
        }

        Long userId = UserHolder.getUser().getId();
        synchronized (userId.toString().intern()){
            //获取事务代理对象
            IVoucherOrderService proxy = (IVoucherOrderService)AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }
		}

    @Transactional
    public Result createVoucherOrder(Long voucherId) {
        Long userId = UserHolder.getUser().getId();

        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        if (count > 0) {
            return Result.fail("您已经购买过一次了！");
        }

        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId).gt("stock", 0)
                .update();

        if (!success) {
            return Result.fail("库存不足！");
        }

        VoucherOrder voucherOrder = new VoucherOrder();
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);

        voucherOrder.setUserId(userId);
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);

        return Result.ok(orderId);

    }
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

防止事务失效

synchronized (userId.toString().intern()){
  //获取事务代理对象
  IVoucherOrderService proxy = (IVoucherOrderService)AopContext.currentProxy();
  return proxy.createVoucherOrder(voucherId);
}
1
2
3
4
5

事务的生效其实是Spring拿到当前对象的代理对象，这里如果直接调用就不是Spring的代理对象了事务就会失效，所以要获取当前对象的代理对象

通过AopContext.currentProxy()API去获取

为什么把生成订单单独提取出来？

因为只有生成订单才会对数据库有插入操作，这个时候才需要事务。

需要事务的同时一人一单也需要加锁（悲观锁）

而且要在事务提交之后在释放锁！

测试

分布式锁

集群下的线程并发安全问题

加锁的原理就是在JVM内部维护了一个锁监视器，如果是集群模式下的话那就是多个JVM，悲观锁就失效了

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

模拟集群环境：

在开一个服务，端口是8082，通过在Vm option里添加-Dserver.port=8082
nginx做负载均衡

此时测试，还是会发现会出现一人多单的情况

什么是分布式锁？

满足分布式系统下或者集群模式下的多线程可见并且互斥的锁

分布式锁的实现方式

redis分布式锁测试

# 实现分布式锁时需要实现的两个基本方法

# 1.添加锁，利用setnx的互斥特性
SETNX lock thread1
# 2.添加锁过期时间，避免服务宕机引起的死锁
EXPIRE lock 10

# 释放锁，删除即可
127.0.0.1:6379> DEL lock
(integer) 1
1
2
3
4
5
6
7
8
9
10

redis中加锁的一些特殊情况

如果下订单的线程在redis中加了锁，这时如果redis宕机了，那么其他线程就会一直处于等待状态，这时就出现了死锁的现象。

如何解决？

利用redis中key过期时间，自动释放锁能避免服务宕机引起的死锁

如果服务在加锁和过期释放期间宕机怎么办？

保证加锁和过期释放的原子性！

redis的set命令可以跟上很多参数，可以同时保证加锁和设置过期时间

EX：设置键的过期时间为 second 秒。 SET key value EX second 效果等同于 SETEX key second value
NX：只在键不存在时，才对键进行设置操作。 SET key value NX 效果等同于 SETNX key value 。

因为 SET 命令可以通过参数来实现和 SETNX 、 SETEX 和 PSETEX 三个命令的效果，所以将来的 Redis 版本可能会废弃并最终移除 SETNX 、 SETEX 和 PSETEX 这三个命令。

127.0.0.1:6379> SET lock thread1 NX EX 10
OK
127.0.0.1:6379> ttl lock
(integer) 5
127.0.0.1:6379> ttl lock
(integer) -2
1
2
3
4
5
6

手动实现分布式锁

实现分布式锁的流程

impl

实现分布式锁的思路就是通过redis中的setnx（如果不存在就创建key，存在就不创建）这样的互斥命令

每当有线程过来抢购的时候，首先会获取锁，也就是执行redis中的setnx命令。如果再有线程过来抢购那么就会被阻塞，只有等该锁被释放其他线程才能再次获取

@Override
public Result seckillVoucher(Long voucherId) {
  SeckillVoucher voucher = seckillVoucherService.getById(voucherId);

  if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
    //尚未开始
    return Result.fail("秒杀尚未开始!");
  }

  if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
    return Result.fail("秒杀已经结束!");
  }

  if (voucher.getStock() < 1) {
    return Result.fail("库存不足！");
  }

  Long userId = UserHolder.getUser().getId();

  //生成分布式锁对象，传入当前用户id和stringRedisTemplate对象
  SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);

  //
  boolean isLock = lock.tryLock(1200);
  if (!isLock){
    //            获取锁失败，返回错误或重试
    return Result.fail("不允许重复下单！");
  }

  try {
    //获取事务代理对象
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
    return proxy.createVoucherOrder(voucherId);
  } finally {
    lock.unlock();
  }
}

public class SimpleRedisLock implements ILock {
    //不同的业务有不同的名称
    private String name;
    private StringRedisTemplate stringRedisTemplate;
    //对锁定义一个统一的前缀
    private static final String KEY_PREFIX = "lock:";

    //锁的名称要求用户传递给我们，所以这里我们定义一个构造函数
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean tryLock(long timeoutSec) {
        /**
         * 版本一：
         * 基础实现
         * key就是固定前缀+锁的名称，value就是线程标识
         * SET lock thread1 NX EX 10
         */
        String threadId = Thread.currentThread().getId();
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        stringRedisTemplate.delete(ID_PREFIX + name);
    }
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

分布式锁误删情况1

分布式锁误删情况说明

获取锁之后，线程A的业务出现了阻塞，直到锁到了超时时间被自动释放，业务还在处于阻塞状态。

这时线程B获取锁开始执行自己的业务，此时线程A阻塞的业务完成后，会把锁给删掉！这样就是分布式锁误删的情况。

所以我们在删除锁的时候需要进行一个判断，看看删除的是不是当前线程所持有的锁

@Override
public Result seckillVoucher(Long voucherId) {
  SeckillVoucher voucher = seckillVoucherService.getById(voucherId);

  if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
    //尚未开始
    return Result.fail("秒杀尚未开始!");
  }

  if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
    return Result.fail("秒杀已经结束!");
  }

  if (voucher.getStock() < 1) {
    return Result.fail("库存不足！");
  }

  Long userId = UserHolder.getUser().getId();

  //生成分布式锁对象，传入当前用户id和stringRedisTemplate对象
  SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);

  //
  boolean isLock = lock.tryLock(1200);
  if (!isLock){
    //            获取锁失败，返回错误或重试
    return Result.fail("不允许重复下单！");
  }

  try {
    //获取事务代理对象
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
    return proxy.createVoucherOrder(voucherId);
  } finally {
    lock.unlock();
  }
}

public class SimpleRedisLock implements ILock {
    //不同的业务有不同的名称
    private String name;
    private StringRedisTemplate stringRedisTemplate;
    //对锁定义一个统一的前缀
    private static final String KEY_PREFIX = "lock:";

    //锁的名称要求用户传递给我们，所以这里我们定义一个构造函数
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }
  
    private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";

    @Override
    public boolean tryLock(long timeoutSec) {
        /**
         * 版本一：
         * 基础实现
         * key就是固定前缀+锁的名称，value就是线程标识
         * SET lock thread1 NX EX 10
         */
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
         /**
         * 版本二：
         * 释放锁的时候判断是不是当前线程的锁
         */
        //获取线程id
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        //获取key
        String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        if (threadId.equals(id)) {
            stringRedisTemplate.delete(KEY_PREFIX + name);
        }
    }
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

分布式锁误删情况2

情况说明

如果JVM发送FULL GC时会阻塞所有的代码，因为判断标识是否一致和释放锁是两步，所以在判断成功之后如果发生FUll GC那么其他线程再次获取锁的时候，还是可能发生误删的情况

为了避免这种情况的发生，我们必须保证判断锁标识的动作和释放锁的动作是原子性的！

这就是下面我们要学习的lua脚本

lua脚本解决多条命令的原子性问题

什么是lua脚本？

Redis提供了Lua脚本功能，在一个脚本中编写多条Redis命令，确保多条命令执行时的原子性。Lua是一种编程语言，它的基本语法大家可以参考网站：https://www.runoob.com/lua/lua-tutorial.html

lua脚本的基本使用

在lua脚本中调用函数如下：

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

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

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

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

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

写好脚本以后，需要用Redis命令来调用脚本，调用脚本的常见命令如下：

127.0.0.1:6379> help @scripting

  EVAL script numkeys [key [key ...]] [arg [arg ...]]
  summary: Execute a Lua script server side
  since: 2.6.0
1
2
3
4
5

例如，我们要执行 redis.call(‘set’, ‘name’, ‘jack’) 这个脚本，语法如下：

127.0.0.1:6379> EVAL "return redis.call('set','name','Jack')" 0
1

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

127.0.0.1:6379> EVAL "return redis.call('set',KEYS[1],ARGV[1])" 1 name Tom
OK
127.0.0.1:6379> get name
"Tom"
1
2
3
4

Java调用lua脚本改造分布式锁

释放锁的业务流程是这样的：

获取锁中的线程标示
判断是否与指定的标示（当前线程标示）一致
如果一致则释放锁（删除）
如果不一致则什么都不做
如果用Lua脚本来表示则是这样的

---
--- Generated by EmmyLua(https://github.com/EmmyLua)
--- Created by qiang.
--- DateTime: 2023/1/8 21:24
---

if (redis.call('get', KEYS[1]) == ARGV[1]) then
    --释放锁
    return redis.call('del', KEYS[1])
end
--如果不匹配
return 0
1
2
3
4
5
6
7
8
9
10
11
12

RedisTemplate调用Lua脚本的API如下：

@Override
public Result seckillVoucher(Long voucherId) {
  SeckillVoucher voucher = seckillVoucherService.getById(voucherId);

  if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
    //尚未开始
    return Result.fail("秒杀尚未开始!");
  }

  if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
    return Result.fail("秒杀已经结束!");
  }

  if (voucher.getStock() < 1) {
    return Result.fail("库存不足！");
  }

  Long userId = UserHolder.getUser().getId();

  //生成分布式锁对象，传入当前用户id和stringRedisTemplate对象
  SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);

  //
  boolean isLock = lock.tryLock(1200);
  if (!isLock){
    //            获取锁失败，返回错误或重试
    return Result.fail("不允许重复下单！");
  }

  try {
    //获取事务代理对象
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
    return proxy.createVoucherOrder(voucherId);
  } finally {
    lock.unlock();
  }
}

public class SimpleRedisLock implements ILock {
  //不同的业务有不同的名称
  private String name;
  private StringRedisTemplate stringRedisTemplate;
  //对锁定义一个统一的前缀
  private static final String KEY_PREFIX = "lock:";

  //锁的名称要求用户传递给我们，所以这里我们定义一个构造函数
  public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
    this.name = name;
    this.stringRedisTemplate = stringRedisTemplate;
  }

  private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
  
  private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;

  static {
    UNLOCK_SCRIPT = new DefaultRedisScript<>();
    UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
    UNLOCK_SCRIPT.setResultType(Long.class);
  }

  @Override
  public boolean tryLock(long timeoutSec) {
    /**
         * 版本一：
         * 基础实现
         * key就是固定前缀+锁的名称，value就是线程标识
         * SET lock thread1 NX EX 10
         */
    String threadId = ID_PREFIX + Thread.currentThread().getId();
    Boolean success = stringRedisTemplate.opsForValue()
      .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
    return Boolean.TRUE.equals(success);
  }

  @Override
  public void unlock() {
        /**
         * 版本三
         * 通过lua脚本来释放锁
         */
        stringRedisTemplate.execute(
                UNLOCK_SCRIPT,
                Collections.singletonList(KEY_PREFIX + name),
                ID_PREFIX + Thread.currentThread().getId());
    }
  }
}
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

Redisson

setnx实现的分布式锁存在的问题

什么是Redisson？

Redisson基于redis实现了一套分布式工具的集合

官网地址： https://redisson.org
GitHub地址： https://github.com/redisson/redisson

Redisson快速入门

一、引入依赖：

<dependency>
  <groupId>org.redisson</groupId>
  <artifactId>redisson</artifactId>
  <version>3.11.1</version>
</dependency>
1
2
3
4
5

二、配置Redisson客户端

@Configuration
public class  RedissonConfig {

    @Bean
    public RedissonClient redissonClient(){
        // 配置
        Config config = new Config();
        config.useSingleServer().setAddress("redis://172.20.10.2:6379");
        // 创建RedissonClient对象
        return Redisson.create(config);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

三、使用Redisson的分布式锁

@Override
public Result seckillVoucher(Long voucherId) {
  SeckillVoucher voucher = seckillVoucherService.getById(voucherId);

  if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
    //尚未开始
    return Result.fail("秒杀尚未开始!");
  }

  if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
    return Result.fail("秒杀已经结束!");
  }

  if (voucher.getStock() < 1) {
    return Result.fail("库存不足！");
  }

  Long userId = UserHolder.getUser().getId();

  RLock lock = redissonClient.getLock("lock:order:" + userId);

  /**
         * tryLock参数说明：
         * long waitTime 超时等待时间  默认是-1，也就是不等待，获取不到就直接返回false
         * long leaseTime 超时释放时间 默认是30s，如果该锁超过30s会自动释放
         */
  boolean isLock = lock.tryLock();
  if (!isLock) {
    //            获取锁失败，返回错误或重试
    return Result.fail("不允许重复下单！");
  }

  try {
    //获取事务代理对象
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
    return proxy.createVoucherOrder(voucherId);
  } finally {
    lock.unlock();
  }
}
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

秒杀优化

异步秒杀思路

将原先逻辑的串行执行改为异步执行，也就是将判断用户有没有秒杀资格交给redis去做，如果有那就把用户信息和订单信息保存到阻塞队列中交给其他线程去执行

基于redis完成秒杀资格判断

redis数据结构的选择

判断库存是否充足：可以选用String结构，key是优惠卷的信息，value是库存的数量

判断一人一单：可以选用set结构，将下过单的用户保存到set集合当中

流程如下：

实现

1.新增秒杀优惠券的同时，将优惠券信息保存到Redis中

@Override
@Transactional
public void addSeckillVoucher(Voucher voucher) {
		...
  	...
    stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());
}
1
2
3
4
5
6
7

2.基于Lua脚本，判断秒杀库存、一人一单，决定用户是否抢购成功

---
--- Generated by EmmyLua(https://github.com/EmmyLua)
--- Created by qiang.
--- DateTime: 2023/1/9 14:41
---
-- 1.参数列表
--判断库存是否充足需要去redis中去查，所以需要知道优惠卷id
-- 1.1优惠卷id
local voucherId = ARGV[1]

--判断一人一单需要知道用户id
-- 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判断库存是否大于0 get stock
if (tonumber(redis.call('get', stockKey)) <= 0) then
    -- 3.2.库存不足，返回1
    return 1
end


-- 判断用户是否下单 SISMEMBER orderKey userId
--127.0.0.1:6379> sadd setCollection1 1 2 3
--(integer) 3
--127.0.0.1:6379> SISMEMBER setCollection1 2
--(integer) 1
--127.0.0.1:6379> SISMEMBER setCollection1 0
--(integer) 0

if (redis.call('SISMEMBER', orderKey, userId) == 1) then
    --存在，说明是重复下单
    return 2
end

-- 3.4扣库存 incrby stockKey - 1
redis.call('incrby', stockKey, -1)
-- 3.5下单
redis.call('sadd', orderKey, userId)
return 0
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

3.java代码如下

PS:秒杀卷必须已经被保存到redis当中

因为lua脚本在执行的时候会去redis中读取优惠卷的库存，不然会出现如下错误：

user_script:26: attempt to compare nil with number

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    //加载seckill.lua文件
    private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        SECKILL_SCRIPT.setResultType(Long.class);
    }

    @Override
    public Result seckillVoucher(Long voucherId) {
       /**
         * 秒杀实现六
         * 通过redis的lua脚本对秒杀进行优化
         */
        Long userId = UserHolder.getUser().getId();

//        执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString()
        );
//        判断结果是否为0
        int r = result.intValue();

        if (r != 0){
//            不为0，代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
        }
//        为0，有购买资格，把下单信息保存到阻塞队列
        long orderId = redisIdWorker.nextId("order");

//        返回订单id
        return Result.ok(orderId);
    }
}
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

基于阻塞队列实现异步下单

防止事务失效

事务的生效其实是Spring拿到当前对象的代理对象，这里如果直接调用（直接创建订单）就不是Spring的代理对象了事务就会失效，所以要获取当前对象的代理对象通过AopContext.currentProxy()API去获取

@Slf4j
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {

  @Resource
  private ISeckillVoucherService seckillVoucherService;

  @Resource
  private RedisIdWorker redisIdWorker;

  @Resource
  private RedissonClient redissonClient;

  @Resource
  private StringRedisTemplate stringRedisTemplate;

  //加载seckill.lua文件
  private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

  static {
    SECKILL_SCRIPT = new DefaultRedisScript<>();
    SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
    SECKILL_SCRIPT.setResultType(Long.class);
  }

  //阻塞队列
  private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024 * 1024);
  //线程池
  private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

  //在类初始化之后就执行init方法
  //init方法会去执行创建订单线程VoucherOrderHandler（新的线程，通过实现Runnable接口创建）
  @PostConstruct
  private void init(){
    SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
  }

  //VoucherOrderHandler为线程任务
  //该线程会去读阻塞队列中的订单信息，然后再去调用创建订单方法，完成异步下单
  private class VoucherOrderHandler implements Runnable{
    @Override
    public void run() {
      while (true){
        try {
          //                获取队列中的订单信息
          VoucherOrder voucherOrder = orderTasks.take();
          //                    创建订单
          handleVoucherOrder(voucherOrder);
        } catch (Exception e) {
          log.error("处理订单异常",e);
        }
      }
    }
  }

  /**
     * 异步创建订单
     */
  private void handleVoucherOrder(VoucherOrder voucherOrder) {
    //这里创建订单的线程不是主线程，所以不能从userHolder里获取用户，只能从订单对象中获取用户id
    Long userId = voucherOrder.getUserId();
    RLock lock = redissonClient.getLock("lock:order:" + userId);

    /**
         * tryLock参数说明：
         * long waitTime 超时等待时间  默认是-1，也就是不等待，获取不到就直接返回false
         * long leaseTime 超时释放时间 默认是30s，如果该锁超过30s会自动释放
         */
    boolean isLock = lock.tryLock();
    if (!isLock) {
      //兜底方案，其实不用再去获取锁，因为在lua脚本中已经判断过一人一单
      log.error("不允许重复下单！");
      return;
    }

    try {
      //获取事务代理对象
      //这里不能通过AopContext.currentProxy()去获取代理对象，因为创建优惠卷订单（createVoucherOrder）是在主线程执行的
      //而当前方法是新的线程执行的代码，我们必须用主线程才能防止创建优惠卷订单（createVoucherOrder）事务失效
      proxy.createVoucherOrder(voucherOrder);
    } finally {
      lock.unlock();
    }
  }

  IVoucherOrderService proxy;
  @Override
  public Result seckillVoucher(Long voucherId) {
    /**
         * 秒杀实现六
         * 通过redis的lua脚本对秒杀进行优化
         */
    Long userId = UserHolder.getUser().getId();

    //      1.执行lua脚本
    Long result = stringRedisTemplate.execute(
      SECKILL_SCRIPT,
      Collections.emptyList(),
      voucherId.toString(), userId.toString()
    );
    //       2 判断结果是否为0
    int r = result.intValue();

    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);

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


  @Transactional
  public void createVoucherOrder(VoucherOrder voucherOrder) {
    Long userId = voucherOrder.getUserId();

    int count = query().eq("user_id", userId).eq("voucher_id", voucherOrder).count();
    if (count > 0) {
      log.error("您已经购买过一次了！");
      return;
    }

    boolean success = seckillVoucherService.update()
      .setSql("stock = stock - 1")
      .eq("voucher_id", voucherOrder.getVoucherId()).gt("stock", 0)
      .update();

    if (!success) {
      log.error("库存不足！");
      return;
    }

    save(voucherOrder);
  }
}
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

总结

新增秒杀优惠券的同时，将优惠券信息保存到Redis中
基于Lua脚本，判断秒杀库存、一人一单，决定用户是否抢购成功
如果抢购成功，将优惠券id和用户id封装后存入阻塞队列

IVoucherOrderService proxy;
@Override
public Result seckillVoucher(Long voucherId) {
  /**
         * 秒杀实现六
         * 通过redis的lua脚本对秒杀进行优化
         */
  Long userId = UserHolder.getUser().getId();

  //      1.执行lua脚本
  Long result = stringRedisTemplate.execute(
    SECKILL_SCRIPT,
    Collections.emptyList(),
    voucherId.toString(), userId.toString()
  );
  //       2 判断结果是否为0
  int r = result.intValue();

  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);
  //        返回订单id
  return Result.ok(orderId);
}
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

开启线程任务，不断从阻塞队列中获取信息，实现异步下单功能

//加载seckill.lua文件
  private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

  static {
    SECKILL_SCRIPT = new DefaultRedisScript<>();
    SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
    SECKILL_SCRIPT.setResultType(Long.class);
  }

  //阻塞队列
  private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024 * 1024);
  //线程池
  private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

  //在类初始化之后就执行init方法
  //init方法会去执行创建订单线程VoucherOrderHandler（新的线程，通过实现Runnable接口创建）
  @PostConstruct
  private void init(){
    SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
  }

  //VoucherOrderHandler为线程任务
  //该线程会去读阻塞队列中的订单信息，然后再去调用创建订单方法，完成异步下单
  private class VoucherOrderHandler implements Runnable{
    @Override
    public void run() {
      while (true){
        try {
          //                获取队列中的订单信息
          VoucherOrder voucherOrder = orderTasks.take();
          //                    创建订单
          handleVoucherOrder(voucherOrder);
        } catch (Exception e) {
          log.error("处理订单异常",e);
        }
      }
    }
  }

  /**
     * 异步创建订单
     */
  private void handleVoucherOrder(VoucherOrder voucherOrder) {
    //这里创建订单的线程不是主线程，所以不能从userHolder里获取用户，只能从订单对象中获取用户id
    Long userId = voucherOrder.getUserId();
    RLock lock = redissonClient.getLock("lock:order:" + userId);

    /**
         * tryLock参数说明：
         * long waitTime 超时等待时间  默认是-1，也就是不等待，获取不到就直接返回false
         * long leaseTime 超时释放时间 默认是30s，如果该锁超过30s会自动释放
         */
    boolean isLock = lock.tryLock();
    if (!isLock) {
      //兜底方案，其实不用再去获取锁，因为在lua脚本中已经判断过一人一单
      log.error("不允许重复下单！");
      return;
    }

    try {
      //获取事务代理对象
      //这里不能通过AopContext.currentProxy()去获取代理对象，因为创建优惠卷订单（createVoucherOrder）是在主线程执行的
      //而当前方法是新的线程执行的代码，我们必须用主线程才能防止创建优惠卷订单（createVoucherOrder）事务失效
      proxy.createVoucherOrder(voucherOrder);
    } finally {
      lock.unlock();
    }
  }
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

Redis消息队列

把订单信息放到阻塞队列的缺点是什么？

无法持久化
受JVM内存大小影响

那为什么消息队列能解决这些问题？

消息队列属于JVM以外的独立服务，不受JVM内存的限制
消息队列里的消息可以持久化，并且消息队列会保证消息至少被消费一次

现在有哪些消息队列可以用呢？

Kafka、RabbitMQ、RocketMQ…

但是我们都不用这些，因为我们项目规模比较小，我们用reids去实现消息队列就可以胜任

Redis提供了三种不同的方式来实现消息队列：

list结构：基于List结构模拟消息队列
PubSub：基本的点对点消息模型
Stream：比较完善的消息队列模型

基于List实现消息队列

# lpush命令在l1队列中放入两个元素
127.0.0.1:6379> LPUSH l1 element1 element2
(integer) 2

# brpop命令在l1队列右侧取出第一个元素，等待时间20s
127.0.0.1:6379> BRPOP l1 20
1) "l1"
2) "element1"

# brpop命令在l1队列右侧取出第二个元素，等待时间20s
127.0.0.1:6379> BRPOP l1 20
1) "l1"
2) "element2"

# brpop命令在l1队列右侧取出第三个元素，等待时间20s，元素被取完，命令处于阻塞状态
127.0.0.1:6379> BRPOP l1 20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

基于List的消息队列有哪些优缺点？

优点：

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

缺点：

无法避免消息丢失
只支持单消费者

PubSub实现消息队列

# 向频道发送消息
127.0.0.1:6379> PUBLISH order.q1 hello
(integer) 2
127.0.0.1:6379> PUBLISH order.q2 hello
(integer) 1

# 订阅一个或多个频道
127.0.0.1:6379> SUBSCRIBE order.q1
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "order.q1"
3) (integer) 1
1) "message"
2) "order.q1"
3) "hello"

# 订阅与pattern格式匹配的所有频道
127.0.0.1:6379> PSUBSCRIBE order.*
Reading messages... (press Ctrl-C to quit)
1) "psubscribe"
2) "order.*"
3) (integer) 1
1) "pmessage"
2) "order.*"
3) "order.q1"
4) "hello"
1) "pmessage"
2) "order.*"
3) "order.q2"
4) "hello"
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

基于PubSub的消息队列有哪些优缺点

优点：

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

缺点：

不支持数据持久化（向频道发送消息如果没人接受，那么消息会被直接丢掉）
无法避免消息丢失
消息堆积有上限，超出时数据丢失

Stream消息队列

单消费模式

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

发送消息

读取消息的方式之一：XREAD

如果不指定阻塞时长

测试

# 写消息
127.0.0.1:6379> XADD users * name zs age 12
"1673337915109-0"

# 读消息
127.0.0.1:6379> XREAD count 1 streams user 0
(nil)
127.0.0.1:6379> XREAD count 1 streams users 0
1) 1) "users"
   2) 1) 1) "1673337915109-0"
         2) 1) "name"
            2) "zs"
            3) "age"
            4) "12"
            
# 消息可重复读
127.0.0.1:6379> XREAD count 1 streams users 0
1) 1) "users"
   2) 1) 1) "1673337915109-0"
         2) 1) "name"
            2) "zs"
            3) "age"
            4) "12"
            
            
# 再次发送消息
127.0.0.1:6379> XADD users * name ls age 21
"1673338159927-0"

# 阻塞等待消息            
127.0.0.1:6379> XREAD COUNT 1 BLOCK 0 STREAMS users $
1) 1) "users"
   2) 1) 1) "1673338159927-0"
         2) 1) "name"
            2) "ls"
            3) "age"
            4) "21"
(13.00s)
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

消息漏读情况

当我们指定起始ID为$时，代表读取最新的消息，如果我们处理一条消息的过程中，又有超过1条以上的消息到达队列，则下次获取时也只能获取到最新的一条，会出现漏读消息的问题

消费组模式

创建消费者组

从消费者组读取消息

测试

创建消费者组

127.0.0.1:6379> XGROUP create s1 g1 0
OK
1
2

读取消费者组

127.0.0.1:6379> XREADGROUP group g1 c1 count 1 block 2000 streams s1 >

1) 1) "s1"
   2) 1) 1) "1673336869091-0"
         2) 1) "k1"
            2) "v1"
1
2
3
4
5
6

在s1队列中添加多条消息

127.0.0.1:6379> XADD s1 * k2 v2
"1673354707296-0"
127.0.0.1:6379> XADD s1 * k3 v3
"1673354711159-0"
1
2
3
4

读取消费者组中的数据

通过>号获取没有被确认的消息

127.0.0.1:6379> XREADGROUP group g1 c1 count 1 block 2000 streams s1 >

1) 1) "s1"
   2) 1) 1) "1673354707296-0"
         2) 1) "k2"
            2) "v2"
1
2
3
4
5
6

读取消费者组中的数据

通过>号获取没有被确认的消息

127.0.0.1:6379> XREADGROUP group g1 c1 count 1 block 2000 streams s1 >

1) 1) "s1"
   2) 1) 1) "1673354711159-0"
         2) 1) "k3"
            2) "v3"
1
2
3
4
5
6

查看消息队列中那一条消息没有被处理

-,+号代表id范围，表示所有id
10代表获取消息的数量

127.0.0.1:6379> XPENDING s1 g1 - + 10

1) 1) "1673336869091-0"
   2) "c1"
   3) (integer) 1113736
   4) (integer) 1
1
2
3
4
5
6

读取pending-list中没有被确认的消息

0,代表读取pending-list中第一条没有被确认的消息

127.0.0.1:6379> XREADGROUP group g1 c1 count 1 block 2000 streams s1 0

1) 1) "s1"
   2) 1) 1) "1673336869091-0"
         2) 1) "k1"
            2) "v1"
1
2
3
4
5
6

确认消息

127.0.0.1:6379> XACK s1 g1 1673336869091-0
(integer) 1
1
2

再次查看pending-list中没有被处理的消息

127.0.0.1:6379> XREADGROUP group g1 c1 count 1 block 2000 streams s1 0

1) 1) "s1"
   2) (empty array)   
1
2
3
4

impl

stream消息队列业务流程处理思路：

1.初始化stream消息队列，如果没有的话就去创建一个，如果stream存在，判断group（消费者组）是否存在
2.加载seckill.lua脚本，去做秒杀资格和一人一单判断，最后把订单相关信息保存到redis的消息队列中
3.开始读取stream消息队列中的消息，然后进行解析，从而获得订单信息进而把订单信息异步保存到数据库中
4.进行消息队列的确认
5.如果遇见没有处理的消息，会被捕捉异常进入handlePendingList方法，重新去pending-list中获取未处理的第一条消息，同样会在数据库中被保存

/**
 * @author qiang
 * @since 2022-12-27
 */
@Slf4j
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    //加载seckill.lua文件
    private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        SECKILL_SCRIPT.setResultType(Long.class);
    }

    //线程池
    private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

    //在类初始化之后就执行init方法
    //init方法会去执行创建订单线程VoucherOrderHandler（新的线程，通过实现Runnable接口创建）
    @PostConstruct
    private void init() {
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    }


    //VoucherOrderHandler为线程任务
    //该线程会去读消息队列中的订单信息，然后再去调用创建订单方法，完成异步下单
    private class VoucherOrderHandler implements Runnable {
        private final String queueName = "stream.orders";

        @Override
        public void run() {
            while (true) {
                try {
                    // 0.初始化stream
                    initStream();
                    // 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(queueName, 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.创建订单
                    handleVoucherOrder(voucherOrder);
                    // 4.确认消息 XACK stream.orders g1 id
                    stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", record.getId());

                } catch (Exception e) {
                    log.error("处理订单异常", e);
                    handlePendingList();
                }
            }
        }

        public void initStream() {
            Boolean exists = stringRedisTemplate.hasKey(queueName);
            if (BooleanUtil.isFalse(exists)) {
                log.info("stream不存在，开始创建stream");
                // 不存在，需要创建
                stringRedisTemplate.opsForStream().createGroup(queueName, ReadOffset.latest(), "g1");
                log.info("stream和group创建完毕");
                return;
            }
            // stream存在，判断group是否存在
            StreamInfo.XInfoGroups groups = stringRedisTemplate.opsForStream().groups(queueName);
            if (groups.isEmpty()) {
                log.info("group不存在，开始创建group");
                // group不存在，创建group
                stringRedisTemplate.opsForStream().createGroup(queueName, ReadOffset.latest(), "g1");
                log.info("group创建完毕");
            }
        }

        private void handlePendingList() {
            while (true) {
                try {
                    // 1.获取消息队列中的订单信息 XREADGROUP GROUP g1 c1 COUNT 1 STREAMS s1 0
                    List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                            Consumer.from("g1", "c1"),
                            StreamReadOptions.empty().count(1),
                            StreamOffset.create(queueName, 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.创建订单
                    handleVoucherOrder(voucherOrder);
                    // 4.确认消息 XACK stream.orders g1 id
                    stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", record.getId());
                } catch (Exception e) {
                    log.error("处理订单异常", e);
                }
            }
        }

    }

    /**
     * 异步创建订单
     */
    private void handleVoucherOrder(VoucherOrder voucherOrder) {
        //这里创建订单的线程不是主线程，所以不能从userHolder里获取用户，只能从订单对象中获取用户id
        Long userId = voucherOrder.getUserId();
        RLock lock = redissonClient.getLock("lock:order:" + userId);

        /**
         * tryLock参数说明：
         * long waitTime 超时等待时间  默认是-1，也就是不等待，获取不到就直接返回false
         * long leaseTime 超时释放时间 默认是30s，如果该锁超过30s会自动释放
         */
        boolean isLock = lock.tryLock();
        if (!isLock) {
            //兜底方案，其实不用再去获取锁，因为在lua脚本中已经判断过一人一单
            log.error("不允许重复下单！");
            return;
        }

        try {
            //获取事务代理对象
            //这里不能通过AopContext.currentProxy()去获取代理对象，因为创建优惠卷订单（createVoucherOrder）是在主线程执行的
            //而当前方法是新的线程执行的代码，我们必须用主线程才能防止创建优惠卷订单（createVoucherOrder）事务失效
            proxy.createVoucherOrder(voucherOrder);
        } finally {
            lock.unlock();
        }
    }

    //通过主线程获取代理对象
    private IVoucherOrderService proxy;

    @Override
    public Result seckillVoucher(Long voucherId) {
        /**
         * 秒杀实现七：
         * 使用redis提供的Stream消息队列优化秒杀
         */
        Long userId = UserHolder.getUser().getId();
        //获取订单id
        long orderId = redisIdWorker.nextId("order");


//      1.执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString(), String.valueOf(orderId)
        );
//       2 判断结果是否为0
        int r = result.intValue();

        if (r != 0) {
//            2.1 不为0，代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
        }

        proxy = (IVoucherOrderService) AopContext.currentProxy();
//        返回订单id
        return Result.ok(orderId);
    }


    @Transactional
    public void createVoucherOrder(VoucherOrder voucherOrder) {
        Long userId = voucherOrder.getUserId();

        int count = query().eq("user_id", userId).eq("voucher_id", voucherOrder).count();
        if (count > 0) {
            log.error("您已经购买过一次了！");
            return;
        }

        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherOrder.getVoucherId()).gt("stock", 0)
                .update();

        if (!success) {
            log.error("库存不足！");
            return;
        }

        save(voucherOrder);
    }
}
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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

lua脚本

---
--- Generated by EmmyLua(https://github.com/EmmyLua)
--- Created by qiang.
--- DateTime: 2023/1/9 14:41
---
-- 1.参数列表
--判断库存是否充足需要去redis中去查，所以需要知道优惠卷id
-- 1.1优惠卷id
local voucherId = ARGV[1]

--判断一人一单需要知道用户id
-- 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判断库存是否大于0 get stock
if (tonumber(redis.call('get', stockKey)) <= 0) then
    -- 3.2.库存不足，返回1
    return 1
end


-- 判断用户是否下单 SISMEMBER orderKey userId
--127.0.0.1:6379> sadd setCollection1 1 2 3
--(integer) 3
--127.0.0.1:6379> SISMEMBER setCollection1 2
--(integer) 1
--127.0.0.1:6379> SISMEMBER setCollection1 0
--(integer) 0

if (redis.call('SISMEMBER', orderKey, userId) == 1) then
    --存在，说明是重复下单
    return 2
end

-- 3.4扣库存 incrby stockKey - 1
redis.call('incrby', stockKey, -1)
-- 3.5下单
redis.call('sadd', orderKey, userId)
-- 3.6发送消息到队列中，XADD stream.orders * k1 v1 k2 v2 ...
-- *代表消息的id自动生成，orderId的key为id是因为订单实体类中订单id的字段属性为id
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
return 0
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

总结

STREAM类型消息队列的XREADGROUP命令特点：

消息可回溯
可以多消费者争抢消息，加快消费速度
可以阻塞读取
没有消息漏读的风险
有消息确认机制，保证消息至少被消费一次

总结

STREAM类型消息队列的XREADGROUP命令特点：

消息可回溯
可以多消费者争抢消息，加快消费速度
可以阻塞读取
没有消息漏读的风险
有消息确认机制，保证消息至少被消费一次

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/372756