Base Time-Design Patterns-Chain of Responsibility

Base 2017-01

责任链模式的定义

• 使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间耦合关系，将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

责任链模式的优点

• 最为显著的优点就是将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌，两者解耦，提高系统的灵活性。

责任链模式的缺点

• 性能问题，每个请求都是从链头遍历到链尾，特别是在链比较长的时候，性能是一个问题。
• 调试不是很方便，特别是链条比较长的，环节比较多的时候，由于采用了类似递归的方式 ，调试的时候逻辑可能比较复杂。

UML

Code

责任链处理节点接口ILogger.java

public interface ILogger {
    int LEVEL_INFO = 1;
    int LEVEL_WARN = 2;
    int LEVEL_ERROR = 3;
    String TAG = "chainOfResponsibility";
    void setNextLogger(ILogger logger);
    void logMessage(int level, String message);
    void write(String message);
}

基类，实现ILogger接口类BaseLogger.java

public abstract class BaseLogger implements ILogger {
    private ILogger mNext;
    protected int mLevel;
    public BaseLogger() {
        mLevel = 0;
    }
    public BaseLogger(int level) {
        mLevel = level;
    }
    @Override
    public void setNextLogger(ILogger logger) {
        mNext = logger;
    }
    @Override
    public void logMessage(final int level, String message) {
        if (level <= mLevel) {
            write(message);
        }
        if (mNext != null) {
            mNext.logMessage(level, message);
        }
    }
    public abstract void write(String message);
}

具体实现类InfoLogger.java

public class InfoLogger extends BaseLogger {
    public InfoLogger() {
        super();
        mLevel = LEVEL_INFO;
    }
    @Override
    public void write(String message) {
        Log.i(TAG, "Info: " + message);
    }
}

具体实现类WarnLogger.java

public class WarnLogger extends BaseLogger {
    public WarnLogger() {
        super();
        mLevel = LEVEL_WARN;
    }
    @Override
    public void write(String message) {
        Log.w(TAG, "Warn: " + message);
    }
}

具体实现类ErrorLogger.java

public class ErrorLogger extends BaseLogger {
    public ErrorLogger() {
        super();
        mLevel = LEVEL_ERROR;
    }
    @Override
    public void write(String message) {
        Log.e(TAG, "Error: " + message);
    }
}

测试用例类TestCase.java

public class TestCase {
    private TestCase() {
        //Do Nothing
    }
    public static void exe() {
        //生成Logger链
        ILogger loggerInfo = new InfoLogger();
        ILogger loggerWarn = new WarnLogger();
        ILogger loggerError = new ErrorLogger();
        loggerInfo.setNextLogger(loggerWarn);
        loggerWarn.setNextLogger(loggerError);
        //放入责任链中执行
        loggerInfo.logMessage(ILogger.LEVEL_INFO, "LEVEL_INFO");
        loggerInfo.logMessage(ILogger.LEVEL_WARN, "LEVEL_WARN");
        loggerInfo.logMessage(ILogger.LEVEL_ERROR, "LEVEL_ERROR");
    }
}

验证结果

参考博文：
Chain of Responsibility Pattern