第16章-订单秒杀

1、秒杀业务分析

学习目标：

能够说出秒杀业务流程
独立搭建秒杀模块
完成基于定时任务完成秒杀商品缓存预热
完成秒杀商品列表以及详情展示
完成商品秒杀

1.1 需求分析

所谓“秒杀”，就是网络卖家发布一些超低价格的商品，所有买家在同一时间网上抢购的一种销售方式。通俗一点讲就是网络商家为促销等目的组织的网上限时抢购活动。由于商品价格低廉，往往一上架就被抢购一空，有时只用一秒钟。

秒杀商品通常有三种限制：库存限制、时间限制、购买量限制。

（1）库存限制：商家只拿出限量的商品来秒杀。比如某商品实际库存是200件，但只拿出50件来参与秒杀。我们可以将其称为“秒杀库存”。商家赔本赚吆喝，图啥？人气！

（2）时间限制：通常秒杀都是有特定的时间段，只能在设定时间段进行秒杀活动；

（3）购买量限制：同一个商品只允许用户最多购买几件。比如某手机限购1件。张某第一次买个1件，那么在该次秒杀活动中就不能再次抢购

1.2 秒杀功能分析

列表页

详情页

排队页

下单页

支付页

1.3 数据库表

秒杀商品表seckill_goods

2、搭建秒杀模块

我们先把秒杀模块搭建好，秒杀一共有三个模块，秒杀微服务模块service-activity，负责封装秒杀全部服务端业务；秒杀前端模块web-all，负责前端显示业务；service-activity-client api接口模块

提供秒杀商品基础代码

2.1 搭建service-activity模块

2.1.1 搭建service-activity

搭建方式如service-order

2.1.2 修改pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>gmall-service</artifactId>
        <groupId>com.atguigu.gmall</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service-activity</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.atguigu.gmall</groupId>
            <artifactId>service-user-client</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>com.atguigu.gmall</groupId>
            <artifactId>service-order-client</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>com.atguigu.gmall</groupId>
            <artifactId>rabbit-util</artifactId>
            <version>1.0</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>service-activity</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.1.3 启动类

package com.atguigu.gmall;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class ActivityApp {

    public static void main(String[] args) {
        SpringApplication.run(ActivityApp.class, args);
    }

}

2.1.3 添加配置

在resources目录下新建：bootstrap.properties

spring.application.name=service-activity
spring.profiles.active=dev
spring.cloud.nacos.discovery.server-addr=192.168.200.128:8848
spring.cloud.nacos.config.server-addr=192.168.200.128:8848
spring.cloud.nacos.config.prefix=${spring.application.name}
spring.cloud.nacos.config.file-extension=yaml
spring.cloud.nacos.config.shared-configs[0].data-id=common.yaml

2.2 搭建service-activity-client模块

搭建service-activity-client，搭建方式如service-order-client

2.3 添加依赖，配置网关

2.3.1 在web-all中引入依赖

<dependency>
    <groupId>com.atguigu.gmall</groupId>
    <artifactId>service-activity-client</artifactId>
    <version>1.0</version>
</dependency>

3、秒杀商品导入缓存

缓存数据实现思路：service-task模块统一管理我们的定时任务，为了减少service-task模块的耦合度，我们可以在定时任务模块只发送mq消息，需要执行定时任务的模块监听该消息即可，这样有利于我们后期动态控制，例如：每天凌晨一点我们发送定时任务信息到mq交换机，如果秒杀业务凌晨一点需要导入数据到缓存，那么秒杀业务绑定队列到交换机就可以了，其他业务也是一样，这样就做到了很好的扩展。

上面提到我们要控制库存数量，不能超卖，那么如何控制呢？在这里我们提供一种解决方案，那就我们在导入商品缓存数据时，同时将商品库存信息导入队列{list}，利用redis队列的原子性，保证库存不超卖

库存加入队列实施方案

1，如果秒杀商品有N个库存，那么我就循环往队列放入N个队列数据

2，秒杀开始时，用户进入，然后就从队列里面出队，只有队列里面有数据，说明就一点有库存（redis队列保证了原子性），队列为空了说明商品售罄

3.1 编写定时任务

在service-task模块发送消息

3.1.1 搭建service-task服务

在gmall-service模块下新增子模块: service-task . 搭建方式如service-mq

3.1.2 修改配置pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>gmall-service</artifactId>
        <groupId>com.atguigu.gmall</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service-task</artifactId>

    <dependencies>
        <!--rabbitmq消息队列-->
        <dependency>
            <groupId>com.atguigu.gmall</groupId>
            <artifactId>rabbit-util</artifactId>
            <version>1.0</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>service-task</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

说明：引入rabbit-util依赖定时发送消息

3.1.3 启动类

package com.atguigu.gmall;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)//取消数据源自动配置
@EnableDiscoveryClient
public class TaskApp {

   public static void main(String[] args) {
      SpringApplication.run(TaskApp.class, args);
   }

}

3.1.4 添加配置文件

bootstrap.properties

spring.application.name=service-task
spring.profiles.active=dev
spring.cloud.nacos.discovery.server-addr=192.168.200.128:8848
spring.cloud.nacos.config.server-addr=192.168.200.128:8848
spring.cloud.nacos.config.prefix=${spring.application.name}
spring.cloud.nacos.config.file-extension=yaml
spring.cloud.nacos.config.shared-configs[0].data-id=common.yaml

3.1.4 添加定时任务

定义凌晨一点mq相关常量

/**
 * 定时任务
 */
public static final String EXCHANGE_DIRECT_TASK = "exchange.direct.task";
public static final String ROUTING_TASK_1 = "seckill.task.1";
//队列
public static final String QUEUE_TASK_1  = "queue.task.1";

package com.atguigu.gmall.task.scheduled;

import com.atguigu.gmall.common.constant.MqConst;
import com.atguigu.gmall.common.service.RabbitService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.scheduling.annotation.EnableScheduling;

/**
 * @author: atguigu
 * @create: 2023-03-17 10:13
 */
@Slf4j
@Component
@EnableScheduling //开启定时任务
public class ScheduledTask {

    @Autowired
    private RabbitService rabbitService;


    /**
     * cron表达式 出处:定时任务框架Quartz
     * 定时任务逻辑:
     * 每日凌晨1点执行 秒杀商品预热消息发送
     * 开发阶段:每隔30秒触发一次
     */
    //@Scheduled(cron = "0 0 1 * * ?")
    @Scheduled(cron = "0/30 * * * * ?")
    public void sendImpSeckGoodsMsg() {
        log.info("定时任务秒杀商品预热消息发送");
        rabbitService.sendMessage(MqConst.EXCHANGE_DIRECT_TASK, MqConst.ROUTING_TASK_1, "");
    }
}

3.2 监听定时任务信息

在service-activity模块绑定与监听消息，处理缓存逻辑，更新状态位

3.2.1 数据导入缓存

3.2.1.1 在service-util的RedisConst类中定义常量

//秒杀商品前缀
public static final String SECKILL_GOODS = "seckill:goods";
public static final String SECKILL_ORDERS = "seckill:orders";
public static final String SECKILL_ORDERS_USERS = "seckill:orders:users";
public static final String SECKILL_STOCK_PREFIX = "seckill:stock:";
public static final String SECKILL_USER = "seckill:user:";
//用户锁定时间 单位：秒
public static final int SECKILL__TIMEOUT = 60 * 60;

3.2.1.2 监听消息

在service-activity秒杀微服务中监听消息，批量导入秒杀商品到Redis完成缓存预热

package com.atguigu.gmall.activity.receiver;

import com.atguigu.gmall.activity.model.SeckillGoods;
import com.atguigu.gmall.activity.service.SeckillGoodsService;
import com.atguigu.gmall.common.constant.MqConst;
import com.atguigu.gmall.common.constant.RedisConst;
import com.atguigu.gmall.common.util.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.BoundListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

/**
 * @author: atguigu
 * @create: 2023-03-17 10:38
 */
@Slf4j
@Component
public class SeckillReceiver {


    @Autowired
    private SeckillGoodsService seckillGoodsService;

