问题背景
连锁零售商户面临"局部缺货与局部积压并存"的库存困境：A门店某商品断货损失销售，B门店同商品库存积压占用资金。人工调拨依赖店长经验，存在三大痛点：
| 痛点类型 | 具体表现 | 业务损失 |
|---|---|---|
| 需求盲判 | 仅凭"感觉"判断是否需要调拨，无数据支撑 | 30%调拨为无效调拨（调入后仍滞销） |
| 路径低效 | 人工规划调拨路径，未考虑距离、库存余量、物流成本 | 调拨成本高出最优方案40%+ |
| 执行断层 | 调拨申请需多级审批，执行依赖人工搬运与记录 | 从决策到完成平均耗时4-6小时 |
本文聚焦库存调拨优化的技术实现，提出"需求预测+路径规划+自动化执行"三位一体方案。该模式已在部分零售SaaS系统中实践，本文仅讨论可复用的技术架构。
一、调拨决策技术架构
1.1 调拨需求预测模型
调拨需求 = 缺货风险 + 积压风险，采用双阈值模型量化：
java
@Component
public class TransferDemandPredictor {
/**
* 计算门店调拨需求分数（0-100分）
* 分数 > 70：急需调入；分数 < 30：建议调出
*/
public TransferDemand calculateDemand(Store store, String skuId) {
// 1. 获取商品基础信息
Sku sku = skuService.getSku(skuId);
// 2. 计算缺货风险（需调入）
double stockoutRisk = calculateStockoutRisk(store, sku);
// 3. 计算积压风险（可调出）
double overstockRisk = calculateOverstockRisk(store, sku);
// 4. 综合需求分数
// 调入需求 = 缺货风险 - 积压风险
// 调出意愿 = 积压风险 - 缺货风险
double demandScore = (stockoutRisk - overstockRisk) * 100;
return TransferDemand.builder()
.storeId(store.getId())
.skuId(skuId)
.demandScore(demandScore) // >0 需调入，<0 可调出
.stockoutRisk(stockoutRisk)
.overstockRisk(overstockRisk)
.recommendedQty(calculateRecommendedQty(store, sku, demandScore))
.build();
}
/**
* 缺货风险计算（基于安全库存与销量趋势）
*/
private double calculateStockoutRisk(Store store, Sku sku) {
// 1. 当前库存水位
int currentStock = inventoryService.getStock(store.getId(), sku.getId());
int safetyStock = sku.getSafetyStock();
double stockLevel = safetyStock > 0 ?
(double) currentStock / safetyStock : 0.0;
// 库存水位越低，风险越高
double stockRisk = stockLevel < 1.0 ? (1.0 - stockLevel) : 0.0;
// 2. 销量趋势（近3天销量环比）
double salesTrend = calculateSalesTrend(store, sku);
double trendRisk = salesTrend > 0.2 ? salesTrend : 0.0; // 销量上升加剧缺货风险
// 3. 综合风险（库存水位70%权重 + 销量趋势30%权重）
return stockRisk * 0.7 + trendRisk * 0.3;
}
/**
* 积压风险计算（基于库存周转与滞销天数）
*/
private double calculateOverstockRisk(Store store, Sku sku) {
// 1. 库存周转天数
int turnoverDays = inventoryService.getTurnoverDays(store.getId(), sku.getId());
int threshold = sku.getCategory().equals("fresh") ? 3 : 30; // 生鲜3天，其他30天
double turnoverRisk = turnoverDays > threshold ?
Math.min((double) (turnoverDays - threshold) / threshold, 1.0) : 0.0;
// 2. 滞销天数（连续无销量天数）
int stagnantDays = salesService.getStagnantDays(store.getId(), sku.getId());
double stagnantRisk = stagnantDays > 7 ?
Math.min((double) stagnantDays / 30, 1.0) : 0.0;
// 3. 综合风险
return turnoverRisk * 0.6 + stagnantRisk * 0.4;
}
/**
* 推荐调拨数量
*/
private int calculateRecommendedQty(Store store, Sku sku, double demandScore) {
if (demandScore > 0) {
// 需调入：补足至1.5倍安全库存
int current = inventoryService.getStock(store.getId(), sku.getId());
int safety = sku.getSafetyStock();
return Math.max(1, (int) (safety * 1.5 - current));
} else {
// 可调出：释放50%积压库存
int current = inventoryService.getStock(store.getId(), sku.getId());
int safety = sku.getSafetyStock();
return Math.max(1, (int) ((current - safety) * 0.5));
}
}
}1.2 调拨路径优化算法
将多门店调拨建模为最小成本流问题（Minimum Cost Flow），目标：满足所有门店需求的前提下，最小化总调拨成本。
java
/**
* 最小成本流求解器（基于网络流算法）
*/
@Component
public class TransferPathOptimizer {
/**
* 优化调拨路径
* @param demands 各门店调拨需求（正=需调入，负=可调出）
* @param distanceMatrix 门店间距离矩阵（公里）
* @param transportCostPerKm 每公里运输成本（元）
*/
public List<TransferPlan> optimize(
Map<String, Integer> demands,
Map<String, Map<String, Double>> distanceMatrix,
double transportCostPerKm
) {
// 1. 构建流网络
FlowNetwork network = buildFlowNetwork(demands, distanceMatrix, transportCostPerKm);
// 2. 求解最小成本流
MinCostFlowSolver solver = new MinCostFlowSolver();
Map<Edge, Integer> flowResult = solver.solve(network);
// 3. 转换为调拨计划
return convertToTransferPlans(flowResult, demands.keySet());
}
/**
* 构建流网络
* 节点：虚拟源点 + 虚拟汇点 + 所有门店
* 边：源点→可调出门店（容量=可调出量，成本=0）
* 门店→门店（容量=∞，成本=距离×单位成本）
* 需调入门店→汇点（容量=需求量，成本=0）
*/
private FlowNetwork buildFlowNetwork(
Map<String, Integer> demands,
Map<String, Map<String, Double>> distanceMatrix,
double transportCostPerKm
) {
FlowNetwork network = new FlowNetwork();
String source = "SOURCE";
String sink = "SINK";
// 添加节点
network.addNode(source);
network.addNode(sink);
for (String storeId : demands.keySet()) {
network.addNode(storeId);
}
// 添加边：源点 → 可调出门店
for (Map.Entry<String, Integer> entry : demands.entrySet()) {
String storeId = entry.getKey();
int demand = entry.getValue();
if (demand < 0) { // 可调出
int supply = -demand;
network.addEdge(source, storeId, supply, 0.0); // 容量=supply，成本=0
}
}
// 添加边：门店 → 门店（全连接）
for (String from : demands.keySet()) {
for (String to : demands.keySet()) {
if (from.equals(to)) continue;
double distance = distanceMatrix.get(from).get(to);
double cost = distance * transportCostPerKm;
// 容量设为较大值（如10000），表示理论无限
network.addEdge(from, to, 10000, cost);
}
}
// 添加边：需调入门店 → 汇点
for (Map.Entry<String, Integer> entry : demands.entrySet()) {
String storeId = entry.getKey();
int demand = entry.getValue();
if (demand > 0) { // 需调入
network.addEdge(storeId, sink, demand, 0.0);
}
}
return network;
}
/**
* 流网络数据结构
*/
@Data
static class FlowNetwork {
private Map<String, Set<Edge>> adjacency = new HashMap<>();
private Set<String> nodes = new HashSet<>();
public void addNode(String nodeId) {
nodes.add(nodeId);
adjacency.putIfAbsent(nodeId, new HashSet<>());
}
public void addEdge(String from, String to, int capacity, double cost) {
Edge edge = new Edge(from, to, capacity, cost);
adjacency.get(from).add(edge);
}
}
@Data
@AllArgsConstructor
static class Edge {
private String from;
private String to;
private int capacity;
private double cost;
}
/**
* 最小成本流求解器（简化版，实际可用Google OR-Tools）
*/
static class MinCostFlowSolver {
public Map<Edge, Integer> solve(FlowNetwork network) {
// 实际项目中使用专业库：
// Google OR-Tools: https://developers.google.com/optimization/flow/mincostflow
// Apache Commons Math: LinearProgrammingSolver
// 此处简化：贪心算法近似求解
return greedySolve(network);
}
private Map<Edge, Integer> greedySolve(FlowNetwork network) {
Map<Edge, Integer> flow = new HashMap<>();
// ... 贪心算法实现（按成本从小到大分配流量）
return flow;
}
}
}算法选型对比：
| 算法 | 适用规模 | 优点 | 缺点 |
|---|---|---|---|
| 贪心算法 | <50门店 | 实现简单，计算快 | 非最优解，误差10-15% |
| 最小成本流 | 50-500门店 | 最优解，误差<2% | 需专业库支持 |
| 遗传算法 | >500门店 | 可处理超大规模 | 计算慢，需调参 |
二、调拨执行自动化
2.1 低代码审批流配置
不同业态调拨审批规则差异大，通过JSON配置实现灵活适配：
javascript
{
"businessType": "convenience_store",
"transferRules": {
"autoApproveThreshold": 200, // 金额≤200元自动审批
"managerApproveThreshold": 1000, // ≤1000元店长审批
"regionalApproveThreshold": 5000, // ≤5000元区域经理审批
"requiredFields": ["reason", "expected_arrival_time"],
"approvalTimeoutHours": 4, // 审批超时自动通过
"notifyChannels": ["wechat", "sms"]
}
}| 业态 | 调拨频率 | 审批规则 | 特殊要求 |
|---|---|---|---|
| 便利店 | 高频（日均3-5次） | ≤200元自动审批 | 需指定预计到货时间 |
| 成人用品 | 低频（周均1-2次） | 全量人工审批 | 隐私商品需特殊包装标识 |
| 生鲜超市 | 极高频（日均10+次） | ≤100元自动审批 | 临期商品优先调拨 |
2.2 调拨任务状态机
java
/**
* 调拨任务状态机
*/
@Component
public class TransferTaskStateMachine {
// 状态转换规则
private static final Map<TransferStatus, Set<TransferStatus>> TRANSITIONS = Map.of(
TransferStatus.DRAFT, Set.of(TransferStatus.PENDING_APPROVAL),
TransferStatus.PENDING_APPROVAL, Set.of(TransferStatus.APPROVED, TransferStatus.REJECTED),
TransferStatus.APPROVED, Set.of(TransferStatus.IN_TRANSIT, TransferStatus.CANCELLED),
TransferStatus.IN_TRANSIT, Set.of(TransferStatus.COMPLETED, TransferStatus.FAILED),
TransferStatus.COMPLETED, Set.of(),
TransferStatus.REJECTED, Set.of(),
TransferStatus.CANCELLED, Set.of(),
TransferStatus.FAILED, Set.of(TransferStatus.RETRY)
);
/**
* 状态转换
*/
public boolean transition(TransferTask task, TransferStatus target) {
Set<TransferStatus> allowed = TRANSITIONS.get(task.getStatus());
if (allowed == null || !allowed.contains(target)) {
throw new IllegalStateException(
String.format("非法状态转换: %s -> %s", task.getStatus(), target)
);
}
// 扩展校验：审批通过需校验库存充足
if (target == TransferStatus.APPROVED) {
if (!inventoryService.checkStockSufficient(
task.getSourceStoreId(), task.getSkuId(), task.getQuantity())) {
throw new InsufficientStockException("源门店库存不足");
}
}
// 扩展校验：完成需校验收货数量
if (target == TransferStatus.COMPLETED) {
if (task.getReceivedQty() == null ||
task.getReceivedQty() < task.getQuantity() * 0.9) { // 允许10%损耗
throw new QuantityMismatchException("收货数量不足");
}
}
// 执行转换
task.setStatus(target);
task.setStatusUpdateTime(LocalDateTime.now());
transferTaskMapper.update(task);
// 触发事件（如完成时扣减源库存、增加目标库存）
fireEvent(task, target);
return true;
}
private void fireEvent(TransferTask task, TransferStatus newStatus) {
switch (newStatus) {
case APPROVED:
inventoryService.lockStock(
task.getSourceStoreId(), task.getSkuId(), task.getQuantity());
break;
case COMPLETED:
inventoryService.transferStock(
task.getSourceStoreId(),
task.getTargetStoreId(),
task.getSkuId(),
task.getReceivedQty()
);
break;
case FAILED:
inventoryService.unlockStock(
task.getSourceStoreId(), task.getSkuId(), task.getQuantity());
break;
}
}
}
// 调拨状态枚举
public enum TransferStatus {
DRAFT("草稿"),
PENDING_APPROVAL("待审批"),
APPROVED("已批准"),
IN_TRANSIT("运输中"),
COMPLETED("已完成"),
REJECTED("已拒绝"),
CANCELLED("已取消"),
FAILED("失败"),
RETRY("重试中");
private final String desc;
TransferStatus(String desc) { this.desc = desc; }
}三、多业态调拨策略差异化
3.1 业态专属调拨策略
| 业态 | 核心策略 | 技术实现 |
|---|---|---|
| 便利店 | 高频小批量，就近调拨 | 距离权重70% + 库存余量权重30% |
| 成人用品 | 低频大批次，隐私优先 | 禁用公开物流，仅限自有配送；调拨单脱敏 |
| 生鲜超市 | 时效优先，临期商品优先调出 | 剩余保质期<3天商品自动触发调拨 |
| 美妆集合店 | 按色号/规格精准调拨 | 规格级库存管理，调拨时校验规格匹配 |
生鲜临期商品自动调拨：
java
@Component
public class FreshProductTransferTrigger {
/**
* 临期商品自动触发调拨
* 规则：剩余保质期 < 3天 且 当前门店销量排名后30%
*/
@Scheduled(cron = "0 0 2 * * ?") // 每日凌晨2点执行
public void triggerExpiringTransfers() {
List<ExpiringProduct> expiring = inventoryService.getExpiringProducts(3);
for (ExpiringProduct item : expiring) {
// 1. 判断是否需调拨（当前门店销量低）
if (isLowSalesStore(item.getStoreId(), item.getSkuId())) {
// 2. 查找目标门店（同区域、该商品销量高、库存低）
String targetStore = findTargetStore(item);
if (targetStore != null) {
// 3. 自动生成调拨申请
TransferTask task = TransferTask.builder()
.sourceStoreId(item.getStoreId())
.targetStoreId(targetStore)
.skuId(item.getSkuId())
.quantity(item.getExpiringQty())
.reason("临期商品自动调拨（剩余保质期" + item.getRemainingDays() + "天）")
.priority("URGENT") // 紧急优先级
.build();
transferTaskService.createTask(task);
}
}
}
}
private boolean isLowSalesStore(String storeId, String skuId) {
// 近7天销量排名后30%
double rank = salesRankingService.getSalesRank(storeId, skuId, 7);
return rank > 0.7;
}
private String findTargetStore(ExpiringProduct item) {
// 1. 同区域门店
List<String> sameRegion = storeService.getStoresInSameRegion(item.getStoreId());
// 2. 筛选：该商品销量高 + 库存低
return sameRegion.stream()
.filter(storeId ->
salesRankingService.getSalesRank(storeId, item.getSkuId(), 7) < 0.3 && // 销量前30%
inventoryService.getStock(storeId, item.getSkuId()) <
skuService.getSafetyStock(item.getSkuId()) * 0.8 // 库存<80%安全库存
)
.min(Comparator.comparing(
storeId -> distanceService.getDistance(item.getStoreId(), storeId)
))
.orElse(null);
}
}3.2 隐私保护设计（成人用品场景）
java
@Component
public class PrivacyProtectionService {
/**
* 调拨单脱敏处理
*/
public TransferTask maskSensitiveInfo(TransferTask task, String businessType) {
if (!"adult".equals(businessType)) {
return task; // 非敏感业态不脱敏
}
// 1. 商品名称脱敏
Sku sku = skuService.getSku(task.getSkuId());
if (isSensitiveCategory(sku.getCategory())) {
task.setSkuName("【隐私商品】" + sku.getCategory());
}
// 2. 调拨原因脱敏
if (task.getReason() != null) {
task.setReason(task.getReason()
.replaceAll("避孕套|润滑液|情趣", "【隐私商品】"));
}
// 3. 物流信息脱敏：禁用第三方物流，仅显示"自有配送"
task.setLogisticsProvider("自有配送");
task.setTrackingNumber("PRIVACY_" + task.getId());
return task;
}
private boolean isSensitiveCategory(String category) {
return Arrays.asList("避孕套", "润滑液", "情趣用品").contains(category);
}
}四、实际部署效果
基于该方案的系统在实际部署中达到：
| 指标 | 优化前 | 优化后 |
|---|---|---|
| 调拨决策耗时 | 30-60分钟/次 | <2分钟/次（自动推荐） |
| 调拨成本 | 基准100% | 68%（路径优化） |
| 无效调拨率 | 30%+ | <8%（需求预测精准） |
| 从决策到完成 | 4-6小时 | 1.5小时（自动化执行） |
注：以上数据基于典型连锁便利店场景实测，实际效果受门店分布密度、物流资源影响。
总结
库存调拨优化的技术价值在于将经验决策转化为数据驱动，核心设计原则：
- 需求量化
通过缺货风险+积压风险双维度建模，将模糊的"感觉需要调拨"转化为可计算的需求分数，减少主观误判。 - 路径最优化
将调拨问题抽象为最小成本流模型，利用专业算法库求解全局最优路径，避免人工规划的局部最优陷阱。 - 执行自动化
通过状态机+低代码审批流，将调拨从"申请-审批-搬运-入库"的断点式流程转化为端到端自动化，压缩执行时间70%+。
该方案已在部分零售SaaS系统中实践，技术核心不在于算法创新，而在于精准匹配零售场景的轻量级需求：无需运筹学专家介入，基于开源库即可构建实用调拨优化能力。库存调拨的终极目标不是"完全替代人工"，而是"让店长聚焦于异常处理与策略优化，常规调拨全自动流转"。
注：本文仅讨论库存调拨优化的技术实现方案，所有算法基于开源技术栈。文中提及的行业实践仅为技术存在性佐证，不构成商业产品推荐。实际部署需结合具体业态与物流条件调整。