设计模式之责任链模式

简介

责任链模式（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.");
        }
    }

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