    @Autowired
    private RedisTemplate redisTemplate;

    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(MqConst.EXCHANGE_DIRECT_TASK),
            value = @Queue(value = MqConst.QUEUE_TASK_1, durable = "true"),
            key = {MqConst.ROUTING_TASK_1}
    ))
    public void processImportSeckill2Redis(Message message, Channel channel) {
        try {
            log.info("接收到商品预热消息");
            //1.查询数据库中当日参与秒杀商品 审核状态:通过 秒杀商品库存大于0
            LambdaQueryWrapper<SeckillGoods> queryWrapper = new LambdaQueryWrapper<>();
            //审核状态取值 1:审核通知  2:审核不通过
            queryWrapper.eq(SeckillGoods::getStatus, "1");
            queryWrapper.gt(SeckillGoods::getStockCount, 0);
            //在SQL后增加函数 采用 apply方法进行拼接SQL
            queryWrapper.apply("DATE_FORMAT(start_time,'%Y-%m-%d') = '" + DateUtil.formatDate(new Date()) + "'");
            List<SeckillGoods> seckillGoodsList = seckillGoodsService.list(queryWrapper);
            //2.将参与秒杀商品加入分布式缓存Redis
            if (!CollectionUtils.isEmpty(seckillGoodsList)) {
                //2.1 将所有参与秒杀商品业务数据放入缓存:Hash类型
                //2.1.1 构建所有秒杀商品业务数据Hash结构key
                String seckillGoodsKey = RedisConst.SECKILL_GOODS;
                //2.12.2 构建操作秒杀商品hash操作对象
                BoundHashOperations<String, String, SeckillGoods> hashOps = redisTemplate.boundHashOps(seckillGoodsKey);
                for (SeckillGoods seckillGoods : seckillGoodsList) {
                    //2.1.3 判断秒杀hash中是否包含秒杀商品
                    if (hashOps.hasKey(seckillGoods.getSkuId().toString())) {
                        continue;
                    }
                    hashOps.put(seckillGoods.getSkuId().toString(), seckillGoods);

                    //2.2 每件秒杀商品都有库存队列:List类型
                    //2.2.1 构建当前秒杀商品库存Key seckill:stock:商品SkuId
                    String skuStockKey = RedisConst.SECKILL_STOCK_PREFIX + seckillGoods.getSkuId();
                    //2.2.2 根据商品秒杀库存数量生成库存队列
                    BoundListOperations<String, String> stockListOps = redisTemplate.boundListOps(skuStockKey);
                    for (Integer i = 0; i < seckillGoods.getStockCount(); i++) {
                        stockListOps.leftPush(seckillGoods.getSkuId().toString());
                    }

                    //3.todo 将商品"状态位"加入到本地缓存中
                }
            }
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (IOException e) {
            e.printStackTrace();
            log.error("[秒杀服务]秒杀商品预热异常:{}", e);
        }

    }
}

3.2.1.3 SeckillGoodsMapper

package com.atguigu.gmall.activity.mapper;

import com.atguigu.gmall.model.activity.SeckillGoods;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface SeckillGoodsMapper extends BaseMapper<SeckillGoods> {
}

3.2.2 更新状态位

由于我们的秒杀服务时集群部署service-activity的，我们面临一个问题？RabbitMQ 如何实现对同一个应用的多个节点进行广播呢？

RabbitMQ 只能对绑定到交换机上面的不同队列实现广播，对于同一队列的消费者他们存在竞争关系，同一个消息只会被同一个队列下其中一个消费者接收，达不到广播效果；

我们目前的需求是定时任务发送消息，我们将秒杀商品导入缓存，同事更新集群的状态位，既然RabbitMQ 达不到广播的效果，我们就放弃吗？当然不是，我们很容易就想到一种解决方案，通过redis的发布订阅模式来通知其他兄弟节点，这不问题就解决了吗?

过程大致如下：

应用启动，多个节点监听同一个队列（此时多个节点是竞争关系，一条消息只会发到其中一个节点上）
消息生产者发送消息，同一条消息只被其中一个节点收到收到消息的节点通过redis的发布订阅模式来通知其他兄弟节点

接下来配置redis发布与订阅

参考资料：

https://www.runoob.com/redis/redis-pub-sub.html

3.2.2.1 redis发布与订阅实现

package com.atguigu.gmall.activity.redis;


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.StringRedisTemplate;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;

@Configuration
public class RedisChannelConfig {

    /*
         docker exec -it  bc92 redis-cli
         subscribe seckillpush // 订阅 接收消息
         publish seckillpush admin // 发布消息
     */
    /**
     * 注入订阅主题
     * @param connectionFactory redis 链接工厂
     * @param listenerAdapter 消息监听适配器
     * @return 订阅主题对象
     */
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                            MessageListenerAdapter listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        //订阅主题 消费者定订阅
        container.addMessageListener(listenerAdapter, new PatternTopic("seckillpush"));
        //这个container 可以添加多个 messageListener
        return container;
    }

    /**
     * 返回消息监听器
     * @param receiver 创建接收消息对象
     * @return
     */
    @Bean
    MessageListenerAdapter listenerAdapter(MessageReceive receiver) {
        //这个地方 是给 messageListenerAdapter 传入一个消息接受的处理器，利用反射的方法调用“receiveMessage”
        //也有好几个重载方法，这边默认调用处理器的方法 叫handleMessage 可以自己到源码里面看
        return new MessageListenerAdapter(receiver, "receiveSeckillGoodState");
    }

    @Bean //注入操作数据的template
    StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
        return new StringRedisTemplate(connectionFactory);
    }

}

监听消息

package com.atguigu.gmall.activity.redis;

import com.atguigu.gmall.activity.util.CacheHelper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Component;

/**
 * @author: atguigu
 * @create: 2023-01-30 15:19
 */
@Slf4j
@Component
public class MessageReceive {

    /**
     * 当前JVM实例监听Redis中 秒杀商品状态 话题,更新当前JVM本地缓存中商品状态
     *
     * @param state 形式:""19:1"" 需要将其中引号去掉  商品ID:状态
     *              状态1:可以买  状态0:售罄
     */
    public void receiveSeckillGoodState(String state) {
        if (StringUtils.isNotBlank(state)) {
            log.info("监听到秒杀状态消息:" + state);
            state = state.replace("\"", "");
            //将秒杀商品状态放入本地缓存中
            String[] split = state.split(":");
            if (split != null && split.length == 2) {
                CacheHelper.put(split[0], split[1]);
            }
        }
    }
}

CacheHelper类本地缓存类

package com.atguigu.gmall.activity.util;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 系统缓存类
 */
public class CacheHelper {

    /**
     * 缓存容器
     */
    private final static Map<String, Object> cacheMap = new ConcurrentHashMap<String, Object>();

    /**
     * 加入缓存
     *
     * @param key
     * @param cacheObject
     */
    public static void put(String key, Object cacheObject) {
        cacheMap.put(key, cacheObject);
    }

    /**
     * 获取缓存
     * @param key
     * @return
     */
    public static Object get(String key) {
        return cacheMap.get(key);
    }

    /**
     * 清除缓存
     *
     * @param key
     * @return
     */
    public static void remove(String key) {
        cacheMap.remove(key);
    }

    public static synchronized void removeAll() {
        cacheMap.clear();
    }
}

说明：

1，RedisChannelConfig 类配置redis监听的主题和消息处理器

2，MessageReceive 类为消息处理器，消息message为：商品id与状态位，如：1:1 表示商品id为1，状态位为1

3.2.2.2 redis发布消息

监听已经配置好，接下来我就发布消息，更改秒杀监听器{ SeckillReceiver }，如下

完整代码如下

package com.atguigu.gmall.activity.receiver;

import com.atguigu.gmall.activity.model.SeckillGoods;
import com.atguigu.gmall.activity.service.SeckillGoodsService;
import com.atguigu.gmall.common.constant.MqConst;
import com.atguigu.gmall.common.constant.RedisConst;
import com.atguigu.gmall.common.util.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.BoundListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

/**
 * @author: atguigu
 * @create: 2023-03-17 10:38
 */
@Slf4j
@Component
public class SeckillReceiver {


    @Autowired
    private SeckillGoodsService seckillGoodsService;

    @Autowired
    private RedisTemplate redisTemplate;

    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(MqConst.EXCHANGE_DIRECT_TASK),
            value = @Queue(value = MqConst.QUEUE_TASK_1, durable = "true"),
            key = {MqConst.ROUTING_TASK_1}
    ))
    public void processImportSeckill2Redis(Message message, Channel channel) {
        try {
            log.info("接收到商品预热消息");
            //1.查询数据库中当日参与秒杀商品 审核状态:通过 秒杀商品库存大于0
            LambdaQueryWrapper<SeckillGoods> queryWrapper = new LambdaQueryWrapper<>();
            //审核状态取值 1:审核通知  2:审核不通过
            queryWrapper.eq(SeckillGoods::getStatus, "1");
            queryWrapper.gt(SeckillGoods::getStockCount, 0);
            //在SQL后增加函数 采用 apply方法进行拼接SQL
            queryWrapper.apply("DATE_FORMAT(start_time,'%Y-%m-%d') = '" + DateUtil.formatDate(new Date()) + "'");
            List<SeckillGoods> seckillGoodsList = seckillGoodsService.list(queryWrapper);
            //2.将参与秒杀商品加入分布式缓存Redis
            if (!CollectionUtils.isEmpty(seckillGoodsList)) {
                //2.1 将所有参与秒杀商品业务数据放入缓存:Hash类型
                //2.1.1 构建所有秒杀商品业务数据Hash结构key
                String seckillGoodsKey = RedisConst.SECKILL_GOODS;
                //2.12.2 构建操作秒杀商品hash操作对象
                BoundHashOperations<String, String, SeckillGoods> hashOps = redisTemplate.boundHashOps(seckillGoodsKey);
                for (SeckillGoods seckillGoods : seckillGoodsList) {
                    //2.1.3 判断秒杀hash中是否包含秒杀商品
                    if (hashOps.hasKey(seckillGoods.getSkuId().toString())) {
                        continue;
                    }
                    hashOps.put(seckillGoods.getSkuId().toString(), seckillGoods);

                    //2.2 每件秒杀商品都有库存队列:List类型
                    //2.2.1 构建当前秒杀商品库存Key seckill:stock:商品SkuId
                    String skuStockKey = RedisConst.SECKILL_STOCK_PREFIX + seckillGoods.getSkuId();
                    //2.2.2 根据商品秒杀库存数量生成库存队列
                    BoundListOperations<String, String> stockListOps = redisTemplate.boundListOps(skuStockKey);
                    for (Integer i = 0; i < seckillGoods.getStockCount(); i++) {
                        stockListOps.leftPush(seckillGoods.getSkuId().toString());
                    }

                    //3.新增代码-将商品"状态位"加入到本地缓存中
                    //将商品状态 发送到Redis 发布订阅话题:seckillpush
                    String msg = seckillGoods.getSkuId() + ":1";
                    redisTemplate.convertAndSend("seckillpush", msg);
                }
            }
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (IOException e) {
            e.printStackTrace();
            log.error("[秒杀服务]秒杀商品预热异常:{}", e);
        }
    }
}

