Question

我的情景是我有API。执行tday的是函数CompleteFlow（），其中包含一些业务逻辑，如Step1（），Step2（）。

明天除了功能A之外，还可能需要调用Step3（）等其他逻辑。

然后Step4（）。依此类推..

一般而言。

Class A
{

CompleteFlow()

}


CompleteFlow()
{
Step 1(),
Step 2().
....
....
....
}

在我的序列中同样明智，将来可以添加新的业务逻辑。我需要再次编写一个UI客户端。

适合我的最佳设计模式是什么。（请举例说明）

Answer 1

我建议抽象出每一步并确保它实现一个公共接口指定的契约。并收集容器中的所有步骤对象，您的CompleteFlow必须按顺序调用容器中的每个步骤对象。如果要添加新步骤，只需实现一个新类并将相同的对象添加到步骤容器中。

或者您可以让您的步骤类使用workflowsteps容器注册。所以容器完全独立于步骤。良好的设计坚持松耦合。因此，根据需要，您可以修改类。

根据你的评论，我看到调用步骤的顺序基本上是顺序的。否则，您可能必须实现状态机或工作流引擎。

并提供具体的用例，可以帮助我们为您的查询提供更具体的答案。

  class IStep {
      public:
         virtual void execute() = 0;
  };

  class ConcreteStep1 : public IStep {
       public:
          void execute() {
             cout << "Doing Step1";
          }
  }

  vector<IStep> workflowSteps;
  workflowSteps.push_back(new ConcreteStep1());
  // Add other steps like this.

  void CompleteFlow() {
      for (vector<IStep>::iterator it = workflowSteps.begin() ; it != workflowSteps.end(); ++it)
         (*it)->execute();
  }

Answer 2

您可以尝试使用责任链，因此UI客户端调用将是这样的：

UI Client -----> Call Step1() // Suppose if you want to restrict the call to Step1(),
                              // pass some parameters in UI Client which you can handle
                     |        // in function calls
                     |        
                     V        
                 Call Step2()  // Otherwise pass the call to the next
                     |         //handler Step2().   
                     |
                     V
                  ......

通过这种方式，您可以从UI客户端控制您的函数调用，无论是在特定步骤中停止还是继续执行下一步功能。希望这可以帮助。您还可以参考链接：http://en.wikipedia.org/wiki/Chain-of-responsibility_patter n来解释责任链。

Answer 3

您可以将所有步骤抽象为步骤链。步骤链将是一个可重用的类，因此它不是特定于一个类。在您的案例类A。

为步骤链按顺序执行的有序步骤创建一个接口。

public interface Step {
    public void execute();
}

public interface Ordered {
    public int getOrder();
    public void setOrder(int order);
}

public interface OrderedStep extends Step, Ordered {
}

比较器，用于帮助对实现有序的实例进行排序。

public class OrderedComparator implements Comparator<Ordered> {
    public int compare(Ordered a, Ordered b) {
        if (a.getOrder() > b.getOrder()) {
            return 1;
        }

        if (a.getOrder() < b.getOrder()) {
            return -1;
        }
        return 0;
    }
}

步骤链将负责按指定的顺序执行所有步骤。

public class OrderedStepChain {
    List<OrderedStep> steps = new ArrayList<OrderedStep>();

    public void addStep(OrderedStep step) {
        steps.add(step);
    }

    public void execute() {
        Collections.sort(steps, new OrderedComparator());

        for (OrderedStep step : steps) {
            step.execute();
        }
    }
}

步骤的简单实现。

public class OrderedStepImpl implements OrderedStep {
    public int order;

    public void setOrder(int order) {
        this.order = order;
    }

    public int getOrder() {
        return order;
    }

    public void execute() {
        System.out.println("Step#" + order + " executed");
    }
}

通过步骤链处理所有步骤，它非常容易使用。将此功能添加到可能需要它的其他类中也更容易。

public class A {
    OrderedStepChain stepChain = new OrderedStepChain();

    // add steps backwards
    public void createSteps() {
        for (int i = 9; i > 0; i--) {
            OrderedStep step = new OrderedStepImpl();
            step.setOrder(i);
            stepChain.addStep(step);
        }
    }

    /* 
     * Other objects may interact with the step chain
     * adding additional steps.
     */
    public OrderedStepChain getStepChain() {
        return this.stepChain;
    }

    public void completeFlow() {
        stepChain.execute();
    }
}

当我运行单元测试时，输出是。

Step#1 executed
Step#2 executed
Step#3 executed
Step#4 executed
Step#5 executed
Step#6 executed
Step#7 executed
Step#8 executed
Step#9 executed

Answer 4

这是我在Java中的伪代码：

public class Input
{
    public Map<Object,Class> data;
    public Input ()
    {
        data = new TreeMap<Object,Class>();
    }
}

public interface Step
{
    public void execute (Input in);
    public void revert ();
}

// Map<StepID, <Step, StepPriority>>
public class StepChain
{
    Map<Long, Pair<Step,Long>> chain;

    public StepChain ()
    {
        chain = new TreeMap<Long, Pair<Step,Long>>();
    }

    public void addStep (Long stepId, Step step, Long stepPriority)
    {
        chain.put(stepId, new Pair<Step,Long>(step,stepPriority));
    }

    public Queue<Step> getStack ()
    {
        Stack<Step> stack= new Stack<Step>();
        Map<Step,Long> map = new TreeMap<Step,Long>();

        for (Pair<Step,Long> p : chain.getValues())
        {
            map.put(p.getFirst(), p.getSecond());
        }

        for (Step step : map.getKeySet())
        {
            stack.push(step);
        }

        return stack;
    }
}

如何适应需要成为ap的一部分的新逻辑

4 个答案: