用于处理复杂条件求值的设计模式

Question

我的设计是为了维护一个系统，它考虑到三个变量的值，以确定它将采取的行动。

我想重构它以使用一个设计模式，但找不到一个适合它的需要。

为了解释这种情况，我将使用一个健身房系统作为例子。

每个健身房用户都有一个合同类型，可以是：

null

null

• 无限制
• 过_65
• 限制移动性
• Medical_Condition
• 低于_18

对于这三个特征的每个组合，都应该执行一组任意的操作。例如：

如果PLATINUM_MEMBERSHIP+PERSONAL_TRAINING+over_65：

null

null

1. 拒绝订阅

if（任何成员资格）+STEP+medical_condition:

1. 需要医疗批准
2. 签名表

null

等等。

特征的组合可以有一组动作，这些动作不是排他性的，并且不是所有的组合都得到保证。

旧代码使用嵌套开关作为实现。示例：

switch (contractType):

    case PLATINUM_MEMBERSHIP:

        switch (gymClass):            

            case (PERSONAL_TRAINING):

                switch (physicalCondition):            

                    case (OVER_65):

                        requiresMedicalApproval();
                        requiresSignedForm();

...

null

你有什么建议？

谢谢你。

编辑：

public enum TypeOfContract { ... }
public enum GymClasses { ... }
public enum PhysicalCondition { ... }

public interface Command {
    public void execute(Map<String, Object> parametersMap);
}

public class Procedures {

    private List<Command> actionsToExecute = new LinkedList<Command>();

    public static final Procedures NO_ACTIONS_TO_EXECUTE = new Procedures();

    private Procedures() {}

    public Procedures(Command... commandsToExecute) {

        if (commandsToExecute == null || commandsToExecute.length == 0) {
            throw new IllegalArgumentException("Procedures must have at least a command for execution.");
        }

        for (Command command : commandsToExecute) {
            actionsToExecute.add(command);
        }
    }

    public List<Command> getActionsToExecute() {
        return Collections.unmodifiableList(this.actionsToExecute);
    }   
}    

如果三个变量的组合不存在，它将发送NO_ACTIONS_TO_EXECUTE而不是null。

4）RulesEngine类，用于注册规则及其命令

public class RulesEngine {

    private static final int NUMBER_OF_FIRST_LEVEL_RULES = TypeOfContract.values().length;
    private static final int NUMBER_OF_SECOND_LEVEL_RULES = GymClasses.values().length;
    private static final int NUMBER_OF_THIRD_LEVEL_RULES = PhysicalCondition.values().length;

    private static final Procedures[][][] RULES =
            new Procedures[NUMBER_OF_FIRST_LEVEL_RULES]
                    [NUMBER_OF_SECOND_LEVEL_RULES]
                    [NUMBER_OF_THIRD_LEVEL_RULES];

    { //static block
        RULES
            [TypeOfContract.PLATINUM_MEMBERSHIP.ordinal()]
            [GymClasses.PERSONAL_TRAINING.ordinal()]
            [PhysicalCondition.OVER_65.ordinal()] =
                new Procedures(new RequireMedicalApproval(), 
                               new RequireSignedForm() );

        RULES
            [TypeOfContract.GOLD_MEMBERSHIP.ordinal()]
            [GymClasses.PERSONAL_TRAINING.ordinal()]
            [PhysicalCondition.OVER_65.ordinal()] =
                new Procedures(new RequireMedicalApproval(), 
                               new RequireSignedForm(), 
                               new AddExtraMonthlyFee() );

        ...             

    }

    private RulesEngine() {}

    public static Procedures loadProcedures(TypeOfContract TypeOfContract, 
            GymClasses GymClasses, PhysicalCondition PhysicalCondition) {
        Procedures procedures = RULES
                                [TypeOfContract.ordinal()]
                                [GymClasses.ordinal()]
                                [PhysicalCondition.ordinal()];
        if (procedures == null) {
            return Procedures.NO_ACTIONS_TO_EXECUTE;
        }
        return procedures;
    }

}

（为了在此站点中的可视化而进行的异常代码格式设置）

RULES
    [TypeOfContract.PLATINUM_MEMBERSHIP.ordinal()]
    [GymClasses.PERSONAL_TRAINING.ordinal()]
    [PhysicalCondition.OVER_65.ordinal()]

为了表示需要执行的操作,将关联一个Procedures类,包装要执行的操作：

new Procedures(new RequireMedicalApproval(), new RequireSignedForm() );

RequireMedicalApproval和RequireSignedForm都实现了命令接口。

定义这个变量组合的整行是：

RULES
        [TypeOfContract.PLATINUM_MEMBERSHIP.ordinal()]
        [GymClasses.PERSONAL_TRAINING.ordinal()]
        [PhysicalCondition.OVER_65.ordinal()] =
            new Procedures(new RequireMedicalApproval(), 
                           new RequireSignedForm() );

    Map<String, Object> context = new HashMap<String, Object>();
    context.put("userId", 123);
    context.put("contractId", "C45354");
    context.put("userDetails", userDetails);
    context.put("typeOfContract", TypeOfContract.PLATINUM_MEMBERSHIP);
    context.put("GymClasses", GymClasses.PERSONAL_TRAINING);
    context.put("PhysicalCondition", PhysicalCondition.OVER_65);
    ...

    Procedures loadedProcedures = RulesEngine.loadProcedures(
                                        TypeOfContract.PLATINUM_MEMBERSHIP, 
                                        GymClasses.PERSONAL_TRAINING, 
                                        PhysicalCondition.OVER_65);

    for (Command action : loadedProcedures.getActionsToExecute()) {
        action.equals(context);
    }

操作需要执行的所有信息现在都在映射中。

由三个枚举表示的条件被传递给RulesEngine。

RulesEngine将评估组合是否有关联的操作，并且它将返回一个Procedures对象，其中包含需要执行的这些操作的列表。

如果不是（组合没有与之关联的操作），RulesEngine将返回一个有效的Procedures对象，其中包含一个空列表。

6）优点

null

null

Answer 1

你会有多少选择？假设每个类别有8位，也许你可以把一个特定的组合表示为一个24位的数字，每个类别有8位。当您收到一组选项时，将其转换为一个位模式，然后根据位掩码将和转换为一个位模式，以确定是否需要执行某个操作。

这仍然需要您执行测试，但至少它们不是嵌套的，并且您只需要在添加新特性时添加一个新的测试。