说明：到目前我们就实现了商品信息导入缓存，同时更新状态位的工作

4、秒杀列表与详情

YAPI接口地址：

秒杀商品列表：http://192.168.200.128:3000/project/11/interface/api/539

秒杀商品详情：http://192.168.200.128:3000/project/11/interface/api/499

4.1 封装秒杀列表与详情接口

4.1.1 完成控制器

SeckillGoodsApiController

package com.atguigu.gmall.activity.api;

import com.atguigu.gmall.activity.model.SeckillGoods;
import com.atguigu.gmall.activity.service.SeckillGoodsService;
import com.atguigu.gmall.common.result.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @author: atguigu
 * @create: 2023-03-17 14:20
 */
@RestController
@RequestMapping("/api/activity")
public class SeckillGoodsApiController {

    @Autowired
    private SeckillGoodsService seckillGoodsService;


    /**
     * 查询Redis中当日秒杀商品列表
     *
     * @return
     */
    @GetMapping("/inner/seckill/findAll")
    public Result getSeckillGoodsList() {
        List<SeckillGoods> seckillGoodsList = seckillGoodsService.getSeckillGoodsList();
        return Result.ok(seckillGoodsList);
    }

    /**
     * 查询指定秒杀商品信息
     * @param skuId
     * @return
     */
    @GetMapping("/inner/seckill/getSeckillGoods/{skuId}")
    public Result getSeckillGoods(@PathVariable("skuId") Long skuId){
        SeckillGoods seckillGoods  = seckillGoodsService.getSeckillGoods(skuId);
        return Result.ok(seckillGoods);
    }

}

4.1.2 业务接口

package com.atguigu.gmall.activity.service;

import com.atguigu.gmall.activity.model.SeckillGoods;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.List;

public interface SeckillGoodsService extends IService<SeckillGoods> {
       /**
     * 查询Redis中当日秒杀商品列表
     *
     * @return
     */
    List<SeckillGoods> getSeckillGoodsList();

    /**
     * 查询指定秒杀商品信息
     * @param skuId
     * @return
     */
    SeckillGoods getSeckillGoods(Long skuId);
}

4.1.2 业务实现类

package com.atguigu.gmall.activity.service.impl;

import com.atguigu.gmall.activity.mapper.SeckillGoodsMapper;
import com.atguigu.gmall.activity.model.SeckillGoods;
import com.atguigu.gmall.activity.service.SeckillGoodsService;
import com.atguigu.gmall.common.constant.RedisConst;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author: atguigu
 * @create: 2023-01-30 11:47
 */
@Slf4j
@Service
public class SeckillGoodsServiceImpl extends ServiceImpl<SeckillGoodsMapper, SeckillGoods> implements SeckillGoodsService {

    @Autowired
    private RedisTemplate redisTemplate;


    /**
     * 查询Redis中当日秒杀商品列表
     *
     * @return
     */
    @Override
    public List<SeckillGoods> getSeckillGoodsList() {
        String seckillGoodsKey = RedisConst.SECKILL_GOODS;
        BoundHashOperations<String, String, SeckillGoods> hashOps = redisTemplate.boundHashOps(seckillGoodsKey);
        return hashOps.values();
    }

    /**
     * 查询指定秒杀商品信息
     *
     * @param skuId
     * @return
     */
    @Override
    public SeckillGoods getSeckillGoods(Long skuId) {
        String seckillGoodsKey = RedisConst.SECKILL_GOODS;
        BoundHashOperations<String, String, SeckillGoods> hashOps = redisTemplate.boundHashOps(seckillGoodsKey);
        if (hashOps.hasKey(skuId.toString())) {
            return hashOps.get(skuId.toString());
        }
        return null;
    }
}

4.2 在service-activity-client模块添加接口

远程调用Feign API接口

package com.atguigu.gmall.activity.client;

import com.atguigu.gmall.activity.client.impl.ActivityDegradeFeignClient;
import com.atguigu.gmall.common.result.Result;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(value = "service-activity", fallback = ActivityDegradeFeignClient.class)
public interface ActivityFeignClient {

    /**
     * 查询Redis中当日秒杀商品列表
     *
     * @return
     */
    @GetMapping("/api/activity/inner/seckill/findAll")
    public Result getSeckillGoodsList();


    /**
     * 查询指定秒杀商品信息
     *
     * @param skuId
     * @return
     */
    @GetMapping("/api/activity/inner/seckill/getSeckillGoods/{skuId}")
    public Result getSeckillGoods(@PathVariable("skuId") Long skuId);
}

服务降级类

package com.atguigu.gmall.activity.client.impl;

import com.atguigu.gmall.activity.client.ActivityFeignClient;
import com.atguigu.gmall.common.result.Result;
import org.springframework.stereotype.Component;

@Component
public class ActivityDegradeFeignClient implements ActivityFeignClient {


    @Override
    public Result getSeckillGoodsList() {
        return null;
    }

    @Override
    public Result getSeckillGoods(Long skuId) {
        return null;
    }
}

4.3 页面渲染

4.3.1 在web-all 中编写控制器

在 web-all 项目中添加控制器

package com.atguigu.gmall.all.controller;

import com.atguigu.gmall.activity.client.ActivityFeignClient;
import com.atguigu.gmall.common.result.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class SeckillController {

    @Autowired
    private ActivityFeignClient activityFeignClient;

    /**
     * 渲染秒杀商品列表页面
     *
     * @param model
     * @return
     */
    @GetMapping("/seckill.html")
    public String seckillIndexHtml(Model model) {
        //远程调用秒杀服务获取秒杀商品列表
        Result result = activityFeignClient.getSeckillGoodsList();
        model.addAttribute("list", result.getData());
        return "/seckill/index";
    }


    /**
     * 渲染秒杀商品详情页面
     *
     * @param model
     * @return
     */
    @GetMapping("/seckill/{skuId}.html")
    public String seckillGoodsHtml(Model model, @PathVariable("skuId") Long skuId) {
        Result result = activityFeignClient.getSeckillGoods(skuId);
        model.addAttribute("item", result.getData());
        return "/seckill/item";
    }
}

列表

页面资源： \templates\seckill\index.html

<div class="goods-list" id="item">
   <ul class="seckill" id="seckill">
      <li class="seckill-item" th:each="item: ${list}">
         <div class="pic" th:@click="|detail(${item.skuId})|">
            <img th:src="${item.skuDefaultImg}" alt=''>
         </div>
         <div class="intro">
            <span th:text="${item.skuName}">手机</span>
         </div>
         <div class='price'>
            <b class='sec-price' th:text="'￥'+${item.costPrice}">￥0</b>
            <b class='ever-price' th:text="'￥'+${item.price}">￥0</b>
         </div>
         <div class='num'>
            <div th:text="'已售'+${item.num}">已售1</div>
            <div class='progress'>
               <div class='sui-progress progress-danger'>
                  <span style='width: 70%;' class='bar'></span>
               </div>
            </div>
            <div>剩余
               <b class='owned' th:text="${item.stockCount}">0</b>件</div>
         </div>
         <a class='sui-btn btn-block btn-buy' th:href="'/seckill/'+${item.skuId}+'.html'" target='_blank'>立即抢购</a>
      </li>
   </ul>
</div>

4.3.2 秒杀详情页面功能介绍

说明：

1，立即购买，该按钮我们要加以控制，该按钮就是一个链接，页面只是控制能不能点击，一般用户可以绕过去，直接点击秒杀下单，所以我们要加以控制，在秒杀没有开始前，不能进入秒杀页面

4.3.2.1 web-all添加商品详情控制器

SeckillController

/**
 * 渲染抢购页面-排队页面
 *
 * @param skuId    秒杀商品
 * @param skuIdStr 抢购码
 * @return
 */
