企业官网建设流程全解析

如果你是一名Java开发者，或者正在寻找一个能真正“撑起”简历、体现你系统设计能力的实战项目，那么WMS（仓储管理系统）绝对是一个黄金选择。它不像一个简单的CRUD后台，也不像一些纯前端炫技的项目，它连接着真实的物理世界——货架、商品、订单、人员，背后是复杂的业务流程、数据一致性和并发挑战。然而，很多教程要么停留在概念，要么直接丢给你一个庞大的开源项目，让人无从下手。

这篇文章要解决的，正是这个痛点。我们将从一个开发者的视角，从零开始，完整地拆解一个WMS项目的核心模块、技术选型、数据库设计到关键代码实现的全流程。我不会只告诉你“WMS很重要”，而是会带你弄清楚：为什么库存扣减不能简单用UPDATE stock SET quantity = quantity - 1？波次拣选算法到底在解决什么问题？高并发下的库存超卖该如何从数据库层面防范？

读完本文，你将获得的不只是一个项目经验，更是一套处理复杂业务系统、设计高可靠数据模型的实战方法论。无论你是想深入学习Java企业级开发，还是为面试储备一个高质量的实战项目，这篇文章都将提供一条清晰的路径。

1. WMS项目实战：为什么它值得你投入时间？

在开始敲代码之前，我们必须先想清楚：为什么是WMS？它比一个博客系统、电商后台难在哪里，价值又在哪里？

第一，业务复杂度高，是练习领域驱动设计（DDD）的绝佳场景。WMS涉及的核心领域包括：仓库、库区、货架、储位、商品、批次、库存、入库单、出库单、盘点单、波次、拣货任务、复核、打包等。这些实体之间的关系错综复杂，比如一个商品可以有多个批次的库存分布在不同的储位上。如何清晰地划分聚合根、实体、值对象，如何设计仓储层（Repository）来保证聚合的事务一致性，这些都是WMS项目能带给你的深度思考。

第二，对数据一致性和并发控制要求极高。这是WMS的核心挑战，也是面试官最爱深挖的点。想象一下“双十一”场景，同一件商品被成千上万个订单同时抢购。简单的应用层锁或数据库行锁都可能成为性能瓶颈，甚至导致死锁。WMS实战会让你深入理解悲观锁、乐观锁、分布式锁的应用场景，以及如何利用数据库的唯一约束、版本号（version）、库存预占等机制来保证“库存不超卖”这条生命线。

第三，技术栈全面，能串联起后端开发的核心技能。一个完整的WMS后端项目通常会涵盖：

• Spring Boot/Cloud: 快速构建微服务。
• MySQL: 核心业务数据存储，涉及大量复杂查询和事务。
• Redis: 用作缓存（如热点商品信息）和分布式锁的实现组件。
• RabbitMQ/Kafka: 解耦耗时操作，如异步生成拣货单、同步库存到ERP。
• Elasticsearch: 用于订单、库存日志的高效检索。
• Docker: 环境容器化。
• JPA/MyBatis-Plus: 数据持久层框架。

通过WMS项目，你能有机地练习这些技术的整合，而不是孤立地学习。

第四，具备强烈的现实意义和扩展性。WMS是供应链的数字基石。理解它，你就能更好地理解整个电商、物流、零售行业的运作逻辑。在此基础上，你可以轻松扩展出OMS（订单管理系统）、TMS（运输管理系统）等项目，构建你自己的“供应链中台”知识体系。

所以，这个项目不适合只想抄代码的人，它适合那些愿意透过业务看技术本质，通过解决实际问题来提升架构能力的开发者。接下来，我们就从最核心的模型开始。

2. 核心概念与领域模型拆解

在动手设计数据库和写代码前，我们必须统一语言，理解WMS领域内的关键概念及其关系。这是避免后期逻辑混乱的基础。

2.1 核心实体与定义

