责任链模式为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推使多个对象都有机会处理请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止

场景

责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌

  1. 有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。
  2. 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
  3. 可动态指定一组对象处理请求。

实现

责任链模式涉及到的角色：

  • 抽象处理者角色：定义了处理请求的接口或者抽象类，提供了处理请求的的方法和设置下一个处理者的方法
  • 具体处理者角色：实现或者继承抽象这角色

抽象处理者

  1. public abstract class AbstractLogger {
  2.    public static int INFO = 1;
  3.    public static int DEBUG = 2;
  4.    public static int ERROR = 3;
  6.    protected int level;
  8.    //责任链中的下一个元素
  9.    protected AbstractLogger nextLogger;
  11.    public void setNextLogger(AbstractLogger nextLogger){
  12.       this.nextLogger = nextLogger;
  13.    }
  15.    public void logMessage(int level, String message){
  16.       if(this.level <= level){
  17.          write(message);
  18.       }
  19.       if(nextLogger !=null){
  20.          nextLogger.logMessage(level, message);
  21.       }
  22.    }
  24.    abstract protected void write(String message);
  26. }

具体处理者

  1. public class ConsoleLogger extends AbstractLogger {
  3.    public ConsoleLogger(int level){
  4.       this.level = level;
  5.    }
  7.    @Override
  8.    protected void write(String message) {    
  9.       System.out.println("Standard Console::Logger: " + message);
  10.    }
  11. }
  13. public class ErrorLogger extends AbstractLogger {
  15.    public ErrorLogger(int level){
  16.       this.level = level;
  17.    }
  19.    @Override
  20.    protected void write(String message) {    
  21.       System.out.println("Error Console::Logger: " + message);
  22.    }
  23. }
  25. public class FileLogger extends AbstractLogger {
  27.    public FileLogger(int level){
  28.       this.level = level;
  29.    }
  31.    @Override
  32.    protected void write(String message) {    
  33.       System.out.println("File::Logger: " + message);
  34.    }
  35. }

客户端

  1. public class ChainPatternDemo {
  3.    private static AbstractLogger getChainOfLoggers(){
  5.       AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
  6.       AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
  7.       AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
  9.       errorLogger.setNextLogger(fileLogger);
  10.       fileLogger.setNextLogger(consoleLogger);
  12.       return errorLogger;  
  13.    }
  15.    public static void main(String[] args) {
  16.       AbstractLogger loggerChain = getChainOfLoggers();
  18.       loggerChain.logMessage(AbstractLogger.INFO, 
  19.          "This is an information.");
  21.       loggerChain.logMessage(AbstractLogger.DEBUG, 
  22.          "This is an debug level information.");
  24.       loggerChain.logMessage(AbstractLogger.ERROR, 
  25.          "This is an error information.");
  26.    }
  27. }

优点

  • 责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌，两者解耦，提高系统的灵活性
  • 增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任

缺点

  • 不能保证请求一定被接收处理
  • 性能问题，每个请求都是从链头遍历到链尾，特别是在链比较长的时候，性能是一个非常大的问题
  • 调试不很方便，特别是链条比较长，环节比较多的时候，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂

Android 中的应用

点击事件分发

参考

书籍：《设计模式之禅》、《Android源码设计模式》
技术文章：菜鸟教程-设计模式
博客：我的Java设计模式-责任链模式