OptaPlanner模式匹配领域建模求助：变量绑定一致性问题

针对你的需求，这里提供两种可行的解决方案，优先推荐通过约束实现的轻量方案，适合新手快速落地。

解决方案1：通过硬约束实现变量全局一致性 #

保留你现有核心模型，通过添加约束规则来校验变量的全局绑定一致性，无需调整实体结构。

1. 完善ThingPattern辅助方法 #

给ThingPattern添加工具方法，用于区分常量属性和变量属性，提取变量与对应属性键的映射：

class ThingPattern {
    String type;
    Map<String, String> properties;
    @PlanningVariable(valueRangeProviderRefs = {"things"}, nullable = true)
    Thing thing;

    // 判断属性值是否为变量（比如以< >包裹）
    private boolean isVariable(String value) {
        return value != null && value.startsWith("<") && value.endsWith(">");
    }

    // 提取变量名（去除< >）
    private String extractVariableName(String value) {
        return value.substring(1, value.length() - 1);
    }

    // 获取当前Pattern中变量到属性键的映射
    public Map<String, String> getVariableToPropertyMap() {
        Map<String, String> variableMap = new HashMap<>();
        for (Map.Entry<String, String> entry : properties.entrySet()) {
            if (isVariable(entry.getValue())) {
                variableMap.put(extractVariableName(entry.getValue()), entry.getKey());
            }
        }
        return variableMap;
    }

    // 获取当前Pattern中的常量属性键值对
    public Map<String, String> getConstantProperties() {
        Map<String, String> constantMap = new HashMap<>();
        for (Map.Entry<String, String> entry : properties.entrySet()) {
            if (!isVariable(entry.getValue())) {
                constantMap.put(entry.getKey(), entry.getValue());
            }
        }
        return constantMap;
    }
}

2. 编写约束规则 #

使用ConstraintStream API实现所有业务约束，包括变量全局一致性校验：

public class ThingPatternConstraintProvider implements ConstraintProvider {
    @Override
    public Constraint[] defineConstraints(ConstraintFactory factory) {
        return new Constraint[] {
            // 硬约束1：Pattern与Thing类型必须匹配
            typeMatchConstraint(factory),
            // 硬约束2：Thing必须包含Pattern的所有属性键
            thingContainsAllPropertiesConstraint(factory),
            // 硬约束3：常量属性值必须完全匹配
            constantPropertyMatchConstraint(factory),
            // 硬约束4：同一变量的绑定值必须全局一致
            variableConsistencyConstraint(factory),
            // 软约束：尽可能多地分配Pattern到Thing
            maximizeAssignedPatterns(factory)
        };
    }

    private Constraint typeMatchConstraint(ConstraintFactory factory) {
        return factory.forEach(ThingPattern.class)
                .filter(pattern -> pattern.getThing() != null)
                .filter(pattern -> !pattern.getType().equals(pattern.getThing().getType()))
                .penalize(HardSoftScore.ONE_HARD)
                .asConstraint("Type mismatch between pattern and thing");
    }

    private Constraint thingContainsAllPropertiesConstraint(ConstraintFactory factory) {
        return factory.forEach(ThingPattern.class)
                .filter(pattern -> pattern.getThing() != null)
                .filter(pattern -> !pattern.getThing().getProperties().keySet().containsAll(pattern.getProperties().keySet()))
                .penalize(HardSoftScore.ONE_HARD)
                .asConstraint("Thing missing required properties from pattern");
    }

    private Constraint constantPropertyMatchConstraint(ConstraintFactory factory) {
        return factory.forEach(ThingPattern.class)
                .filter(pattern -> pattern.getThing() != null)
                .flatMap(pattern -> pattern.getConstantProperties().entrySet().stream()
                        .map(entry -> new ConstantPropertyTuple(pattern, entry.getKey(), entry.getValue())))
                .filter(tuple -> !tuple.getValue().equals(tuple.getPattern().getThing().getProperties().get(tuple.getKey())))
                .penalize(HardSoftScore.ONE_HARD)
                .asConstraint("Constant property value mismatch");
    }

