18.ChainOfResponsibility-职责链模式

Chain Of Responsibility 职责链模式

• 职责链模式:
  使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，
  将这个对象连成一条链，并沿着个链传递请求，直到有一个对象处理为止。
  发出这个请求的客户端并不知道链上的哪个对象最终处理这个请求，这使得系统能够在不影响客户端的状况下动态地从新组织链和分配责任。

• 使用场景:

  1. 有多个的对象能够处理一个请求，哪一个对象处理该请求运行时刻自动肯定。
  2. 你想在不明确指定接收者的状况下，向多个对象中的一个提交一个请求。
  3. 可动态指定一组对象处理请求。

• 示例类图:
  

• 示例代码:

// Handler
public abstract class AbstractLogger {
    public static final int INFO = 1;
    public static final int DEBUG = 2;
    public static final int ERROR = 3;
    protected int level;
    // next element in chain or responsibility
    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);
        }
    }

    protected abstract 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("Standard Console::Logger: " + message);
    }
}
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);
    }
}
public class FileLogger extends AbstractLogger {
    public FileLogger(int level) {
        this.level = level;
    }

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

// 测试
public class ChainTest {

    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, "information.");
        loggerChain.logMessage(AbstractLogger.DEBUG, "debug level information.");
        loggerChain.logMessage(AbstractLogger.ERROR, "error information.");
    }
}

• 抽象处理者(Handler)角色：
  定义出一个处理请求的接口。若是须要，接口能够定义 出一个方法以设定和返回对下家的引用。
  这个角色一般由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，
  抽象方法 handleRequest()规范了子类处理请求的操做。

• 具体处理者(ConcreteHandler)角色：
  具体处理者接到请求后，能够选择将请求处理掉，或者将请求传给下家。因为具体处理者持有对下家的引用，
  所以，若是须要，具体处理者能够访问下家。

• 优势:
  在于能够下降系统的耦合度，简化对象的相互链接，同时加强给对象指派职责的灵活性，增长新的请求处理类也很方便。

• 缺点:
  不能保证请求必定被接收，且对于比较长的职责链，请求的处理可能涉及到多个处理对象，系统性能将受到必定影响，并且在进行代码调试时不太方便。