Java设计模式 三十五 责任链模式 + 中介者模式

责任链模式 + 中介者模式

责任链模式（Chain of Responsibility Pattern）和中介者模式（Mediator Pattern）是两种行为型设计模式，它们分别处理不同的职责和协作方式。将这两种模式结合使用，可以更好地解耦系统中的组件，特别是在需要处理多个对象之间复杂交互的场景中。让我们看看这两种模式的特点以及如何结合使用。

• 责任链模式（Chain of Responsibility Pattern）旨在将请求的处理从发送者解耦，允许多个处理对象形成一个链条，每个处理对象决定是否处理请求。如果某个对象不能处理该请求，它会将请求传递给链条中的下一个对象，直到请求被处理或链条末尾。

• 中介者模式（Mediator Pattern）则是通过引入一个中介者对象来协调和管理多个对象的交互，从而避免它们之间直接的相互依赖。中介者通过集中控制各个组件的交互来降低系统的耦合度。

将这两种模式结合使用时，责任链模式用于处理请求的传递，而中介者模式则管理这些请求的处理过程，并协调多个处理者之间的合作。

---

1. 场景说明：客服请求处理系统

假设我们有一个客服请求处理系统，其中包含多个不同级别的客服人员（如初级客服、高级客服、经理等）。每个客服人员能够处理不同类型的请求，但如果某个客服无法处理请求，他会将请求传递给下一位更高级别的客服。而且，所有的请求处理都通过一个中介者进行管理和协调，以确保请求的流转和处理的顺序。

---

2. 设计步骤

(1) 定义请求

首先，我们定义一个请求对象，表示需要处理的客户请求。

// 客户请求
public class CustomerRequest {
    private String requestDescription;
    
    public CustomerRequest(String requestDescription) {
        this.requestDescription = requestDescription;
    }
    
    public String getRequestDescription() {
        return requestDescription;
    }
}

(2) 定义处理者接口

接着，我们定义一个处理者接口，每个客服都可以根据自己的能力来处理请求。如果无法处理请求，它会将请求转交给链条中的下一个客服。

// 处理者接口
public interface RequestHandler {
    void setNextHandler(RequestHandler nextHandler);  // 设置下一个处理者
    void handleRequest(CustomerRequest request);  // 处理请求
}

(3) 具体处理者：初级客服、高级客服、经理

我们定义几个具体的处理者：初级客服、高级客服和经理。每个处理者都能处理不同类型的请求，并将无法处理的请求传递给下一个处理者。

// 初级客服
public class JuniorSupport implements RequestHandler {
    private RequestHandler nextHandler;

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

    @Override
    public void handleRequest(CustomerRequest request) {
        if (request.getRequestDescription().equals("Basic Inquiry")) {
            System.out.println("Junior Support handling: " + request.getRequestDescription());
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 高级客服
public class SeniorSupport implements RequestHandler {
    private RequestHandler nextHandler;

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

    @Override
    public void handleRequest(CustomerRequest request) {
        if (request.getRequestDescription().equals("Technical Issue")) {
            System.out.println("Senior Support handling: " + request.getRequestDescription());
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 经理
public class Manager implements RequestHandler {
    private RequestHandler nextHandler;

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

    @Override
    public void handleRequest(CustomerRequest request) {
        if (request.getRequestDescription().equals("Complaint")) {
            System.out.println("Manager handling: " + request.getRequestDescription());
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

(4) 定义中介者接口

然后，我们定义一个中介者接口，该接口负责协调各个处理者的工作，接收并管理请求的流转。中介者的作用是简化各个处理者之间的交互，使得处理者之间不需要直接依赖。

// 中介者接口
public interface SupportMediator {
    void registerHandler(RequestHandler handler);  // 注册处理者
    void handleRequest(CustomerRequest request);  // 处理请求
}

(5) 具体中介者：客服请求管理器

接着，我们实现一个具体的中介者，它管理多个处理者，并控制请求的流转。

// 客服请求管理器
public class SupportRequestManager implements SupportMediator {
    private List<RequestHandler> handlers = new ArrayList<>();

    @Override
    public void registerHandler(RequestHandler handler) {
        handlers.add(handler);
    }

    @Override
    public void handleRequest(CustomerRequest request) {
        for (RequestHandler handler : handlers) {
            handler.handleRequest(request);
        }
    }
}

(6) 客户端代码：

在客户端，我们创建中介者（客服请求管理器）和各个处理者，并注册它们。当收到请求时，客户端通过中介者来处理请求。

public class Client {
    public static void main(String[] args) {
        // 创建各个客服处理者
        RequestHandler juniorSupport = new JuniorSupport();
        RequestHandler seniorSupport = new SeniorSupport();
        RequestHandler manager = new Manager();

        // 创建中介者
        SupportMediator mediator = new SupportRequestManager();

        // 注册处理者
        mediator.registerHandler(juniorSupport);
        mediator.registerHandler(seniorSupport);
        mediator.registerHandler(manager);

        // 创建客服请求
        CustomerRequest basicInquiry = new CustomerRequest("Basic Inquiry");
        CustomerRequest technicalIssue = new CustomerRequest("Technical Issue");
        CustomerRequest complaint = new CustomerRequest("Complaint");

        // 通过中介者处理请求
        System.out.println("Processing Basic Inquiry:");
        mediator.handleRequest(basicInquiry);  // 只有初级客服会处理

        System.out.println("\nProcessing Technical Issue:");
        mediator.handleRequest(technicalIssue);  // 高级客服会处理

        System.out.println("\nProcessing Complaint:");
        mediator.handleRequest(complaint);  // 经理会处理
    }
}

---

3. 运行结果：

Processing Basic Inquiry:
Junior Support handling: Basic Inquiry

Processing Technical Issue:
Senior Support handling: Technical Issue

Processing Complaint:
Manager handling: Complaint

---

4. 优点：

责任链模式的优势：

1. 解耦请求发送者和处理者： 请求发送者只需要将请求发送给责任链中的第一个处理者，责任链会自动处理请求或将其转发给下一个处理者。
2. 动态处理请求： 可以灵活地调整责任链的顺序，或者在链条中添加或移除处理者，而不会影响到客户端代码。
3. 责任分担： 每个处理者只负责处理自己擅长的请求，避免了单个处理者承担过多责任。

中介者模式的优势：

1. 集中控制： 中介者控制了各个组件之间的交互，避免了它们之间直接依赖，简化了复杂的交互逻辑。
2. 减少耦合： 各个组件不再相互引用，而是通过中介者进行通信，从而降低了系统的耦合度。
3. 集中管理： 所有的请求流转都通过中介者进行管理，便于扩展和维护。

---

5. 结合的优势：

将责任链模式和中介者模式结合使用，能够带来以下好处：

1. 请求流转和协作分离： 责任链模式处理请求的传递和分发，而中介者模式则集中管理请求的处理和组件之间的协作。这样，责任链只关注如何传递请求，中介者则负责协调具体的处理逻辑。
2. 灵活扩展： 新的请求类型或新的处理者可以很容易地加入到责任链中，而中介者管理逻辑的变化不会影响到具体的处理者。
3. 清晰的职责划分： 通过责任链和中介者模式的结合，系统中的职责得到了更好的划分，既保证了请求的正确流转，又简化了多个组件之间的交互。

---

6. 总结：

将责任链模式和中介者模式结合使用，可以使得请求的处理更加灵活和可扩展。责任链模式负责请求的传递和处理，而中介者模式则集中管理请求的流转和各个组件的交互。通过这种组合模式，可以有效地解耦系统中的各个组件，提高系统的可维护性、灵活性和扩展性。