责任链模式 Go 语言实战

发布于：2025-07-02 ⋅ 阅读:(15) ⋅ 点赞:(0)

责任链模式（Chain of Responsibility）

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

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

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

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

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

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

示例代码

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

package main

import (
	"fmt"
)

// Request 是一个简单的请求结构体，包含请求类型和内容。
type Request struct {
	Type    string
	Content string
}

// Handler 是处理者接口，定义了处理请求的方法和设置下一个处理者的方法。
type Handler interface {
	SetNext(handler Handler) Handler
	Handle(request *Request) bool
}

// BaseHandler 是一个基础处理者结构体，实现了 Handler 接口。
type BaseHandler struct {
	next Handler
}

// SetNext 设置下一个处理者。
func (h *BaseHandler) SetNext(handler Handler) Handler {
	h.next = handler
	return 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 main

import (
	"fmt"
)

// Handler 是处理者接口，定义了处理请求的方法和设置下一个处理者的方法。
type Handler interface {
	SetNext(handler Handler) Handler
	Handle(order *Order) bool
}

// Order 是一个简单的订单结构体，包含订单信息。
type Order struct {
	ItemID    string
	Quantity  int
	PaymentOK bool
}

// BaseHandler 是一个基础处理者结构体，实现了 Handler 接口。
type BaseHandler struct {
	next Handler
}

// SetNext 设置下一个处理者。
func (h *BaseHandler) SetNext(handler Handler) Handler {
	h.next = handler
	return 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 main

import (
	"fmt"
)

// Handler 是处理者接口，定义了处理请求的方法和设置下一个处理者的方法。
type Handler interface {
	SetNext(handler Handler) Handler
	Handle(order *Order) bool
}

// Order 是一个简单的订单结构体，包含订单信息。
type Order struct {
	ItemID    string
	Quantity  int
	PaymentOK bool
}

// BaseHandler 是一个基础处理者结构体，实现了 Handler 接口。
type BaseHandler struct {
	next Handler
}

// SetNext 设置下一个处理者。
func (h *BaseHandler) SetNext(handler Handler) Handler {
	h.next = handler
	return 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 main

import (
	"fmt"
)

// Request 是一个简单的请求结构体，包含请求类型和内容。
type Request struct {
	Type    string
	Content string
}

// Handler 是处理者接口，定义了处理请求的方法和设置下一个处理者的方法。
type Handler interface {
	SetNext(handler Handler) Handler
	Handle(request *Request) bool
}

// BaseHandler 是一个基础处理者结构体，实现了 Handler 接口。
type BaseHandler struct {
	next Handler
}

// SetNext 设置下一个处理者。
func (h *BaseHandler) SetNext(handler Handler) Handler {
	h.next = handler
	return 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 Handler
	var currentHandler Handler

	for _, name := range handlerNames {
		handler := HandlerFactory(name)
		if handler == nil {
			fmt.Println("Unknown handler:", name)
			continue
		}
		if firstHandler == nil {
			firstHandler = handler
			currentHandler = 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 函数中，假设从某个数据源（如配置文件、数据库、环境变量）获取处理者顺序。

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

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布