设计模式：责任链模式

什么是责任链模式

责任链模式在面向对象程式设计里是一种软件设计模式，它包含了一些命令对象和一系列的处理对象。每一个处理对象决定它能处理哪些命令对象，它也知道如何将它不能处理的命令对象传递给该链中的下一个处理对象。该模式还描述了往该处理链的末尾添加新的处理对象的方法。

责任链模式的结构

Handler（抽象处理者）
ConcreteHandler（具体处理者）

抽象处理者持有下一个处理者的引用。具体处理者实现一个抽象处理者，每个具体处理者都清楚自己可以处理什么和不可以处理什么，当它不能处理时，把要处理的对象传递给下一个处理者。

责任链模式的一个实例

日志（Log）有几种级别，Debug、Info、Warn、Error.当使用Debug级别时，所有日志都打印，使用Info级别时，只打印Info、Warn和Error.使用Warn级别时，只打印Warn和Error.使用Error级别时，只打印Error.

实例代码

Message

public class Message {
    private String msg;
    private int logLevel;
    public Message(String msg,int logLevel){
        this.msg = msg;
        this.logLevel = logLevel;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public int getLogLevel() {
        return logLevel;
    }

    public void setLogLevel(int logLevel) {
        this.logLevel = logLevel;
    }
}

Log

public abstract class Log {

    public static int DEBUG = 1;
    public static int INFO = 2;
    public static int WARN = 3;
    public static int ERROR = 4;

    protected Log next;

    public Log setNext(Log next){
        this.next = next;
        return this;
    }

    public abstract void handleLog(Message message);
}

DebugLog

public class DebugLog extends Log {
    @Override
    public void handleLog(Message message) {
        if (message.getLogLevel() <= Log.DEBUG){
            writeLog(message);
        }
        if (this.next != null){
            this.next.handleLog(message);
        }
    }

    private void writeLog(Message message){
        System.out.println("Debug : " + message.getMsg());
    }
}

InfoLog

public class InfoLog extends Log {
    @Override
    public void handleLog(Message message) {
        if (message.getLogLevel() <= Log.INFO){
            writeLog(message);
        }
        if (this.next != null){
            this.next.handleLog(message);
        }
    }

    public void writeLog(Message message){
        System.out.println("Info : " + message.getMsg());
    }
}

WarnLog

public class WarnLog extends Log {
    @Override
    public void handleLog(Message message) {
        if (message.getLogLevel() <= Log.WARN){
            writeLog(message);
        }
        if (this.next != null){
            this.next.handleLog(message);
        }
    }

    public void writeLog(Message message){
        System.out.println("Warn : " + message.getMsg());
    }
}

ErrorLog

public class ErrorLog extends Log {
    @Override
    public void handleLog(Message message) {
        if (message.getLogLevel() <= Log.ERROR){
            writeLog(message);
        }
        if (this.next != null){
            this.next.handleLog(message);
        }
    }

    public void writeLog(Message message){
        System.out.println("Error : " + message.getMsg());
    }
}

Client

public class Client {
    public static void main(String args[]){
        Log debug = new DebugLog().setNext(new InfoLog().setNext(new WarnLog().setNext(new ErrorLog())));

//        debug.handleLog(new Message("A log message",Log.INFO));
        debug.handleLog(new Message("A log message",Log.WARN));

    }
}

实例结果

Warn : A log message
Error : A log message

纯的责任链和不纯的责任链

纯的责任链每个处理者判断自己能否处理对象，能够处理的话承担全部责任，处理后不再向后传递。不纯的责任链每个处理者可以处理对象并向后传递。

（完）