秒杀业务的实现

最新推荐文章于 2024-06-18 11:02:20 发布
最新推荐文章于 2024-06-18 11:02:20 发布
阅读量58 收藏
点赞数
文章标签： 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78471233/article/details/134292093
版权

需求: 设计一个高并发下的秒杀架构最核心的业务:
1、防止同一个用户多次秒杀一件商品
2、判断库存是否充足
3、下单业务:将订单信息写入数据库 同时要递减数据库中的库存4、redis 预热秒杀的商品，需要参与秒杀的商品提前存到 redis 中，包括库存

使用的技术栈

  1. Springboot

  2. redis

  3. rabbitma

  4. Mysql

  5. MybatisPlus (mybatis)

 结构图

代码结构

 spike-server的pom依赖

     <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-extension</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.0</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>8.0.33</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>

        <!--连接池信息-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.16</version>
        </dependency>
        <!--布隆过滤器-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.3.9</version>
        </dependency>
        <!--分布式锁-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.7.5</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

  spike-web的pom依赖

    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.3.9</version>
        </dependency>
    </dependencies>

 spike-server配置yml文件

server:
  port: 8081
spring:
  application:
    name: spike-server
  redis:
    port: 6379
    host: 192.168.224.129
    password: 22ebiwdqnok2
    database: 0
  rabbitmq:
    username: yl
    password: admin
    virtual-host: /yl
    host: 192.168.224.129
    port: 5672
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/spike?userUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: admin
    type: com.alibaba.druid.pool.DruidDataSource
    dbcp2:
      min-idle: 5
      initial-size: 10
      max-total: 50
      max-wait-millis: 2000
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: cn.yl.spike.vo
  mapper-locations: classpath*:cn/yl/spike/service/mapper/xml/*.xml

 spike-web配置yml文件

server:
  port: 8080
spring:
  rabbitmq:
    port: 5672
    host: 192.168.224.129
    virtual-host: /yl
    username: yl
    password: admin
    listener:
      simple:
        acknowledge-mode: manual
  application:
    name: spike-web
  redis:
    host: 192.168.224.129
    port: 6379
    password: 22ebiwdqnok2@lo
    database: 0

spike-server代码

启动类

import cn.hutool.bloomfilter.BitMapBloomFilter;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;


// Generated by https://start.springboot.io
// 优质的 spring/boot/data/security/cloud 框架中文文档尽在 => https://springdoc.cn
@SpringBootApplication
@MapperScan(basePackages = "cn.yl.spike.mapper")
public class SpikeServerApplication {

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

    /**
     * 布隆过滤器
     * @return
     */
    @Bean
    public BitMapBloomFilter bitMapBloomFilter() {
        return new BitMapBloomFilter(100);
    }
}

utils配置类

import cn.yl.spike.service.GoodsService;
import cn.yl.spike.vo.Goods;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;

//CommandLineRunner初始户化数据接口实现类

@Component
public class MysqlToRedis implements CommandLineRunner {
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private GoodsService goodsService;

    public void goodsToRedis() {
        //封装查询数据
        QueryWrapper<Goods> goodsQueryWrapper = new QueryWrapper<>();
        goodsQueryWrapper.eq("spike", 1);
        List<Goods> list = goodsService.list(goodsQueryWrapper);
        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        //将查询的商品库存同步到redis中
        list.forEach(goods -> {
            redisTemplate.opsForValue().set(goods.getGoodsId() + "stock", goods.getTotalStocks().toString());
        });
    }

    @Override
    public void run(String... args) throws Exception {
        this.goodsToRedis();
    }
}

 

import cn.hutool.bloomfilter.BitMapBloomFilter;
import cn.yl.spike.service.OrderTableService;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.rabbitmq.client.Channel;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class SpikeConsumer {
    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private BitMapBloomFilter bloomFilter;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private OrderTableService orderTableService;

    private final String LOCK_KEY = "spike-lock";

    @RabbitListener(queues = "spike-web") //监听spike-web队列
    private void handlerSpikeMessage(Message message, Channel channel) {
        //获取分布式公平锁
        RLock fairLock = redissonClient.getFairLock(LOCK_KEY);
        //看门狗机制获取到锁执行后面代码,否则等待
        fairLock.lock();
        //取得队列中的消息
        String spikeMessage = new String(message.getBody());
        //执行核心业务方法
        JSONObject jsonObject = JSON.parseObject(spikeMessage);
        //取得商品编号和用户编号
        Integer userId = jsonObject.getInteger("userId");
        Integer goodsId = jsonObject.getInteger("goodsId");
        //判断库存
        long stock = Long.parseLong(redisTemplate.opsForValue().get(goodsId + "stock"));
        if (stock <= 0) {
            return;
        }
        //取得消息编号
        String messageId = message.getMessageProperties().getMessageId();
        //取得投递编号
        long tag = message.getMessageProperties().getDeliveryTag();
        //判断是否重复消费
        try {
            if (bloomFilter.contains(messageId)) {
                channel.basicAck(tag, false);
                return;
            }
            orderTableService.addOrder(userId, goodsId);
            channel.basicAck(tag, false);
            //更新redis中递减的库存
            redisTemplate.opsForValue().decrement(goodsId + "stock");
            bloomFilter.add(messageId);//存储消费编号

        } catch (Exception e) {
            try {
                channel.basicAck(tag, false);
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
            e.printStackTrace();
        } finally {
            //释放锁
            fairLock.unlock();
        }
    }
}

 redisson配置类

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

//redisson配置类
@Configuration
public class RedissonConfig {
    @Value("${spring.redis.host}")
    private String host;//主机地址
    @Value("${spring.redis.port}")
    private String port;//主机端口
    @Value("${spring.redis.password}")
    private String password;//密码

    /**
     * 生成redisson客户端对象
     *
     * @return
     */
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
        return Redisson.create(config);
    }
}

