Patrones de diseño en Go con ejemplos para desarrolladores

Patrones de diseño en Go (Golang) con ejemplos de código

Los patrones de diseño son soluciones probadas para problemas típicos de desarrollo. En Go, con su sintaxis concisa y la ausencia de POO clásico, muchos patrones adquieren una implementación única. En este artículo analizaremos tres grupos de patrones: creacionales, estructurales y de comportamiento, con ejemplos prácticos en Golang.

El material será útil tanto para principiantes como para desarrolladores Go experimentados que busquen escribir código limpio, reutilizable y testeable.

1. Patrones creacionales (Creational Patterns)

Los patrones creacionales gestionan el proceso de creación de objetos. En Go, donde no hay constructores ni herencia, su implementación es especialmente elegante.

1.1. Singleton (Singleton)

Garantiza que un tipo tenga solo una instancia y proporciona un punto de acceso global a ella. En Go se implementa frecuentemente mediante sync.Once.

package singleton

import (    "sync")

type Database struct {    connection string}

var (    instance *Database    once     sync.Once)

func GetDatabase() *Database {    once.Do(func() {        instance = &Database{connection: "postgres://user:pass@localhost/db"}    })    return instance}

Cuándo usarlo: trabajo con pool de conexiones, caché, logger.

1.2. Método fábrica (Factory Method)

Define una interfaz para crear un objeto, pero permite que las subclases alteren el tipo del objeto creado. En Go, el método fábrica es simplemente una función que devuelve una interfaz.

package factory

import "fmt"

// Product interfacetype INotification interface {    Send(message string) string}

// Concrete productstype Email struct{}

func (e *Email) Send(msg string) string {    return fmt.Sprintf("Email sent: %s", msg)}

type SMS struct{}

func (s *SMS) Send(msg string) string {    return fmt.Sprintf("SMS sent: %s", msg)}

// Factory functionfunc CreateNotification(notifType string) INotification {    switch notifType {    case "email":        return &Email{}    case "sms":        return &SMS{}    default:        return nil    }}

Cuándo usarlo: cuando el tipo del objeto a crear no se conoce de antemano.

1.3. Constructor (Builder)

Separa la construcción de un objeto complejo de su representación. En Go, el builder es una estructura con métodos setters que devuelven a sí mismos para permitir llamadas encadenadas.

package builder

type Pizza struct {    Size     string    Cheese   bool    Pepperoni bool}

type PizzaBuilder struct {    pizza Pizza}

func NewPizzaBuilder() *PizzaBuilder {    return &PizzaBuilder{}}

func (b *PizzaBuilder) SetSize(size string) *PizzaBuilder {    b.pizza.Size = size    return b}

func (b *PizzaBuilder) AddCheese() *PizzaBuilder {    b.pizza.Cheese = true    return b}

func (b *PizzaBuilder) AddPepperoni() *PizzaBuilder {    b.pizza.Pepperoni = true    return b}

func (b *PizzaBuilder) Build() Pizza {    return b.pizza}

Cuándo usarlo: cuando un objeto tiene muchos parámetros opcionales.

2. Patrones estructurales (Structural Patterns)

Los patrones estructurales definen formas de ensamblar objetos y clases en estructuras más grandes, manteniendo la flexibilidad y eficiencia.

2.1. Adaptador (Adapter)

Permite que objetos con interfaces incompatibles trabajen juntos. En Go se utilizan interfaces y estructuras envolventes para ello.

package adapter

import "fmt"

// Target interfacetype USB interface {    ConnectWithUSB() string}

// Adaptee (clase incompatible)type MemoryCard struct{}

func (m *MemoryCard) ReadFromCard() string {    return "Data read from memory card"}

// Adaptertype CardReader struct {    card *MemoryC