Go语言中组件注册与发现的实践：规避反射限制

package sql

import (
    "database/sql/driver"
    "sync"
)

var (
    driversMu sync.RWMutex
    drivers   = make(map[string]driver.Driver)
)

// Register 注册一个数据库驱动。
// 驱动名称必须唯一。
func Register(name string, driver driver.Driver) {
    driversMu.Lock()
    defer driversMu.Unlock()
    if _, ok := drivers[name]; ok {
        panic("sql: Register called twice for driver " + name)
    }
    drivers[name] = driver
}

// Open 根据驱动名称和连接字符串打开一个数据库连接。
func Open(driverName, dataSourceName string) (*DB, error) {
    driversMu.RLock()
    driver, ok := drivers[driverName]
    driversMu.RUnlock()
    if !ok {
        return nil, fmt.Errorf("sql: unknown driver %q (forgotten import?)", driverName)
    }
    // ... 使用 driver 创建连接 ...
    return &DB{}, nil // 简化
}

package pq

import (
    "database/sql"
    "database/sql/driver" // 引入 driver 接口
)

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

func (d *drv) Open(name string) (driver.Conn, error) {
    // ... 实现具体的PostgreSQL连接逻辑 ...
    return nil, nil // 简化
}

func init() {
    // 在包初始化时，将PostgreSQL驱动注册到 database/sql 包
    sql.Register("postgres", &drv{})
}

package main

import (
    _ "github.com/lib/pq" // 仅导入，触发其 init() 函数，注册驱动
    "database/sql"
    "log"
)

func main() {
    db, err := sql.Open("postgres", "user=pqtest dbname=pqtest sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    log.Println("Successfully connected to PostgreSQL!")
    // ... 执行数据库操作 ...
}

package mao

import (
    "fmt"
    "sync"
)

// Route 定义了路由信息
type Route struct {
    Name, Host, Path, Method string
}

// ControllerInterface 定义了控制器必须实现的接口，以便框架能够发现其路由
type ControllerInterface interface {
    GetRoutes() []Route
}

var (
    controllerMu sync.RWMutex
    // registeredControllers 存储所有已注册的控制器实例
    registeredControllers []ControllerInterface
)

// RegisterController 注册一个控制器实例到框架中
func RegisterController(c ControllerInterface) {
    controllerMu.Lock()
    defer controllerMu.Unlock()
    registeredControllers = append(registeredControllers, c)
    fmt.Printf("Mao Framework: Controller %T registered.\n", c)
}

// GetRegisteredControllers 获取所有已注册的控制器
func GetRegisteredControllers() []ControllerInterface {
    controllerMu.RLock()
    defer controllerMu.RUnlock()
    // 返回一个副本以防止外部修改
    controllers := make([]ControllerInterface, len(registeredControllers))
    copy(controllers, registeredControllers)
    return controllers
}

// InitRouter 是框架路由器初始化的入口，它会遍历所有注册的控制器来构建路由表
func InitRouter() {
    fmt.Println("Mao Framework: Initializing router...")
    controllers := GetRegisteredControllers()
    for _, c := range controllers {
        routes := c.GetRoutes()
        for _, route := range routes {
            fmt.Printf("  Registering Route: Name=%s, Method=%s, Path=%s\n", route.Name, route.Method, route.Path)
            // 这里是实际的路由注册逻辑，例如添加到内部路由树
        }
    }
    fmt.Println("Mao Framework: Router initialized.")
}

package controller

import (
    "fmt"
    "mao" // 导入你的框架包
)

// DefaultController 实现了 mao.ControllerInterface
type DefaultController struct {
    // 可以嵌入 mao.Controller 结构体来继承一些通用功能
    mao.Controller
}

// Index 是一个控制器方法
func (this *DefaultController) Index() string {
    return "Hello from DefaultController Index!"
}

// GetRoutes 返回 DefaultController 定义的路由列表
func (this *DefaultController) GetRoutes() []mao.Route {
    // 在这里定义该控制器相关的路由
    return []mao.Route{
        {"default_index", "localhost", "/", "GET"},
        {"default_hello", "localhost", "/hello", "GET"},
    }
}

func init() {
    // 在包初始化时，将 DefaultController 实例注册到 mao 框架
    // 注意：这里通常注册一个实例，如果控制器是无状态的，可以注册一个单例。
    // 如果控制器需要依赖注入，可能需要更复杂的注册工厂模式。
    mao.RegisterController(&DefaultController{})
}

package main

import (
    _ "your_project/controller" // 导入控制器包，触发其 init() 函数进行注册
    "mao"                      // 导入你的框架包
    "fmt"
)

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

    // 此时，controller 包的 init() 函数已经执行，DefaultController 已被注册。
    // 现在可以初始化路由器，它会发现所有已注册的控制器及其路由。
    mao.InitRouter()

    fmt.Println("Application running...")
    // 启动 HTTP 服务器等
}