【设计模式】Java 设计模式之责任链模式（Chain of Responsibility） - 服务器托管|北京服务器租用|机房托管租用|IDC托管租用|机房机柜带宽租用-价格及费用咨询

责任链模式（Chain of Responsibility）

一、概述

责任链模式是一种行为设计模式，它允许请求在对象链中传递。每个对象都有机会处理该请求，并且能将其传递给链中的下一个对象。这种模式为请求创建了一个处理对象的链，并沿着这条链传递该请求，直到有一个对象处理它为止。

二、模式结构

责任链模式主要包含以下几个角色：

抽象处理者（Handler）角色：定义了一个处理请求的接口，同时含有一个后继者的引用。
具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以则处理，否则将该请求转发给它的后继者。
客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求。

三、实现方式

通常，实现责任链模式时，我们会在每个处理者对象中维护一个指向下一个处理者的引用。当处理者无法处理请求时，它会将该请求传递给下一个处理者。

四、代码示例

下面是一个简单的责任链模式的代码示例：

// 抽象处理者
public abstract class Handler {
    protected Handler nextHandler;

    public void setNextHandler(Handler handler) {
        this.nextHandler = handler;
    }

    public abstract void handleRequest(String request);
}

// 具体处理者A
public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("TypeA".equals(request)) {
            System.out.println("ConcreteHandlerA handles request: " + request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("No handler for request: " + request);
            }
        }
    }
}

// 具体处理者B
public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("TypeB".equals(request)) {
            System.out.println("ConcreteHandlerB handles request: " + request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("No handler for request: " + request);
            }
        }
    }
}

// 客户类
public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNextHandler(handlerB);

        handlerA.handleRequest("TypeA"); // 输出: ConcreteHandlerA handles request: TypeA
        handlerA.handleRequest("TypeB"); // 输出: ConcreteHandlerB handles request: TypeB
        handlerA.handleRequest("TypeC"); // 输出: No handler for request: TypeC
    }
}

五、优缺点分析

优点：

降低了对象之间的耦合度。该模式使得一个对象无须知道到底哪一个对象会处理其请求以及链的结构。
增强了系统的可扩展服务器托管网性。可以根据需要增加新的请求处理类，满足开闭原则。
增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。

缺点：

不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。

六、常见应用场景

责任链模式常见于以下场景：

多个对象可以处理同一请求，但具体由哪个对象处理该请求在运行时确定。
当你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
当系统需要动态地决定请求的处理者时。

七、实际应用案例解读

假设在一个日志系统中，不同类型的日志需要不同的处理器来处理，如错误日志、警告日志、信息日志等。我们可以使用责任链模式来构建一个日志处理链，每个处理器负责处理特定类型的日志，如果无法处理则传递给下一个处理器。

例如，ErrorHandler 处理错误日志，WarningHandler 处理警告日志，InfoHandler 处理信息日志。当收到一条日志时，先传递给 ErrorHandler，如果它不能处理（比如这条日志不是错误类型），则传递给 WarningHandler，如果还是不能处理，最后传递给 InfoHandler。

代码示例：

// 日志处理器接口
public interface LogHandler {
    boolean handle(Log log);
}

// 错误日志处理器
public class ErrorHandler implements LogHandler {
    @Override
    public boolean handle(Log log) {
        if (log.getLevel().equals(LogLevel.ERROR)) {
            System.out.println("Error log handled: " + log.getMessage());
            return true; // 已处理
        }
        return false; // 未处理，传递给下一个处理器
    }
}

// 警告日志处理器
public class WarningHandler implements LogHandler {
    private LogHandler nextHandler;

    public WarningHandler(LogHandler nextHandler) {
        this.服务器托管网nextHandler = nextHandler;
    }

    @Override
    public boolean handle(Log log) {
        if (log.getLevel().equals(LogLevel.WARNING)) {
            System.out.println("Warning log handled: " + log.getMessage());
            return true;
        }
        if (nextHandler != null) {
            return nextHandler.handle(log);
        }
        return false;
    }
}

// 信息日志处理器
public class InfoHandler implements LogHandler {
    @Override
    public boolean handle(Log log) {
        if (log.getLevel().equals(LogLevel.INFO)) {
            System.out.println("Info log handled: " + log.getMessage());
            return true;
        }
        return false;
    }
}

// 日志类
public class Log {
    private LogLevel level;
    private String message;

    // 省略构造器和其他方法
}

// 日志级别枚举
public enum LogLevel {
    ERROR, WARNING, INFO
}

