设计模式中职责链 chain of responsibility案例举例

我就是我 2024-03-22 11:13 42阅读 0赞

### JAVA实现案例 ###

职责链（Chain of Responsibility）模式是一种行为型模式，它将请求从发送者和接收者解耦，通过沿着一个链传递请求，使得可以多个对象都有机会处理请求。下面是一个简单的JAVA实现职责链模式的例子：

业务场景员工申请请假由经理审批，员工申请加薪则由总经理审批。

首先定义一个请求类 Request.java：

public class Request {
        
        private String requestType;
        private String requestDescription;
    
        public Request(String type, String description) {
        
            this.requestType = type;
            this.requestDescription = description;
        }
    
        public String getRequestType() {
        
            return requestType;
        }
    
        public String getRequestDescription() {
        
            return requestDescription;
        }
    }

然后定义一个抽象处理器类 Handler.java：

public abstract class Handler {
        
        protected Handler successor;// 维持后继的责任对象
    
        public void setSuccessor(Handler successor) {
        
            this.successor = successor;
        }
    
        // 处理请求的方法
        public abstract void handleRequest(Request request);
    }

接下来定义两个具体处理器类：CEOHandler.java和VPHandler.java。CEOHanlder可以批准所有请求，而VPHandler只能够处理某些特定类型的请求。

public class CEOHandler extends Handler {
        
        @Override
        public void handleRequest(Request request) {
        
            System.out.println("CEO can approve any request.");
        }
    }
    
    public class VPHandler extends Handler {
        
        @Override
        public void handleRequest(Request request) {
        
            if (request.getRequestType().equals("leave")) {
        
                System.out.println("VP can approve leave requests.");
            } else {
        
                // 如果自己不能处理的话，就将请求转发给后继者
                if (successor != null) {
        
                    successor.handleRequest(request);
                }
            }
        }
    }

最后，创建一个客户端类 Client.java：

public class Client {
        
        public static void main(String[] args) {
        
            // 设置责任链
            CEOHandler ceoHandler = new CEOHandler();
            VPHandler vpHandler = new VPHandler();
            vpHandler.setSuccessor(ceoHandler);
    
            // 创建请求
            Request request1 = new Request("leave", "I want to take a leave today.");
            Request request2 = new Request("salary", "I want to increase my salary.");
    
            // 处理请求
            vpHandler.handleRequest(request1);
            vpHandler.handleRequest(request2);
        }
    }

输出结果：

VP can approve leave requests.
    CEO can approve any request.

这个例子中，CEOHandler担当责任链中的最后一个处理器，在它之前的处理器都没有能够处理请求时，请求会传递到CEOHandler中。而VPHandler只能够处理特定类型的请求，如果收到其他类型的请求，就会将请求传递给下一个处理器。

### Python实现职责链模式 ###

假设我们有一个餐厅系统，餐厅可以接收来自不同用户的点餐，但是每个用户都有不同的需求和特殊要求，因此我们需要一种技术来处理这些请求并将它们传递给正确的对象。在这种情况下，使用职责链模式是非常合适的。

下面是一个简单的职责链示例，用于处理来自客户端的点餐请求：

class Request:
    
        def __init__(self, meal_type, table_number, additional_request):
            self.meal_type = meal_type
            self.table_number = table_number
            self.additional_request = additional_request
    
    
    class Handler:
    
        def __init__(self, successor=None):
            self.successor = successor
    
        def handle_request(self, request):
            if self.successor is not None:
                return self.successor.handle_request(request)
    
    
    class WaiterHandler(Handler):
    
        def handle_request(self, request):
            if request.meal_type == "drink":
                print("Waiter serves drink to table", request.table_number)
                return True
            else:
                return super().handle_request(request)
    
    
    class ChefHandler(Handler):
    
        def handle_request(self, request):
            if request.meal_type == "main_dish" and request.additional_request == "vegan":
                print("Chef prepares vegan dish for table", request.table_number)
                return True
            else:
                return super().handle_request(request)
    
    
    class ManagerHandler(Handler):
    
        def handle_request(self, request):
            if request.meal_type == "complimentary_dish":
                print("Manager gives complimentary dish to table", request.table_number)
                return True
            else:
                return super().handle_request(request)

在这个示例中，我们有一个处理请求的基类Handler，以及三个具体处理类WaiterHandler、ChefHandler和ManagerHandler。每个类都有一个handle\_request方法来处理来自客户端的请求。如果请求无法在当前处理程序中处理，它将被传递给职责链中的下一个处理程序，直到找到一个可以处理该请求的处理程序为止。

例如，如果客户端发出一个请求要求一道素菜作为主菜，在这种情况下，只有ChefHandler处理程序才能处理该请求。因此，该请求将由ChefHandler类进行处理并返回True。如果客户端请求一杯水，则将请求失败，因为WaiterHandler处理程序将优先处理所有无需特殊处理的请求。

### C ++职责链模式举例 ###

好的，下面是一个简单的 C++ 实现职责链模式的例子：

