责任链模式

1.基本概念

• 为请求创建一个处理链，将请求发送者与接收者进行解耦
• 每个接收者通常包含另一个接收者的引用，根据逻辑，可以将请求转发给下一个接收者处理
• 目的：避免请求发送者与接收者耦合在一起，让多个对象都有可能处理请求，这些对象形成一条链，沿着这条链处理请求
• 责任链上的处理者负责处理请求，客户只需要将请求发送到责任链上，无需关心处理细节和请求的传递，所以责任链将请求的发送者和请求的处理者解耦了

2.代码

package com.chengjie;

abstract class AbstractLogger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    AbstractLogger nextLogger;
    protected int level;

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

//level = 1
class ConsoleLogger extends AbstractLogger {
    public ConsoleLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Console Logger[" + this.level + "]" + message);
    }
}

//level = 2
class DebugLogger extends AbstractLogger {

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

    @Override
    protected void write(String message) {
        System.out.println("Debug Logger[" + this.level + "]" + message);
    }
}

//level = 3
class ErrorLogger extends AbstractLogger {

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

    @Override
    protected void write(String message) {
        System.out.println("Error Logger[" + this.level + "]" + message);
    }
}

public class TestChainResponsibilityPattern {
    private static AbstractLogger getChainOfLogger() {
        AbstractLogger errorLogger = new ErrorLogger(3);
        AbstractLogger debugLogger = new DebugLogger(2);
        AbstractLogger consoleLogger = new ConsoleLogger(1);
        errorLogger.setNextLogger(debugLogger);
        debugLogger.setNextLogger(consoleLogger);
        return errorLogger;
    }

    public static void main(String[] args) {
        AbstractLogger logger = getChainOfLogger();
        logger.logMessage(1, "this is a console message!");
        System.out.println("****************************");
        logger.logMessage(2, "this is a debug message!");
        System.out.println("****************************");
        logger.logMessage(3, "this is a error message!");
    }
}

3.优点

• 降低耦合度
• 简化对象，不需要知道链结构

4.缺点

• 不能保证请求一定被接收

5.应用场景

• 有多个对象可以处理同一个请求
• Struts2的拦截器
• Servlet的Filter

6.参考

　　http://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html