Golang责任链模式怎么做 处理请求的链式传递实现

package main

import (
    "fmt"
    "log"
)

// Request 是我们要在链中传递的请求对象
type Request struct {
    Type    string
    Payload string
    Handled bool // 标记请求是否已被处理
}

// Handler 接口定义了处理者必须实现的方法
type Handler interface {
    SetNext(handler Handler) // 设置下一个处理者
    Handle(req *Request)     // 处理请求
}

// BaseHandler 提供了责任链的基础实现，可以嵌入到具体的处理者中
type BaseHandler struct {
    next Handler
}

// SetNext 设置链中的下一个处理者
func (b *BaseHandler) SetNext(handler Handler) {
    b.next = handler
}

// PassToNext 如果有下一个处理者，则将请求传递下去
func (b *BaseHandler) PassToNext(req *Request) {
    if b.next != nil {
        b.next.Handle(req)
    } else {
        // 如果没有下一个处理者，并且请求未被处理，可以记录或抛出错误
        if !req.Handled {
            log.Printf("Warning: Request type '%s' not handled by any handler in the chain.", req.Type)
        }
    }
}

// --- 具体处理者实现 ---

// AuthenticationHandler 认证处理者
type AuthenticationHandler struct {
    BaseHandler
}

func (h *AuthenticationHandler) Handle(req *Request) {
    if req.Type == "auth" {
        fmt.Printf("AuthenticationHandler: Handling authentication request for payload '%s'\n", req.Payload)
        req.Handled = true
    } else {
        fmt.Printf("AuthenticationHandler: Cannot handle type '%s', passing to next.\n", req.Type)
        h.PassToNext(req)
    }
}

// ValidationHandler 校验处理者
type ValidationHandler struct {
    BaseHandler
}

func (h *ValidationHandler) Handle(req *Request) {
    if req.Type == "validate" {
        fmt.Printf("ValidationHandler: Handling validation request for payload '%s'\n", req.Payload)
        req.Handled = true
    } else {
        fmt.Printf("ValidationHandler: Cannot handle type '%s', passing to next.\n", req.Type)
        h.PassToNext(req)
    }
}

// LoggingHandler 日志处理者 (通常在链的末端或作为通用前置处理)
type LoggingHandler struct {
    BaseHandler
}

func (h *LoggingHandler) Handle(req *Request) {
    fmt.Printf("LoggingHandler: Logging request type '%s' with payload '%s'\n", req.Type, req.Payload)
    // 日志处理者通常不会“消费”请求，而是继续传递
    h.PassToNext(req)
}

// DefaultHandler 默认处理者，如果前面都没有处理，它来兜底
type DefaultHandler struct {
    BaseHandler
}

func (h *DefaultHandler) Handle(req *Request) {
    if !req.Handled { // 只有在前面都没处理的情况下才执行
        fmt.Printf("DefaultHandler: No specific handler found for type '%s', handling as default.\n", req.Type)
        req.Handled = true
    }
    // DefaultHandler 是链的末端，通常不会再传递
}


func main() {
    // 构造责任链
    authHandler := &AuthenticationHandler{}
    validationHandler := &ValidationHandler{}
    loggingHandler := &LoggingHandler{}
    defaultHandler := &DefaultHandler{}

    loggingHandler.SetNext(authHandler)
    authHandler.SetNext(validationHandler)
    validationHandler.SetNext(defaultHandler) // 确保链有终点

    fmt.Println("--- Sending Auth Request ---")
    req1 := &Request{Type: "auth", Payload: "user:pass"}
    loggingHandler.Handle(req1) // 从链的起点开始处理

    fmt.Println("\n--- Sending Validation Request ---")
    req2 := &Request{Type: "validate", Payload: "data:123"}
    loggingHandler.Handle(req2)

    fmt.Println("\n--- Sending Unknown Request ---")
    req3 := &Request{Type: "unknown", Payload: "some_data"}
    loggingHandler.Handle(req3)

    fmt.Println("\n--- Sending Another Auth Request (demonstrating early exit) ---")
    req4 := &Request{Type: "auth", Payload: "admin:secret"}
    loggingHandler.Handle(req4)
}

BaseHandler

PassToNext

Handler

BaseHandler

SetNext

PassToNext

if-else if

Handle

Request

Handled

Error