Injeção de Dependência em Go: para iniciantes

Introdução: Por que a Injeção de Dependência é importante em Go?

Go (Golang) é uma linguagem conhecida por sua simplicidade e desempenho. No entanto, quando seu projeto começa a crescer, o código pode rapidamente se transformar em um "espaguete", onde funções e estruturas estão rigidamente acopladas umas às outras. É aqui que a Injeção de Dependência (DI) entra em ação.

Para desenvolvedores iniciantes, a DI pode parecer um conceito complexo do mundo Java ou C#. Mas em Go, esse padrão é implementado de forma elegante e sem frameworks. Neste artigo, vamos explorar o que é Injeção de Dependência, por que ela é necessária e como aplicá-la corretamente em Go com exemplos práticos.

Se você quer escrever código testável, flexível e de fácil manutenção em Golang, este artigo é para você.

O que é Injeção de Dependência (DI)?

Injeção de Dependência é um padrão de projeto no qual um objeto recebe suas dependências (outros objetos necessários para seu funcionamento) de fora, em vez de criá-los internamente.

Em palavras simples: em vez de escrever myService := MyService{} dentro do seu código, você "injeta" uma instância já pronta de myService no construtor ou método.

Problema sem DI

Imagine que você tem um aplicativo para enviar notificações. Sem DI, o código pode ser assim:

package main\n\nimport "fmt"\n\ntype EmailNotifier struct{}\n\nfunc (e EmailNotifier) Send(message string) {\n    fmt.Println("Enviando email:", message)\n}\n\ntype UserService struct {\n    notifier EmailNotifier // Acoplamento rígido\n}\n\nfunc NewUserService() *UserService {\n    return &UserService{\n        notifier: EmailNotifier{}, // Criando dependência internamente\n    }\n}\n\nfunc (u *UserService) NotifyUser(message string) {\n    u.notifier.Send(message)\n}\n\nfunc main() {\n    service := NewUserService()\n    service.NotifyUser("Olá!")\n}\n

O que há de errado aqui?

\n
• Acoplamento rígido: UserService está preso a EmailNotifier. Se quiser substituir Email por SMS, terá que alterar o código de UserService.
\n
• Dificuldade de teste: Você não conseguirá testar UserService sem enviar um email real. Para testes unitários, isso é crítico.
\n

Solução com DI

Agora, reescrevemos o mesmo exemplo usando Injeção de Dependência:

package main\n\nimport "fmt"\n\n// Notifier — interface que abstrai o envio de notificações\ntype Notifier interface {\n    Send(message string)\n}\n\ntype EmailNotifier struct{}\n\nfunc (e EmailNotifier) Send(message string) {\n    fmt.Println("Enviando email:", message)\n}\n\ntype SMSNotifier struct{}\n\nfunc (s SMSNotifier) Send(message string) {\n    fmt.Println("Enviando SMS:", message)\n}\n\ntype UserService struct {\n    notifier Notifier // Dependência via interface\n}\n\n// NewUserService recebe Notifier de fora\nfunc NewUserService(n Notifier) *UserService {\n    return &UserService{notifier: n}\n}\n\nfunc (u *UserService) NotifyUser(message string) {\n    u.notifier.Send(message)\n}\n\nfunc main() {\n    // Injetando EmailNotifier\n    emailService := NewUserService(EmailNotifier{})\n    emailService.NotifyUser("Olá por email!")\n\n    // Injetando SMSNotifier — sem alterar UserService!\n    smsService := NewUserService(SMSNotifier{})\n    smsService.NotifyUser("Olá por SMS!")\n}\n

Agora, UserService não sabe qual notificador está sendo usado. Ele apenas chama o método Send do objeto recebido. Isso é Injeção de Dependência.

Principais vantagens da DI em Go

1. Testabilidade (Objetos Mock)

A DI torna seu código ideal para testes unitários. Você pode facilmente substituir uma dependência real por um "mock" (simulador).

package main\n\nimport "testing"\n\ntype MockNotifier struc