java链路器模式handler

原创

mob64ca12cfec58 2024-08-16 04:15:10 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12cfec58的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 链路器模式 Handler: 一个科普文章

在现代软件开发中，设计模式是让代码更加灵活和可维护的关键。链路器模式（Chain of Responsibility Pattern）是一种行为性设计模式，旨在通过将请求发送到链中的多个处理者中，以避免请求的发送者与接收者之间的紧密耦合。本文将重点介绍 Java 中的链路器模式，并通过代码示例帮助你更好地理解这一模式的应用。

什么是链路器模式

链路器模式定义了一种请求-处理的模式，其中每个处理者都能决定是否处理该请求或者将请求传递给下一个处理者。就如同一个问路的人，问完一个人后，可以选择继续问下一个，直到有人能够解决他的问题。

这种模式常用于事件处理系统、日志系统、权限验证等场景。通过链路器模式，我们可以在运行时改变处理请求的方式，提高系统的灵活性。

链路器模式的结构

链路器模式主要包含以下几个部分：

Handler：抽象类或接口，定义处理请求的方法。
ConcreteHandler：具体的处理者类，继承或实现 Handler，处理具体的请求。
Client：发送请求的客户端。

代码示例

以下是一个简单的 Java 样例，演示链路器模式的基本使用。

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

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

    public abstract void handleRequest(int request);
}

// 具体处理者
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 0 && request < 10) {
            System.out.println("Handler A handling request " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("Handler B handling request " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 20) {
            System.out.println("Handler C handling request " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

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

        handlerA.setNextHandler(handlerB);
        handlerB.setNextHandler(handlerC);

        for (int i = 0; i < 30; i += 5) {
            handlerA.handleRequest(i);
        }
    }
}

代码示例解释

在这个示例中，我们定义了一个抽象处理者 Handler，它包含指向下一个处理者的引用。在具体处理者 ConcreteHandlerA、ConcreteHandlerB 和 ConcreteHandlerC 中，我们检查请求的范围并决定是否处理该请求。如果当前处理者无法处理请求，它会将请求传递给下一个处理者。

序列图

以下是链路器模式的序列图，展示了请求是如何在处理者之间传递的：

sequenceDiagram
    participant Client
    participant HandlerA as A
    participant HandlerB as B
    participant HandlerC as C

    Client->>A: request(5)
    A->>A: handle request
    A->>B: pass request(5)

    Client->>A: request(15)
    A->>A: handle request
    A->>B: pass request(15)
    B->>B: handle request
    B->>A: pass request(15)

    Client->>A: request(25)
    A->>A: handle request
    A->>B: pass request(25)
    B->>B: pass request(25)
    B->>C: pass request(25)
    C->>C: handle request