• 设计高并发秒杀系统：保障稳定性与数据一致性



    ✨✨谢谢大家捧场，祝屏幕前的小伙伴们每天都有好运相伴左右，一定要天天开心哦！✨✨ 
    🎈🎈作者主页： 喔的嘛呀🎈🎈

    目录

    引言

    一. 系统架构设计

    1. 系统架构图

    二、 系统流程

    三、流程实现（简单代码示范）

    1、用户访问秒杀页面，点击秒杀按钮发起秒杀请求

    前端部分（HTML + JavaScript）：

    后端部分（Java + Spring Boot）：

    2、前端负载均衡器将请求分发到多个前端应用服务器上。

    Nginx配置示例：

    Apache配置示例：

    3、前端应用服务器验证用户身份，检查秒杀活动是否开始，是否已经结束。

    前端应用服务器（使用Java + Spring Boot）：

    4、前端应用服务器请求缓存服务器获取商品信息和库存数量

    前端应用服务器（Java + Spring Boot）：

    5、缓存负载均衡器将请求分发到多个缓存应用服务器上。

    Redis Cluster配置示例：

    Memcached Cluster配置示例：

    缓存应用服务器（Java + Spring Boot）：

    6、缓存应用服务器返回商品信息和库存数量给前端应用服务器

    缓存应用服务器（Java + Spring Boot）：

    7、前端应用服务器根据库存数量判断是否可以参与秒杀，如果可以则生成订单。

    前端应用服务器（Java + Spring Boot）：

    8、前端应用服务器将订单信息发送到后端负载均衡器

    前端应用服务器（Java + Spring Boot）：

    8、后端负载均衡器将请求分发到多个后端应用服务器上

    后端负载均衡器（简化示例）：

    9、后端应用服务器消费订单信息，根据订单信息生成订单，并更新库存数量。

    后端应用服务器（Java + Spring Boot）：

    10、后端应用服务器将订单信息写入数据库集群

    后端应用服务器（Java + Spring Boot）：

    11、 分布式锁用于保护对库存数量的操作，确保数据的一致性。

    后端应用服务器（Java + Spring Boot）：

     总结

    引言

    设计高并发秒杀系统是一个挑战性的任务，需要考虑到系统的性能、稳定性和数据一致性。本文将介绍如何设计一个高并发的秒杀系统，使用消息队列和分布式锁来确保系统的稳定性和数据一致性。

    一. 系统架构设计

    我们的高并发秒杀系统将采用以下架构：

    • 前端页面：提供秒杀活动的入口，展示商品信息和剩余库存数量。
    • 后端服务：处理用户请求，验证用户身份，检查库存，并生成订单。
    • 数据库：存储商品信息和订单信息。
    • 缓存：缓存商品信息和库存数量，减少对数据库的访问压力。
    • 消息队列：用于异步处理订单生成和库存扣减操作，确保系统的高可用性和稳定性。
    • 分布式锁：用于保护对库存数量的操作，确保数据一致性。

    1. 系统架构图

    1.                                         +-------------------------------------+
    2.                                         |             前端负载均衡器                |
    3.                                         +-----------+--------------+--------------+
    4.                                                     |                          |
    5.                                         +-----------v--------------+--------------+
    6.                                         |        前端应用服务器           |       CDN      |
    7.                                         +-----------+--------------+--------------+
    8.                                                     |                          |
    9.         +----------------------+---------v----------+--------------+-------v--------+-------------+
    10.         |            缓存层                |         |          后端应用服务器           |       数据库集群      |
    11.         +-----------+--------------+         +-----------+--------------+--------------+
    12.                     |                          |                          |
    13.         +-----------v--------------+         +-----------v--------------+--------------+
    14.         |          缓存服务器           |         |         消息队列              |       主数据库         |
    15.         +-----------+--------------+         +-----------+--------------+--------------+
    16.                     |                          |                          |
    17.         +-----------v--------------+         +-----------v--------------+
    18.         |        缓存存储(Redis)    |         |     业务数据存储(MySQL)    |
    19.         +---------------------------+         +---------------------------+

    在这个架构中：

    • 前端负载均衡器：负责将用户请求分发到多个前端应用服务器和CDN上，实现请求的负载均衡，如Nginx。
    • 前端应用服务器：处理用户请求，包括验证用户身份、检查秒杀活动是否开始、是否已经结束等，如Tomcat。
    • CDN：用于加速网页内容传输，提高访问速度和用户体验。
    • 缓存层：使用缓存层存储热点数据，减轻数据库压力，如Redis。
    • 缓存服务器：用于存储缓存数据，如Redis服务器。
    • 消息队列：用于处理订单生成和库存扣减等业务逻辑，提高系统的并发处理能力，如RabbitMQ。
    • 业务数据存储：存储业务数据，如MySQL数据库集群。

    通过以上架构设计，可以实现一个高并发的秒杀系统，保证系统的性能、稳定性和数据一致性，为用户提供良好的秒杀体验。

    二、 系统流程

    1. 用户访问秒杀页面，点击秒杀按钮发起秒杀请求。
    2. 前端负载均衡器将请求分发到多个前端应用服务器上。
    3. 前端应用服务器验证用户身份，检查秒杀活动是否开始，是否已经结束。
    4. 前端应用服务器请求缓存服务器获取商品信息和库存数量。
    5. 缓存负载均衡器将请求分发到多个缓存应用服务器上。
    6. 缓存应用服务器返回商品信息和库存数量给前端应用服务器。
    7. 前端应用服务器根据库存数量判断是否可以参与秒杀，如果可以则生成订单。
    8. 前端应用服务器将订单信息发送到后端负载均衡器。
    9. 后端负载均衡器将请求分发到多个后端应用服务器上。
    10. 后端应用服务器消费订单信息，根据订单信息生成订单，并更新库存数量。
    11. 后端应用服务器将订单信息写入数据库集群。
    12. 分布式锁用于保护对库存数量的操作，确保数据的一致性。

    三、流程实现（简单代码示范）

    1、用户访问秒杀页面，点击秒杀按钮发起秒杀请求

    流程如下：

    前端部分（HTML + JavaScript）：

    1. <!DOCTYPE html>
    2. <html>
    3. <head>
    4.     <title>秒杀页面</title>
    5. </head>
    6. <body>
    7.     <h1>欢迎参加秒杀活动！</h1>
    8.     <button id="seckillButton">秒杀按钮</button>
    9.     <div id="result"></div>
    10.  
    11.     <script>
    12.         document.getElementById("seckillButton").addEventListener("click", function() {
    13.             // 模拟用户ID和商品ID
    14.             var userId = 123;
    15.             var productId = 456;
    16.  
    17.             fetch("/seckill", {
    18.                 method: "POST",
    19.                 headers: {
    20.                     "Content-Type": "application/json"
    21.                 },
    22.                 body: JSON.stringify({ userId: userId, productId: productId })
    23.             })
    24.             .then(response => response.json())
    25.             .then(data => {
    26.                 document.getElementById("result").innerText = data.message;
    27.             });
    28.         });
    29.     </script>
    30. </body>
    31. </html>

    后端部分（Java + Spring Boot）：

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.web.bind.annotation.PostMapping;
    4. import org.springframework.web.bind.annotation.RequestBody;
    5. import org.springframework.web.bind.annotation.RestController;
    6.  
    7. @SpringBootApplication
    8. public class SeckillApplication {
    9.  
    10.     private boolean seckillStarted = true; // 模拟秒杀活动是否开始
    11.     private int stock = 10; // 模拟商品库存
    12.  
    13.     public static void main(String[] args) {
    14.         SpringApplication.run(SeckillApplication.class, args);
    15.     }
    16.  
    17.     @RestController
    18.     public class SeckillController {
    19.  
    20.         @PostMapping("/seckill")
    21.         public String seckill(@RequestBody SeckillRequest request) {
    22.             if (!seckillStarted) {
    23.                 return "秒杀活动未开始";
    24.             }
    25.  
    26.             if (stock <= 0) {
    27.                 return "商品已售罄";
    28.             }
    29.  
    30.             // 模拟生成订单
    31.             stock--;
    32.             return "秒杀成功";
    33.         }
    34.     }
    35.  
    36.     public static class SeckillRequest {
    37.         private Long userId;
    38.         private Long productId;
    39.  
    40.         // 省略getter和setter方法
    41.     }
    42. }

    2、前端负载均衡器将请求分发到多个前端应用服务器上。

    前端负载均衡器将请求分发到多个前端应用服务器上，可以通过配置负载均衡器（如Nginx、Apache等）来实现。以下是一个简单的示例：

    假设有两台前端应用服务器，分别运行在不同的端口上（假设为8001和8002）。

    Nginx配置示例：

    1. upstream frontends {
    2.     server 127.0.0.1:8001;
    3.     server 127.0.0.1:8002;
    4. }
    5.  
    6. server {
    7.     listen 80;
    8.     server_name example.com;
    9.  
    10.     location / {
    11.         proxy_pass http://frontends;
    12.     }
    13. }

    在这个示例中，Nginx配置了一个名为frontends的upstream，其中包含两台前端应用服务器的地址和端口。当收到用户请求时，Nginx会根据一定的负载均衡算法（如轮询、权重等）将请求转发到这些服务器上。

    Apache配置示例：

    1. <Proxy balancer://frontends>
    2.     BalancerMember http://127.0.0.1:8001
    3.     BalancerMember http://127.0.0.1:8002
    4. </Proxy>
    5.  
    6. <VirtualHost *:80>
    7.     ServerName example.com
    8.  
    9.     ProxyPass / balancer://frontends/
    10.     ProxyPassReverse / balancer://frontends/
    11. </VirtualHost>

    在这个示例中，Apache配置了一个名为frontends的负载均衡器，其中包含两台前端应用服务器的地址和端口。当收到用户请求时，Apache会将请求转发到这些服务器上，实现负载均衡。

    3、前端应用服务器验证用户身份，检查秒杀活动是否开始，是否已经结束。

    以下是一个简单的示例，展示前端应用服务器验证用户身份，检查秒杀活动是否开始或结束的过程：

    前端应用服务器（使用Java + Spring Boot）：

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.web.bind.annotation.PostMapping;
    4. import org.springframework.web.bind.annotation.RequestBody;
    5. import org.springframework.web.bind.annotation.RestController;
    6.  
    7. @SpringBootApplication
    8. public class FrontendApplication {
    9.  
    10.     private boolean seckillStarted = true; // 模拟秒杀活动是否开始
    11.     private boolean seckillEnded = false; // 模拟秒杀活动是否结束
    12.  
    13.     public static void main(String[] args) {
    14.         SpringApplication.run(FrontendApplication.class, args);
    15.     }
    16.  
    17.     @RestController
    18.     public class SeckillController {
    19.  
    20.         @PostMapping("/seckill")
    21.         public String seckill(@RequestBody SeckillRequest request) {
    22.             // 验证用户身份，假设用户身份验证通过
    23.             if (!isUserAuthenticated(request.getUserId())) {
    24.                 return "用户身份验证失败";
    25.             }
    26.  
    27.             // 检查秒杀活动是否开始或结束
    28.             if (!isSeckillStarted()) {
    29.                 return "秒杀活动未开始";
    30.             }
    31.  
    32.             if (isSeckillEnded()) {
    33.                 return "秒杀活动已结束";
    34.             }
    35.  
    36.             // 处理秒杀请求
    37.             return "秒杀请求处理中";
    38.         }
    39.  
    40.         private boolean isUserAuthenticated(Long userId) {
    41.             // 省略实际的用户身份验证逻辑
    42.             return true;
    43.         }
    44.  
    45.         private boolean isSeckillStarted() {
    46.             // 省略实际的秒杀活动开始检查逻辑
    47.             return seckillStarted;
    48.         }
    49.  
    50.         private boolean isSeckillEnded() {
    51.             // 省略实际的秒杀活动结束检查逻辑
    52.             return seckillEnded;
    53.         }
    54.     }
    55.  
    56.     public static class SeckillRequest {
    57.         private Long userId;
    58.         private Long productId;
    59.  
    60.         // 省略getter和setter方法
    61.     }
    62. }

    在这个示例中，前端应用服务器通过Spring Boot框架实现了一个简单的/seckill接口，接收用户的秒杀请求。在处理请求之前，先验证用户身份，然后检查秒杀活动是否开始或结束。如果用户身份验证失败，则返回"用户身份验证失败"；如果秒杀活动未开始，则返回"秒杀活动未开始"；如果秒杀活动已结束，则返回"秒杀活动已结束"；否则处理秒杀请求。

    4、前端应用服务器请求缓存服务器获取商品信息和库存数量

    前端应用服务器（Java + Spring Boot）：

    首先，需要在前端应用服务器中配置缓存服务器的地址和端口信息，以便发送请求。

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.web.bind.annotation.PostMapping;
    4. import org.springframework.web.bind.annotation.RequestBody;
    5. import org.springframework.web.bind.annotation.RestController;
    6. import org.springframework.web.client.RestTemplate;
    7.  
    8. @SpringBootApplication
    9. public class FrontendApplication {
    10.  
    11.     private static final String CACHE_SERVER_URL = "http://cache-server:8080"; // 缓存服务器地址
    12.  
    13.     public static void main(String[] args) {
    14.         SpringApplication.run(FrontendApplication.class, args);
    15.     }
    16.  
    17.     @RestController
    18.     public class SeckillController {
    19.  
    20.         private final RestTemplate restTemplate = new RestTemplate();
    21.  
    22.         @PostMapping("/seckill")
    23.         public String seckill(@RequestBody SeckillRequest request) {
    24.             // 请求缓存服务器获取商品信息和库存数量
    25.             String url = CACHE_SERVER_URL + "/product/" + request.getProductId();
    26.             ProductInfo productInfo = restTemplate.getForObject(url, ProductInfo.class);
    27.  
    28.             if (productInfo == null) {
    29.                 return "获取商品信息失败";
    30.             }
    31.  
    32.             // 处理秒杀请求
    33.             return "请求处理中";
    34.         }
    35.     }
    36.  
    37.     public static class SeckillRequest {
    38.         private Long userId;
    39.         private Long productId;
    40.  
    41.         // 省略getter和setter方法
    42.     }
    43.  
    44.     public static class ProductInfo {
    45.         private Long productId;
    46.         private String productName;
    47.         private int stock;
    48.  
    49.         // 省略getter和setter方法
    50.     }
    51. }

    在这个示例中，前端应用服务器使用RestTemplate发送GET请求到缓存服务器的/product/{productId}路由，获取商品信息和库存数量。如果成功获取到商品信息，则继续处理秒杀请求；否则返回"获取商品信息失败"。

    5、缓存负载均衡器将请求分发到多个缓存应用服务器上。

    缓存负载均衡器将请求分发到多个缓存应用服务器上，可以通过配置缓存负载均衡器（如Redis Cluster、Memcached Cluster等）来实现。以下是一个简单的示例：

    假设有两台缓存应用服务器，分别运行在不同的地址和端口上（假设为cache-server1:6379和cache-server2:6379）。

    Redis Cluster配置示例：

    1. # 启动redis-server节点1
    2. redis-server --port 6379
    3.  
    4. # 启动redis-server节点2
    5. redis-server --port 6380
    6.  
    7. # 创建Redis Cluster
    8. redis-cli --cluster create cache-server1:6379 cache-server2:6379 --cluster-replicas 1

    在这个示例中，我们创建了一个包含两个主节点和一个从节点的Redis Cluster。缓存负载均衡器可以将请求分发到这个Redis Cluster上，实现缓存的负载均衡。

    Memcached Cluster配置示例：

    1. # 安装memcached
    2. sudo apt-get update
    3. sudo apt-get install memcached
    4.  
    5. # 启动memcached节点1
    6. memcached -p 11211 -d
    7.  
    8. # 启动memcached节点2
    9. memcached -p 11212 -d
    10.  
    11. # 配置memcached集群
    12. echo "add 127.0.0.1 11212" | nc 127.0.0.1 11211

    在这个示例中，我们创建了一个包含两个节点的Memcached Cluster。缓存负载均衡器可以将请求分发到这个Memcached Cluster上，实现缓存的负载均衡。

    在实际生产环境中，需要根据具体需求和负载情况来配置缓存负载均衡器，并保证缓存服务器之间的数据同步和一致性。

    6、缓存应用服务器返回商品信息和库存数量给前端应用服务器

    缓存应用服务器（Java + Spring Boot）：

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.web.bind.annotation.GetMapping;
    4. import org.springframework.web.bind.annotation.PathVariable;
    5. import org.springframework.web.bind.annotation.RestController;
    6.  
    7. import java.util.HashMap;
    8. import java.util.Map;
    9.  
    10. @SpringBootApplication
    11. public class CacheServerApplication {
    12.  
    13.     private static final Map<Long, ProductInfo> productCache = new HashMap<>();
    14.  
    15.     public static void main(String[] args) {
    16.         SpringApplication.run(CacheServerApplication.class, args);
    17.     }
    18.  
    19.     @RestController
    20.     public class CacheController {
    21.  
    22.         @GetMapping("/product/{productId}")
    23.         public ProductInfo getProductInfo(@PathVariable Long productId) {
    24.             // 从缓存中获取商品信息
    25.             return productCache.getOrDefault(productId, new ProductInfo(productId, "Unknown", 0));
    26.         }
    27.     }
    28.  
    29.     public static class ProductInfo {
    30.         private Long productId;
    31.         private String productName;
    32.         private int stock;
    33.  
    34.         public ProductInfo(Long productId, String productName, int stock) {
    35.             this.productId = productId;
    36.             this.productName = productName;
    37.             this.stock = stock;
    38.         }
    39.  
    40.         // 省略getter和setter方法
    41.     }
    42. }

    在这个示例中，缓存应用服务器通过Spring Boot框架实现了一个简单的/cache接口，接收前端应用服务器的商品信息请求。根据商品ID从缓存中获取商品信息，如果缓存中不存在该商品信息，则返回一个未知商品信息。

    6、缓存应用服务器返回商品信息和库存数量给前端应用服务器

    缓存应用服务器（Java + Spring Boot）：

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.web.bind.annotation.GetMapping;
    4. import org.springframework.web.bind.annotation.PathVariable;
    5. import org.springframework.web.bind.annotation.RestController;
    6.  
    7. import java.util.HashMap;
    8. import java.util.Map;
    9.  
    10. @SpringBootApplication
    11. public class CacheServerApplication {
    12.  
    13.     private static final Map<Long, ProductInfo> productCache = new HashMap<>();
    14.  
    15.     public static void main(String[] args) {
    16.         SpringApplication.run(CacheServerApplication.class, args);
    17.     }
    18.  
    19.     @RestController
    20.     public class CacheController {
    21.  
    22.         @GetMapping("/product/{productId}")
    23.         public ProductInfo getProductInfo(@PathVariable Long productId) {
    24.             // 从缓存中获取商品信息
    25.             return productCache.getOrDefault(productId, new ProductInfo(productId, "Unknown", 0));
    26.         }
    27.     }
    28.  
    29.     public static class ProductInfo {
    30.         private Long productId;
    31.         private String productName;
    32.         private int stock;
    33.  
    34.         public ProductInfo(Long productId, String productName, int stock) {
    35.             this.productId = productId;
    36.             this.productName = productName;
    37.             this.stock = stock;
    38.         }
    39.  
    40.         // 省略getter和setter方法
    41.     }
    42. }

    在这个示例中，缓存应用服务器通过Spring Boot框架实现了一个简单的/cache接口，接收前端应用服务器的商品信息请求。根据商品ID从缓存中获取商品信息，如果缓存中不存在该商品信息，则返回一个未知商品信息。

    7、前端应用服务器根据库存数量判断是否可以参与秒杀，如果可以则生成订单。

    前端应用服务器（Java + Spring Boot）：

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.web.bind.annotation.PostMapping;
    4. import org.springframework.web.bind.annotation.RequestBody;
    5. import org.springframework.web.bind.annotation.RestController;
    6.  
    7. import java.util.HashMap;
    8. import java.util.Map;
    9.  
    10. @SpringBootApplication
    11. public class FrontendApplication {
    12.  
    13.     private static final Map<Long, Integer> stockMap = new HashMap<>(); // 模拟商品库存
    14.     private static final Map<Long, Boolean> seckillMap = new HashMap<>(); // 模拟秒杀活动是否开始
    15.     private static final Map<Long, Boolean> seckillEndMap = new HashMap<>(); // 模拟秒杀活动是否结束
    16.     private static final Map<Long, Long> userOrders = new HashMap<>(); // 模拟用户订单
    17.  
    18.     public static void main(String[] args) {
    19.         // 初始化商品库存
    20.         stockMap.put(1L, 10);
    21.         // 初始化秒杀活动状态
    22.         seckillMap.put(1L, true);
    23.         // 初始化秒杀活动结束状态
    24.         seckillEndMap.put(1L, false);
    25.  
    26.         SpringApplication.run(FrontendApplication.class, args);
    27.     }
    28.  
    29.     @RestController
    30.     public class SeckillController {
    31.  
    32.         @PostMapping("/seckill")
    33.         public String seckill(@RequestBody SeckillRequest request) {
    34.             Long productId = request.getProductId();
    35.             Long userId = request.getUserId();
    36.  
    37.             // 判断秒杀活动是否开始或结束
    38.             if (!seckillMap.getOrDefault(productId, false)) {
    39.                 return "秒杀活动未开始";
    40.             }
    41.  
    42.             if (seckillEndMap.getOrDefault(productId, true)) {
    43.                 return "秒杀活动已结束";
    44.             }
    45.  
    46.             // 判断库存是否足够
    47.             Integer stock = stockMap.getOrDefault(productId, 0);
    48.             if (stock <= 0) {
    49.                 return "商品已售罄";
    50.             }
    51.  
    52.             // 生成订单
    53.             userOrders.put(userId, productId);
    54.             // 更新库存
    55.             stockMap.put(productId, stock - 1);
    56.  
    57.             return "秒杀成功";
    58.         }
    59.     }
    60.  
    61.     public static class SeckillRequest {
    62.         private Long userId;
    63.         private Long productId;
    64.  
    65.         // 省略getter和setter方法
    66.     }
    67. }

    在这个示例中，前端应用服务器根据商品ID获取库存数量，判断秒杀活动是否开始或结束，以及库存是否足够。如果满足条件，则生成订单并更新库存，返回秒杀成功；否则返回相应的错误信息。

    8、前端应用服务器将订单信息发送到后端负载均衡器

    前端应用服务器（Java + Spring Boot）：

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.web.bind.annotation.PostMapping;
    4. import org.springframework.web.bind.annotation.RequestBody;
    5. import org.springframework.web.bind.annotation.RestController;
    6. import org.springframework.web.client.RestTemplate;
    7.  
    8. @SpringBootApplication
    9. public class FrontendApplication {
    10.  
    11.     private static final String LOAD_BALANCER_URL = "http://backend-load-balancer";
    12.  
    13.     public static void main(String[] args) {
    14.         SpringApplication.run(FrontendApplication.class, args);
    15.     }
    16.  
    17.     @RestController
    18.     public class OrderController {
    19.  
    20.         private final RestTemplate restTemplate = new RestTemplate();
    21.  
    22.         @PostMapping("/order")
    23.         public String placeOrder(@RequestBody OrderRequest request) {
    24.             // 向后端负载均衡器发送订单信息
    25.             String url = LOAD_BALANCER_URL + "/order";
    26.             return restTemplate.postForObject(url, request, String.class);
    27.         }
    28.     }
    29.  
    30.     public static class OrderRequest {
    31.         private Long orderId;
    32.         private Long productId;
    33.         private Long userId;
    34.  
    35.         // 省略getter和setter方法
    36.     }
    37. }

    在这个示例中，前端应用服务器通过Spring Boot框架实现了一个简单的/order接口，接收订单信息，并使用RestTemplate将订单信息发送到后端负载均衡器的/order接口。

    8、后端负载均衡器将请求分发到多个后端应用服务器上

    后端负载均衡器（简化示例）：

    在实际应用中，后端负载均衡器可以使用诸如Nginx、HAProxy、AWS ELB等工具来实现。这里简化为直接在Java中模拟负载均衡器的行为。

    1. import java.util.ArrayList;
    2. import java.util.List;
    3. import java.util.Random;
    4.  
    5. public class LoadBalancer {
    6.  
    7.     private List<String> backendServers;
    8.  
    9.     public LoadBalancer() {
    10.         backendServers = new ArrayList<>();
    11.         backendServers.add("http://backend-server1");
    12.         backendServers.add("http://backend-server2");
    13.         // 添加更多后端服务器...
    14.     }
    15.  
    16.     public String selectBackendServer() {
    17.         // 模拟负载均衡算法，这里简单使用随机选择
    18.         Random random = new Random();
    19.         int index = random.nextInt(backendServers.size());
    20.         return backendServers.get(index);
    21.     }
    22.  
    23.     public static void main(String[] args) {
    24.         LoadBalancer loadBalancer = new LoadBalancer();
    25.         // 模拟请求分发给后端服务器
    26.         for (int i = 0; i < 10; i++) {
    27.             String backendServer = loadBalancer.selectBackendServer();
    28.             System.out.println("Request sent to: " + backendServer);
    29.         }
    30.     }
    31. }

    在这个示例中，LoadBalancer类模拟了一个简单的负载均衡器，它维护了一个后端服务器列表，并实现了一个简单的随机选择算法来选择后端服务器。在实际应用中，需要根据实际情况选择合适的负载均衡算法。

    9、后端应用服务器消费订单信息，根据订单信息生成订单，并更新库存数量。

    后端应用服务器（Java + Spring Boot）：

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.web.bind.annotation.PostMapping;
    4. import org.springframework.web.bind.annotation.RequestBody;
    5. import org.springframework.web.bind.annotation.RestController;
    6.  
    7. import java.util.HashMap;
    8. import java.util.Map;
    9.  
    10. @SpringBootApplication
    11. public class BackendApplication {
    12.  
    13.     private static final Map<Long, Integer> stockMap = new HashMap<>();
    14.  
    15.     public static void main(String[] args) {
    16.         // 初始化库存数量
    17.         stockMap.put(1L, 10);
    18.  
    19.         SpringApplication.run(BackendApplication.class, args);
    20.     }
    21.  
    22.     @RestController
    23.     public class OrderController {
    24.  
    25.         @PostMapping("/order")
    26.         public String createOrder(@RequestBody OrderRequest request) {
    27.             Long orderId = request.getOrderId();
    28.             Long productId = request.getProductId();
    29.             Long userId = request.getUserId();
    30.  
    31.             // 判断库存是否足够
    32.             Integer stock = stockMap.getOrDefault(productId, 0);
    33.             if (stock <= 0) {
    34.                 return "商品已售罄";
    35.             }
    36.  
    37.             // 生成订单
    38.             String orderInfo = "订单信息：订单号-" + orderId + "，商品ID-" + productId + "，用户ID-" + userId;
    39.             // 更新库存数量
    40.             stockMap.put(productId, stock - 1);
    41.  
    42.             return "生成订单成功：" + orderInfo;
    43.         }
    44.     }
    45.  
    46.     public static class OrderRequest {
    47.         private Long orderId;
    48.         private Long productId;
    49.         private Long userId;
    50.  
    51.         // 省略getter和setter方法
    52.     }
    53. }

    在这个示例中，后端应用服务器通过Spring Boot框架实现了一个简单的/order接口，接收订单信息，并根据订单信息生成订单，并更新库存数量。如果库存不足，则返回"商品已售罄"。

    10、后端应用服务器将订单信息写入数据库集群

    将订单信息写入数据库集群是一个关键的步骤，需要考虑到数据的一致性和高可用性。下面是一个详细全面的示例，演示如何将订单信息写入数据库集群：

    后端应用服务器（Java + Spring Boot）：

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.web.bind.annotation.PostMapping;
    4. import org.springframework.web.bind.annotation.RequestBody;
    5. import org.springframework.web.bind.annotation.RestController;
    6.  
    7. import java.sql.Connection;
    8. import java.sql.DriverManager;
    9. import java.sql.PreparedStatement;
    10. import java.sql.SQLException;
    11.  
    12. @SpringBootApplication
    13. public class BackendApplication {
    14.  
    15.     public static void main(String[] args) {
    16.         SpringApplication.run(BackendApplication.class, args);
    17.     }
    18.  
    19.     @RestController
    20.     public class OrderController {
    21.  
    22.         @PostMapping("/order")
    23.         public String createOrder(@RequestBody OrderRequest request) {
    24.             Long orderId = request.getOrderId();
    25.             Long productId = request.getProductId();
    26.             Long userId = request.getUserId();
    27.  
    28.             // 生成订单
    29.             String orderInfo = "订单信息：订单号-" + orderId + "，商品ID-" + productId + "，用户ID-" + userId;
    30.  
    31.             // 将订单信息写入数据库集群
    32.             boolean success = writeToDatabase(orderInfo);
    33.  
    34.             if (success) {
    35.                 return "生成订单成功：" + orderInfo;
    36.             } else {
    37.                 return "生成订单失败：" + orderInfo;
    38.             }
    39.         }
    40.  
    41.         private boolean writeToDatabase(String orderInfo) {
    42.             // 连接数据库集群 这里为了方便演示没有用yaml进行配置
    43.             String url = "jdbc:mysql://database-cluster:3306/database";
    44.             String user = "user";
    45.             String password = "password";
    46.             try (Connection connection = DriverManager.getConnection(url, user, password)) {
    47.                 // 写入订单信息
    48.                 String sql = "INSERT INTO orders (order_info) VALUES (?)";
    49.                 try (PreparedStatement statement = connection.prepareStatement(sql)) {
    50.                     statement.setString(1, orderInfo);
    51.                     int rowsAffected = statement.executeUpdate();
    52.                     return rowsAffected > 0;
    53.                 }
    54.             } catch (SQLException e) {
    55.                 e.printStackTrace();
    56.                 return false;
    57.             }
    58.         }
    59.     }
    60.  
    61.     public static class OrderRequest {
    62.         private Long orderId;
    63.         private Long productId;
    64.         private Long userId;
    65.  
    66.         // 省略getter和setter方法
    67.     }
    68. }

    11、 分布式锁用于保护对库存数量的操作，确保数据的一致性。

    分布式锁用于保护对库存数量的操作，确保数据的一致性。下面是一个详细全面的示例，演示如何使用Redis实现分布式锁来保护对库存数量的操作：

    后端应用服务器（Java + Spring Boot）：

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.web.bind.annotation.PostMapping;
    4. import org.springframework.web.bind.annotation.RequestBody;
    5. import org.springframework.web.bind.annotation.RestController;
    6. import redis.clients.jedis.Jedis;
    7.  
    8. @SpringBootApplication
    9. public class BackendApplication {
    10.  
    11.     private static final String REDIS_HOST = "localhost";
    12.     private static final int REDIS_PORT = 6379;
    13.     private static final String LOCK_KEY = "inventory_lock";
    14.     private static final String INVENTORY_KEY = "inventory";
    15.  
    16.     public static void main(String[] args) {
    17.         SpringApplication.run(BackendApplication.class, args);
    18.     }
    19.  
    20.     @RestController
    21.     public class OrderController {
    22.  
    23.         @PostMapping("/order")
    24.         public String createOrder(@RequestBody OrderRequest request) {
    25.             Long orderId = request.getOrderId();
    26.             Long productId = request.getProductId();
    27.             Long userId = request.getUserId();
    28.  
    29.             // 获取分布式锁
    30.             try (Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT)) {
    31.                 boolean locked = false;
    32.                 while (!locked) {
    33.                     locked = jedis.setnx(LOCK_KEY, "locked") == 1;
    34.                     if (!locked) {
    35.                         try {
    36.                             Thread.sleep(100);
    37.                         } catch (InterruptedException e) {
    38.                             Thread.currentThread().interrupt();
    39.                         }
    40.                     }
    41.                 }
    42.  
    43.                 // 获取锁成功，处理订单
    44.                 int stock = Integer.parseInt(jedis.get(INVENTORY_KEY));
    45.                 if (stock > 0) {
    46.                     // 生成订单
    47.                     String orderInfo = "订单信息：订单号-" + orderId + "，商品ID-" + productId + "，用户ID-" + userId;
    48.                     System.out.println("生成订单成功：" + orderInfo);
    49.  
    50.                     // 更新库存数量
    51.                     jedis.set(INVENTORY_KEY, String.valueOf(stock - 1));
    52.                 } else {
    53.                     System.out.println("商品已售罄");
    54.                 }
    55.  
    56.                 // 释放锁
    57.                 jedis.del(LOCK_KEY);
    58.             }
    59.  
    60.             return "订单处理完成";
    61.         }
    62.     }
    63.  
    64.     public static class OrderRequest {
    65.         private Long orderId;
    66.         private Long productId;
    67.         private Long userId;
    68.  
    69.         // 省略getter和setter方法
    70.     }
    71. }

    在这个示例中，后端应用服务器通过Spring Boot框架实现了一个简单的/order接口，接收订单信息，并使用Redis实现分布式锁来保护对库存数量的操作。当多个请求同时到达时，只有一个请求能够获得锁并处理订单，其他请求需要等待锁释放后才能继续处理。这样可以保证对库存数量的操作是原子性的，从而确保数据的一致性。

     总结

    设计高并发的秒杀系统需要考虑到多个方面，包括系统架构、技术选型、流程设计和代码实现等。通过合理的架构设计和技术选型，可以实现一个稳定高效的秒杀系统，为用户提供良好的购物体验。

  • 相关阅读:
    C++看谁排得快
    机器学习-特征选择：使用Lassco回归精确选择最佳特征
    Leetcode978. Longest Turbulent Subarray
    使去中心化媒体网络相关联的NFT元数据标准
    MAC: 使用技巧
    lambda stream流处理异常的方法/不终止stream流处理异常
    2023 安装 facebookresearch slowfast
    海量数据处理
    LeetCode讲解篇之77. 组合
    SpringBoot接口 - 如何生成接口文档之非侵入方式（通过注释生成）Smart-Doc？
  • 原文地址：https://blog.csdn.net/2201_75809246/article/details/136515839