3分钟解决排程难题：OptaPlanner与Timefold优化引擎实战指南

你是否还在为员工排班冲突焦头烂额？生产计划排程耗时一整天？配送路线规划成本居高不下？本文将带你掌握Java生态最强大的两款智能优化引擎——OptaPlanner与Timefold，通过3个实战场景演示如何用代码实现自动化决策优化，让计算机替你解决90%的复杂排程问题。

读完本文你将获得：

• 理解约束满足问题（Constraint Satisfaction Problem, CSP）的核心解决思路
• 掌握OptaPlanner与Timefold的选型决策框架
• 3个完整业务场景的代码实现模板（员工排班/车辆路径/生产排程）
• 性能调优参数配置指南

什么是智能优化引擎？

在README.md中，我们可以看到这两个项目被归类在Constraint Satisfaction Problem Solver（约束满足问题求解器）类别下：

• OptaPlanner - Business planning and resource scheduling optimization solver.
• Timefold - Flexible solver with Spring/Quarkus support and quickstarts for the Vehicle Routing Problem, Maintenance Scheduling, Employee Shift Scheduling and much more.

简单来说，这类工具能在海量可能的方案中，快速找到满足所有业务约束（如"员工不能连续工作超过8小时"）且优化目标（如"最小化配送距离"）的最优解。传统编程方法需要开发者手动编写规则引擎，而优化引擎通过元启发式算法（如遗传算法、模拟退火）自动探索解决方案空间。

OptaPlanner vs Timefold：选型决策指南

特性	OptaPlanner	Timefold
项目状态	活跃维护	2022年从OptaPlanner分叉
许可证	Apache License 2.0	Apache License 2.0
框架集成	Spring, Quarkus, K8s	Spring, Quarkus, Micronaut
学习曲线	中等	低（改进了文档和API）
性能优化	优秀	基于OptaPlanner 8改进
典型场景	复杂生产排程	快速应用开发

选型建议：新项目优先选择Timefold，其提供更现代的API和更好的开发者体验；遗留系统维护可继续使用OptaPlanner。两者核心算法相同，迁移成本低。

实战场景1：员工排班系统（Timefold实现）

假设我们需要解决一个医院护士排班问题，约束条件包括：

• 每位护士每天工作不超过8小时
• 不允许连续工作超过5天
• 每个班次至少有2名护士在岗

首先在pom.xml中添加依赖（使用国内Maven仓库）：

<dependency>
    <groupId>ai.timefold.solver</groupId>
    <artifactId>timefold-solver-core</artifactId>
    <version>1.8.0</version>
</dependency>

定义排班问题实体类：

@PlanningEntity
public class ShiftAssignment {
    @PlanningId
    private Long id;
    
    private Nurse nurse;
    
    private LocalDate date;
    
    @PlanningVariable(valueRangeProviderRefs = "nurseRange")
    private Nurse assignedNurse;
    
    // getter/setter
}

创建约束定义类：

public class NurseRosteringConstraintProvider implements ConstraintProvider {
    @Override
    public Constraint[] defineConstraints(ConstraintFactory factory) {
        return new Constraint[] {
            // 每天工作不超过8小时
            factory.forEach(ShiftAssignment.class)
                .groupBy(ShiftAssignment::getAssignedNurse, 
                         ShiftAssignment::getDate,
                         ConstraintCollectors.sum(ShiftAssignment::getDuration))
                .filter((nurse, date, duration) -> duration.compareTo(Duration.ofHours(8)) > 0)
                .penalize("Max 8 hours per day", HardSoftScore.ONE_HARD),
                
            // 连续工作不超过5天
            factory.forEach(ShiftAssignment.class)
                .groupBy(ShiftAssignment::getAssignedNurse,
                         ConstraintCollectors.sequence(ShiftAssignment::getDate))
                .filter((nurse, dates) -> dates.size() > 5)
                .penalize("Max 5 consecutive days", HardSoftScore.ONE_HARD)
        };
    }
}

