Conceptos básicos de patrones de Go

10 ejemplos para empezar con patrones y modismos de Go - 7 básicos y 3 intermedios.

Prerrequisitos

• Go 1.26.x instalado (go version reporta go1.26 o posterior)
• Familiaridad con structs, métodos e interfaces

go version

Ejemplos básicos

1. Incrustar para promover métodos

Compón comportamiento incrustando un tipo con los métodos que necesitas.

type LoggingHandler struct {
    http.Handler
    log *slog.Logger
}
 
func (h LoggingHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    h.log.Info("request", "path", r.URL.Path)
    h.Handler.ServeHTTP(w, r)
}

• La incrustación anónima promueve ServeHTTP del manejador interno
• El tipo externo no es una subclase; es un struct distinto que envuelve el comportamiento
• Usa la incrustación para decoradores delgados, no jerarquías profundas

Relacionado: Modismos de Go: Composición sobre Herencia - por qué Go evita la herencia

2. Definir una interfaz de consumidor

Declara la interfaz donde llamas al comportamiento, no donde lo implementas.

// paquete consumidor
type Clock interface {
    Now() time.Time
}
 
func TTL(c Clock, issued time.Time, ttl time.Duration) bool {
    return c.Now().After(issued.Add(ttl))
}

• Las interfaces se satisfacen implícitamente cuando los métodos coinciden
• Las interfaces pequeñas (un método) son fáciles de simular en pruebas
• Mantén los nombres basados en roles (Clock, Store) no en implementaciones (PostgresClock)

Relacionado: Funciones Constructoras y APIs de Paquetes - conectando dependencias a través de constructores

3. Constructor con estado no exportado

Devuelve valores inicializados desde funciones New en lugar de exportar structs mutables.

type Counter struct {
    n atomic.Int64
}
 
func NewCounter() *Counter { return &Counter{} }
 
func (c *Counter) Inc() { c.n.Add(1) }
func (c *Counter) Value() int64 { return c.n.Load() }

• New documenta la construcción válida; el valor cero puede ser inválido para algunos tipos
• Los campos no exportados evitan que la mutación externa rompa invariantes
• Métodos en receptores de puntero cuando el estado muta

Relacionado: Funciones Constructoras y APIs de Paquetes - convenciones New/Open

4. Tipo de Opción Funcional

Modela configuraciones opcionales como funciones que mutan el objetivo durante la construcción.

type Option func(*Server)
 
func WithPort(p int) Option {
    return func(s *Server) { s.port = p }
}
 
func NewServer(opts ...Option) *Server {
    s := &Server{port: 8080}
    for _, opt := range opts {
        opt(s)
    }
    return s
}

• Los valores predeterminados viven en New; los llamadores anulan solo lo que necesitan
• Las opciones se componen: NewServer(WithPort(3000), WithTLS(cert))
• Exporta funciones de opción, mantén el alias de tipo de opción sin exportar si es posible

Relacionado: Patrón de Opciones Funcionales - recorrido completo del patrón

5. Cadena de Middleware HTTP

Envuelve manejadores con funciones que se ejecutan antes y después de la lógica interna.