@GetMapping("/seckill/queue.html")
public String seckillQueueHtml(Model model, @RequestParam("skuId") Long skuId, @RequestParam("skuIdStr") String skuIdStr) {
    model.addAttribute("skuId", skuId);
    model.addAttribute("skuIdStr", skuIdStr);
    return "/seckill/queue";

}

4.3.2.2 详情页面介绍

4.3.2.2.1 基本信息渲染

<div class="product-info">
   <div class="fl preview-wrap">
      <!--放大镜效果-->
      <div class="zoom">
         <!--默认第一个预览-->
         <div id="preview" class="spec-preview">
            <span class="jqzoom"><img th:jqimg="${item.skuDefaultImg}" th:src="${item.skuDefaultImg}" width="400" height="400"/></span>
         </div>
      </div>
   </div>
   <div class="fr itemInfo-wrap">
      <div class="sku-name">
         <h4 th:text="${item.skuName}">三星</h4>
      </div>
      <div class="news">
         <span><img src="/img/_/clock.png"/>品优秒杀</span>
         <span class="overtime">{{timeTitle}}：{{timeString}}</span>
      </div>
      <div class="summary">
         <div class="summary-wrap">

            <div class="fl title">
               <i>秒杀价</i>
            </div>
            <div class="fl price">
               <i>¥</i>
               <em th:text="${item.costPrice}">0</em>
               <span th:text="'原价：'+${item.price}">原价：0</span>
            </div>
            <div class="fr remark">
               剩余库存：<span th:text="${item.stockCount}">0</span>
            </div>
         </div>
         <div class="summary-wrap">
            <div class="fl title">
               <i>促　　销</i>
            </div>
            <div class="fl fix-width">
               <i class="red-bg">加价购</i>
               <em class="t-gray">满999.00另加20.00元，或满1999.00另加30.00元，或满2999.00另加40.00元，即可在购物车换购热销商品</em>
            </div>
         </div>
      </div>
      <div class="support">
         <div class="summary-wrap">
            <div class="fl title">
               <i>支　　持</i>
            </div>
            <div class="fl fix-width">
               <em class="t-gray">以旧换新，闲置手机回收 4G套餐超值抢 礼品购</em>
            </div>
         </div>
         <div class="summary-wrap">
            <div class="fl title">
               <i>配 送 至</i>
            </div>
            <div class="fl fix-width">
               <em class="t-gray">满999.00另加20.00元，或满1999.00另加30.00元，或满2999.00另加40.00元，即可在购物车换购热销商品</em>
            </div>
         </div>
      </div>
      <div class="clearfix choose">
         <div class="summary-wrap">
            <div class="fl title">

            </div>
            <div class="fl">
               <ul class="btn-choose unstyled">
                  <li>
                     <a href="javascript:" v-if="isBuy" @click="queue()" class="sui-btn  btn-danger addshopcar">立即抢购</a>
                     <a href="javascript:" v-if="!isBuy" class="sui-btn  btn-danger addshopcar" disabled="disabled">立即抢购</a>
                  </li>
               </ul>
            </div>
         </div>
      </div>
   </div>
</div>

4.3.2.2.2 倒计时处理

思路：页面初始化时，拿到商品秒杀开始时间和结束时间等信息，实现距离开始时间和活动倒计时。

活动未开始时，显示距离开始时间倒计时；

活动开始后，显示活动结束时间倒计时。

倒计时代码片段

init() {
// debugger
// 计算出剩余时间
var startTime = new Date(this.data.startTime).getTime();
var endTime = new Date(this.data.endTime).getTime();
var nowTime = new Date().getTime();  //存在问题的  实际当前系统时间，从时间服务器获取统一时间标准

var secondes = 0;
// 还未开始抢购
if(startTime > nowTime) {
   this.timeTitle = '距离开始'
   secondes = Math.floor((startTime - nowTime) / 1000);
}
if(nowTime > startTime && nowTime < endTime) {
   this.isBuy = true
   this.timeTitle = '距离结束'
   secondes = Math.floor((endTime - nowTime) / 1000);
}
if(nowTime > endTime) {
   this.timeTitle = '抢购结束'
   secondes = 0;
}

const timer = setInterval(() => {
   secondes = secondes - 1
   this.timeString = this.convertTimeString(secondes)
}, 1000);
// 通过$once来监听定时器，在beforeDestroy钩子可以被清除。
this.$once('hook:beforeDestroy', () => {
   clearInterval(timer);
})
},

时间转换方法

convertTimeString(allseconds) {
    if(allseconds <= 0) return '00:00:00'
    // 计算天数
    var days = Math.floor(allseconds / (60 * 60 * 24));
    // 小时
    var hours = Math.floor((allseconds - (days * 60 * 60 * 24)) / (60 * 60));
    // 分钟
    var minutes = Math.floor((allseconds - (days * 60 * 60 * 24) - (hours * 60 * 60)) / 60);
    // 秒
    var seconds = allseconds - (days * 60 * 60 * 24) - (hours * 60 * 60) - (minutes * 60);

    //拼接时间
    var timString = "";
    if (days > 0) {
        timString = days + "天:";
    }
    return timString += hours + ":" + minutes + ":" + seconds;
}

4.3.2.3 秒杀按钮控制

在进入秒杀功能前，我们加一个下单码，只有你获取到该下单码，才能够进入秒杀方法进行秒杀

避免：用户提前知悉秒杀地址，通过恶意刷单软件进行非法下单。下单码生成条件：本地缓存中商品状态必须“1”；当前用户购买商品在销售时间内。

4.3.2.3.1 获取抢购码

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/531

SeckillGoodsApiController

/**
 * 为当前用户生成当前抢购商品抢购码
 * @param skuId
 * @param request
 * @return
 */
@GetMapping("/seckill/auth/getSeckillSkuIdStr/{skuId}")
public Result getSeckillSkuIdStr(@PathVariable("skuId") Long skuId, HttpServletRequest request){
    //获取登录用户ID
    String userId = AuthContextHolder.getUserId(request);
    //生成抢购码
    return seckillGoodsService.getSeckillSkuIdStr(skuId, userId);
}

SeckillGoodsService

/**
 * 为当前用户生成当前抢购商品抢购码
 * @param skuId
 * @return
 */
Result getSeckillSkuIdStr(Long skuId, String userId);

SeckillGoodsServiceImpl

/**
 * 为当前用户生成当前抢购商品抢购码
 *
 * @param skuId
 * @return
 */
@Override
public Result getSeckillSkuIdStr(Long skuId, String userId) {
    //1.验证秒杀商品状态-查询本地缓存
    String state = (String) CacheHelper.get(skuId.toString());
    if (StringUtils.isBlank(state)) {
        return Result.build(null, ResultCodeEnum.ILLEGAL_REQUEST);
    }
    if ("0".equals(state)) {
        return Result.build(null, ResultCodeEnum.SECKILL_FINISH);
    }
    if ("1".equals(state)) {
        //2.验证秒杀商品时间
        SeckillGoods seckillGoods = this.getSeckillGoods(skuId);
        Date now = new Date();
        if (DateUtil.dateCompare(seckillGoods.getStartTime(), now) && DateUtil.dateCompare(now, seckillGoods.getEndTime())) {
            //3.生成抢购码 将来用户秒杀时候会进行验证 todo 考虑将用户抢购码存入Redis
            String encrypt = MD5.encrypt(userId + skuId);
            return Result.ok(encrypt);
        }
    }
    return Result.build(null, ResultCodeEnum.ILLEGAL_REQUEST);
}

说明：只有在商品秒杀时间范围内，才能获取下单码，这样我们就有效控制了用户非法秒杀，下单码我们可以根据业务自定义规则，目前我们定义为当前用户id MD5加密。

4.3.2.3.2 前端页面

页面获取下单码，进入秒杀场景

queue() {
       seckill.getSeckillSkuIdStr(this.skuId).then(response => {
        var skuIdStr = response.data.data
        window.location.href = '/seckill/queue.html?skuId='+this.skuId+'&skuIdStr='+skuIdStr
    })
},

前端js完整代码如下

