Coincidencia avanzada de patrones de controlador con comodines usando controladores personalizados

Al usar http.HandleFunc para definir patrones de enrutamiento en Go, los mecanismos integrados no ofrezca soporte para comodines. Esto puede ser un factor limitante para capturar componentes de URL dinámicos.

Controlador personalizado con coincidencia de patrones de expresiones regulares

Para superar esta limitación, es factible crear un controlador personalizado que admite la coincidencia de patrones flexible mediante expresiones regulares. A continuación se muestra un ejemplo:

import (
    "net/http"
    "regexp"
)

type route struct {
    pattern *regexp.Regexp
    handler http.Handler
}

type RegexpHandler struct {
    routes []*route
}

// Handler adds a route to the custom handler.
func (h *RegexpHandler) Handler(pattern *regexp.Regexp, handler http.Handler) {
    h.routes = append(h.routes, &route{pattern, handler})
}

// HandleFunc adds a function-based route to the custom handler.
func (h *RegexpHandler) HandleFunc(pattern *regexp.Regexp, handler func(http.ResponseWriter, *http.Request)) {
    h.routes = append(h.routes, &route{pattern, http.HandlerFunc(handler)})
}

// ServeHTTP iterates through registered routes and checks if any pattern matches the request. If a match is found, the corresponding handler is invoked.
func (h *RegexpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    for _, route := range h.routes {
        if route.pattern.MatchString(r.URL.Path) {
            route.handler.ServeHTTP(w, r)
            return
        }
    }
    // No pattern matched, return a 404 response.
    http.NotFound(w, r)
}

Uso:

Ejemplo de uso del controlador personalizado para manejar URL con patrones comodín:

import (
    "log"
    "net/http"
)

func main() {
    rh := &RegexpHandler{}

    // Define a regular expression for capturing any valid URL string.
    pattern := regexp.MustCompile(`/groups/.*/people`)
    rh.HandleFunc(pattern, peopleInGroupHandler)

    // Start the web server and use the custom handler.
    log.Fatal(http.ListenAndServe(":8080", rh))
}

Este enfoque le permite crear patrones de enrutamiento flexibles más allá de las limitaciones de http.HandleFunc mientras mantiene el control sobre la lógica de coincidencia de rutas dentro del controlador personalizado.