Inyección de Dependencias en Go: principios, ejemplos y mejores prácticas

Inyección de Dependencias en Go: principios, ejemplos y mejores prácticas

La Inyección de Dependencias (DI) es uno de los principios clave de diseño que ayuda a crear aplicaciones flexibles, comprobables y fáciles de mantener. En el lenguaje Go, a pesar de su simplicidad y la ausencia de contenedores DI integrados, la inyección de dependencias se utiliza ampliamente. En este artículo, analizaremos qué es la Inyección de Dependencias en Go, cómo implementarla manualmente y con la ayuda de bibliotecas populares, y también consideraremos las mejores prácticas.

¿Qué es la Inyección de Dependencias?

La Inyección de Dependencias es un patrón de diseño en el que un objeto recibe sus dependencias desde el exterior, en lugar de crearlas por sí mismo. El objetivo principal es reducir el acoplamiento entre componentes y aumentar la comprobabilidad del código.

En Go, la DI se implementa pasando dependencias a estructuras (structs) o funciones. Consideremos un ejemplo simple sin DI:

package main

import "fmt"

type Logger struct{}

func (l *Logger) Log(message string) {    fmt.Println("Log:", message)}

type Service struct {    logger *Logger}

func NewService() *Service {    return &Service{        logger: &Logger{}, // Acoplamiento rígido    }}

func (s *Service) DoSomething() {    s.logger.Log("Doing something")}

Y ahora el mismo ejemplo usando DI:

package main

import "fmt"

type Logger interface {    Log(message string)}

type ConsoleLogger struct{}

func (l *ConsoleLogger) Log(message string) {    fmt.Println("Log:", message)}

type Service struct {    logger Logger // Dependencia a través de una interfaz}

func NewService(logger Logger) *Service {    return &Service{logger: logger} // Inyección de dependencia}

func (s *Service) DoSomething() {    s.logger.Log("Doing something")}

Ventajas de la Inyección de Dependencias en Go

• Comprobabilidad: Puede reemplazar fácilmente las dependencias reales con mocks o stubs en las pruebas.
• Flexibilidad: Cambiar el comportamiento de la aplicación se reduce a reemplazar la implementación de la dependencia.
• Limpieza del código: El código se vuelve más modular, cada estructura se encarga solo de su propia lógica.
• Simplificación de la refactorización: Las dependencias se declaran explícitamente, lo que facilita la comprensión y modificación del código.

Formas de inyectar dependencias en Go

En Go existen varios enfoques para implementar DI. Consideremos los principales.

1. Inyección a través del constructor (Constructor Injection)

La forma más común. Las dependencias se pasan a través de una función constructora (NewSomething()).

type UserRepository interface {    FindByID(id int) (*User, error)}

type UserService struct {    repo UserRepository}

func NewUserService(repo UserRepository) *UserService {    return &UserService{repo: repo}}

2. Inyección a través de campos de la estructura (Field Injection)

Las dependencias se asignan directamente a los campos de la estructura. Este enfoque es menos preferible, ya que puede provocar una inicialización incompleta del objeto.

type UserService struct {    Repo UserRepository}

func main() {    svc := &UserService{}    svc.Repo = &PostgresRepository{}}

3. Inyección a través de métodos (Method Injection)

La dependencia se pasa al método, no al constructor. Útil para dependencias temporales.

type UserService struct{}

func (s *UserService) GetUser(repo UserRepository, id int) (*User, error) {    return repo.FindByID(id)}

Ejemplo: construcción de un servidor HTTP con DI

Consideremos un ejemplo más complejo: la creación de un servidor HTTP con inyección de dependencias.

package main

import (    "encoding/json"    "net/http")

// Definimos las interfacestype UserRepository int