<script src="/js/api/seckill.js"></script>
<script th:inline="javascript">
   var item = new Vue({
      el: '#item',

      data: {
         skuId: [[${item.skuId}]],
         data: [[${item}]],
            timeTitle: '距离开始',
            timeString: '00:00:00',
            isBuy: false
      },

        created() {
            this.init()
        },

        methods: {
            init() {
            // debugger
            // 计算出剩余时间
            var startTime = new Date(this.data.startTime).getTime();
            var endTime = new Date(this.data.endTime).getTime();
            var nowTime = new Date().getTime();

            var secondes = 0;
            // 还未开始抢购
            if(startTime > nowTime) {
               this.timeTitle = '距离开始'
               secondes = Math.floor((startTime - nowTime) / 1000);
            }
            if(nowTime > startTime && nowTime < endTime) {
               this.isBuy = true
               this.timeTitle = '距离结束'
               secondes = Math.floor((endTime - nowTime) / 1000);
            }
            if(nowTime > endTime) {
               this.timeTitle = '抢购结束'
               secondes = 0;
            }

            const timer = setInterval(() => {
               secondes = secondes - 1
               this.timeString = this.convertTimeString(secondes)
            }, 1000);
            // 通过$once来监听定时器，在beforeDestroy钩子可以被清除。
            this.$once('hook:beforeDestroy', () => {
               clearInterval(timer);
            })
            },
            queue() {
                            seckill.getSeckillSkuIdStr(this.skuId).then(response => {
                    var skuIdStr = response.data.data
                    window.location.href = '/seckill/queue.html?skuId='+this.skuId+'&skuIdStr='+skuIdStr
                })
            },
            convertTimeString(allseconds) {
                if(allseconds <= 0) return '00:00:00'
                // 计算天数
                var days = Math.floor(allseconds / (60 * 60 * 24));
                // 小时
                var hours = Math.floor((allseconds - (days * 60 * 60 * 24)) / (60 * 60));
                // 分钟
                var minutes = Math.floor((allseconds - (days * 60 * 60 * 24) - (hours * 60 * 60)) / 60);
                // 秒
                var seconds = allseconds - (days * 60 * 60 * 24) - (hours * 60 * 60) - (minutes * 60);
                //拼接时间
                var timString = "";
                if (days > 0) {
                    timString = days + "天:";
                }
                return timString += hours + ":" + minutes + ":" + seconds;
            }
        }
   })
</script>

4.3.3 编写排队控制器

web-all模块中SeckillController

/**
 * 渲染抢购页面-排队页面
 *
 * @param skuId    秒杀商品
 * @param skuIdStr 抢购码
 * @return
 */
@GetMapping("/seckill/queue.html")
public String seckillQueueHtml(Model model, @RequestParam("skuId") Long skuId, @RequestParam("skuIdStr") String skuIdStr) {
    model.addAttribute("skuId", skuId);
    model.addAttribute("skuIdStr", skuIdStr);
    return "/seckill/queue";

}

页面

页面资源： \templates\seckill\queue.html

<div class="cart py-container" id="item">
    <div class="seckill_dev" v-if="show == 1">
        排队中...
    </div>
    <div class="seckill_dev" v-if="show == 2">
        {{message}}
    </div>
    <div class="seckill_dev" v-if="show == 3">
        抢购成功&nbsp;&nbsp;

        <a href="/seckill/trade.html" target="_blank">去下单</a>
    </div>
    <div class="seckill_dev" v-if="show == 4">
        抢购成功&nbsp;&nbsp;

        <a href="/myOrder.html" target="_blank">我的订单</a>
    </div>
</div>

Js部分

<script src="/js/api/seckill.js"></script>
<script th:inline="javascript">
    var item = new Vue({
        el: '#item',

        data: {
            skuId: [[${skuId}]],
            skuIdStr: [[${skuIdStr}]],
            data: {},
            show: 1,
            code: 211,
            message: '',
            isCheckOrder: false
        },

        mounted() {
            const timer = setInterval(() => {
                if(this.code != 211) {
                    clearInterval(timer);
                }
                this.checkOrder()
            }, 3000);
            // 通过$once来监听定时器，在beforeDestroy钩子可以被清除。
            this.$once('hook:beforeDestroy', () => {
                clearInterval(timer);
            })
        },

        created() {
            this.saveOrder();
        },

        methods: {
            saveOrder() {
                seckill.seckillOrder(this.skuId, this.skuIdStr).then(response => {
                    debugger
                    console.log(JSON.stringify(response))
                    if(response.data.code == 200) {
                        this.isCheckOrder = true
                    } else {
                        this.show = 2
                        this.message = response.data.message
                    }

                })
            },

            checkOrder() {
                if(!this.isCheckOrder) return

                seckill.checkOrder(this.skuId).then(response => {
                     debugger
                    this.data = response.data.data
                    this.code = response.data.code
                    console.log(JSON.stringify(this.data))
                    //排队中
                    if(response.data.code == 211) {
                        this.show = 1
                    } else {
                        //秒杀成功
                        if(response.data.code == 215) {
                            this.show = 3
                            this.message = response.data.message
                        } else {
                            if(response.data.code == 218) {
                                this.show = 4
                                this.message = response.data.message
                            } else {
                                this.show = 2
                                this.message = response.data.message
                            }
                        }
                    }
                })
            }
        }
    })
</script>

说明：该页面直接通过controller返回页面，进入页面后显示排队中，然后通过异步执行秒杀下单，提交成功，页面通过轮询后台方法查询秒杀状态

5、整合秒杀业务

秒杀的主要目的就是获取一个下单资格，拥有下单资格就可以去下单支付，获取下单资格后的流程就与正常下单流程一样，只是没有购物车这一步，总结起来就是，秒杀根据库存获取下单资格，拥有下单资格进入下单页面（选择地址，支付方式，提交订单，然后支付订单）

步骤：

1，校验抢购码，只有正确获得抢购码的请求才是合法请求

2，校验状态位state，

State为null，说明非法请求；

State为0说明已经售罄；

State为1，说明可以抢购

状态位是在内存中判断，效率极高，如果售罄，直接就返回了，不会给服务器造成太大压力

3，前面条件都成立，将秒杀用户加入队列，然后直接返回

4，前端轮询秒杀状态，查询秒杀结果

5.1 秒杀下单

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/515

5.1.1 添加mq常量MqConst类

/**
 * 秒杀
 */
public static final String EXCHANGE_DIRECT_SECKILL_USER = "exchange.direct.seckill.user";
public static final String ROUTING_SECKILL_USER = "seckill.user";
//队列
public static final String QUEUE_SECKILL_USER  = "queue.seckill.user";

5.1.2 定义实体UserRecode

记录哪个用户要购买哪个商品！

@Data
public class UserRecode implements Serializable {

   private static final long serialVersionUID = 1L;

   private Long skuId;
   
   private String userId;
}

5.1.3 编写控制器

SeckillGoodsApiController

/**
 * 秒杀下单预处理(不处理真实秒杀业务,将秒杀购买意向发送MQ)
 * @param request
 * @param skuId 购买商品
 * @param skuIdStr 抢购码
 * @return
 */
@PostMapping("/seckill/auth/seckillOrder/{skuId}")
public Result seckillPre(HttpServletRequest request, @PathVariable("skuId") Long skuId, @RequestParam("skuIdStr") String skuIdStr){
    //获取用户ID
    String userId = AuthContextHolder.getUserId(request);
    return seckillGoodsService.seckillPre(userId, skuId, skuIdStr);
}

5.1.4 业务层接口

SeckillGoodsService

/**
 * 秒杀下单预处理(不处理真实秒杀业务,将秒杀购买意向发送MQ)
 * @param skuId 购买商品
 * @param skuIdStr 抢购码
 * @return
 */
Result seckillPre(String userId, Long skuId, String skuIdStr);

5.1.5 业务层实现

SeckillGoodsServiceImpl

/**
 * 秒杀下单预处理(不处理真实秒杀业务,将秒杀购买意向发送MQ)
 *
 * @param skuId    购买商品
 * @param skuIdStr 抢购码
 * @return
 */
@Override
public Result seckillPre(String userId, Long skuId, String skuIdStr) {
    //1.验证用户提交的抢购码是否在正确
    //1.1 根据用户提交参数生成抢购码,跟用户提交的比较
    String encrypt = MD5.encrypt(userId + skuId);
    if (StringUtils.isBlank(encrypt) || !encrypt.equals(skuIdStr)) {
        return Result.build(null, ResultCodeEnum.ILLEGAL_REQUEST);
    }

    //2.验证本地缓存中秒杀商品状态 是否为"1"
    String state = (String) CacheHelper.get(skuId.toString());
    if (StringUtils.isBlank(state) || "0".equals(state)) {
        return Result.build(null, ResultCodeEnum.ILLEGAL_REQUEST);
    }

    if ("1".equals(state)) {
        //3.构建用户秒杀商品购买意向,将秒杀请求放入消息队列
        UserRecode userRecode = new UserRecode();
        userRecode.setUserId(userId);
        userRecode.setSkuId(skuId);
        rabbitService.sendMessage(MqConst.EXCHANGE_DIRECT_SECKILL_USER, MqConst.ROUTING_SECKILL_USER, userRecode);
        return Result.ok();
    }
    return Result.build(null, ResultCodeEnum.ILLEGAL_REQUEST);
}

5.2 秒杀下单监听

思路：

1，首先判断产品状态位，我们前面不是已经判断过了吗？因为产品可能随时售罄，mq队列里面可能堆积了十万数据，但是已经售罄了，那么后续流程就没有必要再走了；

2，判断用户是否已经下过订单，这个地方就是控制用户重复下单，同一个用户只能抢购一个下单资格，怎么控制呢？很简单，我们可以利用setnx控制用户，当用户第一次进来时，返回true，可以抢购，以后进入返回false，直接返回，过期时间可以根据业务自定义，这样用户这一段咋们就控制注了

3，获取队列中的商品，如果能够获取，则商品有库存，可以下单。如果获取的商品id为空，则商品售罄，商品售罄我们要第一时间通知兄弟节点，更新状态位，所以在这里发送redis广播

