当前位置： 首页 > news >正文

责任链模式 Go 语言实战

news 2025/7/2 11:43:54

责任链模式（Chain of Responsibility）

责任链模式是一种行为设计模式，它允许将请求沿着处理者链进行传递，直到有一个处理者能够处理它。这个模式的主要目的是解耦请求的发送者和接收者，使得多个对象都有机会处理这个请求，而不需要明确指定哪个对象处理请求。

责任链模式的结构
  1. 处理者接口（Handler）：定义一个处理请求的接口，通常包括一个处理请求的方法和一个设置下一个处理者的方法。
  2. 具体处理者（Concrete Handler）：实现处理者接口的类。每个具体处理者都包含对下一个处理者的引用。如果当前处理者能够处理请求，它就会处理；否则，它会将请求传递给下一个处理者。
  3. 客户端（Client）：负责创建处理者链并将请求发送到链的起始处理者。
责任链模式的适用场景
  1. 请求的处理方式和顺序未知：当程序需要使用不同方式处理不同种类的请求，且请求类型和顺序预先未知时，责任链模式非常适用。
  2. 多个处理者按顺序执行：当必须按顺序执行多个处理者时，责任链模式可以确保所有请求严格按照链上的顺序通过处理者。
  3. 动态改变处理者及其顺序：可以在运行时动态地插入和移除处理者，或者改变其顺序。
责任链模式的优点
  • 降低耦合度：请求的发送者和接收者解耦。
  • 增强灵活性：可以在运行时动态地添加、删除或重新排列处理者。
  • 责任分担：多个处理者可以分担处理请求的责任。
责任链模式的缺点
  • 请求处理不保证：如果链上的所有处理者都不能处理请求，可能会导致请求未被处理。
  • 调试困难：由于请求沿着链传递，可能会导致调试和跟踪请求处理过程变得复杂。

示例场景：请求的处理方式和顺序未知——在线客服系统

假设我们有一个在线客服系统，用户的请求需要根据不同的情况进行处理。请求可能包括以下几种类型：

  1. 技术支持：处理技术相关的问题。
  2. 销售咨询：处理销售相关的问题。
  3. 投诉处理：处理用户投诉。
  4. 一般查询：处理一般性查询。

在这个场景中，用户请求的处理方式和顺序是未知的。我们可以使用责任链模式来动态地决定请求的处理者和处理顺序。

示例代码

以下是一个使用责任链模式实现在线客服系统的 Go 代码示例：

package mainimport ("fmt"
)// Request 是一个简单的请求结构体，包含请求类型和内容。
type Request struct {Type    stringContent string
}// Handler 是处理者接口，定义了处理请求的方法和设置下一个处理者的方法。
type Handler interface {SetNext(handler Handler) HandlerHandle(request *Request) bool
}// BaseHandler 是一个基础处理者结构体，实现了 Handler 接口。
type BaseHandler struct {next Handler
}// SetNext 设置下一个处理者。
func (h *BaseHandler) SetNext(handler Handler) Handler {h.next = handlerreturn handler
}// Handle 调用下一个处理者。
func (h *BaseHandler) Handle(request *Request) bool {if h.next != nil {return h.next.Handle(request)}return true
}// TechSupportHandler 是一个具体处理者，负责处理技术支持请求。
type TechSupportHandler struct {BaseHandler
}// Handle 处理技术支持请求。
func (h *TechSupportHandler) Handle(request *Request) bool {if request.Type == "tech_support" {fmt.Println("Handling tech support request:", request.Content)return true}return h.BaseHandler.Handle(request)
}// SalesHandler 是一个具体处理者，负责处理销售咨询请求。
type SalesHandler struct {BaseHandler
}// Handle 处理销售咨询请求。
func (h *SalesHandler) Handle(request *Request) bool {if request.Type == "sales" {fmt.Println("Handling sales request:", request.Content)return true}return h.BaseHandler.Handle(request)
}// ComplaintHandler 是一个具体处理者，负责处理投诉请求。
type ComplaintHandler struct {BaseHandler
}// Handle 处理投诉请求。
func (h *ComplaintHandler) Handle(request *Request) bool {if request.Type == "complaint" {fmt.Println("Handling complaint request:", request.Content)return true}return h.BaseHandler.Handle(request)
}// GeneralQueryHandler 是一个具体处理者，负责处理一般查询请求。
type GeneralQueryHandler struct {BaseHandler
}// Handle 处理一般查询请求。
func (h *GeneralQueryHandler) Handle(request *Request) bool {if request.Type == "general_query" {fmt.Println("Handling general query request:", request.Content)return true}return h.BaseHandler.Handle(request)
}func main() {// 创建请求requests := []*Request{{Type: "tech_support", Content: "How to reset my password?"},{Type: "sales", Content: "What is the price of product X?"},{Type: "complaint", Content: "I am not satisfied with the service."},{Type: "general_query", Content: "What are your working hours?"},}// 创建处理者techSupportHandler := &TechSupportHandler{}salesHandler := &SalesHandler{}complaintHandler := &ComplaintHandler{}generalQueryHandler := &GeneralQueryHandler{}// 动态设置责任链techSupportHandler.SetNext(salesHandler).SetNext(complaintHandler).SetNext(generalQueryHandler)// 处理请求for _, request := range requests {if techSupportHandler.Handle(request) {fmt.Println("Request processed successfully.")} else {fmt.Println("Request processing failed.")}}
}

