责任链模式 Go 语言实战
责任链模式（Chain of Responsibility）
责任链模式是一种行为设计模式，它允许将请求沿着处理者链进行传递，直到有一个处理者能够处理它。这个模式的主要目的是解耦请求的发送者和接收者，使得多个对象都有机会处理这个请求，而不需要明确指定哪个对象处理请求。
责任链模式的结构
- 处理者接口（Handler）：定义一个处理请求的接口，通常包括一个处理请求的方法和一个设置下一个处理者的方法。
- 具体处理者（Concrete Handler）：实现处理者接口的类。每个具体处理者都包含对下一个处理者的引用。如果当前处理者能够处理请求，它就会处理；否则，它会将请求传递给下一个处理者。
- 客户端（Client）：负责创建处理者链并将请求发送到链的起始处理者。
责任链模式的适用场景
- 请求的处理方式和顺序未知：当程序需要使用不同方式处理不同种类的请求，且请求类型和顺序预先未知时，责任链模式非常适用。
- 多个处理者按顺序执行：当必须按顺序执行多个处理者时，责任链模式可以确保所有请求严格按照链上的顺序通过处理者。
- 动态改变处理者及其顺序：可以在运行时动态地插入和移除处理者，或者改变其顺序。
责任链模式的优点
- 降低耦合度：请求的发送者和接收者解耦。
- 增强灵活性：可以在运行时动态地添加、删除或重新排列处理者。
- 责任分担：多个处理者可以分担处理请求的责任。
责任链模式的缺点
- 请求处理不保证：如果链上的所有处理者都不能处理请求，可能会导致请求未被处理。
- 调试困难：由于请求沿着链传递，可能会导致调试和跟踪请求处理过程变得复杂。
示例场景：请求的处理方式和顺序未知——在线客服系统
假设我们有一个在线客服系统，用户的请求需要根据不同的情况进行处理。请求可能包括以下几种类型：
- 技术支持：处理技术相关的问题。
- 销售咨询：处理销售相关的问题。
- 投诉处理：处理用户投诉。
- 一般查询：处理一般性查询。
在这个场景中，用户请求的处理方式和顺序是未知的。我们可以使用责任链模式来动态地决定请求的处理者和处理顺序。
示例代码
以下是一个使用责任链模式实现在线客服系统的 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.")
}
}
}
示例场景：多个处理者按顺序执行——电子商务平台的订单处理系统
在这个系统中，订单需要经过多个步骤的处理，每个步骤都由一个处理者负责。处理步骤必须按特定顺序执行，以确保订单的正确处理。
场景描述
- 库存检查：在处理订单之前，系统需要检查所需商品的库存是否充足。如果库存不足，订单处理将被中止。
- 支付处理：如果库存充足，系统将处理支付事务。如果支付失败，订单处理将被中止。
- 订单确认：如果支付成功，系统将确认订单并通知用户。
- 发货安排：最后，系统安排发货，将订单信息传递给物流部门。
示例代码
以下是一个简单的 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.")
}
}
}
代码说明
- Handler 接口和 BaseHandler：定义了处理者接口和基础处理者结构体。
- 具体处理者：实现了不同类型请求的处理者。
- HandlerFactory：工厂方法，根据名称创建处理者实例。
- BuildChain：根据处理者名称列表构建责任链。
- 数据源：在
main函数中，假设从某个数据源（如配置文件、数据库、环境变量）获取处理者顺序。
通过这种设计，责任链的构建可以从外部数据源获取配置，实现动态调整而无需修改代码。你可以根据具体需求选择合适的数据源和配置管理方式。