架构与系统设计 / 系统课时

搭建可压测的本地演练环境

搭建可压测的本地演练环境

这一节把 Java 服务、Redis、Kafka、MySQL 和压测工具组成一个最小可重复环境。目标不是搭出生产集群,而是先固定依赖、启动顺序和验收请求,确保商品查询、抢购、异步下单与结果查询能够完整走通。

学习目标

  • 用 Docker Compose 启动 Redis、Kafka 与 MySQL,并验证基础连通性。
  • 启动最小 Java 秒杀服务,完成库存预热、请求入队和异步落单。
  • 用接口冒烟与小流量压测得到可重复的本地基线。

准备本机工具

本节默认本机已安装 JDK 21、Maven 3.9+、Docker、Docker Compose 插件与 k6。先确认版本,任何一项失败都先修复对应工具或 Docker 守护进程。

bash
java -version
mvn -version
docker version
docker compose version
k6 version

预期输出

text
openjdk version "<VERSION>"
Apache Maven <VERSION>
Docker version <VERSION>, build <ID>
Docker Compose version v<VERSION>
k6 v<VERSION>

具体补丁号和构建号可能不同,但五条命令都应正常退出。

启动 Redis、Kafka 与 MySQL

在空目录创建 compose.yaml。这三个依赖都使用单节点配置,目的是降低本地复现实验的成本,不代表生产部署方式。

yaml
services:
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
  mysql:
    image: mysql:8
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: flashsale
    ports:
      - "3306:3306"
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-proot"]
      interval: 5s
      timeout: 3s
      retries: 20
  kafka:
    image: apache/kafka:3.8.1
    ports:
      - "9092:9092"
    environment:
      KAFKA_NODE_ID: 1
      KAFKA_PROCESS_ROLES: broker,controller
      KAFKA_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@localhost:9093
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1

该配置生效后,Java 服务可通过本机端口 6379、9092 和 3306 访问三个依赖。真实端口若被占用,可以修改左侧宿主机端口,并同步修改应用配置。

启动依赖:

bash
docker compose up -d
docker compose ps

预期输出

text
<NAME>  redis:7-alpine        redis  Up <TIME>
<NAME>  mysql:8               mysql  Up <TIME>
<NAME>  apache/kafka:3.8.1    kafka  Up <TIME>

容器名称和运行时长会不同;关键是三个服务均处于运行状态,MySQL 随后应进入健康状态。

建立最小 Java 服务

创建 Maven 标准项目,把下面内容保存为 pom.xml。它提供 Web、Redis、Kafka、JDBC 与 MySQL 驱动,并固定在支持 JDK 21 的 Spring Boot 版本上。

xml
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.3.5</version>
    <relativePath/>
  </parent>
  <groupId>com.example</groupId>
  <artifactId>flashsale</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <properties><java.version>21</java.version></properties>
  <dependencies>
    <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>
    <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>
    <dependency><groupId>org.springframework.kafka</groupId><artifactId>spring-kafka</artifactId></dependency>
    <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency>
    <dependency><groupId>com.mysql</groupId><artifactId>mysql-connector-j</artifactId><scope>runtime</scope></dependency>
  </dependencies>
  <build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
</project>

该配置无需单独产生控制台输出;验证方法是后面的 mvn spring-boot:run 能解析依赖并成功启动应用。

把下面配置保存为 src/main/resources/application.yml:

yaml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/flashsale?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
    username: root
    password: root
  data:
    redis:
      host: localhost
      port: 6379
  kafka:
    bootstrap-servers: localhost:9092
    consumer:
      group-id: flash-sale-order
      auto-offset-reset: earliest
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
server:
  port: 8080

配置生效后,服务应连接 Redis、Kafka 和 MySQL;验证时应确认应用启动日志没有连接拒绝或认证失败。

把主类保存为 src/main/java/com/example/flashsale/FlashSaleApplication.java。它在启动时建表并把商品 sku-1 的库存预热为 20;抢购接口使用 Redis 原子递减库存,成功后写入 Kafka;消费者异步落单到 MySQL;结果接口查询订单状态。

java
package com.example.flashsale;

import java.util.Map;
import java.util.UUID;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.ResponseEntity;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
@RestController
public class FlashSaleApplication implements CommandLineRunner {
    private final StringRedisTemplate redis;
    private final KafkaTemplate<String, String> kafka;
    private final JdbcTemplate jdbc;

    public FlashSaleApplication(StringRedisTemplate redis, KafkaTemplate<String, String> kafka, JdbcTemplate jdbc) {
        this.redis = redis;
        this.kafka = kafka;
        this.jdbc = jdbc;
    }

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

