高并发秒杀系统架构

<!--redisson分布式锁-->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.13.6</version>
</dependency>
<!--整合Redis , 底层可以用jedis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <!--排除redis默认的java开发客户端依赖，因为高并发情况下会有内存溢出问题，我们使用jedis来操作Java-->
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!--引入redis的java客户端包，jedis依赖-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

package com.xx.redis.config;


import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * 注册redisson
 */
@Configuration
public class RedissonConfig {


    //创建客户端
    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379").setPassword("root");
        return Redisson.create(config);
    }
}

package com.xx.redis.config;


import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;


import javax.annotation.Resource;


/**
 * RedisJson序列化
 */
//缓存的配置
@Configuration
public class RedisConfig {


    @Resource
    private RedisConnectionFactory factory;




    //使用JSON进行序列化
    @Bean
    public RedisTemplate<Object, Object> redisTemplate() {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();


        redisTemplate.setConnectionFactory(factory);
        //JSON格式序列化
        GenericFastJsonRedisSerializer serializer = new GenericFastJsonRedisSerializer();
         //key的序列化
        redisTemplate.setKeySerializer(serializer);
        //value的序列化
        redisTemplate.setValueSerializer(serializer);
        //hash结构key的序列化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //hash结构value的序列化
        redisTemplate.setHashValueSerializer(serializer);
        return redisTemplate;
    }


}

/**
  * 发布活动，需要判断是否重复发布，需要判断此活动中是否有商品，判断是否在有效时间之内
  */
@Override
public void publish(Long activityId) {
    AssertUtil.isNotNull(activityId, GlobalErrorCode.PARAM_IS_NULL);
    //获取活动信息
    KillActivity killActivity = selectById(activityId);
    //秒杀活动不存在
    AssertUtil.isNotNull(killActivity, GlobalErrorCode.KILL_ACTIVITY_EMPTY);
    //秒杀活动重复发布
    AssertUtil.isEqualsTrim(killActivity.getPublishStatus(),1,GlobalErrorCode.KILL_ACTIVITY_REPEAT);
    //查询活动下的商品
    Wrapper<KillCourse> wrapper = new EntityWrapper<>();
    wrapper.eq("activity_id",killActivity.getId());
    List<KillCourse> killCourses = killCourseService.selectList(wrapper);
    //活动下没有商品
    AssertUtil.isNotNull(killCourses,GlobalErrorCode.KILL_ACTIVITY_PRODUCT_EMPTY);
    Date date = new Date();
    //活动过期
    boolean time = date.before(killActivity.getBeginTime());
    AssertUtil.isTrue(time,GlobalErrorCode.KILL_ACTIVITY_EXPIRED);
    //发布活动，使用hash结构将活动与对应的课程缓存进redis，并设置库存的信号量
    killCourses.forEach(e->{
        //设置信号量
        RSemaphore semaphore = redissonClient.getSemaphore(e.getId().toString());
        semaphore.trySetPermits(e.getKillCount());
        //hash结构存入redis————Long,Map<Long,Value>
        String Akey = "activity"+":"+activityId;
        redisTemplate.opsForHash().put(Akey,e.getId().toString(),e);
    });
    killActivity.setPublishStatus(1);//修改状态为已发布
    killActivity.setPublishTime(new Date());  //修改发布时间
    updateById(killActivity);
}

/**
  * 从redis获取秒杀商品
  */
@Override
public List<KillCourse> online() {
    //获取redis中所有key以activity开头的值
    Set<Object> keys = redisTemplate.keys("activity:*");
    //秒杀活动不存在
    AssertUtil.isNotNull(keys,GlobalErrorCode.KILL_ACTIVITY_DOES_NOT_EXIST);
    List<KillCourse> killCourses = new ArrayList<>();
    keys.forEach(k->{
        //从redis取出所有大key为k的值
        List values = redisTemplate.opsForHash().values(k);
        killCourses.addAll(values);
    });
    return killCourses;
}

/**
  * 从redis获取获取一个秒杀商品的信息
  */
@Override
public KillCourse one(Long killId, Long activityId) {
    //先对参数进行判空
    AssertUtil.isNotNull(killId,GlobalErrorCode.PARAM_IS_NULL);
    AssertUtil.isNotNull(activityId,GlobalErrorCode.PARAM_IS_NULL);
    //从redis中获取商品信息
    String Akey = "activity"+":"+activityId;
    KillCourse killCourse = (KillCourse) redisTemplate.opsForHash().get(Akey, killId.toString());
    return killCourse;
}

/**
  * 用户商品详情页点击立即秒杀
  */
