小谈设计模式（25）—职责链模式

专栏介绍

专栏地址

http://t.csdnimg.cn/VpriY

专栏介绍

主要对目前市面上常见的23种设计模式进行逐一分析和总结，希望有兴趣的小伙伴们可以看一下，会持续更新的。希望各位可以监督我，我们一起学习进步，加油，各位。

职责链模式

职责链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。职责链模式将请求的发送者和接收者解耦，让多个对象都有机会处理请求，直到其中一个对象处理成功为止。

分析

在职责链模式中，通常会有一个抽象处理者（Handler）类，它定义了处理请求的接口和一个指向下一个处理者的引用。具体处理者（ConcreteHandler）类实现了抽象处理者的接口，负责处理特定的请求，如果自己无法处理，则将请求传递给下一个处理者。

角色分析

抽象处理者（Handler）

定义了处理请求的接口，并持有下一个处理者的引用。

具体处理者（ConcreteHandler）

实现了抽象处理者的接口，负责处理特定的请求，如果无法处理则将请求传递给下一个处理者。

客户端（Client）

创建处理链，并将请求发送给链中的第一个处理者。

优缺点分析

优点

1

降低了请求的发送者和接收者之间的耦合，请求发送者无需知道具体的处理者，只需将请求发送给第一个处理者即可。

2

可以动态地增加或修改处理链，增强了灵活性。

3

可以将请求的处理逻辑分布到多个处理者中，避免了单个处理者处理过多的责任。

缺点

1

请求可能无法被处理，或者没有处理者能够处理请求，需要在链的末尾设置一个默认的处理者来处理这种情况。

2

请求可能会被多个处理者都处理，需要控制好处理者之间的关系，避免重复处理。

应用场景

多级审批流程

例如请假审批、报销审批等，每个级别的领导都有机会处理请求。

异常处理

例如在一个系统中，可以通过职责链模式将不同类型的异常交给不同的处理者处理。

日志记录

例如在一个系统中，可以通过职责链模式将不同级别的日志交给不同的处理者记录。

Java程序分析

首先，我们需要定义抽象处理者（Handler）接口，包含处理请求的方法和设置下一个处理者的方法：

public abstract class Handler {
    protected Handler nextHandler;

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

    public abstract void handleRequest(Request request);
}
1
2
3
4
5
6
7
8
9

然后，我们创建具体处理者（ConcreteHandler）类，实现抽象处理者接口，并在处理请求时判断是否能够处理该请求，如果能够处理则进行处理，否则将请求传递给下一个处理者：

public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals("TypeA")) {
            System.out.println("ConcreteHandlerA handles the request.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals("TypeB")) {
            System.out.println("ConcreteHandlerB handles the request.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals("TypeC")) {
            System.out.println("ConcreteHandlerC handles the request.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

最后，我们创建客户端（Client）类，创建处理链并将请求发送给链中的第一个处理者：

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);

        Request requestA = new Request("TypeA");
        Request requestB = new Request("TypeB");
        Request requestC = new Request("TypeC");
        Request requestD = new Request("TypeD");

        handlerA.handleRequest(requestA);
        handlerA.handleRequest(requestB);
        handlerA.handleRequest(requestC);
        handlerA.handleRequest(requestD);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输出结果

ConcreteHandlerA handles the request.
ConcreteHandlerB handles the request.
ConcreteHandlerC handles the request.
No handler can handle the request.
1
2
3
4

分析

在这个示例中，我们创建了三个具体处理者（ConcreteHandlerA、ConcreteHandlerB、ConcreteHandlerC），它们分别能够处理不同类型的请求。我们通过设置每个处理者的下一个处理者，形成了一个处理链。当客户端发送请求时，请求会从链的第一个处理者开始处理，如果某个处理者能够处理该请求，则进行处理，否则将请求传递给下一个处理者，直到找到能够处理请求的处理者为止。如果整个链都无法处理请求，则输出提示信息。