    @Override
    public void run(String... args) {
        jdbc.execute("CREATE TABLE IF NOT EXISTS flash_order (request_id VARCHAR(64) PRIMARY KEY, sku VARCHAR(64) NOT NULL)");
        redis.opsForValue().set("stock:sku-1", "20");
    }

    @GetMapping("/products/{sku}")
    public Map<String, Object> product(@PathVariable String sku) {
        String stock = redis.opsForValue().get("stock:" + sku);
        return Map.of("sku", sku, "stock", stock == null ? 0 : Integer.parseInt(stock));
    }

    @PostMapping("/flash-sale/{sku}")
    public ResponseEntity<Map<String, String>> buy(@PathVariable String sku) {
        Long left = redis.opsForValue().decrement("stock:" + sku);
        if (left == null || left < 0) {
            redis.opsForValue().increment("stock:" + sku);
            return ResponseEntity.status(409).body(Map.of("status", "SOLD_OUT"));
        }
        String requestId = UUID.randomUUID().toString();
        kafka.send("flash-sale-orders", requestId, requestId + "," + sku);
        return ResponseEntity.accepted().body(Map.of("requestId", requestId, "status", "QUEUED"));
    }

    @KafkaListener(topics = "flash-sale-orders")
    public void createOrder(String message) {
        String[] parts = message.split(",", 2);
        jdbc.update("INSERT IGNORE INTO flash_order(request_id, sku) VALUES (?, ?)", parts[0], parts[1]);
    }

    @GetMapping("/results/{requestId}")
    public Map<String, String> result(@PathVariable String requestId) {
        Integer count = jdbc.queryForObject("SELECT COUNT(*) FROM flash_order WHERE request_id = ?", Integer.class, requestId);
        return Map.of("status", count != null && count == 1 ? "SUCCESS" : "PENDING");
    }
}

预期结果

text
应用启动后提供商品查询、抢购提交、异步下单和结果查询四段最小链路。

这段代码只用于建立压测基线,生产系统还需要用户维度幂等、消息可靠投递、订单唯一约束和补偿机制。验证标准不是“架构已经完善”,而是四个接口阶段能稳定复现。

启动应用:

bash
mvn spring-boot:run

预期输出

text
Started FlashSaleApplication in <TIME> seconds

启动耗时会因机器不同而变化;若出现 Redis、Kafka 或 MySQL 连接错误,先回到 docker compose ps 检查依赖是否已就绪。

本地秒杀演练环境与请求链路

跑通四段业务链路

先查询商品,再提交抢购。第二条命令返回的 requestId 每次不同,用实际值替换后续 <ID>。

bash
curl -s http://localhost:8080/products/sku-1
curl -i -X POST http://localhost:8080/flash-sale/sku-1

预期输出

text
{"sku":"sku-1","stock":20}
HTTP/1.1 202
{"requestId":"<ID>","status":"QUEUED"}

随后查询异步结果;Kafka 消费和 MySQL 写入需要短暂时间,因此第一次可能仍是 PENDING,再次查询应变为 SUCCESS。

bash
curl -s http://localhost:8080/results/<ID>

预期输出

text
{"status":"SUCCESS"}

如果一直是 PENDING,依次检查应用日志中的 Kafka 消费异常、Kafka 容器状态和 MySQL 写入错误,不要先通过增加重试掩盖根因。

固定一个小流量压测基线

业务链路跑通后再压测,否则错误率只会反映环境没准备好。下面用 k6 对商品查询做 10 秒固定并发的基线测试;把脚本保存为 smoke.js。

javascript
import http from 'k6/http';
import { check } from 'k6';

export const options = {
  vus: 10,
  duration: '10s',
};

export default function () {
  const res = http.get('http://localhost:8080/products/sku-1');
  check(res, { 'status is 200': (r) => r.status === 200 });
}

预期结果

text
脚本以 10 个虚拟用户持续请求 10 秒,并检查商品查询接口是否返回 HTTP 200。

接着执行压测并记录吞吐与延迟。

bash
k6 run smoke.js

预期输出

text
checks.........................: 100.00%
http_req_failed................: 0.00%
http_reqs......................: <COUNT>

请求总数和延迟统计会随机器不同而变化,因此只固定并发数、持续时间和零失败条件,不把某个具体 QPS 当作所有机器都必须达到的结果。

这套环境的验收标准很简单:依赖能一键启动,Java 服务能稳定启动,四段业务链路可重复跑通,小流量压测零失败。只有基线可复现,后面的限流、热点保护、异步化和库存一致性实验才有可比较的前后结果。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

搭建可压测的本地演练环境

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通