spike-web代码

启动类

import cn.hutool.bloomfilter.BitMapBloomFilter;
import org.springframework.amqp.core.Queue;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class SpikeWebApplication {

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

    @Bean
    public BitMapBloomFilter bitMapBloomFilter() {
        return new BitMapBloomFilter(100);
    }

    @Bean
    Queue queue() {
        return new Queue("spike-web");
    }
}

控制层

import cn.hutool.bloomfilter.BitMapBloomFilter;
import com.alibaba.fastjson.JSON;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.UUID;

@RestController
@CrossOrigin  //开启跨域支持
public class SpikeController {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private BitMapBloomFilter bitMapBloomFilter;

    @GetMapping("spike/{userId}/{goodsId}")
    public Object doSpike(@PathVariable Integer userId
            , @PathVariable Integer goodsId, HttpServletResponse response) {
        //设置商品的唯一标识
        String spikeId = userId + "-" + goodsId;
        //判断是否已经参与过
        if (bitMapBloomFilter.contains(spikeId)) {
            return "你已参加过秒杀活动,请选择其他秒杀商品";
        }
        //判断库存
        Long stoke = Long.parseLong(redisTemplate.opsForValue().get(goodsId + "stock"));
        if (stoke < 1) {
            return "该商品已被抢购一空,请选择其他商品";
        }
        //参与过秒杀,添加到过滤器中
        bitMapBloomFilter.add(spikeId);
        //封装发送信息
        Map<String, Integer> spikeMessage = Map.of("userId", userId, "goodsId", goodsId);
        //发送消息
        rabbitTemplate.convertAndSend("", "spike-web", JSON.toJSONString(spikeMessage), message -> {
            MessageProperties messageProperties = message.getMessageProperties();
            String messageId = UUID.randomUUID().toString().replaceAll("-", "");
            messageProperties.setMessageId(messageId);
            return message;
        });
        return "正在拼命抢购中,请稍后查看订单详情...";
    }
}

