Java设计模式—责任链模式（Chin of Responsibility）

目录

前言

一、责任链模式的简介

二、责任链模式的概念

三、责任链模式的作用

四、责任链模式的优、缺点

1.责任链模式的优点

2.责任链模式的缺点

五、责任链模式的应用场景

六、代码案例

UML类图

 1.定义一个请求枚举类

 2.定义一个请求类

3.定义一个抽象处理接口

4、定义具体处理类

5.Main代码测试

总结

---

前言

使用责任链模式，它可以动态地添加或删除处理器，从而改变处理请求的顺序和方式。同时，责任链模式也可以减少对象之间的耦合度，提高代码的可扩展性和可维护性。

---

一、责任链模式的简介

责任链模式（Chin of Responsibility）是一种行为型设计模式，它通过将请求的发送者和接收者解耦来实现请求的处理。

---

二、责任链模式的概念

责任链模式（Chin of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链子，并沿着这条链传递该请求，直到有一对象处理到它为止。

---

三、责任链模式的作用

责任链模式（Chin of Responsibility）的作用是将请求的发送者和接收者解耦，使多个对象都有机会处理该请求。它将这些对象连接成一条链，并沿着链传递请求，直到有一个对象处理它为止。

责任链模式的主要作用包括以下：

1. 降低系统的耦合度
2. 增强系统的灵活性
3. 提高代码的可扩展性
4. 提高代码的可维护性

---

四、责任链模式的优、缺点

1.责任链模式的优点

1. 降低系统的耦合度：请求发送者和接收者之间不直接交互，而是通过责任链上的多个对象进行交互，从而降低了它们之间的耦合度。
2. 增强系统的灵活性：可以动态地增加或删除处理器，从而改变请求的处理顺序和方式。
3. 提高代码的可扩展性：因为每个处理器都只负责处理自己能够处理的请求，所以可以方便地添加新的处理器来处理新的请求类型。
4. 提高代码的可维护性：因为每个处理器都只负责处理自己能够处理的请求，所以可以方便地添加新的处理器来处理新的请求类型。

2.责任链模式的缺点

1. 请求可能没有被处理：如果没有任何一个处理器能够处理该请求，则该请求将被忽略。
2. 系统性能可能受影响：由于责任链中可能包含大量的处理器，因此可能会影响系统的性能。

---

五、责任链模式的应用场景

责任链的使用场景有以下几点：

1. 处理请求需要多个对象协作，且不确定哪个对象能够处理请求。
2. 需要动态指定能够处理请求的对象集合。
3. 需要在不明确接收者的情况下，向多个对象中的一个或多个发送请求。
4. 可以通过在运行时添加或删除处理器来改变请求处理的顺序。
5. 当一个请求需要被多个对象进行处理时，可以使用责任链模式避免产生复杂的嵌套调用。
6. 可以将责任链模式与其他设计模式结合使用，如装饰器模式、工厂模式等，以实现更加灵活的功能。

---

六、代码案例

UML类图

 1.定义一个请求枚举类

RequestType请求枚举

/***
 * 定义请求枚举
 */
public enum RequestType {
    TYPE_A, TYPE_B, TYPE_C
}

---

 2.定义一个请求类

Request请求类

/***
 * 定义请求类
 */
public class Request {
    private String name;
    private RequestType type;

    public Request(String name, RequestType type) {
        this.name = name;
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public RequestType getType() {
        return type;
    }
}

---

3.定义一个抽象处理接口

定义一个抽象处理器（Handler）类，其中包含一个指向下一个处理器的引用，并定义一个处理请求的方法。

Handler抽象类

/***
 * 定义一个抽象处理器（Handler）类，其中包含一个指向下一个处理器的引用，并定义一个处理请求的方法。
 */
public abstract class Handler {
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(Request request);
}

---

4、定义具体处理类

ConcreteHandlerA类

/***
 * 定义具体处理类
 */
public class ConcreteHandlerA extends Handler {

    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals(RequestType.TYPE_A)) {
            System.out.println("ConcreteHandlerA处理请求" +request.getName());
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

ConcreteHandlerB类

/***
 * 定义具体处理类
 */
public class ConcreteHandlerB extends Handler {

    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals(RequestType.TYPE_B)) {
            System.out.println("ConcreteHandlerB处理请求" + request.getName());
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }

ConcreteHandlerC类

/***
 * 定义具体处理类
 */
public class ConcreteHandlerC extends Handler {

    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals(RequestType.TYPE_C)) {
            System.out.println("ConcreteHandlerC处理请求" + request.getName());
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

---

5.Main代码测试

 public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();

        handlerA.setSuccessor(handlerB);
        handlerB.setSuccessor(handlerC);

        Request request1 = new Request("已处理 1", RequestType.TYPE_A);
        Request request2 = new Request("已处理 2", RequestType.TYPE_B);
        Request request3 = new Request("已处理 3", RequestType.TYPE_C);

        handlerA.handleRequest(request1);
        handlerA.handleRequest(request2);
        handlerA.handleRequest(request3);
    }

输出结果：

 

---

总结

这个示例中，具体处理器类实现了抽象处理器接口，并根据自己的能力来判断是否能够处理请求。如果不能处理，则将请求传递给下一个处理器。客户端创建责任链并将请求发送给第一个处理器，处理器依次处理请求，直到有一个处理器能够处理它为止。