责任链模式

前言

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。
在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

责任链模式的实现

下面我们以日志打印为例。

package chain;

public abstract class AbstractLogger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;
    protected int level;
    
    //责任链中下一个元素
    protected AbstractLogger nextLogger;
    
    public void setNextLogger(AbstractLogger nextLogger){
        this.nextLogger = nextLogger;
     }

    public void logMessage(int level, String message){
        if(this.level == level){
            write(message);
         }
        if(nextLogger !=null){
            nextLogger.logMessage(level, message);
         }
    }
    abstract protected void write(String message);
    
}

首先我们定义一个抽象类，
定义等级常量，
定义下个责任链对象和设置下个责任链的方法，
定义一个判断责任划分的方法logMessage()，
最后定义一个抽象方法write()供子类实现。
下面是三个扩展的实体类：

public class InfoLogger extends AbstractLogger{

    public InfoLogger(int level){
          this.level = level;
       }
    
    @Override
    protected void write(String message) {
        // TODO Auto-generated method stub
        System.out.println("Info::Logger: " + message);
    }

}

public class DebugLogger extends AbstractLogger {
     
   public DebugLogger(int level){
      this.level = level;
   }
 
   @Override
   protected void write(String message) {    
      System.out.println("debug::Logger: " + message);
   }
}

public class ErrorLogger extends AbstractLogger {
     
   public ErrorLogger(int level){
      this.level = level;
   }
 
   @Override
   protected void write(String message) {    
      System.out.println("Error::Logger: " + message);
   }
}

最后是责任链的实现和测试：

public class ChainTest {
     private static AbstractLogger getChainOfLoggers(){
         
        AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
        AbstractLogger infoLogger = new InfoLogger(AbstractLogger.INFO);
        AbstractLogger debugLogger = new DebugLogger(AbstractLogger.DEBUG);
        
        errorLogger.setNextLogger(debugLogger);
        debugLogger.setNextLogger(infoLogger);
 
      return errorLogger;  
   }
    public static void main(String[] args){
        
        AbstractLogger loggerChain = getChainOfLoggers();
        loggerChain.logMessage(AbstractLogger.INFO, "This is an info information.");
        System.out.println("-----------------");
        loggerChain.logMessage(AbstractLogger.DEBUG, 
         "This is a debug information.");
        System.out.println("-----------------");
        loggerChain.logMessage(AbstractLogger.ERROR, 
         "This is an error information.");
    }
}

Info::Logger: This is an info information.
-----------------
debug::Logger: This is a debug information.
-----------------
Error::Logger: This is an error information.

当我们指定了日志等级时，程序内部就能根据等级动态的打印所需要的日志。以上就是责任链模式简单的示例。
优点
1.将请求的发送者和接收者解耦。
2.可以简化对象，因为它不需要知道链的结构。
3.通过改变链的成员或调动它们的次序，允许动态的新增或者删除责任。
缺点
1.不能保证请求一定被执行，如果没有任何对象处理，可能会被链尾端之外。
2.运行是不易观察运行特征，有碍于除错。