设计模式（13）——责任链（Chain of Responsibility)

责任链是什么？

责任链条模式使多个对象都有机会处理请求。打个比方说，责任就是得分，多个对象就是篮球队员，在三分线的远投的时候，球由投手投篮。带球突破则由后卫负责。。。

责任链模式的适用范围

1. 有多个对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

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

3. 可处理的一个请求对象集合应被动态指定。

责任链模式的例子

abstract class Logger {
    public static int ERR = 3;
    public static int NOTICE = 5;
    public static int DEBUG = 7;
    private int mask;
 
    // The next element in the chain of responsibility
    private Logger next;
 
    public Logger(int mask) {
        this.mask = mask;
    }
 
    public void setNext(Logger logger) {
        next = logger;
    }
 
    public void message(String msg, int priority) {
        if (priority <= mask) {
            writeMessage(msg);
        }
        if (next != null) {
            next.message(msg, priority);
        }
    }
 
    abstract protected void writeMessage(String msg);
}
 
class StdoutLogger extends Logger {
    public StdoutLogger(int mask) {
        super(mask);
    }
 
    protected void writeMessage(String msg) {
        System.out.println("Writing to stdout: " + msg);
    }
}
 
class EmailLogger extends Logger {
    public EmailLogger(int mask) {
        super(mask);
    }
 
    protected void writeMessage(String msg) {
        System.out.println("Sending via e-mail: " + msg);
    }
}
 
class StderrLogger extends Logger {
    public StderrLogger(int mask) {
        super(mask);
    }
 
    protected void writeMessage(String msg) {
        System.err.println("Sending to stderr: " + msg);
    }
}
 
public class ChainOfResponsibilityExample {
 
    private static Logger createChain() {
        // Build the chain of responsibility
 
        Logger logger = new StdoutLogger(Logger.DEBUG);
 
        Logger logger1 = new EmailLogger(Logger.NOTICE);
        logger.setNext(logger1);
 
        Logger logger2 = new StderrLogger(Logger.ERR);
        logger1.setNext(logger2);
 
        return logger;
    }
 
    public static void main(String[] args) {
        Logger chain = createChain();
 
        // Handled by StdoutLogger (level = 7)
        chain.message("Entering function y.", Logger.DEBUG);
 
        // Handled by StdoutLogger and EmailLogger (level = 5)
        chain.message("Step1 completed.", Logger.NOTICE);
 
        // Handled by all three loggers (level = 3)
        chain.message("An error has occurred.", Logger.ERR);
    }
}
/*
The output is:
   Writing to stdout:   Entering function y.
   Writing to stdout:   Step1 completed.
   Sending via e-mail:  Step1 completed.
   Writing to stdout:   An error has occurred.
   Sending via e-mail:  An error has occurred.
   Sending to stderr:   An error has occurred.
*/