设计模式（行为型模式）责任链模式

一、简介

  责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，允许你将请求沿着处理者链进行传递，直到有一个处理者能够处理该请求为止。这种模式解耦了发送者和接收者之间的关系，允许多个对象对请求进行处理，但发送者无需知道请求的处理过程和最终哪个对象处理了它。

  在责任链模式中，请求通常沿着一个对象链传递，每个处理者对象都包含了自己的处理逻辑和对下一个处理者的引用。当收到请求时，处理者可以选择自行处理、部分处理或将请求传递给链中的下一个处理者。该模式通常包含以下角色：

• Handler（抽象处理者）： 定义了处理请求的接口，通常包含一个指向下一个处理者的引用。
• ConcreteHandler（具体处理者）： 实现抽象处理者接口，在接收到请求后，如果能够处理则处理请求，否则将请求传递给下一个处理者。

  责任链模式能够动态地建立请求的处理链，可以灵活地添加、移除或调整处理者对象，根据需求自由组合处理链。这样可以避免请求发送者和接收者之间的直接耦合，提高了系统的灵活性和可维护性。

二、责任链模式

  当涉及责任链模式时，可以创建一个处理器接口 Logger 和具体的处理器类 DebugLogger、InfoLogger、WarningLogger、ErrorLogger 和 FatalLogger。每个处理器类都可以处理相应级别的日志，如果不能处理，则将日志传递给下一个处理器

2.1、处理器接口

// 处理器接口
public interface Logger {
    void setNextLogger(Logger nextLogger);
    void logMessage(int level, String message);
}

2.2、具体处理器类

DebugLogger

public class DebugLogger implements Logger {
    private Logger nextLogger;

    @Override
    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    @Override
    public void logMessage(int level, String message) {
        if (level <= 1) {
            System.out.println("Debug Logger: " + message);
        } else if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }
}

InfoLogger

public class InfoLogger implements Logger {
    private Logger nextLogger;

    @Override
    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    @Override
    public void logMessage(int level, String message) {
        if (level <= 2) {
            System.out.println("Info Logger: " + message);
        } else if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }
}

WarningLogger

public class WarningLogger implements Logger {
    private Logger nextLogger;

    @Override
    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    @Override
    public void logMessage(int level, String message) {
        if (level <= 3) {
            System.out.println("Warning Logger: " + message);
        } else if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }
}

ErrorLogger

public class ErrorLogger implements Logger {
    private Logger nextLogger;

    @Override
    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    @Override
    public void logMessage(int level, String message) {
        if (level <= 4) {
            System.out.println("Error Logger: " + message);
        } else if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }
}

FatalLogger

public class FatalLogger implements Logger {
    private Logger nextLogger;

    @Override
    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    @Override
    public void logMessage(int level, String message) {
        if (level <= 5) {
            System.out.println("Fatal Logger: " + message);
        } else if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }
}

2.3、使用

// 测试类
public class ChainOfResponsibilityExample {
    public static void main(String[] args) {
        Logger debugLogger = new DebugLogger();
        Logger infoLogger = new InfoLogger();
        Logger warningLogger = new WarningLogger();
        Logger errorLogger = new ErrorLogger();
        Logger fatalLogger = new FatalLogger();

        // 构建责任链
        debugLogger.setNextLogger(infoLogger);
        infoLogger.setNextLogger(warningLogger);
        warningLogger.setNextLogger(errorLogger);
        errorLogger.setNextLogger(fatalLogger);

        // 测试责任链
        debugLogger.logMessage(2, "This is an info message.");
        debugLogger.logMessage(4, "This is an error message.");
        debugLogger.logMessage(5, "This is a fatal message.");
    }
}

运行结果：

Info Logger: This is an info message.
Error Logger: This is an error message.
Fatal Logger: This is a fatal message.

  在这个示例中，我们创建了多个具体的处理器类来处理不同级别的日志。通过构建责任链，每个处理器类中实现了处理逻辑，并且能够将日志传递给下一个处理器，直至最终处理。在测试类中，演示了发送不同级别的日志请求，并观察责任链的处理过程。

三、优点与缺点

  责任链模式有一些优点和缺点，让我们来看一下：

优点

• 降低耦合度： 将请求发送者和接收者解耦，发送者无需知道请求的处理者，也不需要知道请求是如何被处理以及谁来处理。
• 灵活性和可扩展性：可以动态地调整、增加或删除处理者对象，也可以改变它们之间的顺序，以满足不同的处理需求。
• 单一职责原则： 每个具体处理者都专注于自己的处理逻辑，使得系统更加符合单一职责原则。

缺点

• 请求处理不保证被执行：如果请求没有被任何处理者处理，可能会出现未处理的情况，这需要在设计时考虑清楚。
• 性能问题：如果责任链太长或者处理者逻辑过于复杂，可能会影响性能。同时，递归地向下传递请求可能会影响性能。

  责任链模式适合处理对象之间存在多种处理方式的情况，但在使用时需要注意权衡，避免责任链过长、过于复杂，以及处理者责任划分不清晰等问题。