示例场景：多个处理者按顺序执行——电子商务平台的订单处理系统

在这个系统中，订单需要经过多个步骤的处理，每个步骤都由一个处理者负责。处理步骤必须按特定顺序执行，以确保订单的正确处理。

场景描述
  1. 库存检查：在处理订单之前，系统需要检查所需商品的库存是否充足。如果库存不足，订单处理将被中止。
  2. 支付处理：如果库存充足，系统将处理支付事务。如果支付失败，订单处理将被中止。
  3. 订单确认：如果支付成功，系统将确认订单并通知用户。
  4. 发货安排：最后，系统安排发货，将订单信息传递给物流部门。
示例代码

以下是一个简单的 Go 代码示例，展示了如何使用责任链模式实现上述订单处理场景：

package mainimport ("fmt"
)// Handler 是处理者接口，定义了处理请求的方法和设置下一个处理者的方法。
type Handler interface {SetNext(handler Handler) HandlerHandle(order *Order) bool
}// Order 是一个简单的订单结构体，包含订单信息。
type Order struct {ItemID    stringQuantity  intPaymentOK bool
}// BaseHandler 是一个基础处理者结构体，实现了 Handler 接口。
type BaseHandler struct {next Handler
}// SetNext 设置下一个处理者。
func (h *BaseHandler) SetNext(handler Handler) Handler {h.next = handlerreturn handler
}// Handle 调用下一个处理者。
func (h *BaseHandler) Handle(order *Order) bool {if h.next != nil {return h.next.Handle(order)}return true
}// InventoryHandler 是一个具体处理者，负责检查库存。
type InventoryHandler struct {BaseHandler
}// Handle 检查库存是否充足。
func (h *InventoryHandler) Handle(order *Order) bool {if order.Quantity > 10 { // 假设库存不足的条件fmt.Println("Insufficient inventory!")return false}fmt.Println("Inventory is sufficient.")return h.BaseHandler.Handle(order)
}// PaymentHandler 是一个具体处理者，负责处理支付。
type PaymentHandler struct {BaseHandler
}// Handle 处理支付事务。
func (h *PaymentHandler) Handle(order *Order) bool {if !order.PaymentOK {fmt.Println("Payment failed!")return false}fmt.Println("Payment processed successfully.")return h.BaseHandler.Handle(order)
}// ConfirmationHandler 是一个具体处理者，负责确认订单。
type ConfirmationHandler struct {BaseHandler
}// Handle 确认订单。
func (h *ConfirmationHandler) Handle(order *Order) bool {fmt.Println("Order confirmed.")return h.BaseHandler.Handle(order)
}// ShippingHandler 是一个具体处理者，负责安排发货。
type ShippingHandler struct {BaseHandler
}// Handle 安排发货。
func (h *ShippingHandler) Handle(order *Order) bool {fmt.Println("Shipping arranged.")return h.BaseHandler.Handle(order)
}func main() {// 创建订单order := &Order{ItemID:    "12345",Quantity:  5,PaymentOK: true,}// 创建处理者inventoryHandler := &InventoryHandler{}paymentHandler := &PaymentHandler{}confirmationHandler := &ConfirmationHandler{}shippingHandler := &ShippingHandler{}// 设置责任链inventoryHandler.SetNext(paymentHandler).SetNext(confirmationHandler).SetNext(shippingHandler)// 处理订单if inventoryHandler.Handle(order) {fmt.Println("Order processed successfully.")} else {fmt.Println("Order processing failed.")}
}

动态改变处理者及其顺序

在某些应用场景中，处理请求的逻辑可能需要在运行时动态调整。例如，在一个复杂的电子商务平台中，订单处理流程可能会根据业务需求或用户类型进行动态调整。责任链模式可以通过动态插入、移除或重新排列处理者来实现这种灵活性。

示例代码

以下是一个使用责任链模式实现动态调整处理者顺序的 Go 代码示例：

package mainimport ("fmt"
)// Handler 是处理者接口，定义了处理请求的方法和设置下一个处理者的方法。
type Handler interface {SetNext(handler Handler) HandlerHandle(order *Order) bool
}// Order 是一个简单的订单结构体，包含订单信息。
type Order struct {ItemID    stringQuantity  intPaymentOK bool
}// BaseHandler 是一个基础处理者结构体，实现了 Handler 接口。
type BaseHandler struct {next Handler
}// SetNext 设置下一个处理者。
func (h *BaseHandler) SetNext(handler Handler) Handler {h.next = handlerreturn handler
}// Handle 调用下一个处理者。
func (h *BaseHandler) Handle(order *Order) bool {if h.next != nil {return h.next.Handle(order)}return true
}// InventoryHandler 是一个具体处理者，负责检查库存。
type InventoryHandler struct {BaseHandler
}// Handle 检查库存是否充足。
func (h *InventoryHandler) Handle(order *Order) bool {if order.Quantity > 10 { // 假设库存不足的条件fmt.Println("Insufficient inventory!")return false}fmt.Println("Inventory is sufficient.")return h.BaseHandler.Handle(order)
}// PaymentHandler 是一个具体处理者，负责处理支付。
type PaymentHandler struct {BaseHandler
}// Handle 处理支付事务。
func (h *PaymentHandler) Handle(order *Order) bool {if !order.PaymentOK {fmt.Println("Payment failed!")return false}fmt.Println("Payment processed successfully.")return h.BaseHandler.Handle(order)
}// ConfirmationHandler 是一个具体处理者，负责确认订单。
type ConfirmationHandler struct {BaseHandler
}// Handle 确认订单。
func (h *ConfirmationHandler) Handle(order *Order) bool {fmt.Println("Order confirmed.")return h.BaseHandler.Handle(order)
}// ShippingHandler 是一个具体处理者，负责安排发货。
type ShippingHandler struct {BaseHandler
}// Handle 安排发货。
func (h *ShippingHandler) Handle(order *Order) bool {fmt.Println("Shipping arranged.")return h.BaseHandler.Handle(order)
}// CouponHandler 是一个具体处理者，负责验证优惠券。
type CouponHandler struct {BaseHandler
}// Handle 验证优惠券。
func (h *CouponHandler) Handle(order *Order) bool {fmt.Println("Coupon validated.")return h.BaseHandler.Handle(order)
}func main() {// 创建订单order := &Order{ItemID:    "12345",Quantity:  5,PaymentOK: true,}// 创建处理者inventoryHandler := &InventoryHandler{}paymentHandler := &PaymentHandler{}confirmationHandler := &ConfirmationHandler{}shippingHandler := &ShippingHandler{}couponHandler := &CouponHandler{}// 动态设置责任链// 例如：在促销活动中插入优惠券验证步骤inventoryHandler.SetNext(couponHandler).SetNext(paymentHandler).SetNext(confirmationHandler).SetNext(shippingHandler)// 处理订单if inventoryHandler.Handle(order) {fmt.Println("Order processed successfully.")} else {fmt.Println("Order processing failed.")}// 动态移除处理者// 例如：移除发货安排步骤inventoryHandler.SetNext(paymentHandler).SetNext(confirmationHandler)// 处理订单if inventoryHandler.Handle(order) {fmt.Println("Order processed successfully without shipping.")} else {fmt.Println("Order processing failed.")}
}

通用责任链实现

为了实现更通用的责任链模式，我们可以设计一个框架，使得责任链的构建和管理更加灵活。以下是一个更通用的责任链实现，支持通过任意数据源动态配置责任链：

package mainimport ("fmt"
)// Request 是一个简单的请求结构体，包含请求类型和内容。
type Request struct {Type    stringContent string
}// Handler 是处理者接口，定义了处理请求的方法和设置下一个处理者的方法。
type Handler interface {SetNext(handler Handler) HandlerHandle(request *Request) bool
}// BaseHandler 是一个基础处理者结构体，实现了 Handler 接口。
type BaseHandler struct {next Handler
}// SetNext 设置下一个处理者。
func (h *BaseHandler) SetNext(handler Handler) Handler {h.next = handlerreturn handler
}// Handle 调用下一个处理者。
func (h *BaseHandler) Handle(request *Request) bool {if h.next != nil {return h.next.Handle(request)}return true
}// TechSupportHandler 是一个具体处理者，负责处理技术支持请求。
type TechSupportHandler struct {BaseHandler
}// Handle 处理技术支持请求。
func (h *TechSupportHandler) Handle(request *Request) bool {if request.Type == "tech_support" {fmt.Println("Handling tech support request:", request.Content)return true}return h.BaseHandler.Handle(request)
}// SalesHandler 是一个具体处理者，负责处理销售咨询请求。
type SalesHandler struct {BaseHandler
}// Handle 处理销售咨询请求。
func (h *SalesHandler) Handle(request *Request) bool {if request.Type == "sales" {fmt.Println("Handling sales request:", request.Content)return true}return h.BaseHandler.Handle(request)
}// ComplaintHandler 是一个具体处理者，负责处理投诉请求。
type ComplaintHandler struct {BaseHandler
}// Handle 处理投诉请求。
func (h *ComplaintHandler) Handle(request *Request) bool {if request.Type == "complaint" {fmt.Println("Handling complaint request:", request.Content)return true}return h.BaseHandler.Handle(request)
}// GeneralQueryHandler 是一个具体处理者，负责处理一般查询请求。
type GeneralQueryHandler struct {BaseHandler
}// Handle 处理一般查询请求。
func (h *GeneralQueryHandler) Handle(request *Request) bool {if request.Type == "general_query" {fmt.Println("Handling general query request:", request.Content)return true}return h.BaseHandler.Handle(request)
}// HandlerFactory 是一个工厂方法，用于根据名称创建处理者实例。
func HandlerFactory(name string) Handler {switch name {case "tech_support":return &TechSupportHandler{}case "sales":return &SalesHandler{}case "complaint":return &ComplaintHandler{}case "general_query":return &GeneralQueryHandler{}default:return nil}
}// BuildChain 根据处理者名称列表构建责任链。
func BuildChain(handlerNames []string) Handler {var firstHandler Handlervar currentHandler Handlerfor _, name := range handlerNames {handler := HandlerFactory(name)if handler == nil {fmt.Println("Unknown handler:", name)continue}if firstHandler == nil {firstHandler = handlercurrentHandler = handler} else {currentHandler = currentHandler.SetNext(handler)}}return firstHandler
}func main() {// 创建请求requests := []*Request{{Type: "tech_support", Content: "How to reset my password?"},{Type: "sales", Content: "What is the price of product X?"},{Type: "complaint", Content: "I am not satisfied with the service."},{Type: "general_query", Content: "What are your working hours?"},}// 假设从某个数据源（如配置文件、数据库、环境变量）获取处理者顺序handlerNames := []string{"tech_support", "sales", "complaint", "general_query"}// 构建责任链firstHandler := BuildChain(handlerNames)// 处理请求for _, request := range requests {if firstHandler.Handle(request) {fmt.Println("Request processed successfully.")} else {fmt.Println("Request processing failed.")}}
}

代码说明

  1. Handler 接口和 BaseHandler：定义了处理者接口和基础处理者结构体。
  2. 具体处理者：实现了不同类型请求的处理者。
  3. HandlerFactory：工厂方法，根据名称创建处理者实例。
  4. BuildChain：根据处理者名称列表构建责任链。
  5. 数据源：在 main 函数中，假设从某个数据源（如配置文件、数据库、环境变量）获取处理者顺序。

通过这种设计，责任链的构建可以从外部数据源获取配置，实现动态调整而无需修改代码。你可以根据具体需求选择合适的数据源和配置管理方式。

http://www.dtcms.com/a/264148.html

相关文章：

  • 电脑系统重装有什么用？
  • 动手实践：如何提取Python代码中的字符串变量的值
  • AI问答-vue3：如何选择使用reactive或ref
  • 【HarmonyOS】鸿蒙使用仓颉编程入门
  • 基于Halcon平台的常规OCR与深度OCR性能对比分析
  • 设计模式(行为型)-访问者模式
  • python训练day46 通道注意力
  • 【kernel8】spi协议，验证，模型，设备树处理，spidev，衍生协议
  • AI人工客服实战指南：基于大模型构建生产级智能对话系统
  • Hadoop、Spark、Flink 三大大数据处理框架的能力与应用场景
  • ESP32-S3开发板深度评测：AI语音识别与图像处理全面解析
  • C++ 第四阶段 STL 容器 - 第九讲：详解 std::map 与 std::unordered_map —— 关联容器的深度解析
  • Springboot整合高德地图
  • NeurIPS-2023《A Definition of Continual Reinforcement Learning》
  • 基于GD32 MCU的IAP差分升级方案
  • 迎战 AI Overviews：SEO 不被淘汰的实战策略
  • SpringBoot全局异常详解
  • Electron 应用打包与分发：从开发到交付的完整指南
  • 多容器应用与编排——AI教你学Docker
  • Java-String类静态成员方法深度解析
  • AR 地产互动沙盘：为地产沙盘带来变革​
  • OpenCV-Python Tutorial : A Candy from Official Main Page（二）
  • 设备管理的重要性：企业数字化浪潮下的核心命题
  • 企业上网行为管理：零信任安全产品的对比分析
  • Linux基本命令篇 —— grep命令
  • 防 XSS和CSRF 过滤器（Filter）
  • go语言安装达梦数据完整教程
  • JVM 中的垃圾回收算法及垃圾回收器详解
  • 【仿muduo库实现并发服务器】Connection模块
  • CentOS 8中 更新或下载时报错：为仓库 ‘appstream‘ 下载元数据失败 : Cannot prepare internal