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

清疚 2022-08-08 06:46 140阅读 0赞

### 责任链是什么？ ###

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

### 责任链模式的适用范围 ###

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.
    */