4，将订单记录放入redis缓存，说明用户已经获得下单资格，秒杀成功

5，秒杀成功要更新库存

5.2.1 SeckillReceiver添加监听方法

/**
 * 处理秒杀队列中秒杀请求
 *
 * @param userRecode
 * @param message
 * @param channel
 */
@SneakyThrows
@RabbitListener(bindings = @QueueBinding(
        exchange = @Exchange(MqConst.EXCHANGE_DIRECT_SECKILL_USER),
        value = @Queue(value = MqConst.QUEUE_SECKILL_USER, durable = "true"),
        key = MqConst.ROUTING_SECKILL_USER
))
public void processSeckillRequest(UserRecode userRecode, Message message, Channel channel) {
    try {
        if (userRecode != null) {
            log.info("[秒杀服务]监听到秒杀请求消息:{}", userRecode);
            seckillGoodsService.processSeckillRequest(userRecode);
        }
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    } catch (IOException e) {
        e.printStackTrace();
        log.error("[秒杀服务]处理秒杀请求异常:{}", e);
        channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
    }
}

5.2.2 预下单接口

SeckillGoodsService

/**
 * 处理秒杀队列中下单请求,秒杀订单预处理
 * @param userRecode
 */
void processSeckillRequest(UserRecode userRecode);

5.2.3 实现类

秒杀订单实体类

package com.atguigu.gmall.model.activity;


@Data
public class OrderRecode implements Serializable {

   private static final long serialVersionUID = 1L;

   private String userId;

   private SeckillGoods seckillGoods;

   private Integer num;

   private String orderStr;
}

SeckillGoodsServiceImpl

/**
 * 处理秒杀队列中下单请求,秒杀订单预处理
 *
 * @param userRecode
 */
@Override
public void processSeckillRequest(UserRecode userRecode) {
    //1.从本地缓存中获取商品状态 1:可以继续 0:结束
    String state = (String) CacheHelper.get(userRecode.getSkuId().toString());
    if (StringUtils.isBlank(state)) {
        //秒杀商品以及失效
        return;
    }
    if ("0".equals(state)) {
        //商品已售罄
        return;
    }
    //2.判断用户是否重复下单(是否在排队中)-将用户购买商品存入redis todo:时间截止到今日0点
    String ifQueueKey = RedisConst.SECKILL_USER + userRecode.getUserId() + ":" + userRecode.getSkuId();
    Boolean ifQueue = redisTemplate.opsForValue().setIfAbsent(ifQueueKey, userRecode.getSkuId(), 10, TimeUnit.HOURS);
    if (!ifQueue) {
        //说明用户购买指定商品重复排队
        return;
    }
    //3.从Redis中商品库存List队列中弹数据同时库存List数量减少 成功:秒到(具备购买资格) 失败:售罄-更新本地缓存
    String skuStockKey = RedisConst.SECKILL_STOCK_PREFIX + userRecode.getSkuId();
    BoundListOperations<String, String> stockListOps = redisTemplate.boundListOps(skuStockKey);
    String goodsId = stockListOps.rightPop();
    if (StringUtils.isBlank(goodsId)) {
        //说明分布式缓存中商品库存售罄 发送redis订阅通知,通知每个秒杀服务实例更新本地缓存中商品状态
        String msg = userRecode.getSkuId() + ":0";
        redisTemplate.convertAndSend("seckillpush", msg);
        return;
    }
    //4.生成临时订单(具备抢购资格) 将临时订单存入Redis
    OrderRecode orderRecode = new OrderRecode();
    orderRecode.setUserId(userRecode.getUserId());
    orderRecode.setSeckillGoods(this.getSeckillGoods(userRecode.getSkuId()));
    orderRecode.setNum(1);
    //生成临时订单编号 唯一
    String orderStr = MD5.encrypt(orderRecode.getUserId() + userRecode.getSkuId());
    orderRecode.setOrderStr(orderStr);
    //构建临时订单hash结构的key
    String tempOrderKey = RedisConst.SECKILL_ORDERS;
    BoundHashOperations<String, String, OrderRecode> tempOrderHashOps = redisTemplate.boundHashOps(tempOrderKey);
    tempOrderHashOps.put(userRecode.getUserId(), orderRecode);

    //5.发送更新库存数 消息到MQ
    rabbitService.sendMessage(MqConst.EXCHANGE_DIRECT_SECKILL_STOCK, MqConst.ROUTING_SECKILL_STOCK, userRecode.getSkuId());

}

5.2.4 更新库存

MqConst中增加常量

/**
 * 秒杀减库存
 */
public static final String EXCHANGE_DIRECT_SECKILL_STOCK = "exchange.direct.seckill.stock";
public static final String ROUTING_SECKILL_STOCK = "seckill.stock";
//队列
public static final String QUEUE_SECKILL_STOCK  = "queue.seckill.stock";

监听秒杀减库存：

/**
 * 监听秒杀成功后扣减库存逻辑
 *
 * @param skuId   秒杀商品ID
 * @param message
 * @param channel
 */
@SneakyThrows
@RabbitListener(bindings = @QueueBinding(
        exchange = @Exchange(MqConst.EXCHANGE_DIRECT_SECKILL_STOCK),
        value = @Queue(value = MqConst.QUEUE_SECKILL_STOCK, durable = "true"),
        key = MqConst.ROUTING_SECKILL_STOCK
))
public void processDeductStock(Long skuId, Message message, Channel channel) {
    try {
        if (skuId != null) {
            log.info("[秒杀服务]监听秒杀成功扣减库存消息:{}", skuId);
            seckillGoodsService.deductStock(skuId);
        }
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    } catch (IOException e) {
        e.printStackTrace();
        channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
    }
}

SeckillGoodsService

/**
 * 秒杀成功扣库秒杀商品苦库存
 * @param skuId
 */
void deductStock(Long skuId);

SeckillGoodsServiceImpl

/**
 * 秒杀成功扣库秒杀商品库存
 *
 * @param skuId
 */
@Override
public void deductStock(Long skuId) {
    //1.查询Redis中商品库存List长度--商品最新库存
    String stockListKey = RedisConst.SECKILL_STOCK_PREFIX + skuId;
    BoundListOperations<String, String> stockListOps = redisTemplate.boundListOps(stockListKey);
    Long stockCount = stockListOps.size();
    //2.更新Redis中秒杀商品hash结构中 秒杀信息库存数量
    String seckillGoodsKey = RedisConst.SECKILL_GOODS;
    BoundHashOperations<String, String, SeckillGoods> seckillHashOps = redisTemplate.boundHashOps(seckillGoodsKey);
    SeckillGoods seckillGoods = seckillHashOps.get(skuId.toString());
    if (seckillGoods != null) {
        seckillGoods.setStockCount(stockCount.intValue());
        seckillHashOps.put(skuId.toString(), seckillGoods);

        //3.更新数据库中秒杀商品库存数量
        this.updateById(seckillGoods);
    }
}

5.3 页面轮询接口

思路：

判断用户是否在缓存中存在
判断用户是否抢单成功
判断用户是否下过订单
判断状态位

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/507

5.3.1 控制器

SeckillGoodsController

/**
 * 前端定时发起检查当前用户秒杀商品结果
 *
 * @param skuId 秒杀商品ID
 * @return
 */
@GetMapping("/seckill/auth/checkOrder/{skuId}")
public Result checkOrderResult(HttpServletRequest request, @PathVariable("skuId") Long skuId) {
    String userId = AuthContextHolder.getUserId(request);
    return seckillGoodsService.checkOrderResult(userId, skuId);
}

5.3. 业务接口

SeckillGoodsService接口

/**
 * 前端定时发起检查当前用户秒杀商品结果
 *
 * @param skuId 秒杀商品ID
 * @return
 */
Result checkOrderResult(String userId, Long skuId);

5.3.2 实现类

SeckillGoodsServiceImpl

/**
 * 前端定时发起检查当前用户秒杀商品结果
 *
 * @param skuId 秒杀商品ID
 * @return
 */
@Override
public Result checkOrderResult(String userId, Long skuId) {
    //查询用户对秒杀商品秒杀结果状态:根据响应业务状态码显示不同提示
    //1.判断用户是否在排队,有机会秒杀成功
    String ifQueueKey = RedisConst.SECKILL_USER + userId + ":" + skuId;
    Boolean ifQueue = redisTemplate.hasKey(ifQueueKey);
    if (ifQueue) {
        //2.判断用户是否提交了订单-218 code
        String orderKey = RedisConst.SECKILL_ORDERS_USERS;
        BoundHashOperations<String, String, Long> orderHashOps = redisTemplate.boundHashOps(orderKey);
        if (orderHashOps.hasKey(userId)) {
            //用户提交秒杀订单 获取秒杀成功后订单ID,将订单ID返回
            Long orderId = orderHashOps.get(userId);
            return Result.build(orderId, ResultCodeEnum.SECKILL_ORDER_SUCCESS);
        }

        //3.判断用户是否产生临时订单 - 215code
        String tempOrderKey = RedisConst.SECKILL_ORDERS;
        BoundHashOperations<String, String, OrderRecode> tempOrderHashOps = redisTemplate.boundHashOps(tempOrderKey);
        if (tempOrderHashOps.hasKey(userId)) {
            //用户抢单成功(获取到秒杀下单资格) 将临时订单数据返回
            OrderRecode orderRecode = tempOrderHashOps.get(userId);
            return Result.build(orderRecode, ResultCodeEnum.SECKILL_SUCCESS);
        }
    }

    //4.判断本地缓存中商品状态:0:售罄 1:code:211
    String state = (String) CacheHelper.get(skuId.toString());
    if ("0".equals(state)) {
        return Result.build(null, ResultCodeEnum.SECKILL_FINISH);
    }

    //5.其他情况 211 code
    return Result.build(null, ResultCodeEnum.SECKILL_RUN);
}

