1

私のシナリオは、 API を持っていることです。tday を実行するのは、Step1() 、Step2() などのビジネス ロジックを持つ関数 CompleteFlow() です。

明日、関数 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_pattern責任の連鎖について説明しています。

于 2013-07-25T06:20:22.230 に答える
1

すべてのステップをステップ チェーンに抽象化できます。ステップ チェーンは再利用可能なクラスになるため、1 つのクラスに固有ではありません。あなたの場合、 class 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 に答える
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 に答える
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 に答える