责任链模式

xudaodesu

责任链模式

意图

• 允许将请求沿着处理者链传递，直到请求被处理为止(不一定会被处理、但一定按照指定的顺序执行)

  更像是审批流程，参与审批的人都会进行审批直到通过或者驳回。（顾名思义责任链，就是这条固定链上的人都有责任参与处理事务、对事物进行负责）

  值得注意还有参与执行的顺序，是有序排列的

主要解决的问题

• 解耦请求发送者和接收者，使多个对象都有可能接收请求，而发送者不需要知道哪个对象会处理它。

  当需要向多个对象中的一个提交请求，而不想明确指定接收者时。

使用建议

• 在处理请求时，如果有多个潜在的处理者，考虑使用责任链模式。

  确保链中的每个处理者都明确知道如何传递请求到链的下一个环节。

  比如带有流程事务、参与流程的顺序不可变。如锻造一把剑：捶打->刨锉->磨光->镶嵌->淬火，这个流程就不可变，如果要变就只能新建一条链。

  在造剑的这个流程中，每把剑都会历经这个流程。但每个流程不一定会执行，比如最后一步淬火，不一定每把剑都会参与淬火。这就取决于需求，需不需要淬火

实现

• 我们创建抽象类 AbstractLogger，带有详细的日志记录级别。然后我们创建三种类型的记录器，都扩展了 AbstractLogger。每个记录器消息的级别是否属于自己的级别，如果是则相应地打印出来，否则将不打印并把消息传给下一个记录器

• 

步骤1

public abstract class AbstractLogger {

    AbstractLogger abstractLogger;

    /**
     * 设置下一个日志级别
     * */
    public void setNextLogger(AbstractLogger abstractLogger) {
        this.abstractLogger = abstractLogger;
    }
    /**
     * 执行方法判断当前类是否满足执行条件
     * */
    abstract void logMessage(String message);

}

步骤2

创建扩展了该记录器类的实体类

public class LoggerDedug extends AbstractLogger{
    @Override
    void logMessage( String message) {
            //具体需要执行的方法
            System.out.println("这是dedug日志打印"+message);
            Optional.ofNullable(abstractLogger).ifPresent(abstractLogger -> abstractLogger.logMessage(message));
    }
}

public class LoggerError extends AbstractLogger{
    @Override
    void logMessage(String message) {
        System.out.println("这是erro日志打印"+message);
        Optional.ofNullable(abstractLogger).ifPresent(abstractLogger -> abstractLogger.logMessage(message));
    }
}

public class LoggerDedug extends AbstractLogger{
    @Override
    void logMessage( String message) {
            //具体需要执行的方法
            System.out.println("这是dedug日志打印"+message);
            Optional.ofNullable(abstractLogger).ifPresent(abstractLogger -> abstractLogger.logMessage(message));
    }
}

public class LoggerInfo extends AbstractLogger{
    @Override
    void logMessage(String message) {
         //具体需要执行的方法
        System.out.println("这是info打印"+message);
        Optional.ofNullable(abstractLogger).ifPresent(abstractLogger -> abstractLogger.logMessage(message));
    }
}

步骤3

创建测类

public class Test {
    public static void main(String[] args) {
        AbstractLogger chainOfLoggers = getChainOfLoggers();
        chainOfLoggers.logMessage("hell word");
    }
    private static AbstractLogger getChainOfLoggers(){
        AbstractLogger loggerInfo = new LoggerInfo();
        LoggerDedug loggerDedug = new LoggerDedug();
        LoggerError loggerError = new LoggerError();
        //设置日志执行顺序
        loggerDedug.setNextLogger(loggerInfo);
        loggerError.setNextLogger(loggerDedug);
        //返回最先执行的类
        return loggerError;
    }
    private static AbstractLogger getChainOfLoggers01(){
        AbstractLogger loggerInfo = new LoggerInfo();
        LoggerDedug loggerDedug = new LoggerDedug();
        LoggerError loggerError = new LoggerError();
        //设置日志执行顺序
        loggerDedug.setNextLogger(loggerInfo);
        loggerError.setNextLogger(loggerDedug);
        //返回最先执行的类
        return loggerError;
    }
}

步骤 4

执行程序，输出结果：

这是erro日志打印hell word
这是dedug日志打印hell word
这是info打印hell word
--------------------------------------------------------------------------------------------------------------------------------
这是info打印hello world01
这是dedug日志打印hello world01
这是erro日志打印hello world01

总结

这个版本的责任链应该是最简单的责任链了，也是责任链的本质。没有做任何过滤、筛选操作，只要参与到了这个链中都会执行

扩展：在定义logMessage的时候、可以加入一些参数。在每个实现类、实现logMessage的时候还可以根据关键参数进行过滤判断，决定要不要执行自己的实现