Golang责任链模式如何构建 演示Golang责任链模式的请求处理流程

package main

import "fmt"

// Handler 接口定义了处理请求的方法
type Handler interface {
    SetNext(Handler) Handler
    Handle(request string) string
}

// AbstractHandler 抽象处理器，实现了 SetNext 方法
type AbstractHandler struct {
    next Handler
}

func (h *AbstractHandler) SetNext(next Handler) Handler {
    h.next = next
    return next
}

// ConcreteHandlerA 具体处理器 A
type ConcreteHandlerA struct {
    AbstractHandler
}

func (h *ConcreteHandlerA) Handle(request string) string {
    if request == "A" {
        return "Handler A 处理了请求"
    } else if h.next != nil {
        return h.next.Handle(request)
    }
    return "无法处理请求"
}

// ConcreteHandlerB 具体处理器 B
type ConcreteHandlerB struct {
    AbstractHandler
}

func (h *ConcreteHandlerB) Handle(request string) string {
    if request == "B" {
        return "Handler B 处理了请求"
    } else if h.next != nil {
        return h.next.Handle(request)
    }
    return "无法处理请求"
}

// ConcreteHandlerC 具体处理器 C
type ConcreteHandlerC struct {
    AbstractHandler
}

func (h *ConcreteHandlerC) Handle(request string) string {
    if request == "C" {
        return "Handler C 处理了请求"
    } else if h.next != nil {
        return h.next.Handle(request)
    }
    return "无法处理请求"
}

func main() {
    handlerA := &ConcreteHandlerA{}
    handlerB := &ConcreteHandlerB{}
    handlerC := &ConcreteHandlerC{}

    // 构建责任链
    handlerA.SetNext(handlerB).SetNext(handlerC)

    // 发送请求
    fmt.Println(handlerA.Handle("A")) // 输出: Handler A 处理了请求
    fmt.Println(handlerA.Handle("B")) // 输出: Handler B 处理了请求
    fmt.Println(handlerA.Handle("C")) // 输出: Handler C 处理了请求
    fmt.Println(handlerA.Handle("D")) // 输出: 无法处理请求
}

package main

import (
    "fmt"
    "net/http"
)

// HTTPHandler 接口
type HTTPHandler interface {
    SetNext(HTTPHandler) HTTPHandler
    ServeHTTP(http.ResponseWriter, *http.Request)
}

// AbstractHTTPHandler 抽象处理器
type AbstractHTTPHandler struct {
    next HTTPHandler
}

func (h *AbstractHTTPHandler) SetNext(next HTTPHandler) HTTPHandler {
    h.next = next
    return next
}

// ConcreteHTTPHandlerA 具体处理器 A
type ConcreteHTTPHandlerA struct {
    AbstractHTTPHandler
}

func (h *ConcreteHTTPHandlerA) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/a" {
        fmt.Fprintln(w, "Handler A 处理了请求")
        return
    }
    if h.next != nil {
        h.next.ServeHTTP(w, r)
        return
    }
    http.NotFound(w, r)
}

// ConcreteHTTPHandlerB 具体处理器 B
type ConcreteHTTPHandlerB struct {
    AbstractHTTPHandler
}

func (h *ConcreteHTTPHandlerB) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/b" {
        fmt.Fprintln(w, "Handler B 处理了请求")
        return
    }
    if h.next != nil {
        h.next.ServeHTTP(w, r)
        return
    }
    http.NotFound(w, r)
}

func main() {
    handlerA := &ConcreteHTTPHandlerA{}
    handlerB := &ConcreteHTTPHandlerB{}

    // 构建责任链
    handlerA.SetNext(handlerB)

    // 创建 HTTP 服务
    http.Handle("/", handlerA)
    http.ListenAndServe(":8080", nil)
}