Injeção de Dependências

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 45 de 107.

Injeção de Dependência é uma técnica na qual uma struct recebe suas dependências de fora, em vez de criá-las internamente. Em Go, as interfaces tornam esse padrão natural e poderoso.

Em vez de codificar diretamente uma implementação específica em uma struct, você aceita uma interface. Isso permite trocar implementações sem alterar o código da struct:

type Notifier interface {
    Send(message string) string
}

type EmailNotifier struct{}
func (e EmailNotifier) Send(message string) string {
    return "Email: " + message
}

type SMSNotifier struct{}
func (s SMSNotifier) Send(message string) string {
    return "SMS: " + message
}

Agora crie uma struct que dependa da interface, não de um tipo concreto:

type OrderService struct {
    notifier Notifier  // dependência injetada via interface
}

func NewOrderService(n Notifier) *OrderService {
    return &OrderService{notifier: n}
}

func (o *OrderService) PlaceOrder(item string) string {
    return o.notifier.Send("Order placed: " + item)
}

O OrderService não sabe nem se importa se está usando e-mail ou SMS. Você injeta a dependência ao criar o serviço:

func main() {
    emailService := NewOrderService(EmailNotifier{})
    fmt.Println(emailService.PlaceOrder("Book"))  // Email: Pedido realizado: Book
    
    smsService := NewOrderService(SMSNotifier{})
    fmt.Println(smsService.PlaceOrder("Phone"))   // SMS: Pedido realizado: Phone
}

Essa abordagem torna seu código mais flexível e testável. Durante os testes, você pode injetar um notificador simulado que não envia mensagens de verdade. Em produção, você injeta a implementação real. A estrutura permanece inalterada em ambos os cenários.

Desafio

Fácil

Vamos criar um sistema de registro que demonstra o poder da injeção de dependências. Você criará um serviço que pode gravar registros em diferentes destinos, sem que o serviço saiba ou se importe para onde esses registros realmente vão.

Você organizará seu código em três arquivos:

logger.go: Defina uma interface Logger que exija um método Log(message string) string. Em seguida, crie duas implementações diferentes de logger:
- ConsoleLogger com um campo Prefix. Seu método Log retorna [CONSOLE] [Prefix]: [message]
- FileLogger com um campo Filename. Seu método Log retorna [FILE:[Filename]] [message]
service.go: Crie uma struct AppService que dependa da interface Logger (não de um tipo concreto). Inclua uma função construtora NewAppService que aceite um Logger e retorne um ponteiro para AppService. Dê a AppService um método chamado DoWork(task string) string que use o logger injetado para registrar a mensagem Processing: [task] e retorne o que quer que o logger retorne.
main.go: Leia a configuração da entrada, crie os dois tipos de logger, injete cada um em instâncias separadas de AppService e chame DoWork em cada serviço com a tarefa fornecida. Imprima o resultado de cada chamada de serviço.

As seguintes entradas serão fornecidas:

Linha 1: Prefixo do logger do console
Linha 2: Nome do arquivo do logger de arquivo
Linha 3: Tarefa a ser processada

Por exemplo, dadas as entradas INFO, app.log e user authentication, sua saída deverá ser:

[CONSOLE] INFO: Processing: user authentication
[FILE:app.log] Processing: user authentication

Observe como AppService não sabe se está registrando em um console ou em um arquivo. Ele simplesmente chama Log em qualquer logger que tenha sido injetado. Essa flexibilidade é a essência da injeção de dependências: o mesmo código de serviço funciona com implementações de registro completamente diferentes.

Experimente você mesmo

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	// Ler o prefixo do logger do console
	prefix, _ := reader.ReadString('\n')
	prefix = prefix[:len(prefix)-1]
	
	// Ler o nome do arquivo do logger de arquivo
	filename, _ := reader.ReadString('\n')
	filename = filename[:len(filename)-1]
	
	// Ler a tarefa a processar
	task, _ := reader.ReadString('\n')
	if len(task) > 0 && task[len(task)-1] == '\n' {
		task = task[:len(task)-1]
	}
	
	// TODO: Criar um ConsoleLogger com o prefixo
	
	// TODO: Criar um FileLogger com o nome do arquivo
	
	// TODO: Criar um AppService com o ConsoleLogger injetado
	
	// TODO: Criar outro AppService com o FileLogger injetado
	
	// TODO: Chamar DoWork em cada serviço com a tarefa e imprimir os resultados
	fmt.Println("result1")
	fmt.Println("result2")
}