架构与系统设计 / 系统课时
搭建可压测的本地演练环境
搭建可压测的本地演练环境
这一节把 Java 服务、Redis、Kafka、MySQL 和压测工具组成一个最小可重复环境。目标不是搭出生产集群,而是先固定依赖、启动顺序和验收请求,确保商品查询、抢购、异步下单与结果查询能够完整走通。
学习目标
- 用 Docker Compose 启动 Redis、Kafka 与 MySQL,并验证基础连通性。
- 启动最小 Java 秒杀服务,完成库存预热、请求入队和异步落单。
- 用接口冒烟与小流量压测得到可重复的本地基线。
准备本机工具
本节默认本机已安装 JDK 21、Maven 3.9+、Docker、Docker Compose 插件与 k6。先确认版本,任何一项失败都先修复对应工具或 Docker 守护进程。
java -version
mvn -version
docker version
docker compose version
k6 version预期输出
openjdk version "<VERSION>"
Apache Maven <VERSION>
Docker version <VERSION>, build <ID>
Docker Compose version v<VERSION>
k6 v<VERSION>具体补丁号和构建号可能不同,但五条命令都应正常退出。
启动 Redis、Kafka 与 MySQL
在空目录创建 compose.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 访问三个依赖。真实端口若被占用,可以修改左侧宿主机端口,并同步修改应用配置。
启动依赖:
docker compose up -d
docker compose ps预期输出
<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 版本上。
<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:
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;结果接口查询订单状态。
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");
}
}预期结果
应用启动后提供商品查询、抢购提交、异步下单和结果查询四段最小链路。这段代码只用于建立压测基线,生产系统还需要用户维度幂等、消息可靠投递、订单唯一约束和补偿机制。验证标准不是“架构已经完善”,而是四个接口阶段能稳定复现。
启动应用:
mvn spring-boot:run预期输出
Started FlashSaleApplication in <TIME> seconds启动耗时会因机器不同而变化;若出现 Redis、Kafka 或 MySQL 连接错误,先回到 docker compose ps 检查依赖是否已就绪。

跑通四段业务链路
先查询商品,再提交抢购。第二条命令返回的 requestId 每次不同,用实际值替换后续 <ID>。
curl -s http://localhost:8080/products/sku-1
curl -i -X POST http://localhost:8080/flash-sale/sku-1预期输出
{"sku":"sku-1","stock":20}
HTTP/1.1 202
{"requestId":"<ID>","status":"QUEUED"}随后查询异步结果;Kafka 消费和 MySQL 写入需要短暂时间,因此第一次可能仍是 PENDING,再次查询应变为 SUCCESS。
curl -s http://localhost:8080/results/<ID>预期输出
{"status":"SUCCESS"}如果一直是 PENDING,依次检查应用日志中的 Kafka 消费异常、Kafka 容器状态和 MySQL 写入错误,不要先通过增加重试掩盖根因。
固定一个小流量压测基线
业务链路跑通后再压测,否则错误率只会反映环境没准备好。下面用 k6 对商品查询做 10 秒固定并发的基线测试;把脚本保存为 smoke.js。
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 });
}预期结果
脚本以 10 个虚拟用户持续请求 10 秒,并检查商品查询接口是否返回 HTTP 200。接着执行压测并记录吞吐与延迟。
k6 run smoke.js预期输出
checks.........................: 100.00%
http_req_failed................: 0.00%
http_reqs......................: <COUNT>请求总数和延迟统计会随机器不同而变化,因此只固定并发数、持续时间和零失败条件,不把某个具体 QPS 当作所有机器都必须达到的结果。
这套环境的验收标准很简单:依赖能一键启动,Java 服务能稳定启动,四段业务链路可重复跑通,小流量压测零失败。只有基线可复现,后面的限流、热点保护、异步化和库存一致性实验才有可比较的前后结果。