cn-yl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【Redis实现秒杀业务①】秒杀流程概述｜基本业务实现
梵高
06-23 695
我们大概的思路就是设计一个水果秒杀小项目。首先我们会有一种水果，该水果拥有名字、数量、抢购开始时间和抢购结束时间。
秒杀业务实现
10-29
相对完善的秒杀业务实现，代码应用spring boot+mybatis+redis+activemq+mysql实现，对我们理解高并发业务场景设计有很大帮助，欢迎大家前来下载
秒杀产品的产品分析及业务实现
qq_58480518的博客
11-13 960
对秒杀进行产品分析，设计实现商品秒杀功能(缓存预热库存\随机码\布隆过滤器,检查重复购买和防止超卖,生成订单,消息队列,流控)
秒杀实现思路
iceking7的博客
04-05 1397
今日目标: 秒杀实现思路     实现秒杀下单功能          完成下单并发产生的订单异常问题  超卖     完成高并发下用户下单排队和超限问题 一.秒杀的思路分析 1.需求分析: 所谓“秒杀”，就是网络卖家发布一些超低价格的商品，所有买家在同一时间网上抢购的一...
秒杀如何设计及实现
初听不知曲中意，再听已是曲中人。
05-16 1621
互联网正在高速发展，使用互联网服务的用户越多，高并发的场景也变得越来越多。电商秒杀和抢购，是两个比较典型的互联网高并发场景。虽然我们解决问题的具体技术方案可能千差万别，但是遇到的挑战却是相似的，因此解决问题的思路也异曲同工。
秒杀系统的业务流程以及优化方案(实现异步秒杀)
adru的博客
08-25 1462
确定了我们可以将判断库存和检验一人一单业务抽取出来之后，我们在想一下 还能不能优化，这个时候我们会发现，这两个操作还是在数据库进行的，那么mysql的并发本身也是不高的，现在我们就要通过另一个性能更好的数据库进行实现，就是。首先我们要思考怎么对业务进行拆分，可以想象一个我们去饭店点餐，会有前台接待，询问订单，之后将小票传给后厨去做饭，这样就会快很多，也可以接待更多的客人。如果有下单资格就可以将用户id，优惠券id，和订单id存入一个阻塞队列里面，之后异步进行写入数据库操作。
秒杀业务分析
xinyi_java的博客
08-22 1610
秒杀 1 秒杀业务分析 1.1 需求分析 所谓“秒杀”，就是网络卖家发布一些超低价格的商品，所有买家在同一时间网上抢购的一种销售方式。通俗一点讲就是网络商家为促销等目的组织的网上限时抢购活动。由于商品价格低廉，往往一上架就被抢购一空，有时只用一秒钟。 秒杀商品通常有两种限制：库存限制、时间限制。 需求： （1）录入秒杀商品数据，主要包括：商品标题、原价、秒杀价、商品图片、介绍、秒杀时段等信息 （2）秒杀频道首页列出秒杀商品（进行中的）点击秒杀商品图片跳
秒杀业务分析--redis锁实现
m0_64116616的博客
05-13 657
利用乐观锁和悲观锁解决秒杀业务中的并发问题--reids实现
java实现秒杀业务
Richard_666的博客
01-26 292
秒杀实现技巧
m0_53914150的博客
12-04 788
需求分析 “秒杀”这个词在电商行业中出现的频率较高，如京东或者淘宝平台的各种“秒杀”活动，最典型的就是“双11抢购”。 “秒杀”是指在有限的时间内对有限的商品数量进行抢购的一种行为，这是商家以“低价量少”的商品来获取用户的一种营销手段。 01. 功能性需求 其实，整个秒杀的业务场景并不复杂，可即查看参与秒杀的商品信息，加上购买和支付的动作，如下图所示。 秒杀业务最大的挑战在于3点： 瞬时：持续时间极短，对于热门且具备极强竞争力的商品通常只有一秒。 流量巨大：因为价格低廉，
限时秒杀业务及技术实现解决方案
qq_31432773的博客
05-22 2232
做电商的小伙伴们应该都接触过秒杀活动：像京东秒杀、聚划算秒杀、网易考拉秒杀等等，现在就跟着我来看一下秒杀到底是如何设计并开展的吧！
秒杀业务实现.xmind
09-12
秒杀业务实现
项目实现秒杀
04-12
秒杀业务分析、架构规则、高并发带来的挑战、高并发下的数据安全以及秒杀的三种优化思路
秒杀业务详解
01-29
通过学习此文件，可以详细的了解秒杀的操作流程和代码书写
如何通过SpringBoot实现商城秒杀系统
08-25
"如何通过SpringBoot实现商城秒杀系统" 本文主要介绍了如何通过SpringBoot实现商城秒杀系统。该系统主要包括用户登陆、商品秒杀、订单生成和邮件通知等功能。下面将对该系统的实现进行详细的介绍。 系统架构 该...
1. zookeeper分布式协调者
u010198709的博客
06-18 615
作用：分布式系统中，用于协调者、集群管理、配置管理、命名服务, 解决分布式系统中一致性的问题开源、Apache组件。
MinIO Enterprise Cache：实现超性能的分布式 DRAM 缓存
MinIO
06-17 421
MinIO Cache 是一种缓存服务，它使用内存来缓存经常访问的对象。MinIO Cache 专为 MinIO 企业对象存储构建，是 MinIO 的最佳缓存服务，与不了解 MinIO 对象存储的通用缓存服务不同。如果从 MinIO 缓存请求对象，并且缓存中不存在该对象，则 MinIO 缓存将为您获取该对象并将其放入缓存中以供后续请求使用。此外，MinIO 缓存利用“一致哈希”方案在节点横向扩展操作和节点故障期间进行高效的对象管理。
分布式光纤测温DTS使用的单模光纤与多模光纤有何区别？
厘米级分布式光纤传感
06-17 503
单模光纤是一种在光纤通信中应用广泛的光纤类型，几乎所有的光纤入户和主干线通信都采用单模光纤。无锡布里渊作为分布式光纤测温DTS领域的领先企业，凭借其技术实力和丰富的经验，能够提供可靠的单模分布式光纤测温产品和解决方案。因此，虽然多模光纤的传输距离相对较短，但其光能量传输能力仍然可观，更适用于20公里以内的分布式光纤测温应用。总之，单模光纤和多模光纤在分布式光纤测温DTS中具有不同的应用特点。无锡布里渊作为专业的厂家，能够根据客户需求提供单模分布式光纤测温产品和解决方案，以满足不同应用场景的要求。
QT自定义标题栏窗口，实现拖动及可拉伸效果
最新发布
06-20
QT自定义标题栏窗口，实现拖动及可拉伸效果
java 实现秒杀业务的重点
06-02
实现秒杀业务的重点有以下几个方面： 1. 高并发处理：秒杀业务的特点是短时间内有大量用户同时请求，因此需要考虑如何处理高并发请求。可以采用分布式缓存、消息队列等技术来缓解并发量，同时需要对数据库连接池、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值