【24种设计模式】责任链模式（Chain of Responsibility Pattern）

责任链模式是一种行为设计模式，它允许你将请求沿着处理链进行传递，直到有一个处理者能够处理该请求为止。这种模式将请求的发送者和接收者解耦，使多个对象都有机会处理该请求。

责任链模式的结构

责任链模式由以下几个角色组成：

1. 抽象处理者（Handler）：定义了处理请求的接口，并维护一个指向下一个处理者的引用。
2. 具体处理者（ConcreteHandler）：实现了处理请求的方法，如果自己不能处理该请求，则将请求传递给下一个处理者。
3. 客户端（Client）：创建具体处理者的链，并将请求发送给第一个处理者。

示例代码

以下是一个简单的示例，展示了如何在一个餐厅点餐系统中使用责任链模式。

首先，定义一个抽象处理者接口：

public interface OrderHandler {
    void setNextHandler(OrderHandler nextHandler);
    void handleOrder(Order order);
}
1
2
3
4

然后，创建具体处理者类，分别处理不同类型的订单：

public class OnlineOrderHandler implements OrderHandler {
    private OrderHandler nextHandler;

    @Override
    public void setNextHandler(OrderHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleOrder(Order order) {
        if (order.getType().equals("online")) {
            // 处理在线订单的逻辑
            System.out.println("处理在线订单：" + order);
        } else {
            // 将请求传递给下一个处理者
            nextHandler.handleOrder(order);
        }
    }
}

public class PhoneOrderHandler implements OrderHandler {
    private OrderHandler nextHandler;

    @Override
    public void setNextHandler(OrderHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleOrder(Order order) {
        if (order.getType().equals("phone")) {
            // 处理电话订单的逻辑
            System.out.println("处理电话订单：" + order);
        } else {
            // 将请求传递给下一个处理者
            nextHandler.handleOrder(order);
        }
    }
}

public class WalkInOrderHandler implements OrderHandler {
    private OrderHandler nextHandler;

    @Override
    public void setNextHandler(OrderHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleOrder(Order order) {
        if (order.getType().equals("walk-in")) {
            // 处理现场订单的逻辑
            System.out.println("处理现场订单：" + order);
        } else {
            // 将请求传递给下一个处理者
            nextHandler.handleOrder(order);
        }
    }
}
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

在每个具体处理者中，根据订单的类型来判断是否能够处理该订单。如果能够处理，则执行相应的业务逻辑；否则，将订单传递给下一个处理者。

最后，在客户端创建处理者链并使用它来处理订单：

public class OrderHandlerChain {
    private OrderHandler firstHandler;

    public void addHandler(OrderHandler handler) {
        if (firstHandler == null) {
            firstHandler = handler;
        } else {
            OrderHandler currHandler = firstHandler;
            while (currHandler.getNextHandler() != null) {
                currHandler = currHandler.getNextHandler();
            }
            currHandler.setNextHandler(handler);
        }
    }

    public void handleOrder(Order order) {
        if (firstHandler != null) {
            firstHandler.handleOrder(order);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        OrderHandlerChain chain = new OrderHandlerChain();

        // 创建具体处理者
        OrderHandler onlineHandler = new OnlineOrderHandler();
        OrderHandler phoneHandler = new PhoneOrderHandler();
        OrderHandler walkInHandler = new WalkInOrderHandler();

        // 构建处理者链
        chain.addHandler(onlineHandler);
        chain.addHandler(phoneHandler);
        chain.addHandler(walkInHandler);

        // 创建订单
        Order order1 = new Order("online");
        Order order2 = new Order("phone");
        Order order3 = new Order("walk-in");

        // 处理订单
        chain.handleOrder(order1);
        chain.handleOrder(order2);
        chain.handleOrder(order3);
    }
}
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

在客户端的 main() 方法中，创建了具体处理者和处理者链，并构建了一个包含不同类型订单处理逻辑的责任链。然后，通过链式调用处理者的 handleOrder() 方法，将订单传递给责任链进行处理。

责任链模式的使用场景

责任链模式适用于以下情况：

• 当你希望多个对象都有机会处理请求，并且你不确定哪个对象会处理请求时。
• 当你希望在不显式指定接收者的情况下，将请求的发送者和接收者解耦。
• 当你希望动态地指定处理对象集合，并在处理链中添加或移除处理者时。

常见的应用场景包括：

• 日志记录系统：可以将日志请求沿着处理链传递，由不同的处理器负责处理不同级别的日志。
• 请求过滤器：可以使用责任链模式来处理请求过滤逻辑，例如对请求进行权限验证、防止恶意请求等。
• 用户界面事件处理：可以使用责任链模式来处理用户界面事件，例如鼠标点击、键盘输入等。

责任链模式可以帮助我们构建松耦合、灵活和可扩展的系统。通过使用责任链模式，我们可以轻松地添加、修改或移除处理者，以适应不同的业务需求。

希望这篇博客推文能够帮助你理解责任链模式，并在实际开发中得到应用！如果还有其他问题，请随时提问。