go: Chain of Responsibility Pattern

项目结构：

Go 复制代码

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Chain of Responsibility Pattern  责任链模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/21 20:48
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : repair.go
*/
package domain
 
// 维修类型常量（严格定义业务等级）
const (
    RepairTypeSimple  = "简单维修" // 初级技师
    RepairTypeComplex = "复杂维修" // 高级技师
    RepairTypeMajor   = "重大维修" // 维修主管
)
 
// RepairRequest 维修请求实体（企业级标准：字段完整、不可变）
type RepairRequest struct {
    CustomerName string // 客户姓名
    RepairType   string // 维修类型
    Content      string // 维修详情
}

Go 复制代码

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Chain of Responsibility Pattern  责任链模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/21 20:48
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : base.go
*/
package handler
 
import "godesginpattern/chain/domain"
 
// RepairHandler 责任链核心接口（企业级标准：契约定义）
type RepairHandler interface {
    SetNext(handler RepairHandler) RepairHandler
    HandleRequest(req *domain.RepairRequest) bool
}
 
// BaseRepairHandler 基础处理者（封装Next指针，所有处理者继承）
type BaseRepairHandler struct {
    next RepairHandler
}
 
// SetNext 链式设置下一级处理者
func (b *BaseRepairHandler) SetNext(handler RepairHandler) RepairHandler {
    b.next = handler
    return handler
}
 
// nextHandle 公共方法：传递给下一级处理
func (b *BaseRepairHandler) nextHandle(req *domain.RepairRequest) bool {
    if b.next != nil {
        return b.next.HandleRequest(req)
    }
    return false
}
 
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Chain of Responsibility Pattern  责任链模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/21 20:49
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : junior.go
*/
package handler
 
import (
    "fmt"
    "godesginpattern/chain/domain"
)
 
// JuniorTechnician 初级珠宝技师：仅处理简单维修
type JuniorTechnician struct {
    BaseRepairHandler
}
 
func (j *JuniorTechnician) HandleRequest(req *domain.RepairRequest) bool {
    if req.RepairType == domain.RepairTypeSimple {
        fmt.Printf("【初级技师】处理客户%s的请求：%s（维修内容：%s）✅\n",
            req.CustomerName, req.RepairType, req.Content)
        return true
    }
    // 无法处理，交给下一级
    return j.nextHandle(req)
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Chain of Responsibility Pattern  责任链模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/21 20:49
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : senior.go
*/
package handler
 
import (
    "fmt"
    "godesginpattern/chain/domain"
)
 
// SeniorTechnician 高级珠宝技师：仅处理复杂维修
type SeniorTechnician struct {
    BaseRepairHandler
}
 
func (s *SeniorTechnician) HandleRequest(req *domain.RepairRequest) bool {
    if req.RepairType == domain.RepairTypeComplex {
        fmt.Printf("【高级技师】处理客户%s的请求：%s（维修内容：%s）✅\n",
            req.CustomerName, req.RepairType, req.Content)
        return true
    }
    return s.nextHandle(req)
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Chain of Responsibility Pattern  责任链模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/21 20:49
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : supervisor.go
*/
package handler
 
import (
    "fmt"
    "godesginpattern/chain/domain"
)
 
// RepairSupervisor 维修主管：仅处理重大维修
type RepairSupervisor struct {
    BaseRepairHandler
}
 
func (r *RepairSupervisor) HandleRequest(req *domain.RepairRequest) bool {
    if req.RepairType == domain.RepairTypeMajor {
        fmt.Printf("【维修主管】处理客户%s的请求：%s（维修内容：%s）✅\n",
            req.CustomerName, req.RepairType, req.Content)
        return true
    }
    return r.nextHandle(req)
}

Go 复制代码

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Chain of Responsibility Pattern  责任链模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/21 20:49
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : repair_service.go
*/
package service
 
import (
    "fmt"
    "godesginpattern/chain/domain"
    "godesginpattern/chain/handler"
)
 
// RepairService 维修服务（企业级：对外唯一入口）
type RepairService struct {
    chainHandler handler.RepairHandler // 责任链入口
}
 
// NewRepairService 创建服务（初始化责任链）
func NewRepairService() *RepairService {
    // 1. 创建处理者
    junior := &handler.JuniorTechnician{}
    senior := &handler.SeniorTechnician{}
    supervisor := &handler.RepairSupervisor{}
 
    // 2. 构建标准责任链：初级 → 高级 → 主管
    junior.SetNext(senior).SetNext(supervisor)
 
    return &RepairService{
        chainHandler: junior,
    }
}
 
// SubmitRepair 提交维修请求（对外服务方法）
func (s *RepairService) SubmitRepair(req *domain.RepairRequest) {
    fmt.Println("===== 客户提交维修请求 =====")
    success := s.chainHandler.HandleRequest(req)
    if !success {
        fmt.Printf("❌ 无法处理客户%s的请求：%s（维修内容：%s）\n",
            req.CustomerName, req.RepairType, req.Content)
    }
    fmt.Println()
}

调用：：

Go 复制代码

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Chain of Responsibility Pattern  责任链模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/21 20:51
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : chainbll.go
 
Chain/
├── domain/          # 领域实体层（核心数据模型）
│   └── repair.go    # 维修请求实体、常量定义
├── handler/         # 责任链处理层（接口+实现）
│   ├── base.go      # 基础处理者（公共逻辑）
│   ├── junior.go    # 初级技师
│   ├── senior.go    # 高级技师
│   └── supervisor.go# 维修主管
├── service/         # 业务服务层（责任链构建+调度）
│   └── repair_service.go
├── go.mod           # Go 模块文件
└── main.go          # 程序入口（测试用例）
*/
package bll
 
import (
    "godesginpattern/chain/domain"
    "godesginpattern/chain/service"
)
 
func ChainMain() {
    // 初始化维修服务
    repairService := service.NewRepairService()
 
    // 测试1：简单维修
    req1 := &domain.RepairRequest{
        CustomerName: "张先生",
        RepairType:   domain.RepairTypeSimple,
        Content:      "戒指清洗+抛光",
    }
    repairService.SubmitRepair(req1)
 
    // 测试2：复杂维修
    req2 := &domain.RepairRequest{
        CustomerName: "李女士",
        RepairType:   domain.RepairTypeComplex,
        Content:      "项链宝石松动加固",
    }
    repairService.SubmitRepair(req2)
 
    // 测试3：重大维修
    req3 := &domain.RepairRequest{
        CustomerName: "王先生",
        RepairType:   domain.RepairTypeMajor,
        Content:      "钻戒主石更换+戒托重构",
    }
    repairService.SubmitRepair(req3)
 
    // 测试4：无法处理的请求
    req4 := &domain.RepairRequest{
        CustomerName: "陈女士",
        RepairType:   "古董珠宝修复",
        Content:      "百年翡翠手镯断裂拼接",
    }
    repairService.SubmitRepair(req4)
}

输出：