带任务委托的责任链设计模式推荐

Question

我有一个接口，让我们说2个方法，并有3个不同的实现。

public interface IFace { 
    public void method1(Param param1); 
    public void method2(Param param2); 
} 

public class A implements IFace { 
    public void method1(Param param1){} 
    public void method2(Param param2){} 
} 

public class B implements IFace { 
    public void method1(Param param1){} 
    public void method2(Param param2){} 
} 

public class C implements IFace { 
    public void method1(Param param1){} 
    public void method2(Param param2){} 
} 

现在我有一个要求，因为每只有这两种方法中的一种，需要改进和有一些先决条件按我决定调用特定的实现和模式是，我可能有办法逐个完成这些实现。这似乎像一个完美的适合责任链，我创建了一个这样的：

public interface IChain { 
    public void method1(Param param1); 
    public void setNextChain(IChain iChain); 
} 

public class AA implements IChain { 
    private IChain chain; 

    private IFace a; 

    public void method1(Param param1){ 
     if (thisConditionIsSatisfied(param1)) { 
      a.method1(param1); 
     } else { 
      chain.method1(); 
     } 
    } 

    public void setNextChain(IChain chain){ 
     this.chain = chain 
    } 

    public void setA(IFace a) { 
     this.a = a; 
    } 
} 

public class BB implements IChain { 
    private IChain chain; 

    private IFace b; 

    public void method1(Param param1){ 
     if (thisConditionIsSatisfied(param1)) { 
      b.method1(param1); 
     } else { 
      chain.method1(); 
     } 
    } 

    public void setNextChain(IChain chain){ 
     this.chain = chain 
    } 

    public void setA(IFace b) { 
     this.b = b; 
    } 
} 

public class CC implements IChain { 
    private IChain chain; 

    public void method1(Param param1){ 
     if (thisConditionIsSatisfied(param1)) { 
      //process it here 
     } else { 
      throw new RuntimeException("Couldn't process request.") 
     } 
    } 

    public void setNextChain(IChain chain){ 
     this.chain = chain 
    } 

} 

正如你所看到的，CC不委托给其实施IFACE，是一个完全新的实现C类。

这是我显示非常小的一部分，但问题实际上是我在条件评估，异常处理方面看到了很多重复的相同，调用正确实施的接口等

尽管这比尝试扩展现有接口要好得多，但我想知道是否有任何建议使它在未来的可扩展性或OOPS模式方面更好。

Answer 1

我不这么认为。虽然看起来好像可以通过更少的重复来实现更好的设计，但它似乎并不存在。你的解决方案虽然很好，但我认为这可能是最好的解决方法。

Answer 2

我觉得这不是一个软件工程问题，而是一个设计相关的问题。我的答案如下。

这整体遵循责任链（COR）设计模式（除CC类违规外）。在COR中，所有具体的处理程序（AA，BB，CC）都应该是Abstract Handler类型（最好将它作为常用/默认处理程序代码的地方）绑定在一个链中。在你的实施CC中违反了这个合同，并没有把机会传递给下一个处理程序。如果在N个处理程序的动态链中，如果CC是头，则只处理CC类型的请求。而不是抛出异常CC可以调用super.handle（）并委托给后继者（如下面的代码）。作为您的主要观点，重复代码来自合同，将其委托给后继者（如果处理程序无法处理，委托给后继者（如果存在的话））此代码可以放在抽象处理程序中，如super.handle所示）。后继者的实例也与抽象处理程序保持一致。

每个处理程序在handle（）方法中执行的操作都与COR相关的代码无关。从抽象处理程序扩展到只有每个具体处理程序应该像诚实处理程序一样。

public class AbsChain implements IChain { 
    private IChain successor; // as each handler has it 
    @Override 
    public void method1(Param param1) { 
     if (getSuccessor() != null) { 
      getSuccessor().method1(param1); 
     } else { 
      // Control comes here for totally unhandled request 
     } 
    } 
} 

public class AA extends AbsChain { 
    private IFace a; 

    public void method1(Param param1){ 
     // Handle if you can 
     if (thisConditionIsSatisfied(param1)) { 
      a.method1(param1); 
     } else { 
      //else allow next one to try (default behavior) 
      super.handleRequest(param1); 
     } 
    } 
} 

public class CC implements IChain { 

    public void method1(Param param1){ 
     if (thisConditionIsSatisfied(param1)) { 
      //process it here 
     } else { 
      //throwing Ex here breaks the chain 
      super.handleRequest(param1); // keep passing it 
     } 
    } 
}