Go语言框架中的路由发现：反射的局限与注册机制的实践

// database/sql/sql.go (简化概念)
package sql

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

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

// Register registers a database driver by its name.
func Register(name string, driver driver.Driver) {
    driversMu.Lock()
    defer driversMu.Unlock()
    if _, dup := drivers[name]; dup {
        panic("sql: Register called twice for driver " + name)
    }
    drivers[name] = driver
}

// Open opens a database specified by its database driver name and a
// driver-specific data source name.
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)
    }
    // ... further logic to open connection
    return nil, nil // Simplified
}

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

import (
    "database/sql"
    "database/sql/driver" // Import the driver interface
)

// drv implements the database/sql/driver.Driver interface.
type drv struct{}

// Open returns a new connection to the database.
func (d *drv) Open(name string) (driver.Conn, error) {
    return Open(name) // Internal Open function
}

// init function is called automatically when the package is imported.
func init() {
    sql.Register("postgres", &drv{})
}

package main

import (
    _ "github.com/lib/pq" // This import triggers 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()
    // Use db...
}

// mao/router.go
package mao

import (
    "fmt"
    "sync"
)

// Route defines the structure for a single route.
type Route struct {
    Name, Host, Path, Method string
    Handler                  interface{} // Or a specific handler interface
}

// Controller defines a base controller structure.
type Controller struct {
    // Any common controller fields
}

// controllerRegistry stores all registered controllers and their routes.
var (
    controllerMu sync.RWMutex
    // A map to store routes, perhaps keyed by controller name or route name
    registeredRoutes = make(map[string]Route)
)

// RegisterRoute registers a single route with the framework.
// This function would typically be called by controllers during their init phase.
func RegisterRoute(route Route) error {
    controllerMu.Lock()
    defer controllerMu.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
}

// GetRoutes returns all registered routes.
func GetRoutes() []Route {
    controllerMu.RLock()
    defer controllerMu.RUnlock()

    routes := make([]Route, 0, len(registeredRoutes))
    for _, route := range registeredRoutes {
        routes = append(routes, route)
    }
    return routes
}

// Router represents the mao router that will use the registered routes.
type Router struct {
    // ... router specific fields
}

// NewRouter initializes and returns a new router instance.
// It would typically load all registered routes here.
func NewRouter() *Router {
    router := &Router{}
    // Load routes from registeredRoutes
    for _, route := range GetRoutes() {
        // Add route to router's internal routing table
        fmt.Printf("Router loading: %s %s %s\n", route.Method, route.Path, route.Name)
        // Example: router.Add(route.Method, route.Path, route.Handler)
    }
    return router
}

// controller/default.go
package controller

import (
    "fmt"
    "your_project_path/mao" // Import your mao package
)

// DefaultController implements some web logic.
type DefaultController struct {
    mao.Controller
}

// Index is a handler method.
func (this *DefaultController) Index() string {
    // this.Route = mao.Route{"default_index", "localhost", "/", "GET"} // This line is not needed here anymore for registration
    return "Hello from DefaultController.Index!"
}

// AnotherHandler is another handler method.
func (this *DefaultController) AnotherHandler() string {
    return "This is another handler!"
}

// init function is called automatically when this package is imported.
func init() {
    // Register the routes for DefaultController
    // Note: You might need a way to pass the actual handler function/method
    // This example uses a placeholder string for simplicity.
    // In a real framework, Handler would be an interface or a function type.

    // To register handler methods, you might need to pass a reference to the method
    // or create a wrapper function.
    // For simplicity, let's assume Handler in mao.Route can be a string for now,
    // and the router later resolves it. Or, more robustly:
    // mao.RegisterRoute(mao.Route{"default_index", "localhost", "/", "GET", func(ctx *Context) { new(DefaultController).Index() }})

    // For demonstration, let's register simple routes.
    // In a real scenario, you'd pass a callable handler.
    // Example: mao.Route{Name: "default_index", Path: "/", Method: "GET", Handler: new(DefaultController).Index}
    // This would require mao.Route.Handler to be a func() Response or similar.

    // Let's refine mao.Route to hold a function directly for clarity.
    // Assume mao.Route.Handler is `func() string` for this example.
    // For a real web framework, it would be `func(http.ResponseWriter, *http.Request)` or a custom context type.
    if err := mao.RegisterRoute(mao.Route{
        Name:    "default_index",
        Host:    "localhost",
        Path:    "/",
        Method:  "GET",
        Handler: func() string { return new(DefaultController).Index() }, // Wrap the method call
    }); err != nil {
        fmt.Printf("Error registering route: %v\n", err)
    }

    if err := mao.RegisterRoute(mao.Route{
        Name:    "default_another",
        Host:    "localhost",
        Path:    "/another",
        Method:  "GET",
        Handler: func() string { return new(DefaultController).AnotherHandler() },
    }); err != nil {
        fmt.Printf("Error registering route: %v\n", err)
    }
}

// main.go
package main

import (
    "fmt"
    _ "your_project_path/controller" // Import the controller package to trigger its init()
    "your_project_path/mao"          // Import the mao framework
)

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

    // The controller's init() function has already run due to the blank import.
    // Now, create the router, which will load the registered routes.
    router := mao.NewRouter()

    fmt.Println("\nRegistered routes loaded by router:")
    for _, route := range mao.GetRoutes() {
        fmt.Printf("  - Name: %s, Method: %s, Path: %s\n", route.Name, route.Method, route.Path)
        // In a real scenario, the router would then use route.Handler
    }

    // Simulate serving a request for "/"
    // if route, ok := mao.registeredRoutes["default_index"]; ok {
    //  if handlerFunc, ok := route.Handler.(func() string); ok {
    //      fmt.Printf("\nSimulating request for /: %s\n", handlerFunc())
    //  }
    // }
}