Go语言中类型发现的局限性与注册模式实践

import (
    _ "github.com/lib/pq" // 导入PostgreSQL驱动，下划线表示只执行其init函数
    "database/sql"
    "log"
)

func main() {
    // 通过注册名"postgres"打开数据库连接
    db, err := sql.Open("postgres", "user=pqtest dbname=pqtest sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // ... 执行数据库操作
}

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

import (
    "database/sql"
    "database/sql/driver" // driver包定义了数据库驱动接口
)

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

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

// init 函数在包被导入时自动执行
func init() {
    // 调用 database/sql 包的 Register 函数，将"postgres"与我们的驱动关联起来
    sql.Register("postgres", &drv{})
}

// mao/router.go
package mao

import (
    "fmt"
    "sync"
)

// Route 定义路由结构
type Route struct {
    Name, Host, Path, Method string
}

// Controller 结构体，包含路由定义
type Controller struct {
    Route Route
}

// routerRegistry 是一个全局的路由注册器
// 使用 sync.Mutex 确保并发安全
var (
    routerRegistry = make(map[string]Route)
    registryMutex  sync.Mutex
)

// RegisterRoute 允许外部包注册路由
func RegisterRoute(routeName string, route Route) error {
    registryMutex.Lock()
    defer registryMutex.Unlock()

    if _, exists := routerRegistry[routeName]; exists {
        return fmt.Errorf("route '%s' already registered", routeName)
    }
    routerRegistry[routeName] = route
    fmt.Printf("Registered route: %s -> %s %s\n", routeName, route.Method, route.Path)
    return nil
}

// GetRegisteredRoutes 获取所有已注册的路由
func GetRegisteredRoutes() map[string]Route {
    registryMutex.Lock()
    defer registryMutex.Unlock()
    // 返回一个副本，防止外部修改
    routes := make(map[string]Route)
    for k, v := range routerRegistry {
        routes[k] = v
    }
    return routes
}

// 假设框架启动时会调用此函数来初始化路由
func InitRouter() {
    fmt.Println("Initializing Mao Router...")
    routes := GetRegisteredRoutes()
    for name, route := range routes {
        // 实际的路由绑定逻辑，例如：
        // framework.AddRoute(route.Method, route.Path, handlerFunc)
        fmt.Printf("Router binding: %s [%s %s]\n", name, route.Method, route.Path)
    }
    fmt.Println("Mao Router initialized with", len(routes), "routes.")
}

// controller/default.go
package controller

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

// DefaultController 实现了 mao.Controller
type DefaultController struct {
    mao.Controller
}

// Index 方法，这里不再直接设置this.Route，而是通过init函数注册
func (this *DefaultController) Index() string {
    return "Hello from DefaultController Index!"
}

// init 函数在 controller 包被导入时自动执行
func init() {
    // 注册 default_index 路由
    err := mao.RegisterRoute("default_index", mao.Route{
        Name:   "default_index",
        Host:   "localhost",
        Path:   "/",
        Method: "GET",
    })
    if err != nil {
        fmt.Println("Error registering default_index route:", err)
    }

    // 注册另一个示例路由
    err = mao.RegisterRoute("default_about", mao.Route{
        Name:   "default_about",
        Host:   "localhost",
        Path:   "/about",
        Method: "GET",
    })
    if err != nil {
        fmt.Println("Error registering default_about route:", err)
    }
}

// main.go
package main

import (
    _ "myapp/controller" // 导入控制器包，执行其init函数
    "mao"                // 导入mao框架包
    "fmt"
)

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

    // 假设mao框架在启动时会初始化其路由
    mao.InitRouter()

    // 模拟一个Web服务器运行
    fmt.Println("Web server started, listening for requests...")
    // 实际应用中这里会启动HTTP服务器
    // http.ListenAndServe(":8080", nil)
}