@Override
public String kill(Long activityId, Long killId) {
    //1.判空
    AssertUtil.isNotNull(activityId,GlobalErrorCode.PARAM_IS_NULL);
    AssertUtil.isNotNull(killId,GlobalErrorCode.PARAM_IS_NULL);
    //2.查询当前用户是否秒杀过，一个用户只能秒杀一个
    Long loginId = 3l;
    String UKey = "loginId"+":"+killId;
    //请勿重复秒杀，只能秒杀一件商品
    AssertUtil.isNull(redisTemplate.opsForValue().get(UKey),GlobalErrorCode.KILL_COURSE_REPEAT);
    //3.查询是否存在此秒杀活动对应的课程
    String Akey = "activity"+":"+activityId;
    KillCourse killCourse = (KillCourse) redisTemplate.opsForHash().get(Akey, killId.toString());
    AssertUtil.isNotNull(killCourse,GlobalErrorCode.KILL_ACTIVITY_DOES_NOT_EXIST);
    //4.执行预扣减信号量【库存】
    //获取信号量
    RSemaphore semaphore = redissonClient.getSemaphore(killId.toString());
    //尝试扣减信号量
    boolean b = semaphore.tryAcquire(1);
    //扣减失败，提示商品售罄
    AssertUtil.isTrue(b,GlobalErrorCode.KILL_COURSE_SOLD_OUT);
    //5.秒杀成功，预创订单，订单号作为key值存入redis，将订单号返回
    //创建订单号
    String orderNo = CodeGenerateUtils.generateOrderSn(loginId);
    KillOrderRedisDto killOrderRedisDto = new KillOrderRedisDto(
        orderNo,
        1,
        loginId,
        killId,
        killCourse.getCourseId(),
        killCourse.getActivityId()
    );
    redisTemplate.opsForValue().set(orderNo,killOrderRedisDto);
    //将用户秒杀记录存入redis，防止一个用户多次秒杀
    redisTemplate.opsForValue().set(UKey,killCourse);
    return orderNo;
}

/**
  * 获取防重token
  * @param courseIds
  * @return JSONResult
  */
@Override
public JSONResult createToken(String courseIds) {
    AssertUtil.isNotNull(courseIds, GlobalErrorCode.PARAM_IS_NULL);
    //生成token
    String token = StrUtils.getComplexRandomString(6);
    //用户id暂时写死
    Long loginId = 3l;
    //存入redis
    String key = loginId+":"+courseIds+":"+"token";  //  loginId:courseId  为key


    redisTemplate.opsForValue().set(key,token);
    return JSONResult.success(token);
}

/**
  * 获取秒杀订单详情
  */
@Override
public JSONResult getKillOrderInfo(Long courseId, String orderNo) {
    //获取预创订单
    KillOrderRedisDto killOrderRedisDto = (KillOrderRedisDto) redisTemplate.opsForValue().get(orderNo);
    AssertUtil.isNotNull(killOrderRedisDto,GlobalErrorCode.KILL_COURSE_ORDER_EMPTY);
    //获取redis中的秒杀课程详情
    KillCourse killCourse = (KillCourse) redisTemplate.opsForHash().get("activity" + ":" + killOrderRedisDto.getActivityId(), killOrderRedisDto.getKillId().toString());
    AssertUtil.isNotNull(killCourse,GlobalErrorCode.KILL_COURSE_ORDER_EMPTY);
    CourseOrder order = new CourseOrder();
    //封装课程信息
    Course course = new Course();
    course.setName(killCourse.getCourseName());
    course.setId(killCourse.getCourseId());
    course.setTeacherNames(killCourse.getTeacherNames());
    course.setPic(killCourse.getCoursePic());
    order.setCourse(course);
    //封装课程营销信息
    CourseMarket courseMarket = new CourseMarket();
    courseMarket.setPrice(killCourse.getKillPrice());
    order.setCourseMarket(courseMarket);
    //创建返回给前端数据的VO
    CourseOrderVo courseOrderVo = new CourseOrderVo();
    courseOrderVo.getCourseInfos().add(order);
    courseOrderVo.setTotalAmount(killCourse.getKillPrice());
    return JSONResult.success(courseOrderVo);
}

/**
  * 前端下单，保存秒杀订单详情
  * 需要做的事：
  *      1.验证防重token是否正确
  *      2.将redis的预创订单同步到CourseOrder订单
  *      3.发送事务消息，创建支付订单，需要最后将支付订单返回给前端带着去下单
  *      4.发送延迟消息，订单超时自动关闭订单
  */