    private Constraint variableConsistencyConstraint(ConstraintFactory factory) {
        return factory.forEach(ThingPattern.class)
                .filter(pattern -> pattern.getThing() != null)
                .flatMap(pattern -> pattern.getVariableToPropertyMap().entrySet().stream()
                        .map(entry -> new VariableUsage(pattern, entry.getKey(), entry.getValue())))
                // 按变量名分组，检查组内所有绑定值是否一致
                .groupBy(VariableUsage::getVariableName)
                .filter((variableName, usages) -> {
                    String expectedValue = null;
                    for (VariableUsage usage : usages) {
                        String currentValue = usage.getPattern().getThing().getProperties().get(usage.getPropertyKey());
                        if (expectedValue == null) {
                            expectedValue = currentValue;
                        } else if (!expectedValue.equals(currentValue)) {
                            return true; // 存在不一致，触发惩罚
                        }
                    }
                    return false;
                })
                .penalize(HardSoftScore.ONE_HARD)
                .asConstraint("Variable value inconsistency across patterns");
    }

    private Constraint maximizeAssignedPatterns(ConstraintFactory factory) {
        return factory.forEach(ThingPattern.class)
                .filter(pattern -> pattern.getThing() != null)
                .reward(HardSoftScore.ONE_SOFT)
                .asConstraint("Maximize assigned patterns");
    }

    // 辅助元组类
    private static class ConstantPropertyTuple {
        private final ThingPattern pattern;
        private final String key;
        private final String value;

        public ConstantPropertyTuple(ThingPattern pattern, String key, String value) {
            this.pattern = pattern;
            this.key = key;
            this.value = value;
        }

        // Getters
        public ThingPattern getPattern() { return pattern; }
        public String getKey() { return key; }
        public String getValue() { return value; }
    }

    private static class VariableUsage {
        private final ThingPattern pattern;
        private final String variableName;
        private final String propertyKey;

        public VariableUsage(ThingPattern pattern, String variableName, String propertyKey) {
            this.pattern = pattern;
            this.variableName = variableName;
            this.propertyKey = propertyKey;
        }

        // Getters
        public String getVariableName() { return variableName; }
        public ThingPattern getPattern() { return pattern; }
        public String getPropertyKey() { return propertyKey; }
    }
}

3. 优化搜索空间（可选） #

通过@ValueRangeProvider限制每个Pattern只能分配同类型的Thing，减少无效搜索：

@PlanningEntity
class ThingPattern {
    // ... 原有属性 ...

    @ValueRangeProvider(id = "thingsByType")
    public List<Thing> getCompatibleThings(@ProblemFactCollectionProperty List<Thing> allThings) {
        return allThings.stream()
                .filter(thing -> thing.getType().equals(this.type))
                .collect(Collectors.toList());
    }

    @PlanningVariable(valueRangeProviderRefs = {"thingsByType"}, nullable = true)
    Thing thing;
}

解决方案2：调整领域模型（适合复杂场景） #

如果数据量极大，约束方式性能不足，可以引入全局变量绑定实体，显式管理变量取值。但此方案复杂度较高，适合有一定OptaPlanner基础的开发者。

核心思路是将变量绑定作为独立的规划实体，同时约束Pattern的Thing属性值与变量绑定值一致：

// ProblemFact：Thing和ThingPattern保持不变
class Thing { /* ... */ }
class ThingPattern { /* ... */ }

// PlanningEntity：表示Pattern到Thing的分配
@PlanningEntity
class PatternAssignment {
    private ThingPattern pattern;
    @PlanningVariable(valueRangeProviderRefs = {"things"})
    private Thing thing;
    // Getters/Setters
}

// PlanningEntity：全局变量绑定（单实例）
@PlanningEntity
class GlobalVariableBindings {
    // 变量名到绑定值的映射，需自定义变量类型支持Map
    @PlanningVariable(valueRangeProviderRefs = {"possibleValues"})
    private Map<String, String> variableValueMap;
    // Getters/Setters
}

class Solution {
    @ProblemFactCollectionProperty
    Set<Thing> things;
    @ProblemFactCollectionProperty
    Set<ThingPattern> thingPatterns;
    @PlanningEntityCollectionProperty
    Set<PatternAssignment> patternAssignments;
    @PlanningEntityCollectionProperty
    Set<GlobalVariableBindings> globalVariableBindings; // 仅一个实例
    @PlanningScore
    HardSoftScore score;
}

此方案需要额外添加约束，确保Pattern的变量属性值与全局绑定值一致，适合变量数量固定、业务逻辑复杂的场景。

内容的提问来源于stack exchange，提问作者marinier