设计模式-职责链模式

概述

在生活中我们的审批处理对象不止一个。一般我们只需要把审批文件交给一级领导，一级领导审批通过之后，二级领导又会进行审批...，这个过程中任何一级领导认为不符合条件，则请求中止。

定义

在系统中如果存在多个对象处理同一请求，则可以通过职责链模式将这些处理请求的对象连成一条链，让请求沿着该链进行传递。

职责链模式： 避免将一个请求的发送者与接收者耦合在一起，让多个对象都有机会处理请求。将接受请求的对象连接成一条链，并且沿着这条链传递请求，直到有一个对象能够处理它为止。

职责链模式结构

职责链模式主要包含以下角色。

1. 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
2. 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。

职责链模式应用案例

1、抽象日志记录器

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

2、console日志记录器

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

3、error日志记录器

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

4、file日志记录器

public class FileLogger extends AbstractLogger {

    public FileLogger(int level){
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("File::Logger: " + message);
    }
}

5、案例实现

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 an debug level information.");

        loggerChain.logMessage(AbstractLogger.ERROR, "This is an error information.");
    }
}


// 输出
Standard Console::Logger: This is an information.
File::Logger: This is an debug level information.
Standard Console::Logger: This is an debug level information.
Error Console::Logger: This is an error information.
File::Logger: This is an error information.
Standard Console::Logger: This is an error information.

输出分析：

现在我们建立了三个日志记录器，他们的职责链结构如下：

第一个日志是info级别的，所以直接到console日志记录器。

第一个日志是debug级别的，先到file日志记录器，file日志记录器打印完毕之后，再到console日志记录器。

第三个日志是error级别的，所有日志记录器都会打印。

职责链模式优缺点

优点：

1. 降低耦合度。它将请求的发送者和接收者解耦。

2. 简化了对象。使得对象不需要知道链的结构。

3. 增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。

4. 增加新的请求处理类很方便。

缺点：

1. 由于一个请求没有明确的接收者，那么就不能保证它一定会被处理，该请求可能一直到链的末端都得不到处理；一个请求也可能因职责链没有被正确配置而得不到处理。
2. 对于比较长的职责链，请求的处理可能涉及到多个处理对象，系统的性能会受到一定的影响。
3. 如果建链不当，可能会造成循环调用。

职责链模式适用环境

1. 有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定，客户端只需将请求提交到链上，而无须关心请求的处理对象是谁以及它是如何处理的。

2. 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

3. 可动态指定一组对象处理请求。

参考

设计模式入门实践 (opens new window)

Java设计模式