Interface como Contrato

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

Pensar nas interfaces como contratos ajuda você a projetar programas melhores em Go. Quando uma função aceita um tipo de interface, ela está dizendo: "Não me importo com o tipo concreto que você me fornecer, desde que ele cumpra este contrato."

Esse pensamento baseado em contratos permite escrever funções que se concentram no comportamento, em vez de tipos específicos. Considere uma função que precisa processar dados de várias fontes:

type DataSource interface {
    FetchData() string
}

func ProcessData(src DataSource) {
    data := src.FetchData()
    fmt.Println("Processing:", data)
}

A função ProcessData não sabe nem se importa se recebe uma conexão com o banco de dados, um cliente de API ou um leitor de arquivos. Ela exige apenas que a entrada possa executar FetchData(). Qualquer tipo que respeite esse contrato funciona.

type Database struct{ ConnectionString string }
func (d Database) FetchData() string { return "data from DB" }

type APIClient struct{ Endpoint string }
func (a APIClient) FetchData() string { return "data from API" }

func main() {
    db := Database{ConnectionString: "localhost"}
    api := APIClient{Endpoint: "https://api.example.com"}
    
    ProcessData(db)   // Funciona!
    ProcessData(api)  // Também funciona!
}

Essa abordagem de contrato também torna seu código mais testável. Durante os testes, você pode criar um tipo simulado que satisfaz a interface sem precisar de bancos de dados reais ou conexões de rede. A função em teste não percebe a diferença porque o contrato foi cumprido.

Desafio

Fácil

Vamos criar um sistema de notificações que demonstra como as interfaces funcionam como contratos. Você criará uma interface Notifier que define o que significa enviar uma notificação e, em seguida, implementará vários canais de notificação que respeitam esse contrato.

Você organizará seu código em dois arquivos:

notifiers.go: Defina uma interface Notifier com um único método Notify(message string) string. Em seguida, crie três structs diferentes que atendam a esse contrato:
- ConsoleNotifier com um campo Prefix
- FileNotifier com um campo Filename
- WebhookNotifier com um campo URL
Cada struct deve implementar o método Notify para retornar uma string descrevendo como a notificação seria enviada.
main.go: Crie uma função chamada BroadcastAlert que aceite uma fatia de valores Notifier e uma string de mensagem. Essa função deve chamar Notify em cada notificador e imprimir os resultados. Leia a configuração da entrada, crie os três tipos de notificador e transmita um alerta por meio de todos eles.

As entradas a seguir serão fornecidas:

Linha 1: Prefixo do console
Linha 2: Nome do arquivo
Linha 3: URL do webhook
Linha 4: Mensagem do alerta

Seus métodos Notify devem retornar strings nestes formatos:

ConsoleNotifier: [Prefix] [message]
FileNotifier: Writing to [Filename]: [message]
WebhookNotifier: POST [URL]: [message]

Por exemplo, dadas ALERT:, log.txt, https://hooks.example.com e Server down!, sua saída deverá ser:

ALERT: Server down!
Writing to log.txt: Server down!
POST https://hooks.example.com: Server down!

O poder desse design é que sua função BroadcastAlert não sabe nem se importa com os tipos específicos de notificadores. Ela exige apenas que cada um cumpra o contrato Notifier. Mais tarde, você poderia adicionar um SlackNotifier ou EmailNotifier sem alterar a função de transmissão.

Experimente você mesmo

package main

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

// BroadcastAlert envia uma mensagem por meio de todos os notifiers
// TODO: Implemente esta função para:
// - Aceitar um slice de valores Notifier e uma string de mensagem
// - Chamar Notify em cada notifier e imprimir os resultados
func BroadcastAlert(notifiers []Notifier, message string) {
	// TODO: Percorra os notifiers e imprima o resultado de cada notificação
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Ler o prefixo do console
	scanner.Scan()
	prefix := scanner.Text()
	
	// Ler o nome do arquivo
	scanner.Scan()
	filename := scanner.Text()
	
	// Ler a URL do webhook
	scanner.Scan()
	url := scanner.Text()
	
	// Ler a mensagem de alerta
	scanner.Scan()
	message := scanner.Text()
	
	// TODO: Crie instâncias de todos os três tipos de notifier
	// - ConsoleNotifier com o prefixo
	// - FileNotifier com o nome do arquivo
	// - WebhookNotifier com a URL
	
	// TODO: Crie um slice de Notifier contendo todos os três notifiers
	
	// TODO: Chame BroadcastAlert com os notifiers e a message
	
	_ = prefix
	_ = filename
	_ = url
	_ = message
	fmt.Println("TODO: Implement the solution")
}