没有通用接口的步骤序列的模式

Question

在我的Java应用程序中，我得到了一个方法，它运行一系列长步骤（同步），其中一步结果是下一步的输入。

例如：

// Step 1 
Map<String, SomeObject> objectsMap = someService.createObjectsMap(); 
if (!objectsMap.isEmpty()) { 
    // Step 2 
    AnotherObject anotherObject = anotherService.createAnotherObject(objectsMap); 
    if (null != anotherObject) { 
    // Step 3 that gets anotherObject as input and returns something else 
    } else { // Step 2 failed 
     // log and handle 
    } 
} else { // Step 1 failed 
    // log and handle 
} 

所以我得到了这个系列写了一系列的if-else块的步骤。 这些步骤没有通用接口，因为每个步骤都有不同的签名。我一直在讨厌一些不同，并试图自定义模式，如chain-of-responsibility和command，但无法达到满意的结果。

我不知道这个丑陋的长if-else部分是要走的路还是有一种模式可以帮助使这一系列步骤更加干净和可扩展。

Answer 1

这种情况下 - 你做了很多事情，并希望中止并记录它们中的任何一个失败 - 是什么异常处理的设计。例如：

try { 
    // Step 1 
    Map<String, SomeObject> objectsMap = someService.createObjectsMap(); 
    if (objectsMap.isEmpty()) 
     throw new SomethingWentWrongException("Failed to get object map from service"); 

    // Step 2 
    AnotherObject anotherObject = anotherService.createAnotherObject(objectsMap); 
    if(anotherObject == null) 
     throw new SomethingWentWrongException("Failed to create another object"); 

    // Step 3 that gets anotherObject as input and returns something else 
} catch(SomethingWentWrongException e) { 
    // log and handle 
    e.printStackTrace(); 
} 

理想的情况下，someService.createObjectsMap和anotherService.createAnotherObject会抛出让你检查返回值的自己的异常，而不是。然后你只需要编写：

try { 
    Map<String, SomeObject> objectsMap = someService.createObjectsMap(); 
    AnotherObject anotherObject = anotherService.createAnotherObject(objectsMap); 
    // Step 3 that gets anotherObject as input and returns something else 
} catch(Exception e) { 
    // log and handle 
    e.printStackTrace(); 
} 

（但请注意，您应该只赶上Exception，如果你真的想赶上所有失败），你必须回答自己

Answer 2

一个问题是为什么我想重构我的代码？

你希望它是

• 更干净的代码？
• 更模块化？
• 步骤必须在运行时可配置（可替换）吗？

重构，以使代码干净

如果步骤不需要在运行时进行配置，你想使你的代码更干净的比你应该看一看的评论你制作。每条评论都是一个提示。

步骤

/** 
* Explain what step1 does. 
*/ 
private void step1() { 
    // Step 1 
    Map<String, SomeObject> objectsMap = someService.createObjectsMap(); 
    if (!objectsMap.isEmpty()) { 
     step2(objectsMap); 
    } else { // Step 1 failed 
     // log and handle 
    } 
} 

/** 
* Explain what step2 does. 
*/ 
private void step2(Map<String, SomeObject> objectsMap) { 
    // Step 2 
    final AnotherObject anotherObject = anotherService 
      .createAnotherObject(objectsMap); 
    if (null != anotherObject) { 
     step3(anotherObject); 
    } else { // Step 2 failed 
     // log and handle 
    } 
} 

/** 
* Explain what step3 does. 
*/ 
private void step3(AnotherObject anotherObject) { 
    // Step 3 that gets anotherObject as input and returns something 
    // else 
} 

这种方法只是分解成更小的方法的方法后，打破代码块到方法，并将它们命名。优点是每个较小的方法只对一件事负责。而且因为这是一种方法，所以可以将javadoc添加到它。所以不再需要内嵌评论。

为了使步骤在运行时

更换如果你想配置比你必须封装它们中的对象在运行时（例如，由于一些用户输入的）执行的步骤，因为重构你的应用程序引用了可以替换的对象。

