Pattern 避免重复处理 Block

Question

我有一个 class :

public class VisitorProcessing {
    public void visit(EventA eventA){
           if(condition1....)
                // Do somethings 1
           else{
               if(condition2){
               // Do something 2
               }
               else{
               // Do something 3
               }
           } 
    }
    public void visit(EventB eventB){
           if(condition1....)
                // Do somethings 4
           else{
               if(condition2){
               // Do something 5
               }
               else{
               // Do something 6
               }
           } 
    }
    public void visit(EventC eventC){
           if(condition1....)
                // Do somethings 7
           else{
               if(condition2){
               // Do something 8
               }
               else{
               // Do something 9
               }
           } 
    }
    public void visit(EventD eventD){
           if(condition1....)
                // Do somethings 10
           else{
               if(condition2){
               // Do something 11
               }
               else{
               // Do something 12
               }
           } 
    } 
}

所有事件对象扩展相同的父对象 BasicEvent。并且条件仅指 Event Object 并且可以从 Parent Event 计算。

我想开始重构以将分支逻辑集中在一个地方，因为我不确定条件。我唯一确定的是处理 "DoSomthings..." 。

所以我正在搜索是否有任何已知的执行此操作的模式。

提前致谢

Answer 1

如果您无法更改访问方法，那么您可以创建一个从每个访问方法中调用的过程（BasicEvent 事件）方法。

public class VisitorProcessing {
    public void visit(EventA eventA){
           processEvent(eventA);
           //... EventA specific code goes here
    }
    public void visit(EventB eventB){
           processEvent(eventB);
           //... EventB specific code goes here
    }
    public void visit(EventC eventC){
           processEvent(eventC);
           //... EventC specific code goes here
    }
    public void visit(EventD eventD){
           processEvent(eventD);
           //... EventD specific code goes here
    } 

    private void processEvent(BasicEvent event) {
           if(condition1....)
                // Do somethings 10
           else{
               if(condition2){
               // Do something 11
               }
               else{
               // Do something 12
               }
           } 
    }
}

Answer 2

dispatch方法负责方法的正确调用，每次写3个methid即可

public interface DoSomething {
    void doSomething1();
    void doSomething2();
    void doSomething3();
}

public class VisitorProcessing {

    public void dispatch( DoSomething ds) {
        if(condition1....)
            ds.doSomething1();
       else{
           if(condition2){
               ds.doSomething2();
           }
           else{
               ds.doSomething3();
           }
       } 
    }

    public void visit(EventA eventA){
        DoSomething ds = new DoSomething()
        {
            void doSomething1() {
             // Do somethings 1
            }
            void doSomething2(){
             // Do something 2
            }
            void doSomething3(){
             // Do something 3
            }
        }
        dispatch( ds );
    }

    public void visit(EventB eventB){
        DoSomething ds = new DoSomething()
        {
            void doSomething1() {
             // Do somethings 3
            }
            void doSomething2(){
             // Do something 4
            }
            void doSomething3(){
             // Do something 5
            }
        }
        dispatch( ds );
    }
    ...
}

Answer 3

您可能想看看 chain-of-responsibility pattern。本质上，你有一个 class Handler ，它基于一个决定而行动，并且包含一个 Handler 类型的对象，当条件不满足时可以委托它。示例：

public Class Handler() {
  private Handler next;

  public setNext(Handler next) {
    this.next = next;
  }

  public void action(params) {
    if(some_condition) {
      ...
    }
    else {
      if(next != null)
        next.action(params);
    }
  }
}

当然，class 可以而且应该扩展以创建不同类型的处理程序。在您的情况下，这种模式的优点是您可以在相同条件下使用相同的链，并根据调用 visit 方法来改变操作。此外，您可以非常轻松地添加、编辑和删除条件，甚至可以在运行时修改链。

你的情况：

public Class Condition1 extends Handler {
  public void action(BasicEvent e) {
    if (condition1) {
      if(e instanceof EventA) // Do something 1
      if(e instanceof EventB) // Do something 4
      if(e instanceof EventC) // Do something 7
      if(e instanceof EventD) // Do something 10
    }
    else {
      if(next != null)
        next.action(BasicEvent e);
    }
  }
}

public Class Condition2 extends Handler {
  public void action(BasicEvent e) {
    if (condition2) {
      if(e instanceof EventA) // Do something 2
      if(e instanceof EventB) // Do something 5
      if(e instanceof EventC) // Do something 8
      if(e instanceof EventD) // Do something 11
    }
    else {
      if(next != null)
        next.action(BasicEvent e);
    }
  }
}

public Class ConditionElse extends Handler {
  public void action(BasicEvent e) {
    if(e instanceof EventA) // Do something 3
    if(e instanceof EventB) // Do something 6
    if(e instanceof EventC) // Do something 9
    if(e instanceof EventD) // Do something 12

    // we reached the end of the chain
  }
}

为其他条件创建类似的 classes（如果有）（任意数量），然后形成链：

Condition1 condition_1 = new Condition1();
Condition2 condition_2 = new Condition2();
ConditionElse condition_else = new new ConditionElse();

condition_1.setNext(condition_2);
condition_2.setNext(condition_else);

然后你只需要一个visit方法：

public void visit(BasicEvent e){
  condition1.action(e);
}

我希望我能快速概述适合您情况的模式。 instanceof 部分可以用更好的方式处理，特别是如果你有超过 4 个 subclasses 就值得重构，但我希望你明白要点。

Pattern 避免重复处理 Block

Pattern avoiding duplicate processing Block

java

oop

design-patterns