1. 仓库 (Warehouse): 物流节点，如“北京仓”、“上海仓”。
2. 库区 (Zone): 仓库内的功能划分，如“收货区”、“存储区”、“拣货区”、“发货区”。
3. 货架 (Rack) & 储位 (Storage Location): 货架是物理架子，储位是货架上的具体格子，有唯一的编码（如A-01-001），是库存存放的最小单位。
4. 商品 (Sku): 库存保持单位，一款商品的唯一标识。注意：同一款商品的不同颜色、尺码是不同的SKU。
5. 批次 (Batch/Lot): 同一时间入库的同一SKU商品集合，通常包含生产日期、保质期、供应商等信息。库存管理（特别是食品、医药）必须精确到批次。
6. 库存 (Inventory):这是最核心的概念。它不是一个简单的数字，而是一个状态化的记录。一条库存记录必须关联：sku_id,batch_id,location_id,quantity(可用数量),locked_quantity(锁定数量),status(状态，如正常、冻结、残次)。

2.2 核心业务流程与单据

1. 入库流程:
   • 入库单 (Receipt Order): 记录供应商、预计到货商品清单。
   • 上架任务 (Putaway Task): 根据策略（如按批次、按品类）将已收货的商品分配到具体的储位。
2. 出库流程:
   • 出库单 (Shipment Order): 来自OMS的客户订单集合。
   • 波次 (Wave): 将多个出库单合并，按照一定规则（相同货架区、相同快递公司）生成一批拣货任务，以提升拣货员效率。
   • 拣货任务 (Picking Task) & 拣货明细 (Picking Detail): 告诉拣货员去哪个储位、拣哪个批次的商品、拣多少。
   • 复核 (Checking) & 打包 (Packing): 确保拣出的商品与订单一致，然后打包。
3. 库存管理:
   • 盘点单 (Stocktake Order): 定期或不定期的库存数量核对。
   • 库存移动 (Inventory Movement): 记录库存从一个储位转移到另一个储位。

2.3 领域模型关系简图（用文字描述）

一个 Warehouse 包含多个 Zone。 一个 Zone 包含多个 Rack，一个 Rack 有多个 StorageLocation。 一个 Sku 可以有多个 Batch。 一条 Inventory 记录必须属于一个 StorageLocation、一个 Sku 和一个 Batch。 一个 ShipmentOrder 包含多个 OrderLine（订单行，对应SKU和数量）。 一个 Wave 聚合多个 ShipmentOrder，并生成多个 PickingTask。 一个 PickingTask 包含多个 PickingDetail，每个 Detail 指向一条具体的 Inventory 记录和应拣数量。

理解这些模型后，我们才能设计出合理的数据库表结构。

3. 数据库设计：表结构与核心约束

数据库设计是WMS的骨架。这里给出最核心的几张表及其字段，重点关注如何通过设计保障数据一致性。

3.1 库存表 (inventory) - 核心中的核心