求解器配置：

SolverFactory<NurseRosteringSolution> solverFactory = SolverFactory.create(new SolverConfig()
    .withSolutionClass(NurseRosteringSolution.class)
    .withEntityClasses(ShiftAssignment.class)
    .withConstraintProviderClass(NurseRosteringConstraintProvider.class)
    .withTerminationSpentLimit(Duration.ofMinutes(5)));

Solver<NurseRosteringSolution> solver = solverFactory.buildSolver();
NurseRosteringSolution solution = solver.solve(unsolvedProblem);

实战场景2：车辆路径优化（OptaPlanner实现）

配送公司需要规划10辆货车将100个订单配送到不同地址，目标是最小化总行驶距离和车辆使用数量。

核心模型定义：

@PlanningSolution
public class VehicleRoutingSolution {
    @PlanningEntityCollectionProperty
    private List<Customer> customerList;
    
    @ProblemFactCollectionProperty
    private List<Vehicle> vehicleList;
    
    @PlanningScore
    private HardSoftScore score;
    
    // getter/setter
}

距离计算约束：

public class VehicleRoutingConstraintProvider implements ConstraintProvider {
    @Override
    public Constraint[] defineConstraints(ConstraintFactory factory) {
        return new Constraint[] {
            // 最小化总距离
            factory.forEach(Vehicle.class)
                .join(Customer.class, Joiners.equal(Vehicle::getId, Customer::getVehicleId))
                .groupBy((vehicle, customer) -> vehicle,
                         ConstraintCollectors.sum((vehicle, customer) -> 
                             calculateDistance(vehicle.getDepot(), customer.getLocation())))
                .penalize("Minimize total distance", 
                         HardSoftScore.ONE_SOFT, 
                         (vehicle, distance) -> distance)
        };
    }
    
    private long calculateDistance(Location a, Location b) {
        return (long) Math.hypot(a.getX() - b.getX(), a.getY() - b.getY());
    }
}

性能调优指南

无论是OptaPlanner还是Timefold，都提供了丰富的调优参数。根据README.md的项目分类，这些工具属于High Performance优化范畴，建议配置：

.withSolverConfiguration(new SolverConfig()
    .withLocalSearchPhaseConfig(new LocalSearchPhaseConfig()
        .withLocalSearchType(LocalSearchType.TABU_SEARCH)
        .withTabuSearchPhaseConfig(new TabuSearchPhaseConfig()
            .withAcceptedCountLimit(1000))
        .withTerminationConfig(new TerminationConfig()
            .withBestScoreFeasible(true)
            .withSecondsSpentLimit(30))))

关键调优参数：

• acceptedCountLimit：禁忌搜索接受非改进解的次数
• bestScoreFeasible：找到可行解后提前终止
• neighborhoodSelectionCount：邻域大小，影响搜索广度

选型决策流程图

graph TD
    A[开始] --> B{项目类型}
    B -->|新项目/快速开发| C[选择Timefold]
    B -->|遗留系统维护| D[继续使用OptaPlanner]
    C --> E[Spring Boot集成]
    D --> F[稳定版本依赖]
    E --> G[实现业务约束]
    F --> G
    G --> H[性能调优]
    H --> I[部署上线]

总结与展望

OptaPlanner和Timefold作为Java生态最成熟的智能优化引擎，已被证明能有效解决各类NP难问题。通过本文介绍的约束定义模式和求解器配置，你可以快速将这些工具集成到自己的业务系统中。

建议下一步：

1. 查看官方文档：Timefold文档更友好，OptaPlanner文档更全面
2. 尝试示例项目：从README.md提供的链接获取快速启动模板
3. 加入社区讨论：两个项目都有活跃的GitHub讨论区和Stack Overflow标签

收藏本文，下次遇到排程问题时，3分钟即可快速实现企业级解决方案！关注作者获取更多Java优化技术实践。