#include <iostream>
    #include <string>
    
    class Handler {
        
    public:
        virtual void setNext(Handler* handler) = 0;
        virtual void handle(const std::string& request) = 0;
    };
    
    class BaseHandler : public Handler {
        
    public:
        void setNext(Handler* handler) override {
        
            this->next = handler;
        }
    
        void handle(const std::string& request) override {
        
            if (this->next) {
        
                this->next->handle(request);
            }
        }
    
    private:
        Handler* next = nullptr;
    };
    
    class ConcreteHandler1 : public BaseHandler {
        
    public:
        void handle(const std::string& request) override {
        
            if (request == "one") {
        
                std::cout << "Handled by ConcreteHandler1" << std::endl;
            } else {
        
                BaseHandler::handle(request);
            }
        }
    };
    
    class ConcreteHandler2 : public BaseHandler {
        
    public:
        void handle(const std::string& request) override {
        
            if (request == "two") {
        
                std::cout << "Handled by ConcreteHandler2" << std::endl;
            } else {
        
                BaseHandler::handle(request);
            }
        }
    };
    
    class ConcreteHandler3 : public BaseHandler {
        
    public:
        void handle(const std::string& request) override {
        
            if (request == "three") {
        
                std::cout << "Handled by ConcreteHandler3" << std::endl;
            } else {
        
                BaseHandler::handle(request);
            }
        }
    };
    
    int main() {
        
        ConcreteHandler1 handler1;
        ConcreteHandler2 handler2;
        ConcreteHandler3 handler3;
    
        handler1.setNext(&handler2);
        handler2.setNext(&handler3);
    
        handler1.handle("one");
        handler1.handle("two");
        handler1.handle("three");
        handler1.handle("four");
    
        return 0;
    }

运行结果：

Handled by ConcreteHandler1
    Handled by ConcreteHandler2
    Handled by ConcreteHandler3

在上面的例子中，Handler 类提供了处理请求的接口，并定义了设置下一个处理者的方法。BaseHandler 类实现了 Handler 接口，并提供了设置下一个处理者和调用下一个处理者的默认实现。

ConcreteHandler1、ConcreteHandler2 和 ConcreteHandler3 都继承自 BaseHandler，它们分别处理 “one”、“two” 和 “three” 请求，如果无法处理，则将请求交给下一个处理者来处理。

最后，在 main 函数中，我们可以构建出一条处理链，即 handler1 -> handler2 -> handler3。然后依次向 handler1 发送不同的请求，看看它们是否被正确地处理。

### PHP案例 ###

以下是职责链模式的PHP示例代码：

<?php
    
    // 定义处理器接口
    interface Handler
    {
        
        public function setNext(Handler $handler): Handler;
        public function handle(Request $request): ?string;
    }
    
    // 请求类
    class Request
    {
        
        private $type;
    
        public function __construct(string $type)
        {
        
            $this->type = $type;
        }
    
        public function getType(): string
        {
        
            return $this->type;
        }
    }
    
    // 简单处理器实现
    class SimpleHandler implements Handler
    {
        
        private $nextHandler;
    
        public function setNext(Handler $handler): Handler
        {
        
            $this->nextHandler = $handler;
            return $handler;
        }
    
        public function handle(Request $request): ?string
        {
        
            if ($request->getType() === 'simple') {
        
                return 'SimpleHandler: 处理了请求类型为 simple 的请求。';
            }
    
            // 将请求传递给下一个处理器处理
            if ($this->nextHandler) {
        
                return $this->nextHandler->handle($request);
            }
    
            return null;
        }
    }
    
    // 复杂处理器实现
    class ComplexHandler implements Handler
    {
        
        private $nextHandler;
    
        public function setNext(Handler $handler): Handler
        {
        
            $this->nextHandler = $handler;
            return $handler;
        }
    
        public function handle(Request $request): ?string
        {
        
            if ($request->getType() === 'complex') {
        
                return 'ComplexHandler: 处理了请求类型为 complex 的请求。';
            }
    
            // 将请求传递给下一个处理器处理
            if ($this->nextHandler) {
        
                return $this->nextHandler->handle($request);
            }
    
            return null;
        }
    }
    
    // 客户端代码
    $simpleHandler = new SimpleHandler();
    $complexHandler = new ComplexHandler();
    
    $simpleHandler->setNext($complexHandler);
    
    // 处理简单请求
    $request1 = new Request('simple');
    $result1 = $simpleHandler->handle($request1);
    echo $result1 . "\n";
    
    // 处理复杂请求
    $request2 = new Request('complex');
    $result2 = $simpleHandler->handle($request2);
    echo $result2 . "\n";

在这个示例中，我们定义了一个处理器接口 `Handler`，并实现了两个不同的处理器类 `SimpleHandler` 和 `ComplexHandler`。这两个处理器类都实现了 `Handler` 接口，并且可以相互串联起来形成一个处理器链。在客户端代码中，我们首先创建了一个简单处理器和一个复杂处理器，并使用 `setNext` 方法将它们串联起来。然后，我们分别创建了一个简单请求和一个复杂请求，并将它们传递给处理器链中的第一个处理器（即简单处理器），让它们依次经过处理器链中的所有处理器进行处理。最终，我们得到了相应的处理结果。

职责链模式的主要思想就是将一个大的请求处理过程拆分成多个小的请求处理过程，并将它们串联起来形成一个处理器链，在客户端代码中依次将请求传递给处理器链中的第一个处理器，在处理器链中依次经过所有处理器进行处理，直到得到最终的结果。