WMS仓储系统自研实战——架构设计与核心流程

CREATE TABLE t_location (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    location_code VARCHAR(32) NOT NULL COMMENT '库位编码',
    warehouse_id VARCHAR(32) NOT NULL COMMENT '仓库ID',

    zone_code VARCHAR(8) COMMENT '库区',
    aisle_code VARCHAR(8) COMMENT '巷道',
    rack_code VARCHAR(8) COMMENT '货架',
    level_code VARCHAR(8) COMMENT '层',
    column_code VARCHAR(8) COMMENT '列',

    location_type VARCHAR(16) NOT NULL COMMENT '库位类型',
    status VARCHAR(16) NOT NULL DEFAULT 'EMPTY' COMMENT '状态',

    max_weight DECIMAL(10,2) COMMENT '最大承重(kg)',
    max_volume DECIMAL(10,2) COMMENT '最大体积(m³)',

    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,

    UNIQUE KEY uk_location_code (warehouse_id, location_code),
    KEY idx_zone (warehouse_id, zone_code),
    KEY idx_type_status (location_type, status)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='库位表';

public class ASN {
    private String asnNo;           // ASN单号
    private String warehouseId;     // 仓库ID
    private String supplierId;      // 供应商ID
    private String poNo;            // 采购单号

    private Date expectedDate;      // 预计到货日期
    private List<ASNItem> items;    // 预约明细

    private ASNStatus status;       // 状态
}

public class ASNItem {
    private String skuId;           // SKU编码
    private Integer expectedQty;    // 预约数量
    private Integer receivedQty;    // 已收数量
}

@Component
public class NearestLocationStrategy implements PutawayStrategy {
    @Override
    public String recommendLocation(String skuId, String warehouseId) {
        // 找到该SKU已有库存的库位附近的空库位
        List<String> existingLocations = inventoryService.getLocations(skuId);
        return locationService.findNearestEmpty(existingLocations);
    }
}

@Component
public class ZoneBasedStrategy implements PutawayStrategy {
    @Override
    public String recommendLocation(String skuId, String warehouseId) {
        // 根据SKU属性（品类、周转率）分配到对应库区
        SKU sku = skuService.getSku(skuId);
        String zone = determineZone(sku);
        return locationService.findEmptyInZone(zone);
    }
}

// A区：高周转商品，靠近出库口
// B区：中周转商品
// C区：低周转商品，远离出库口

@Service
public class WaveService {

    public Wave createWave(List<OutboundOrder> orders, WaveStrategy strategy) {
        Wave wave = new Wave();
        wave.setWaveNo(generateWaveNo());

        // 按策略分组
        Map<String, List<OutboundOrder>> groups = strategy.group(orders);

        // 生成拣货任务
        List<PickTask> pickTasks = new ArrayList<>();
        for (List<OutboundOrder> group : groups.values()) {
            PickTask task = createPickTask(group);
            pickTasks.add(task);
        }

        wave.setPickTasks(pickTasks);
        return wave;
    }
}

@Service
public class PickPathOptimizer {

    /**
     * S型路径优化
     * 按巷道顺序，奇数巷道从前往后，偶数巷道从后往前
     */
    public List<PickItem> optimizePath(List<PickItem> items) {
        // 按库位排序
        items.sort((a, b) -> {
            int aisleCompare = a.getAisle().compareTo(b.getAisle());
            if (aisleCompare != 0) return aisleCompare;

            // 奇数巷道正序，偶数巷道倒序
            int aisle = Integer.parseInt(a.getAisle());
            if (aisle % 2 == 1) {
                return a.getLocation().compareTo(b.getLocation());
            } else {
                return b.getLocation().compareTo(a.getLocation());
            }
        });

        return items;
    }
}

@Service
public class CheckService {

    public CheckResult check(String orderNo, String scannedBarcode) {
        OutboundOrder order = orderRepository.findByOrderNo(orderNo);

        // 查找匹配的商品
        OrderItem matchedItem = order.getItems().stream()
            .filter(item -> item.getBarcode().equals(scannedBarcode))
            .findFirst()
            .orElse(null);

        if (matchedItem == null) {
            return CheckResult.error("商品不在订单中");
        }

        // 更新已复核数量
        matchedItem.setCheckedQty(matchedItem.getCheckedQty() + 1);

        // 检查是否超量
        if (matchedItem.getCheckedQty() > matchedItem.getQuantity()) {
            return CheckResult.error("复核数量超出");
        }

        // 检查是否完成
        boolean allChecked = order.getItems().stream()
            .allMatch(item -> item.getCheckedQty().equals(item.getQuantity()));

        if (allChecked) {
            order.setStatus(OrderStatus.CHECKED);
            return CheckResult.complete();
        }

        return CheckResult.success(matchedItem);
    }
}

-- 库位库存表
CREATE TABLE t_location_inventory (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    warehouse_id VARCHAR(32) NOT NULL,
    location_code VARCHAR(32) NOT NULL,
    sku_id VARCHAR(32) NOT NULL,

    quantity INT NOT NULL DEFAULT 0 COMMENT '库存数量',
    locked_qty INT NOT NULL DEFAULT 0 COMMENT '锁定数量',

    batch_no VARCHAR(32) COMMENT '批次号',
    production_date DATE COMMENT '生产日期',
    expiry_date DATE COMMENT '过期日期',

    version INT NOT NULL DEFAULT 0,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

    UNIQUE KEY uk_location_sku (warehouse_id, location_code, sku_id, batch_no),
    KEY idx_sku (sku_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='库位库存表';

-- 库存流水表
CREATE TABLE t_inventory_transaction (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    transaction_no VARCHAR(32) NOT NULL,
    warehouse_id VARCHAR(32) NOT NULL,
    sku_id VARCHAR(32) NOT NULL,

    transaction_type VARCHAR(16) NOT NULL COMMENT '类型：IN/OUT/ADJUST',
    quantity INT NOT NULL COMMENT '变动数量',
    before_qty INT NOT NULL COMMENT '变动前数量',
    after_qty INT NOT NULL COMMENT '变动后数量',

    source_type VARCHAR(32) COMMENT '来源类型',
    source_no VARCHAR(32) COMMENT '来源单号',

    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,

    KEY idx_sku (sku_id),
    KEY idx_source (source_type, source_no)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='库存流水表';

@Service
@Transactional
public class InventoryTransactionService {

    public void addInventory(String warehouseId, String locationCode,
                            String skuId, int quantity, String sourceType, String sourceNo) {
        // 1. 更新库位库存
        LocationInventory inventory = inventoryRepository
            .findByLocation(warehouseId, locationCode, skuId);

        if (inventory == null) {
            inventory = new LocationInventory();
            inventory.setWarehouseId(warehouseId);
            inventory.setLocationCode(locationCode);
            inventory.setSkuId(skuId);
            inventory.setQuantity(0);
        }

        int beforeQty = inventory.getQuantity();
        inventory.setQuantity(beforeQty + quantity);
        inventoryRepository.save(inventory);

        // 2. 记录流水
        InventoryTransaction transaction = new InventoryTransaction();
        transaction.setTransactionNo(generateTransactionNo());
        transaction.setWarehouseId(warehouseId);
        transaction.setSkuId(skuId);
        transaction.setTransactionType("IN");
        transaction.setQuantity(quantity);
        transaction.setBeforeQty(beforeQty);
        transaction.setAfterQty(beforeQty + quantity);
        transaction.setSourceType(sourceType);
        transaction.setSourceNo(sourceNo);
        transactionRepository.save(transaction);

        // 3. 同步OMS可售库存
        omsClient.syncInventory(warehouseId, skuId, inventory.getQuantity());
    }
}

// 使用乐观锁防止并发问题
@Update("UPDATE t_location_inventory " +
        "SET quantity = quantity - #{qty}, version = version + 1 " +
        "WHERE id = #{id} AND version = #{version} AND quantity >= #{qty}")
int deductInventory(@Param("id") Long id,
                   @Param("qty") int qty,
                   @Param("version") int version);

// 批量插入，减少数据库交互
@Insert("<script>" +
        "INSERT INTO t_inventory_transaction (...) VALUES " +
        "<foreach collection='list' item='item' separator=','>" +
        "(#{item.transactionNo}, ...)" +
        "</foreach>" +
        "</script>")
int batchInsert(@Param("list") List<InventoryTransaction> list);