既然你想要所有的步骤都有一个共同的API，你必须使它更通用。

从客户的角度开始思考。这些步骤应该如何执行。例如。

for (Step step : steps) { 
    boolean executeNext = step.execute(); 
    if (!executeNext) { 
     break; 
    } 
} 

设计一个步骤接口

public interface Step { 
    boolean execute(); 
} 

如何通过一个步骤作为输入到另一个的输出？

做一个接口

public static interface StepInput<T> { 
    public T getInput(); 
} 

实现你的脚步。抽象类将帮助你。

public abstract class InputOutputStep<T> implements Step, 
     StepInput<T> { 

    private T returnValue; 

    protected void setReturnValue(T returnValue) { 
     this.returnValue = returnValue; 
    } 

    public T getInput() { 
     return returnValue; 
    } 
} 

public class Step1 extends InputOutputStep<Map<String, SomeObject>> { 

    private StepInput<Map<String, SomeObject>> stepInput; 

    public Step1(StepInput<Map<String, SomeObject>> stepInput) { 
     this.stepInput = stepInput; 
    } 

    public boolean execute() { 
     boolean executeNext = false; 

     Map<String, SomeObject> objectsMap = stepInput.getInput(); 
     if (!objectsMap.isEmpty()) { 
      // Step 2 
      setReturnValue(objectsMap); 
      executeNext = true; 
     } else { // Step 1 failed 
      // log and handle 
     } 

     return executeNext; 
    } 
} 

public class Step2 extends InputOutputStep<AnotherObject> { 

    private StepInput<Map<String, SomeObject>> stepInput; 
    private AnotherService anotherService; 

    public Step2(AnotherService anotherService, 
      StepInput<Map<String, SomeObject>> stepInput) { 
     this.anotherService = anotherService; 
     this.stepInput = stepInput; 
    } 

    public boolean execute() { 
     boolean executeNext = false; 

     Map<String, SomeObject> objectsMap = stepInput.getInput(); 
     AnotherObject anotherObject = anotherService 
       .createAnotherObject(objectsMap); 
     if (null != anotherObject) { 
      setReturnValue(anotherObject); 
      executeNext = true; 
     } else { // Step 2 failed 
      // log and handle 
     } 
     return executeNext; 
    } 
} 

public class Step3 extends InputOutputStep<Void> { 

    private StepInput<AnotherObject> stepInput; 

    public Step3(StepInput<AnotherObject> stepInput) { 
     this.stepInput = stepInput; 
    } 

    public boolean execute() { 
     AnotherObject anotherObject = stepInput.getInput(); 
     setReturnValue(null); 
     return false; 
    } 
} 

在运行时配置的步骤和执行

Step1 step1 = new Step1(stepInput); 
Step2 step2 = new Step2(anotherService, step1); 
Step step3 = new Step3(step2); 

Step[] steps = new Step[]{step1, step2, step3}; 

for (Step step : steps) { 
    boolean executeNext = step.execute(); 
    if (!executeNext) { 
     break; 
    } 
} 

Answer 3

选项：

1. 备忘录模式： 有了纪念品，都可以存储对象的状态。就像当你想重做和撤销东西时一样。 这样，当您在步骤1和步骤3中有类似的方法时，您可以简单地使用1个一般方法。 然后，通过撤消和重做，你知道你必须保存你的状态。 想想保存你的步数的可能性。

2. 策略模式： 使用策略模式，您正在保存IF-ELSE语句。 你只需要去一个功能，策略对象将决定其余的。 将路由器视为策略类。 路由器将确定最佳方式，最佳路径或最佳过程（来自多个过程选项）。

3. 观察者模式： 这就像MVC。 我一直认为观察员是中央电视台。 当一些事情发生变化时，一些奇怪的事情发生了，央视管理员会知道。 所以你有一个控制器类，它监控所有事情，并配置你下一步要去的地方。

谢谢