设计模式之责任链模式

简介

责任链模式（Chain of Responsibility Pattern），使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着者条链传递该请求，直到有对象处理它为止。

优点：

1. 降低耦合度。它将请求的发送者和接收者解耦。
2. 简化了对象。使得对象不需要知道链的结构。
3. 增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
4. 增加新的请求处理类很方便。

缺点：

1. 不能保证请求一定被接收。
2. 系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。
3. 可能不容易观察运行时的特征，有碍于除错。

类图

Handler：抽象的处理类；
ConcreteHandler：具体的处理类。

例：每一个系统都会记录日志信息，而且日志也有不同的级别。我们创建抽象类 AbstractLogger，带有详细的日志记录级别。然后我们创建三种类型的记录器，都扩展了 AbstractLogger。每个记录器消息的级别是否属于自己的级别，如果是则相应地打印出来，否则将不打印并把消息传给下一个记录器。

Java实现

创建抽象的AbstractLogger类

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

创建具体的实现类

public class ConsoleLogger extends AbstractLogger {        //构造方法定义该日志的级别        public ConsoleLogger(int level) {            this.level = level;        }        @Override        protected void write(String message) {            System.out.println("ConsoleLogger:"+message);        }    }

public class ErrorLogger extends AbstractLogger {        //构造方法定义该日志的级别        public ErrorLogger(int level) {            this.level = level;        }        @Override        protected void write(String message) {            System.out.println("ErrorLogger:"+message);        }    }

    public class FileLogger extends AbstractLogger {        //构造方法定义该日志的级别        public FileLogger(int level) {            this.level = level;        }        @Override        protected void write(String message) {            System.out.println("FileLogger:"+message);        }    }

场景类

public class Client {        //初始化具体日志记录类        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 an debug level information.");            loggerChain.logMessage(AbstractLogger.ERROR,                    "This is an error information.");        }    }

从结果中可以看出：记录三条不同级别的日志，第一条打印了一次，第二条两次，第三条三次。这就是责任链模式，当属于自己的时候就处理，不属于则传到下一级。