func withRequestID(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        id := uuid.NewString()
        ctx := context.WithValue(r.Context(), requestIDKey, id)
        w.Header().Set("X-Request-Id", id)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

• La firma del middleware func(http.Handler) http.Handler es nativa de la biblioteca estándar
• El middleware externo se ejecuta primero al entrar, último al salir
• chi, gin y echo usan la misma idea de composición con ayudantes específicos del enrutador

Relacionado: Patrones de Middleware y Decorador - encadenamiento y ordenación

6. Límite de Interfaz de Repositorio

Aísla el almacenamiento detrás de una interfaz de la que depende el servicio.

type User struct { ID string; Email string }
 
type UserRepo interface {
    Get(ctx context.Context, id string) (User, error)
}
 
type Service struct { repo UserRepo }
 
func (s *Service) Email(ctx context.Context, id string) (string, error) {
    u, err := s.repo.Get(ctx, id)
    if err != nil { return "", err }
    return u.Email, nil
}

• Los servicios contienen reglas de negocio; los repositorios contienen detalles de E/S
• Las pruebas pasan un UserRepo en memoria falso sin una base de datos
• El contexto es el primer parámetro en los límites de E/S

Relacionado: Patrones de Capa de Repositorio y Servicio - guía de capas

7. sync.Once para Inicialización Perezosa

Inicializa recursos costosos exactamente una vez, de forma segura bajo concurrencia.

var (
    client *http.Client
    once   sync.Once
)
 
func HTTPClient() *http.Client {
    once.Do(func() {
        client = &http.Client{Timeout: 10 * time.Second}
    })
    return client
}

• once.Do ejecuta la función exactamente una vez entre goroutines
• Prefiere la inyección explícita de dependencias sobre las globales del paquete cuando las pruebas lo permiten
• No pongas conexiones de red dentro de init() - la inicialización perezosa o la conexión de constructores es más segura

Relacionado: Patrones sync.Once y Singleton - cuándo son aceptables las globales

Ejemplos intermedios

8. Opciones Funcionales con Validación

Valida las opciones compuestas antes de devolver el valor construido.

func NewPool(size int, opts ...PoolOption) (*Pool, error) {
    if size <= 0 {
        return nil, errors.New("pool: size must be positive")
    }
    p := &Pool{size: size, idle: 30 * time.Second}
    for _, opt := range opts {
        if err := opt(p); err != nil {
            return nil, err
        }
    }
    return p, nil
}

• Devolver error desde New señala combinaciones inválidas tempranamente
• Las funciones de opción pueden devolver error cuando la validación es por opción
• Los llamadores manejan fallos de construcción como cualquier otra API de Go

Relacionado: Patrón de Opciones Funcionales - estrategias de validación

9. Constructor de Servicio con Interfaces

Conecta un servicio a partir de interfaces definidas en el paquete consumidor.

type Notifier interface {
    Send(ctx context.Context, to, body string) error
}
 
type OrderService struct {
    repo   OrderRepo
    notify Notifier
}
 
func NewOrderService(repo OrderRepo, notify Notifier) *OrderService {
    return &OrderService{repo: repo, notify: notify}
}

• Los parámetros del constructor documentan las dependencias explícitamente
• Sin globales ocultas; las pruebas pasan fakeNotifier y fakeRepo
• Devuelve *OrderService concreto; acepta interfaces en los parámetros

Relacionado: Patrones de Capa de Repositorio y Servicio - pruebas con fakes

10. Pila de Middleware con chi

Compón middleware compatibles con la biblioteca estándar en un enrutador chi.

r := chi.NewRouter()
r.Use(middleware.RequestID)
r.Use(middleware.RealIP)
r.Use(middleware.Recoverer)
r.Get("/health", func(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
})

• r.Use registra el middleware externo para todas las rutas en el ámbito
• Los grupos de rutas aplican middleware a subárboles sin duplicar envoltorios
• chi se mantiene compatible con net/http - los manejadores son http.HandlerFunc simples

Relacionado: Patrones de Middleware y Decorador - encadenamiento independiente del framework

Versiones de la pila: Esta página fue escrita para Go 1.26.x (GC predeterminado Green Tea, go fix modernizers - verifica el parche en la compilación), chi (última versión - verifica en la compilación), gin (última versión - verifica en la compilación), echo (última versión - verifica en la compilación), google.golang.org/grpc (última versión - verifica en la compilación), sigs.k8s.io/controller-runtime (última versión - verifica en la compilación), kubebuilder (última versión - verifica en la compilación), tinygo (última versión - verifica los objetivos de placa en la compilación), wazero (última versión - verifica en la compilación) y golangci-lint (última versión - verifica en la compilación).

Y29kZWd1aWRlcy5pb3xjZ2lvNDg3fDIwMjYwNw==