Go语言中组件发现的替代模式：规避反射的局限性

import (
    _ "github.com/lib/pq" // 导入驱动包，但未直接使用其任何导出符号
    "database/sql"
)

func main() {
    db, err := sql.Open("postgres", "dbname=test user=test password=test host=localhost sslmode=disable")
    if err != nil {
        // 处理错误
    }
    defer db.Close()
    // ... 使用db进行数据库操作
}

// github.com/lib/pq/driver.go (简化版)
package pq

import (
    "database/sql"
    "database/sql/driver" // 导入驱动接口
)

// drv 实现了 database/sql/driver.Driver 接口
type drv struct{}

// Open 方法用于打开数据库连接
func (d *drv) Open(name string) (driver.Conn, error) {
    // 实际的连接逻辑
    return &conn{}, nil
}

// init 函数在包被导入时自动执行
func init() {
    // 将自身注册到 database/sql 包中，使用 "postgres" 作为驱动名
    sql.Register("postgres", &drv{})
}

// mao/router.go
package mao

import (
    "fmt"
    "net/http" // 通常路由会处理HTTP请求
)

// Route 定义了路由的属性
type Route struct {
    Name    string
    Method  string // HTTP方法，如"GET", "POST"
    Path    string // URL路径
    Handler http.HandlerFunc // 路由处理器函数
}

// 内部的路由注册表
var registeredRoutes = make(map[string]Route)

// RegisterRoute 允许外部包注册路由
func RegisterRoute(route Route) {
    if _, exists := registeredRoutes[route.Name]; exists {
        panic(fmt.Sprintf("Route with name '%s' already registered", route.Name))
    }
    registeredRoutes[route.Name] = route
    fmt.Printf("[Mao Router] Registered route: %s %s (Name: %s)\n", route.Method, route.Path, route.Name)
}

// GetRoutes 返回所有已注册的路由，供框架路由器使用
func GetRoutes() map[string]Route {
    return registeredRoutes
}

// Controller 是一个基础控制器结构体，可以被其他控制器嵌入
type Controller struct{}

// myapp/controllers/default_controller.go
package controllers

import (
    "fmt"
    "net/http"
    "your_project/mao" // 假设mao是你的框架包路径
)

// DefaultController 实现了具体的业务逻辑
type DefaultController struct {
    mao.Controller // 嵌入mao的基础控制器
}

// IndexHandler 处理根路径请求
func (d *DefaultController) IndexHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from DefaultController.Index! Path: %s", r.URL.Path)
}

// AboutHandler 处理/about路径请求
func (d *DefaultController) AboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "This is the About page!")
}

// init 函数在包被导入时自动执行，用于注册路由
func init() {
    // 实例化一个控制器，并注册其方法作为处理器
    defaultCtrl := &DefaultController{}

    mao.RegisterRoute(mao.Route{
        Name:    "default_index",
        Method:  http.MethodGet,
        Path:    "/",
        Handler: defaultCtrl.IndexHandler,
    })

    mao.RegisterRoute(mao.Route{
        Name:    "default_about",
        Method:  http.MethodGet,
        Path:    "/about",
        Handler: defaultCtrl.AboutHandler,
    })

    // 也可以注册匿名函数作为处理器
    mao.RegisterRoute(mao.Route{
        Name:    "default_ping",
        Method:  http.MethodGet,
        Path:    "/ping",
        Handler: func(w http.ResponseWriter, r *http.Request) {
            fmt.Fprintf(w, "pong")
        },
    })
}

// main.go
package main

import (
    "fmt"
    "log"
    "net/http"
    "your_project/mao"
    _ "your_project/myapp/controllers" // 关键：导入控制器包以触发其init()函数
)

func main() {
    fmt.Println("Application starting...")

    // 从mao框架获取所有已注册的路由
    routes := mao.GetRoutes()

    // 创建一个HTTP多路复用器
    mux := http.NewServeMux()

    fmt.Println("\nDiscovered and Registering Routes to HTTP Server:")
    for name, route := range routes {
        fmt.Printf("- Name: %s, Method: %s, Path: %s\n", route.Name, route.Method, route.Path)
        // 将注册的路由处理器绑定到HTTP多路复用器
        mux.HandleFunc(route.Path, route.Handler)
    }

    // 启动HTTP服务器
    port := ":8080"
    fmt.Printf("\nServer listening on %s\n", port)
    log.Fatal(http.ListenAndServe(port, mux))
}