5.4 轮询排队页面

该页面有四种状态：

1，排队中

2，各种提示（非法、已售罄等）

3，抢购成功，去下单

4，抢购成功，已下单，显示我的订单

抢购成功，页面显示去下单，跳转下单确认页面

<div class="seckill_dev" v-if="show == 3">
    抢购成功&nbsp;&nbsp;
    <a href="/seckill/trade.html" target="_blank">去下单</a>
</div>

5.5 下单页面

我们已经把下单信息记录到redis缓存中，所以接下来我们要组装下单页数据

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/523

5.5.1 下单页数据数据接口

SeckillGoodsApiController

/**
 * 获取当前登录用户秒杀订单确认页面相关数据
 *
 * @return
 */
@GetMapping("/inner/seckill/auth/trade")
public Result getSeckillOrderTradeDatas(HttpServletRequest request) {
    //获取当前登录用户ID
    String userId = AuthContextHolder.getUserId(request);
    Map<String, Object> tradeDatas = seckillGoodsService.getSeckillOrderTradeDatas(userId);
    return Result.ok(tradeDatas);
}

SeckillGoodsService

/**
 * 获取当前登录用户秒杀订单确认页面相关数据
 *
 * @return
 */
Map<String, Object> getSeckillOrderTradeDatas(String userId);

SeckillGoodsServiceImpl

/**
 * 获取当前登录用户秒杀订单确认页面相关数据
 * ${detailArrayList} 秒杀商品清单
 * ${totalNum}总数
 * ${totalAmount}总金额
 * ${userAddressList} 收件地址列表
 *
 * @return
 */
@Override
public Map<String, Object> getSeckillOrderTradeDatas(String userId) {
    Map<String, Object> tradeMap = new HashMap<>();
    //1.封装秒杀清单数据
    // 1.1 先根据用户ID从临时订单中获取秒杀商品信息
    String tempOrderKey = RedisConst.SECKILL_ORDERS;
    BoundHashOperations<String, String, OrderRecode> tempOrderHashOps = redisTemplate.boundHashOps(tempOrderKey);
    if (tempOrderHashOps.hasKey(userId)) {
        // 1.2 将秒杀商品SeckillGoods转为OrderDetail对象
        OrderRecode orderRecode = tempOrderHashOps.get(userId);
        if (orderRecode != null) {
            SeckillGoods seckillGoods = orderRecode.getSeckillGoods();
            if (seckillGoods != null) {
                OrderDetail orderDetail = new OrderDetail();
                orderDetail.setImgUrl(seckillGoods.getSkuDefaultImg());
                orderDetail.setSkuName(seckillGoods.getSkuName());
                orderDetail.setOrderPrice(seckillGoods.getCostPrice());
                orderDetail.setSkuNum(orderRecode.getNum());
                List<OrderDetail> orderDetailList = Arrays.asList(orderDetail);
                tradeMap.put("detailArrayList", orderDetailList);
                //2. 封装商品总数+商品总金额
                tradeMap.put("totalNum", orderRecode.getNum());

                OrderInfo orderInfo = new OrderInfo();
                orderInfo.setOrderDetailList(orderDetailList);
                orderInfo.sumTotalAmount();
                tradeMap.put("totalAmount", orderInfo.getTotalAmount());
            }
        }
    }
    //3.封装收件地址列表:远程调用用户微服务查询收件地址列表
    List<UserAddress> userAddressList = userFeignClient.getUserAddressListByUserId(Long.valueOf(userId));
    if (!CollectionUtils.isEmpty(userAddressList)) {
        tradeMap.put("userAddressList", userAddressList);
    }
    return tradeMap;
}

5.5.2 service-activity-client添加接口

ActivityFeignClient

/**
 * 获取当前登录用户秒杀订单确认页面相关数据
 *
 * @return
 */
@GetMapping("/api/activity/inner/seckill/auth/trade")
public Result<Map> getSeckillOrderTradeDatas();

ActivityDegradeFeignClient服务降级方法

@Override
public Result<Map> getSeckillOrderTradeDatas() {
    return null;
}

5.5.3 web-all 编写去下单控制器

SeckillController

@Autowired
private ActivityFeignClient activityFeignClient;


/**
 * 渲染秒杀订单确认页面
 *
 * @return
 */
@GetMapping("/seckill/trade.html")
public String seckillOrderTradeHtml(Model model) {
    //远程调用秒杀服务获取相关数据
    Result<Map> result = activityFeignClient.getSeckillOrderTradeDatas();
    model.addAllAttributes(result.getData());
    return "/seckill/trade";
}

5.5.4 提交订单

该页面与正常下单页面类似，只是下单提交接口不一样，因为秒杀下单不需要正常下单的各种判断，因此我们要在订单服务提供一个秒杀下单接口，直接下单

5.5.4.1 service-order模块提供秒杀下单接口

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/795

OrderApiController

/**
 * 提供给秒杀服务调用RestFul接口实现:保存秒杀订单
 * @param orderInfo
 * @return 保存后秒杀订单ID
 */
@PostMapping("/inner/seckill/submitOrder")
public Long submitSeckillOrder(@RequestBody OrderInfo orderInfo){
    return orderInfoService.submitSeckillOrder(orderInfo);
}

OrderInfoService

/**
 * 保存秒杀订单
 * @param orderInfo
 * @return
 */
Long submitSeckillOrder(OrderInfo orderInfo);

OrderInfoServiceImpl

/**
 * 保存秒杀订单
 *
 * @param orderInfo
 * @return
 */
@Override
public Long submitSeckillOrder(OrderInfo orderInfo) {
    saveOrder(orderInfo, "2");
    return orderInfo.getId();
}

/**
 * 保存订单方法(抽取公共方法)
 *
 * @param orderInfo
 * @param orderType 订单类型 1:普通订单 2:秒杀订单
 */
private void saveOrder(OrderInfo orderInfo, String orderType) {
    List<OrderDetail> orderDetailList = orderInfo.getOrderDetailList();
    //4.保存订单信息
    //4.1 封装订单表中其他信息
    orderInfo.sumTotalAmount();
    orderInfo.setOriginalTotalAmount(orderInfo.getTotalAmount());
    orderInfo.setOrderStatus(OrderStatus.UNPAID.name());
    orderInfo.setProcessStatus(ProcessStatus.UNPAID.name());
    orderInfo.setPaymentWay(PaymentType.ALIPAY.name());
    //生成订单编号(唯一)
    String outTradeNo = "";
    Calendar calendar = Calendar.getInstance();
    if ("2".equals(orderType)) {
        outTradeNo = "ATGUIGUMS" + System.currentTimeMillis() + new Random().nextInt(1000);
        calendar.add(Calendar.MINUTE, 5);
        orderInfo.setExpireTime(calendar.getTime());
    } else {
        outTradeNo = "ATGUIGU" + System.currentTimeMillis() + new Random().nextInt(1000);
        calendar.add(Calendar.DATE, 1);
        orderInfo.setExpireTime(calendar.getTime());
    }
    orderInfo.setOutTradeNo(outTradeNo);
    //获取商品名称
    if (!CollectionUtils.isEmpty(orderDetailList)) {
        String tradeBody = orderDetailList.stream().map(OrderDetail::getSkuName).collect(Collectors.joining(","));
        if (tradeBody.length() > 100) {
            orderInfo.setTradeBody(tradeBody.substring(0, 100));
        } else {
            orderInfo.setTradeBody(tradeBody);
        }
        orderInfo.setImgUrl(orderDetailList.get(0).getImgUrl());
    }
    orderInfo.setOperateTime(new Date());
    //失效时间:24小时 超过该时间订单关闭
    orderInfo.setProvinceId(1L); //正常按照前端提交地址ID查询用户地址信息
    calendar.add(Calendar.DATE, 30);
    orderInfo.setRefundableTime(calendar.getTime());
    //4.2 保存订单
    this.save(orderInfo);

    //5.保存订单明细信息
    for (OrderDetail orderDetail : orderDetailList) {
        orderDetail.setOrderId(orderInfo.getId());
        if ("1".equals(orderType)) {
            orderDetail.setSourceId(1L);
            orderDetail.setSourceType("MALL");
        } else {
            orderDetail.setSourceId(2L);
            orderDetail.setSourceType("SECKILL");
        }
    }
    //批量保存订单明细
    orderDetailService.saveBatch(orderDetailList);
}