CREATE TABLE `wms_inventory` ( `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', `sku_id` bigint(20) NOT NULL COMMENT '商品SKU ID', `batch_id` bigint(20) NOT NULL COMMENT '批次ID', `warehouse_id` bigint(20) NOT NULL COMMENT '仓库ID', `zone_id` bigint(20) NOT NULL COMMENT '库区ID', `location_id` bigint(20) NOT NULL COMMENT '储位ID', `quantity` int(11) NOT NULL DEFAULT '0' COMMENT '可用数量', `locked_quantity` int(11) NOT NULL DEFAULT '0' COMMENT '锁定数量（已分配未拣货）', `picked_quantity` int(11) NOT NULL DEFAULT '0' COMMENT '已拣数量', `version` int(11) NOT NULL DEFAULT '0' COMMENT '版本号，用于乐观锁', `status` tinyint(4) NOT NULL DEFAULT '1' COMMENT '状态：1-正常 2-冻结 3-残次', `created_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP, `updated_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, PRIMARY KEY (`id`), UNIQUE KEY `uk_sku_batch_location` (`sku_id`,`batch_id`,`location_id`) COMMENT '同一商品同一批次在同一储位唯一', KEY `idx_location` (`location_id`), KEY `idx_sku_warehouse` (`sku_id`,`warehouse_id`) COMMENT '用于查询某商品在某仓库的总库存' ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='库存表';

设计要点解析：

1. 唯一索引uk_sku_batch_location: 这是保证库存记录唯一的根本，防止重复数据。
2. 库存数量拆分:quantity(可用),locked_quantity(锁定),picked_quantity(已拣)。这是一个状态机：下单时从quantity移到locked_quantity；拣货时从locked_quantity移到picked_quantity。这样能清晰追踪库存状态。
3. 版本号version: 实现乐观锁的关键字段，每次更新时version=version+1，并在WHERE条件中校验旧版本号，防止更新丢失。
4. 联合索引idx_sku_warehouse: 高频查询场景（查某商品在某仓库的总库存）必须优化。

3.2 出库单与波次表

-- 出库单表 CREATE TABLE `wms_shipment_order` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `order_sn` varchar(64) NOT NULL COMMENT '出库单号', `wave_id` bigint(20) DEFAULT NULL COMMENT '所属波次ID', `status` tinyint(4) NOT NULL COMMENT '状态：10-待处理 20-已波次 30-拣货中 40-已拣货 50-已复核 60-已打包 70-已发货', `details` json DEFAULT NULL COMMENT '订单商品快照（JSON，防止商品信息变更）', `total_quantity` int(11) NOT NULL COMMENT '商品总件数', PRIMARY KEY (`id`), UNIQUE KEY `uk_order_sn` (`order_sn`), KEY `idx_wave_id` (`wave_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='出库单表'; -- 波次表 CREATE TABLE `wms_wave` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `wave_sn` varchar(64) NOT NULL COMMENT '波次号', `status` tinyint(4) NOT NULL COMMENT '状态：10-创建 20-执行中 30-已完成', `strategy` varchar(50) DEFAULT NULL COMMENT '生成策略（如：按快递、按库区）', `total_orders` int(11) NOT NULL COMMENT '包含订单数', `created_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (`id`), UNIQUE KEY `uk_wave_sn` (`wave_sn`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='波次表';

3.3 拣货任务与明细表

-- 拣货任务表 CREATE TABLE `wms_picking_task` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `task_sn` varchar(64) NOT NULL COMMENT '任务号', `wave_id` bigint(20) NOT NULL COMMENT '所属波次', `picker_id` bigint(20) DEFAULT NULL COMMENT '拣货员ID', `status` tinyint(4) NOT NULL COMMENT '状态：10-待分配 20-已分配 30-拣货中 40-已完成', `start_time` datetime DEFAULT NULL, `finish_time` datetime DEFAULT NULL, PRIMARY KEY (`id`), KEY `idx_wave_id` (`wave_id`), KEY `idx_picker_status` (`picker_id`,`status`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='拣货任务表'; -- 拣货明细表 CREATE TABLE `wms_picking_detail` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `task_id` bigint(20) NOT NULL COMMENT '拣货任务ID', `inventory_id` bigint(20) NOT NULL COMMENT '来源库存记录ID', `shipment_order_id` bigint(20) NOT NULL COMMENT '所属出库单ID', `sku_id` bigint(20) NOT NULL, `batch_id` bigint(20) NOT NULL, `location_id` bigint(20) NOT NULL, `quantity_required` int(11) NOT NULL COMMENT '需求数量', `quantity_picked` int(11) NOT NULL DEFAULT '0' COMMENT '已拣数量', `status` tinyint(4) NOT NULL COMMENT '状态：10-待拣货 20-已拣货', PRIMARY KEY (`id`), KEY `idx_task_id` (`task_id`), KEY `idx_inventory_id` (`inventory_id`), FOREIGN KEY (`inventory_id`) REFERENCES `wms_inventory` (`id`) ON DELETE RESTRICT ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='拣货明细表';

设计要点解析：

1. 外键约束:picking_detail.inventory_id引用了inventory.id，确保了拣货明细必须指向一条真实的库存记录。
2. 状态追踪: 明细表中的quantity_picked用于记录实际拣货数量，可能与需求数量不同（部分缺货）。
3. 索引设计: 任务ID、库存ID上的索引对查询性能至关重要。

4. 环境准备与项目初始化

我们使用主流的Spring Boot + MyBatis-Plus + MySQL技术栈来构建项目。

4.1 开发环境要求

• JDK: 1.8 或 11
• Maven: 3.6+
• MySQL: 5.7+ (推荐8.0)
• Redis: 5.0+
• IDE: IntelliJ IDEA 或 Eclipse

4.2 初始化Spring Boot项目

使用 Spring Initializr 或IDE创建项目，选择以下依赖：

• Spring Web
• Spring Data JPA (或 MyBatis-Plus，本文示例用MyBatis-Plus)
• MySQL Driver
• Lombok (简化代码)
• Spring Boot DevTools

4.3 核心Maven依赖 (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 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>2.7.18</version> <!-- 选择一个稳定的版本 --> <relativePath/> </parent> <groupId>com.example</groupId> <artifactId>wms-demo</artifactId> <version>0.0.1-SNAPSHOT</version> <name>wms-demo</name> <description>WMS实战项目</description> <properties> <java.version>1.8</java.version> <mybatis-plus.version>3.5.3.1</mybatis-plus.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>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>${mybatis-plus.version}</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </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> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <excludes> <exclude> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </exclude> </excludes> </configuration> </plugin> </plugins> </build> </project>

4.4 基础配置文件 (application.yml)

server: port: 8080 spring: datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/wms_db?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai username: root password: your_password redis: host: localhost port: 6379 database: 0 timeout: 3000ms mybatis-plus: configuration: log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 控制台打印SQL，生产环境关闭 global-config: db-config: id-type: auto logic-delete-field: deleted # 全局逻辑删除字段 logic-delete-value: 1 logic-not-delete-value: 0 mapper-locations: classpath:mapper/*.xml logging: level: com.example.wms.mapper: debug

5. 核心业务逻辑与代码实现

5.1 库存扣减：如何保证不超卖？

这是WMS最核心的并发问题。我们采用“预占库存” + “数据库乐观锁”的方案。

第一步：下单时预占库存。用户下单后，OMS调用WMS的“库存预占”接口，将库存从quantity转移到locked_quantity。

// InventoryService.java 关键方法 @Service @Transactional(rollbackFor = Exception.class) public class InventoryService { @Autowired private InventoryMapper inventoryMapper; /** * 预占库存（核心方法） * @param skuId 商品ID * @param warehouseId 仓库ID * @param quantity 预占数量 * @return 预占成功的库存记录ID列表 */ public List<Long> lockInventory(Long skuId, Long warehouseId, Integer quantity) { // 1. 查询可用库存（按批次、储位，可能有多条） List<Inventory> availableList = inventoryMapper.selectAvailableInventory(skuId, warehouseId, quantity); if (availableList.isEmpty()) { throw new RuntimeException("库存不足"); } List<Long> lockedInventoryIds = new ArrayList<>(); int remaining = quantity; // 2. 遍历库存记录，逐条预占 for (Inventory inv : availableList) { if (remaining <= 0) break; int lockQty = Math.min(inv.getQuantity(), remaining); // 本次预占数量 // 3. 使用乐观锁更新 int updateCount = inventoryMapper.lockInventory(inv.getId(), lockQty, inv.getVersion()); if (updateCount == 0) { // 更新失败，说明版本号冲突，被其他线程修改过。这里可以重试或抛出异常。 throw new RuntimeException("库存并发修改，请重试"); } lockedInventoryIds.add(inv.getId()); remaining -= lockQty; } if (remaining > 0) { // 实际可用库存不足，需要回滚已预占的库存（业务上应触发补偿） throw new RuntimeException("库存不足，预占部分已回滚"); } return lockedInventoryIds; } }

对应的Mapper SQL (InventoryMapper.xml)：

<!-- 锁定库存 --> <update id="lockInventory"> UPDATE wms_inventory SET quantity = quantity - #{lockQty}, locked_quantity = locked_quantity + #{lockQty}, version = version + 1, updated_time = NOW() WHERE id = #{id} AND quantity >= #{lockQty} AND version = #{version} <!-- 乐观锁核心 --> </update> <!-- 查询可用库存 --> <select id="selectAvailableInventory" resultType="com.example.wms.entity.Inventory"> SELECT * FROM wms_inventory WHERE sku_id = #{skuId} AND warehouse_id = #{warehouseId} AND quantity > 0 AND status = 1 ORDER BY batch_id, location_id -- 可按先进先出等策略排序 FOR UPDATE -- 悲观锁，防止查询后被其他事务修改。高并发下需评估性能，或改用更细粒度的锁。 </select>

第二步：拣货时扣减锁定库存。生成拣货任务时，创建picking_detail记录，并更新库存。

// PickingService.java @Service public class PickingService { @Autowired private PickingDetailMapper pickingDetailMapper; @Autowired private InventoryMapper inventoryMapper; @Transactional public void confirmPicking(Long detailId, Integer actualQty) { PickingDetail detail = pickingDetailMapper.selectById(detailId); if (detail == null || !detail.getStatus().equals(PickingStatus.TO_BE_PICKED)) { throw new RuntimeException("拣货明细状态异常"); } // 更新库存：从 locked_quantity 移到 picked_quantity int updateCount = inventoryMapper.pickInventory(detail.getInventoryId(), actualQty); if (updateCount == 0) { throw new RuntimeException("库存扣减失败，可能已被其他操作占用"); } // 更新拣货明细状态和实际数量 detail.setQuantityPicked(actualQty); detail.setStatus(PickingStatus.PICKED); pickingDetailMapper.updateById(detail); } }

<!-- InventoryMapper.xml --> <update id="pickInventory"> UPDATE wms_inventory SET locked_quantity = locked_quantity - #{pickQty}, picked_quantity = picked_quantity + #{pickQty}, version = version + 1 WHERE id = #{inventoryId} AND locked_quantity >= #{pickQty} AND version = #{version} </update>

方案总结：通过quantity,locked_quantity,picked_quantity的状态划分和乐观锁，我们实现了库存的精准控制。在高并发下，乐观锁能避免大量线程阻塞，但需要配合重试机制。对于极端热点商品，可以引入Redis分布式锁进行前置拦截，或使用数据库悲观锁(SELECT ... FOR UPDATE)，但需注意性能。

5.2 波次生成策略实现

波次生成是为了提升拣货效率。一个简单的“按快递公司”波次生成策略示例：

// WaveService.java @Service public class WaveService { @Autowired private ShipmentOrderMapper orderMapper; @Autowired private WaveMapper waveMapper; /** * 按快递公司生成波次 */ @Transactional public Wave generateWaveByCarrier() { // 1. 查询所有状态为“待处理”且未分配波次的订单 List<ShipmentOrder> pendingOrders = orderMapper.selectPendingOrdersWithoutWave(); if (pendingOrders.isEmpty()) { return null; } // 2. 按快递公司分组 Map<String, List<ShipmentOrder>> ordersByCarrier = pendingOrders.stream() .collect(Collectors.groupingBy(ShipmentOrder::getCarrierCode)); List<Wave> waveList = new ArrayList<>(); // 3. 为每个快递公司创建波次 for (Map.Entry<String, List<ShipmentOrder>> entry : ordersByCarrier.entrySet()) { Wave wave = new Wave(); wave.setWaveSn("WAVE" + System.currentTimeMillis() + RandomUtil.randomNumbers(4)); wave.setStatus(WaveStatus.CREATED); wave.setStrategy("BY_CARRIER"); wave.setTotalOrders(entry.getValue().size()); waveMapper.insert(wave); // 4. 将订单关联到此波次 for (ShipmentOrder order : entry.getValue()) { order.setWaveId(wave.getId()); order.setStatus(OrderStatus.WAVE_ASSIGNED); orderMapper.updateById(order); } waveList.add(wave); } // 简单返回第一个波次 return waveList.isEmpty() ? null : waveList.get(0); } }

5.3 使用Redis实现简单的分布式锁

在库存预占等关键操作前，可以对skuId+warehouseId加锁，防止同一商品库存的并发超卖。

// DistributedLockService.java @Component public class DistributedLockService { @Autowired private StringRedisTemplate redisTemplate; private static final String LOCK_PREFIX = "wms:lock:"; private static final long DEFAULT_EXPIRE_TIME = 3000L; // 3秒 public boolean tryLock(String key, String value, long expireTime) { Boolean success = redisTemplate.opsForValue() .setIfAbsent(LOCK_PREFIX + key, value, expireTime, TimeUnit.MILLISECONDS); return Boolean.TRUE.equals(success); } public void unlock(String key, String value) { // 使用Lua脚本保证原子性：只有锁的持有者才能删除 String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"; redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Collections.singletonList(LOCK_PREFIX + key), value); } // 库存预占时使用 public boolean lockInventory(Long skuId, Long warehouseId) { String lockKey = "inv_lock:" + skuId + ":" + warehouseId; String requestId = UUID.randomUUID().toString(); // 唯一标识本次请求 return tryLock(lockKey, requestId, DEFAULT_EXPIRE_TIME); } }

在InventoryService.lockInventory方法开始时调用lockInventory，成功后执行后续逻辑，最后在finally块中释放锁。

6. 项目运行与接口测试

6.1 启动项目

1. 创建数据库wms_db，并执行前面的建表SQL。
2. 修改application.yml中的数据库连接信息。
3. 启动Redis服务。
4. 运行Spring Boot主类WmsDemoApplication。

6.2 使用Postman测试核心接口

接口1：创建商品入库单（模拟数据）

• POST/api/receipt
• Body (JSON):

  { "supplierCode": "SUP001", "details": [ {"skuCode": "SKU1001", "batchNo": "BATCH20240501", "expectedQuantity": 100}, {"skuCode": "SKU1002", "batchNo": "BATCH20240502", "expectedQuantity": 200} ] }

接口2：预占库存（模拟下单）

• POST/api/inventory/lock
• Body (JSON):

  { "orderSn": "SO202405270001", "items": [ {"skuId": 1, "warehouseId": 1, "quantity": 2} ] }

• 预期响应：返回预占成功的库存记录ID列表。

接口3：生成波次

• POST/api/wave/generate/by-carrier
• 预期响应：返回生成的波次信息，并可在数据库中查看相关订单的wave_id已更新。

6.3 验证库存数据一致性

1. 多次并发调用“预占库存”接口（可使用Jmeter或Postman Runner模拟）。
2. 查询数据库wms_inventory表，检查quantity和locked_quantity之和是否始终等于初始总量，且没有出现负数。
3. 观察日志，看是否有乐观锁冲突导致的更新失败（抛出异常）。

7. 常见问题与排查思路

8. 最佳实践与进阶方向

8.1 工程实践建议

1. 接口幂等性: 所有写操作（如创建订单、预占库存）的接口必须支持幂等，通过唯一业务单号（如orderSn）来防止重复提交。
2. 事务边界: 事务不宜过大，避免长事务占用数据库连接。库存预占、扣减等核心操作事务要小且快。
3. 日志与监控: 关键业务节点（库存变化、状态流转）必须打日志。接入APM工具监控接口耗时和数据库慢查询。
4. 数据一致性补偿: 对于跨服务调用（如扣减库存后通知OMS），要设计补偿机制（如定时任务检查状态不一致的数据进行修复）。
5. 代码分层清晰: 严格遵循Controller -> Service -> Manager -> Dao的分层。Service处理业务逻辑，Manager处理跨表事务，Dao只做数据访问。

8.2 性能优化方向

1. 库存查询缓存: 对商品基础信息、仓库-商品的总可用量等读多写少的数据，使用Redis缓存。
2. 异步化: 将生成拣货单、打印发货单等非实时操作，通过消息队列（如RabbitMQ）异步处理，提升主流程响应速度。
3. 数据库读写分离: 将报表查询、历史订单查询等读请求路由到从库，减轻主库压力。
4. 分库分表: 当单表数据量超过千万，可考虑按仓库ID进行分表。

8.3 功能扩展方向

1. 策略模式: 将波次生成策略（按快递、按库区、按订单量）、上架策略（就近上架、ABC分类）抽象为策略接口，便于扩展。
2. 工作流引擎: 引入Activiti或Flowable管理复杂的入库、出库审批流程。
3. 可视化看板: 使用WebSocket实现仓库实时作业看板，展示任务进度和设备状态。
4. 与AGV/自动化设备集成: 定义标准接口，与自动化立库、输送线、拣货机器人进行数据交互。

通过这个从零到一的WMS实战流程，你不仅学会了如何构建一个系统，更重要的是掌握了处理复杂业务逻辑、高并发数据一致性的核心思想。这些经验，是任何书本和简单项目都无法给予的。建议你以此为基础，逐步添加更多模块，如盘点、移库、报表等，最终形成一个完整的作品。在面试中，你可以清晰地阐述数据库设计、并发解决方案和业务抽象过程，这远比简单罗列技术栈更有说服力。