@Override
public JSONResult killPlaceOrder(KillOrderDto killOrderDto) {
    Long loginId = 3l;  //登录用户id暂时写死
    //从redis中获取预创订单
    KillOrderRedisDto killOrderRedisDto = (KillOrderRedisDto) redisTemplate.opsForValue().get(killOrderDto.getOrderNo());
    //1.预创订单异常
    AssertUtil.isNotNull(killOrderRedisDto,GlobalErrorCode.KILL_COURSE_ORDER_EMPTY);
    //2.获取防重token
    String tokenKey = loginId +":"+killOrderRedisDto.getCourseId()+":"+"token";
    Object tokenRedis = redisTemplate.opsForValue().get(tokenKey);
    //防重token异常
    AssertUtil.isNotNull(tokenRedis,GlobalErrorCode.TOKEN_EMPTY_ERROR);
    //3.创建主订单
    List<Long> list = new ArrayList<>();
    list.add(killOrderRedisDto.getCourseId());
    //从redis中获取到秒杀课程详情
    KillCourse killCourse = (KillCourse) redisTemplate.opsForHash().get("activity" + ":" + killOrderRedisDto.getActivityId(), killOrderRedisDto.getKillId().toString());
    //判空，秒杀商品不存在
    AssertUtil.isNotNull(killCourse,GlobalErrorCode.KILL_ACTIVITY_DOES_NOT_EXIST);
    //主订单属性设置完成
    CourseOrder order = saveKillOrder(killOrderDto.getPayType(), killOrderRedisDto.getOrderNo(), killCourse.getKillPrice());
    //4.保存订单明细【包含了主订单信息和订单详情信息】
    CourseOrder courseOrderAndItem = saveKillDeatil(order, killOrderRedisDto.getCourseId(), killCourse.getCoursePic(), killCourse.getCourseName());
    //5.发送事务消息，让mq去执行本地事务，然后发送消息到mq队列，让支付服务拿到message去创建支付单
    Map<String, Long> map = new HashMap<>();
    map.put("loginId",loginId);
    map.put("courseIds",killCourse.getCourseId());
    Message<CourseOrder2PayOrder> message = MessageBuilder.withPayload(new CourseOrder2PayOrder(
        order.getTotalAmount(),
        order.getPayType(),
        order.getOrderNo(),
        order.getUserId(),
        order.getTitle(),
        JSON.toJSONString(map)
    )).build();
    TransactionSendResult result = rocketMQTemplate.sendMessageInTransaction(
        "tx-killOrder-service",
        "topic-killorder:tag-killorder",
        message,
        courseOrderAndItem);
    //获取本地事务执行状态和消息发送状态
    LocalTransactionState localTransactionState = result.getLocalTransactionState();
    SendStatus sendStatus = result.getSendStatus();
    boolean b = localTransactionState == LocalTransactionState.COMMIT_MESSAGE || sendStatus == SendStatus.SEND_OK;
    AssertUtil.isTrue(b,GlobalErrorCode.CREATE_ORDER_ERROR);
    //消息发送成功，删除redis中的预创订单
    redisTemplate.delete(order);
    //发送一个延迟消息，如果超时未支付，则取消订单
    rocketMQTemplate.syncSend(
        "topic-killOrderTimeOut:tag-killOrderTimeOut",
        MessageBuilder.withPayload(killOrderRedisDto.getOrderNo()).build(),   //延迟消息内容，订单号
        3000,   //超过3s未发送成功就不发了
        7     //延迟消息的等级，必须在3分钟之内支付，否则支付超时
    );
    return JSONResult.success(killOrderRedisDto.getOrderNo());
}

package com.xx.mq;


import com.xx.domain.CourseOrder;
import com.xx.dto.CourseOrder2PayOrder;
import com.xx.enums.GlobalErrorCode;
import com.xx.service.ICourseOrderService;
import com.xx.util.AssertUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;


import java.nio.charset.StandardCharsets;


@RocketMQTransactionListener(txProducerGroup = "tx-killOrder-service")
public class KillOrderListener implements RocketMQLocalTransactionListener {


    @Autowired
    private ICourseOrderService orderService;


    /**
     * 执行本地事务
     * @param message
     * @param o
     * @return
     */
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
        try {
            AssertUtil.isNotNull(o, GlobalErrorCode.PARAM_IS_NULL);
            CourseOrder order = (CourseOrder) o;
            //将此对象传给courseOrder业务去保存主订单和详情
            orderService.saveCourseOrderAndItem(order);
            return RocketMQLocalTransactionState.COMMIT;
        } catch (Exception e) {
            e.printStackTrace();
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }


    /**
     * 回调
     * @param message
     * @return
     */
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message message) {
        AssertUtil.isNotNull(message,GlobalErrorCode.PARAM_IS_NULL);
        String s = new String((byte[]) message.getPayload(), StandardCharsets.UTF_8);
        CourseOrder2PayOrder courseOrder2PayOrder = JSON.parseObject(s, CourseOrder2PayOrder.class);
        Wrapper<CourseOrder> wrapper = new EntityWrapper<>();
        wrapper.eq("order_no",courseOrder2PayOrder.getOrderNo());
        CourseOrder order = orderService.selectOne(wrapper);
        if(order!=null){
            return RocketMQLocalTransactionState.COMMIT;
        }else{
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }
}

package com.xx.mq;


import com.xx.domain.CourseOrder;
import com.xx.service.ICourseOrderService;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


import java.nio.charset.StandardCharsets;


@Component
@RocketMQMessageListener(
        consumerGroup = "killOrderTimeOut-consumer",
        topic = "topic-killOrderTimeOut",
        selectorExpression = "tag-killOrderTimeOut",
        messageModel = MessageModel.BROADCASTING)
public class KillOrderTimeOutConsumer implements RocketMQListener<MessageExt> {


    @Autowired
    private ICourseOrderService courseOrderService;


    @Override
    public void onMessage(MessageExt messageExt) {
        if(messageExt.getBody()==null){
            return;
        }
        String orderNo = new String(messageExt.getBody(), StandardCharsets.UTF_8);
        Wrapper<CourseOrder> wrapper = new EntityWrapper<>();
        wrapper.eq("order_no",orderNo);
        CourseOrder order = courseOrderService.selectOne(wrapper);
        if(order==null){
            return;
        }
        if(order.getStatusOrder()==0){
            order.setStatusOrder(4);
            courseOrderService.updateById(order);
        }
    }
}

package com.xx.mq;


import com.xx.domain.PayOrder;
import com.xx.dto.CourseOrder2PayOrder;
import com.xx.service.IPayOrderService;
import com.xx.service.IPayService;
import com.alibaba.fastjson.JSON;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


import java.nio.charset.StandardCharsets;


@Component
@RocketMQMessageListener(
    consumerGroup = "killOrder-consumer",
    topic = "topic-killorder",
    selectorExpression = "tag-killorder",
    messageModel = MessageModel.BROADCASTING
)
public class KillOrderConsumer implements RocketMQListener<MessageExt> {


    @Autowired
    private IPayService payService;


    @Autowired
    private IPayOrderService payOrderService;


    @Override
    public void onMessage(MessageExt messageExt) {
        if(messageExt.getBody()==null){
            return;
        }
        String string = new String(messageExt.getBody(), StandardCharsets.UTF_8);
        //转为我们封装的对象
        CourseOrder2PayOrder courseOrder2PayOrder = JSON.parseObject(string, CourseOrder2PayOrder.class);
        //保存支付单
        PayOrder payOrder = payService.selectOrderNo(courseOrder2PayOrder.getOrderNo());
        if(payOrder!=null){
            return;   //保证幂等性
        }
        payOrderService.saveOrder(courseOrder2PayOrder);
    }
}

package com.xx.mq;


import com.xx.service.IPayService;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


import java.nio.charset.StandardCharsets;


@Component
@RocketMQMessageListener(
        consumerGroup = "killOrderTimeOut-consumer",
        topic = "topic-killOrderTimeOut",
        selectorExpression = "tag-killOrderTimeOut",
        messageModel = MessageModel.BROADCASTING
)
public class KillOrderTimeOutConsumer implements RocketMQListener<MessageExt> {


    @Autowired
    private IPayService payService;


    @Override
    public void onMessage(MessageExt messageExt) {
        if(messageExt.getBody()==null){
            return;  //让mq别发了
        }
        //获取订单号
        String orderNo = new String(messageExt.getBody(), StandardCharsets.UTF_8);
        //取消支付订单，并且要关闭支付交易
        payService.cancelPayOrder(orderNo);
    }
}

/**
  * 查询是否已经将MQ中的消息消费【保存支付订单，前端要根据支付订单查询是否已经创建，返回订单号
  * @param orderNo
  * @return
  */
@GetMapping("/checkPayOrder/{orderNo}")
public JSONResult checkPayOrder(@PathVariable("orderNo") String orderNo){
    AssertUtil.isNotNull(orderNo, GlobalErrorCode.PARAM_IS_NULL);
    PayOrder payOrder = payService.selectOrderNo(orderNo);
    return payOrder !=null ? JSONResult.success(payOrder.getOrderNo()):JSONResult.error();
}