设计模式——责任链模式

定义

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

模板

client：有待处理的请求（Request）
Handler：处理请求的抽象类/接口
Concretehandler 具体的请求处理类，这里只画了一个，其实有多个，他们共同组成一个链条。

实例

下面举一个讲解责任链模式中使用较多的例子。

AbstractLogger(相当于Handler)

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);
   
}

ConsoleLogger(相当于ConcreteHandler)

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

ErrorLogger(相当于ConcreteHandler)

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

FileLogger(相当于ConcreteHandler)

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

ChainPatternDemo(相当于Client)

public class ChainPatternDemo {
   
   // 构造链式结构
   private static AbstractLogger getChainOfLoggers(){
 
      AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
      AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
      AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
 
      errorLogger.setNextLogger(fileLogger);
      fileLogger.setNextLogger(consoleLogger);
 
      return errorLogger;  
   }
 
   public static void main(String[] args) {
      AbstractLogger loggerChain = getChainOfLoggers();
 
      loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");
 
      loggerChain.logMessage(AbstractLogger.DEBUG, 
         "This is a debug level information.");
 
      loggerChain.logMessage(AbstractLogger.ERROR, 
         "This is an error information.");
   }
}

使用场景

1、有多个对象处理同一个请求，具体哪一个对象处理在运行时自行确定
2、在不明白具体接收者的情况下，向多个对象中的一个提交请求
3、代码块中存在多个if-else语句的情况下，可以考虑使用责任链模式进行重构

优点

1、降低请求发送者和接收者之间的耦合度
2、简化了对象、使对象不清除链的结构
3、增加了对象指派职责的灵活度、增强了可扩展性
4、将多个条件语句进行分散到各个具体处理类中，增加代码的可阅读性。使代码更加清晰，责任更明确

缺点

降低程序的性能。每个请求都是从链头遍历到链尾，当链比较长的时候，性能会大幅下降。
不易于调试。由于该模式采用了类似递归的方式，调试的时候逻辑比较复杂。

其它应用场景

okttp中定义了网络拦截器就是一种责任链模式
服务端对消息的处理也是一种责任链模式

来源：https://www.cnblogs.com/NeilZhang/p/12148257.html

标签

责任链模式