1

我的情况是我有 API 。执行 tday 的函数 CompleteFlow() 具有一些业务逻辑，如 Step1()、Step2()。

明天除了函数 A 之外，可能还需要调用另一个逻辑，例如 Step3()。

然后 Step4() ..等等..

所以总的来说。

Class A
{

CompleteFlow()

}


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

就像我的顺序一样，将来可以添加新的业务逻辑。我需要针对这些类编写一个 UI 客户端。

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

4

4 回答 4

1

您可以尝试诸如责任链之类的东西，因此 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，其中解释了责任链。

于 2013-07-25T06:20:22.230 回答
1

我建议将每一步都抽象出来，并确保它实现了由通用接口指定的契约。并收集容器中的所有步骤对象，您的 CompleteFlow 应该必须按顺序调用容器中的每个步骤对象。当您想添加新步骤时，只需实现一个新类并将相同的对象添加到步骤容器中即可。

或者您可以让您的步骤类在工作流步骤容器中注册自己。因此该容器完全独立于步骤。好的设计坚持松耦合。因此，根据需要，您可以修改类。

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

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

  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();
  }
于 2013-07-25T06:01:12.820 回答
1

您可以将所有步骤抽象为一个步骤链。步骤链将是一个可重用的类，因此它不特定于一个类。在您的案例类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
于 2013-07-25T07:21:57.673 回答
0

这是我在 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;
    }
}
于 2013-07-25T09:13:18.370 回答