5.5.4.2 service-order-client模块暴露接口

远程调用API接口方法

/**
 * 提供给秒杀服务调用RestFul接口实现:保存秒杀订单
 * @return 保存后秒杀订单ID
 */
@PostMapping("/api/order/inner/seckill/submitOrder")
public Long submitSeckillOrder(@RequestBody OrderInfo orderInfo);

服务降级方法

@Override
public Long submitSeckillOrder(OrderInfo orderInfo) {
    return null;
}

5.5.4.3 service-activity模块秒杀下单

SeckillGoodsController

/**
 * 前端提交秒杀订单请求
 *
 * @param orderInfo
 * @return
 */
@PostMapping("/seckill/auth/submitOrder")
public Result<Long> submitSeckillOrder(HttpServletRequest request, @RequestBody OrderInfo orderInfo) {
    String userId = AuthContextHolder.getUserId(request);
    orderInfo.setUserId(Long.valueOf(userId));
    Long orderId = seckillGoodsService.submitSeckillOrder(orderInfo);
    return Result.ok(orderId);
}

SeckillGoodsService

/**
 * 保存秒杀订单
 * @param orderInfo
 * @return
 */
Long submitSeckillOrder(OrderInfo orderInfo);

SeckillGoodsServiceImpl

/**
 * 保存秒杀订单
 *
 * @param orderInfo
 * @return
 */
@Override
@Transactional(rollbackFor = Exception.class)
public Long submitSeckillOrder(OrderInfo orderInfo) {
    Long userId = orderInfo.getUserId();
    //1.远程调用订单微服务保存秒杀订单
    Long orderId = orderFeignClient.submitSeckillOrder(orderInfo);
    //2.删除用户秒杀过程中产生临时订单
    String tempOrderKey = RedisConst.SECKILL_ORDERS;
    BoundHashOperations<String, String, OrderRecode> tempOrderHashOps = redisTemplate.boundHashOps(tempOrderKey);
    if (tempOrderHashOps.hasKey(userId.toString())) {
        tempOrderHashOps.delete(userId.toString());
    }
    //3.保存用户秒杀订单记录存储到Redis中
    String seckillOrderKey = RedisConst.SECKILL_ORDERS_USERS;
    BoundHashOperations<String, String, Long> seckillOrderHashOps = redisTemplate.boundHashOps(seckillOrderKey);
    seckillOrderHashOps.put(userId.toString(), orderId);
    return orderId;
}

页面提交订单代码片段

submitOrder() {
    seckill.submitOrder(this.order).then(response => {
        if (response.data.code == 200) {
            window.location.href = 'http://payment.gmall.com/pay.html?orderId=' + response.data.data
        } else {
            alert(response.data.message)
        }
    })
},

说明：下单成功后，后续流程与正常订单一致

5.6 秒杀结束清空redis缓存

秒杀过程中我们写入了大量redis缓存，我们可以在秒杀结束或每天固定时间清除缓存，释放缓存空间；

实现思路：假如根据业务，我们确定每天18点所有秒杀业务结束，那么我们编写定时任务，每天18点发送mq消息，service-activity模块监听消息清理缓存

service-task发送消息

5.6.1 添加常量MqConst类

/**
 * 定时任务
 */
public static final String ROUTING_TASK_18 = "seckill.task.18";
//队列
public static final String QUEUE_TASK_18  = "queue.task.18";

5.6.2 编写定时任务发送消息

service-task模块ScheduledTask增加定时任务

/**
 * 每天晚上18点发送消息，通知秒杀服务清理Redis缓存
 */
//@Scheduled(cron = "0 0 18 * * ?") //正式
@Scheduled(cron = "0/30 * * * * ?")
public void sendClearSeckillGoodsCache() {
    log.info("定时任务执行了");
    rabbitService.sendMessage(MqConst.EXCHANGE_DIRECT_TASK, MqConst.ROUTING_TASK_18, "");
}

5.6.3 接收消息并处理

Service-activity接收消息

SeckillReceiver

/**
 * 定时清理秒杀当日产生缓存+数据库
 *
 * @param message
 * @param channel
 */
@SneakyThrows
@RabbitListener(bindings = @QueueBinding(
        exchange = @Exchange(MqConst.EXCHANGE_DIRECT_TASK),
        value = @Queue(value = MqConst.QUEUE_TASK_18, durable = "true"),
        key = MqConst.ROUTING_TASK_18
))
public void processCleanCache(Message message, Channel channel) {
    try {
        log.info("[秒杀服务] 清理秒杀当日产生缓存");
        seckillGoodsService.processCleanCache();
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    } catch (IOException e) {
        e.printStackTrace();
        channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
    }
}

SeckillGoodsServiceImpl

/**
 * 清理秒杀当天产生缓存数据+数据库秒杀商品状态
 */
@Override
public void processCleanCache() {
    //1.获取当日参与秒杀所有商品-从缓存Hash结构中
    String seckillGoodsKey = RedisConst.SECKILL_GOODS;
    BoundHashOperations<String, String, SeckillGoods> seckillGoodsHashOps = redisTemplate.boundHashOps(seckillGoodsKey);
    List<SeckillGoods> seckillGoodsList = seckillGoodsHashOps.values();
    if (!CollectionUtils.isEmpty(seckillGoodsList)) {
        //2.清除每个商品库存List结构
        for (SeckillGoods seckillGoods : seckillGoodsList) {
            String stockListKey = RedisConst.SECKILL_STOCK_PREFIX + seckillGoods.getSkuId();
            redisTemplate.delete(stockListKey);
            //6.修改数据库中秒杀商品状态 改为 "2"
            seckillGoods.setStatus("2");
            this.updateById(seckillGoods);
        }
    }
    //3.清理所有产生秒杀订单缓存hash
    String seckillOrderKey = RedisConst.SECKILL_ORDERS_USERS;
    redisTemplate.delete(seckillOrderKey);
    //4.删除秒杀商品Hash
    redisTemplate.delete(seckillGoodsKey);
    //5.删除本地缓存中商品状态位
    CacheHelper.removeAll();
}

说明：清空redis缓存，同时更改秒杀商品活动结束

秒杀下单，提交成功，页面通过轮询后台方法查询秒杀状态

第16章-秒杀.md 75 KB Permalink History Raw

第16章-订单秒杀

1、秒杀业务分析

1.1 需求分析

1.2 秒杀功能分析

1.3 数据库表

2、搭建秒杀模块

2.1 搭建service-activity模块

2.1.1 搭建service-activity

2.1.2 修改pom.xml

2.1.3 启动类

2.1.3 添加配置

2.2 搭建service-activity-client模块

2.3 添加依赖，配置网关

2.3.1 在web-all中引入依赖

3、秒杀商品导入缓存

3.1 编写定时任务

3.1.1 搭建service-task服务

3.1.2 修改配置pom.xml

3.1.3 启动类

3.1.4 添加配置文件

3.1.4 添加定时任务

3.2 监听定时任务信息

3.2.1 数据导入缓存

3.2.1.1 在service-util的RedisConst类中定义常量

3.2.1.2 监听消息

3.2.1.3 SeckillGoodsMapper

3.2.2 更新状态位

3.2.2.1 redis发布与订阅实现

3.2.2.2 redis发布消息

4、秒杀列表与详情

4.1 封装秒杀列表与详情接口

4.1.1 完成控制器

4.1.2 业务接口

4.1.2 业务实现类

4.2 在service-activity-client模块添加接口

4.3 页面渲染

4.3.1 在web-all 中编写控制器

4.3.2 秒杀详情页面功能介绍

4.3.2.1 web-all添加商品详情控制器

4.3.2.2 详情页面介绍

4.3.2.2.1 基本信息渲染

4.3.2.2.2 倒计时处理

4.3.2.3 秒杀按钮控制

4.3.2.3.1 获取抢购码

4.3.2.3.2 前端页面

4.3.3 编写排队控制器

5、整合秒杀业务

5.1 秒杀下单

5.1.1 添加mq常量MqConst类

5.1.2 定义实体UserRecode

5.1.3 编写控制器

5.1.4 业务层接口

5.1.5 业务层实现

5.2 秒杀下单监听

5.2.1 SeckillReceiver添加监听方法

5.2.2 预下单接口

5.2.3 实现类

5.2.4 更新库存

5.3 页面轮询接口

5.3.1 控制器

5.3. 业务接口

5.3.2 实现类

5.4 轮询排队页面

5.5 下单页面

5.5.1 下单页数据数据接口

5.5.2 service-activity-client添加接口

5.5.3 web-all 编写去下单控制器

5.5.4 提交订单

5.5.4.1 service-order模块提供秒杀下单接口

5.5.4.2 service-order-client模块暴露接口

5.5.4.3 service-activity模块秒杀下单

5.6 秒杀结束清空redis缓存

5.6.1 添加常量MqConst类

5.6.2 编写定时任务发送消息

5.6.3 接收消息并处理

第16章-秒杀.md 75 KB

Permalink History Raw