OptaPlanner高级调度：处理无可行解的规划变量与过约束规划

Constraint repConflict(ConstraintFactory constraintFactory) {
    // 确保销售代表在任何给定时间只能处理一个预约
    return constraintFactory
            // 选择每个销售代表的预约对
            .forEachUniquePair(Appointment.class,
                    Joiners.equal(Appointment::getRepUuid)) // 根据销售代表UUID分组
            .filter((appt1, appt2) -> {
                // 检查两个预约是否有时间重叠
                // 如果 appt1 的开始时间在 appt2 结束时间之前，并且 appt2 的开始时间在 appt1 结束时间之前，则存在重叠
                return appt1.getStartTime().isBefore(appt2.getEndTime())
                        && appt2.getStartTime().isBefore(appt1.getEndTime());
            })
            // 如果存在重叠，施加一个硬性惩罚
            .penalize(HardSoftScore.ONE_HARD)
            .asConstraint("SalesRep conflict");
}

import org.optaplanner.core.api.domain.entity.PlanningEntity;
import org.optaplanner.core.api.domain.variable.PlanningVariable;
// ... 其他导入

@PlanningEntity
public class Appointment {

    private String uuid; // 预约唯一标识
    private Date startTime;
    private Date endTime;

    // salesRep 是一个规划变量，它会从 salesRepRange 中选择一个 SalesRep 对象
    // nullable = true 允许这个规划变量的值为 null，表示该预约未被分配
    @PlanningVariable(valueRangeProviderRefs = "salesRepRange", nullable = true)
    private SalesRep salesRep; // 被分配的销售代表

    // ... 构造函数, getter 和 setter

    // 确保 getRepUuid() 方法返回 salesRep 的 UUID，如果 salesRep 为 null，则返回 null
    public String getRepUuid() {
        return (salesRep != null) ? salesRep.getUuid() : null;
    }
}

import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;
import org.optaplanner.core.api.score.stream.Constraint;
import org.optaplanner.core.api.score.stream.ConstraintFactory;
// ... 其他导入

public class RepSchedulerConstraintProvider implements ConstraintProvider {

    @Override
    public Constraint[] defineConstraints(ConstraintFactory constraintFactory) {
        return new Constraint[] {
                repConflict(constraintFactory),
                penalizeUnassignedAppointment(constraintFactory)
        };
    }

    Constraint repConflict(ConstraintFactory constraintFactory) {
        // ... （与上面相同的 repConflict 约束）
        return constraintFactory
                .forEachUniquePair(Appointment.class,
                        // 注意：如果 getRepUuid() 返回 null，Joiners.equal 将不会匹配，
                        // 这意味着未分配的预约不会参与此冲突检查，这是期望的行为。
                        Joiners.equal(Appointment::getRepUuid))
                .filter((appt1, appt2) -> {
                    return appt1.getStartTime().isBefore(appt2.getEndTime())
                            && appt2.getStartTime().isBefore(appt1.getEndTime());
                })
                .penalize(HardSoftScore.ONE_HARD)
                .asConstraint("SalesRep conflict");
    }

    Constraint penalizeUnassignedAppointment(ConstraintFactory constraintFactory) {
        // 惩罚所有未被分配销售代表的预约
        return constraintFactory.forEach(Appointment.class)
                .filter(appointment -> appointment.getSalesRep() == null)
                .penalize(HardSoftScore.ONE_SOFT) // 施加一个软性惩罚
                .asConstraint("Penalize unassigned appointment");
    }
}

public class SalesRep {
    private String uuid;
    private String name;
    // ... 构造函数, getter 和 setter
}

import org.optaplanner.core.api.domain.entity.PlanningEntity;
import org.optaplanner.core.api.domain.variable.PlanningVariable;
import java.util.Date;

@PlanningEntity
public class Appointment {
    private String uuid;
    private Date startTime;
    private Date endTime;

    @PlanningVariable(valueRangeProviderRefs = "salesRepRange", nullable = true)
    private SalesRep salesRep;

    public Appointment() {} // OptaPlanner需要无参构造函数

    public Appointment(String uuid, Date startTime, Date endTime) {
        this.uuid = uuid;
        this.startTime = startTime;
        this.endTime = endTime;