// 客户类
public class LoggingSystem {
    public static void main(String[] args) {
        LogHandler errorHandler = new ErrorHandler();
        LogHandler warningHandler = new WarningHandler(new InfoHandler());

        // 组装责任链
        warningHandler.handle(new Log(LogLevel.ERROR, "This is an error log")); // Error log handled
        warningHandler.handle(new Log(LogLevel.WARNING, "This is a warning log")); // Warning log handled
        warningHandler.handle(new Log(LogLevel.INFO, "This is an info log")); // Info log handled
        warningHandler.handle(new Log(LogLevel.DEBUG, "This is a debug log")); // 无处理器处理，因为没有对应的Debug处理器
    }
}

在这个例子中，ErrorHandler、WarningHandler 和 InfoHandler 各自负责处理特定类型的日志。WarningHandler 持有对 InfoHandler 的引用，以便在无法处理警告日志时传递给 InfoHandler。如果 InfoHandler 也不能处理，那么该日志就不会被进一步处理。

八、总结

责任链模式提供了一种将多个请求处理器组织成链的方式，使得请求能够沿着链传递直到被处理。它降低了请求发送者和多个请求处理者之间的耦合度，提高了系统的灵活性和可扩展性。然而，使用责任链模式时需要注意，过长的责任链可能会影响系统性能，且需要确保每个请求都能被正确处理，避免请求丢失。在实际应用中，应根据具体场景和需求来选择合适的实现方式。
九、责任链模式的适用场景

责任链模式在许多场景中都非常有用，特别是在以下情况中：

多个处理器按特定顺序处理请求：当系统中有多个组件需要按特定顺序处理某个请求时，责任链模式可以确保请求按照正确的顺序传递到每个组件。
动态改变处理流程：如果处理请求的流程经常需要动态改变，责任链模式非常适用。通过添加、删除或重新排序处理器，可以轻松改变处理流程。
未知的处理者数量：当处理请求所需的处理器数量未知或可能变化时，责任链模式允许灵活地添加或删除处理器，而无需修改其他代码。
日志记录、异常处理或权限检查：这些通常涉及多个级别的处理，每个级别可能有自己的处理逻辑。责任链模式可以确保这些请求按正确的顺序和逻辑进行处理。
GUI事件处理：在图形用户界面（GUI）中，用户交互事件（如点击、键盘输入等）通常需要经过多个处理阶段，如事件分发、处理、反馈等。责任链模式可以帮助组织这些处理阶段。
中间件或管道处理：在分布式系统或中间件中，请求可能需要经过多个服务或组件的处理。责任链模式可以确保请求按照正确的顺序和逻辑在这些服务或组件之间传递。

十、责任链模式的优缺点

优点：

降低了耦合度：客户端不需要知道链的结构，也不需要指定请求的处理者，只需将请求发送到链的起始点即可。
增强了系统的可扩展性：可以很容易地添加新的请求处理者到链中，以满足开闭原则。
增强了给对象指派职责的灵活性：能够根据运行时的条件动态地改变处理者的顺序。

缺点：

不能保证每个请求都被处理：由于请求是沿着链传递的，如果链中的某个处理者没有正确处理请求，或者链本身存在问题（如循环引用），那么请求可能不会被正确处理。
系统性能可能下降：由于请求需要在链中传递，可能会增加处理时间，特别是在链较长或处理者较多时。
调试可能较复杂：由于请求可能经过多个处理者，定位问题的来源可能比较困难。

十一、实际应用中的注意事项

避免无限循环：在设计责任链时，要确保没有循环引用，否则请求可能会在处理器之间无限循环。
提供明确的错误处理机制：当请求在链中无法被处理时，应提供明确的错误处理机制，如抛出异常或记录日志。
考虑性能优化：如果链较长或处理者较多，可以考虑使用缓存或其他优化技术来提高性能。
保持链的简洁性：尽量避免不必要的处理器，以保持链的简洁性和高效性。
文档化链的结构和行为：为了便于维护和调试，应详细记录链的结构、每个处理器的职责以及处理逻辑。

通过深入了解责任链模式的适用场景、优缺点以及实际应用中的注意事项，我们可以更好地利用该模式来设计和优化我们的软件系统。

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

相关推荐: SpringCloud返回的是xml格式而非JSON数据

一、问题描述：最近接触eureka，写了一个接口，使用@RestController注解修饰了类，预期是返回json格式的数据，但是结果返回的是xml格式的数据。二、问题分析：原因是因为直接或间接引入了jackson-dataformat-xml依赖导致…