Go语言框架设计：避免反射枚举，采用显式注册模式

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

func main() {
    // ...
    db, err := sql.Open("postgres", "user=pqtest dbname=pqtest sslmode=disable")
    // ...
}

// 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 Open(name) // 实际的连接逻辑
}

// init 函数在包被导入时执行
func init() {
    sql.Register("postgres", &drv{}) // 向 database/sql 注册名为 "postgres" 的驱动
}

// mao/router.go
package mao

import (
    "fmt"
    "sync"
)

type Route struct {
    Name, Host, Path, Method string
    Handler                  interface{} // 可以是控制器方法或独立的handler函数
}

var (
    registeredRoutes = make(map[string]Route)
    routesMu         sync.RWMutex
)

// RegisterRoute 注册一个路由到框架中
func RegisterRoute(route Route) error {
    routesMu.Lock()
    defer routesMu.Unlock()

    if _, exists := registeredRoutes[route.Name]; exists {
        return fmt.Errorf("route with name '%s' already registered", route.Name)
    }
    registeredRoutes[route.Name] = route
    fmt.Printf("Registered route: %s %s %s\n", route.Method, route.Path, route.Name)
    return nil
}

// GetRouteByName 根据名称获取已注册的路由
func GetRouteByName(name string) (Route, bool) {
    routesMu.RLock()
    defer routesMu.RUnlock()
    route, ok := registeredRoutes[name]
    return route, ok
}

// GetRoutes 获取所有已注册的路由
func GetRoutes() []Route {
    routesMu.RLock()
    defer routesMu.Unlock()
    routes := make([]Route, 0, len(registeredRoutes))
    for _, route := range registeredRoutes {
        routes = append(routes, route)
    }
    return routes
}

// controller/default.go
package controller

import (
    "fmt"
    "net/http"
    "reflect" // 用于获取方法名称或签名，但不是用于扫描
    "my-app/mao" // 假设mao是你的框架包
)

// Response 是控制器方法的返回类型
type Response struct {
    StatusCode int
    Body       string
}

type DefaultController struct {
    mao.Controller // 嵌入框架提供的基础控制器
}

// Index 是DefaultController的一个方法
func (this *DefaultController) Index() Response {
    // 在这里设置路由信息不再需要，因为路由已在init中注册
    // this.Route = mao.Route{"default_index","localhost","/", "GET"}
    fmt.Println("DefaultController.Index called")
    return Response{StatusCode: http.StatusOK, Body: "Hello from DefaultController.Index!"}
}

// About 是DefaultController的另一个方法
func (this *DefaultController) About() Response {
    fmt.Println("DefaultController.About called")
    return Response{StatusCode: http.StatusOK, Body: "This is the About page."}
}

// init 函数会在包被导入时自动执行
func init() {
    // 实例化一个控制器，用于获取其方法。注意：这里不是创建运行时实例，
    // 而是为了获取方法签名或名称，如果框架需要。
    // 更常见的做法是直接注册路由和对应的处理函数。
    defaultCtrl := &DefaultController{}

    // 注册 Index 路由
    err := mao.RegisterRoute(mao.Route{
        Name:    "default_index",
        Host:    "localhost",
        Path:    "/",
        Method:  http.MethodGet,
        Handler: defaultCtrl.Index, // 直接注册方法作为处理函数
    })
    if err != nil {
        panic(fmt.Sprintf("Failed to register default_index route: %v", err))
    }

    // 注册 About 路由
    err = mao.RegisterRoute(mao.Route{
        Name:    "default_about",
        Host:    "localhost",
        Path:    "/about",
        Method:  http.MethodGet,
        Handler: defaultCtrl.About,
    })
    if err != nil {
        panic(fmt.Sprintf("Failed to register default_about route: %v", err))
    }
}

// main.go
package main

import (
    "fmt"
    "log"
    "net/http"
    "my-app/controller" // 导入控制器包，触发其init函数
    "my-app/mao"        // 导入框架包
)

func main() {
    fmt.Println("Starting application...")

    // 此时，所有在controller包及其子包中注册的路由都已经就绪
    routes := mao.GetRoutes()
    fmt.Println("Registered Routes:")
    for _, r := range routes {
        fmt.Printf("  - Name: %s, Method: %s, Path: %s\n", r.Name, r.Method, r.Path)
        // 假设这里可以根据Handler类型来调用
        // 对于本例，Handler是func() Response，可以直接调用
        // 如果Handler是控制器方法，可能需要反射来调用
    }

    // 模拟一个简单的路由器来处理请求
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // 根据请求路径和方法查找匹配的路由
        for _, route := range routes {
            if route.Path == r.URL.Path && route.Method == r.Method {
                if handlerFunc, ok := route.Handler.(func() mao.Response); ok {
                    resp := handlerFunc()
                    w.WriteHeader(resp.StatusCode)
                    w.Write([]byte(resp.Body))
                    return
                }
            }
        }
        http.NotFound(w, r)
    })

    log.Fatal(http.ListenAndServe(":8080", nil))
}