Go 语言中动态绑定方法与函数字段的实践

package main

import "fmt"

// Foo 是一个简单的结构体
type Foo struct{}

// Bar 是 Foo 类型的一个方法，接收者是 *Foo
func (f *Foo) Bar() bool {
    fmt.Println("Foo.Bar() called")
    return true
}

func main() {
    var f Foo
    // 直接通过结构体实例调用方法，这是 Go 中最常见且推荐的做法
    fmt.Println(f.Bar()) // 输出: Foo.Bar() called\ntrue
}

package main

import (
    "fmt"
    "net/http"
)

// MatcherFunc 定义了一个函数类型，用于路由匹配
type MatcherFunc func(route *Route, r *http.Request) bool

// Route 结构体包含一个可自定义的匹配函数
type Route struct {
    Path    string
    Matcher MatcherFunc // 这是一个函数类型的字段
}

// NewRoute 创建并返回一个 Route 实例
func NewRoute(path string) *Route {
    return &Route{Path: path}
}

// DefaultRouteMatcher 是一个默认的匹配函数
func DefaultRouteMatcher(route *Route, r *http.Request) bool {
    fmt.Printf("Default Matcher: Matching route %s with request path %s\n", route.Path, r.URL.Path)
    return route.Path == r.URL.Path
}

func main() {
    // 创建一个路由实例
    route1 := NewRoute("/users")
    // 如果不设置，Matcher 字段默认为 nil

    // 假设在某个处理逻辑中，我们检查并设置默认匹配器
    if route1.Matcher == nil {
        route1.Matcher = DefaultRouteMatcher
    }

    // 模拟一个 HTTP 请求
    req1, _ := http.NewRequest("GET", "/users", nil)
    req2, _ := http.NewRequest("GET", "/products", nil)

    // 调用匹配器进行匹配
    fmt.Println("Route1 matches req1:", route1.Matcher(route1, req1)) // 输出: Default Matcher: Matching route /users with request path /users\nRoute1 matches req1: true
    fmt.Println("Route1 matches req2:", route1.Matcher(route1, req2)) // 输出: Default Matcher: Matching route /users with request path /products\nRoute1 matches req2: false

    // 创建另一个路由，并设置自定义匹配器
    route2 := NewRoute("/items")
    route2.Matcher = func(route *Route, r *http.Request) bool {
        fmt.Printf("Custom Matcher: Matching route %s (always true for demo)\n", route.Path)
        return true // 示例：总是匹配成功
    }
    req3, _ := http.NewRequest("GET", "/any", nil)
    fmt.Println("Route2 matches req3:", route2.Matcher(route2, req3)) // 输出: Custom Matcher: Matching route /items (always true for demo)\nRoute2 matches req3: true
}

package main

import "fmt"

// BarFunc 定义了一个函数类型，它接受一个 *Foo 实例作为参数
type BarFunc func(foo *Foo) bool

// Foo 结构体包含一个 BarFunc 类型的字段
type Foo struct {
    CustomBar BarFunc // 可自定义的函数字段
}

// Bar 是 Foo 类型的一个方法，它包装了 CustomBar 字段
// 外部调用者无需关心 CustomBar 的参数，它会自动将当前 Foo 实例传递过去
func (f *Foo) Bar() bool {
    // 在调用 CustomBar 之前，可以进行 nil 检查，或者设置默认行为
    if f.CustomBar == nil {
        fmt.Println("No custom BarFunc set, using default behavior.")
        return false // 默认行为
    }
    fmt.Println("Calling CustomBar via Foo.Bar() method.")
    return f.CustomBar(f) // 将当前 Foo 实例 f 传递给 CustomBar
}

// UserBarFunc 是一个符合 BarFunc 签名的函数
func UserBarFunc(foo *Foo) bool {
    fmt.Printf("UserBarFunc called for Foo instance: %+v\n", foo)
    return true
}

func main() {
    var f1 Foo
    // 此时 f1.CustomBar 是 nil
    fmt.Println("f1.Bar() result:", f1.Bar()) // 输出: No custom BarFunc set, using default behavior.\nf1.Bar() result: false

    var f2 Foo
    // 将 UserBarFunc 赋值给 f2 的 CustomBar 字段
    f2.CustomBar = UserBarFunc
    // 通过 f2.Bar() 方法调用 CustomBar，感觉就像调用一个“绑定”的方法
    fmt.Println("f2.Bar() result:", f2.Bar()) // 输出: Calling CustomBar via Foo.Bar() method.\nUserBarFunc called for Foo instance: &{CustomBar:0x...}\nf2.Bar() result: true

    var f3 Foo
    // 也可以使用匿名函数作为 CustomBar
    f3.CustomBar = func(foo *Foo) bool {
        fmt.Printf("Anonymous BarFunc called for Foo instance: %+v\n", foo)
        return false
    }
    fmt.Println("f3.Bar() result:", f3.Bar()) // 输出: Calling CustomBar via Foo.Bar() method.\nAnonymous BarFunc called for Foo instance: &{CustomBar:0x...}\nf3.Bar() result: false
}