Interface como Contrato

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

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

Este pensamento baseado em contratos permite que você escreva 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 de banco de dados, um cliente de API ou um leitor de arquivos. Ela apenas exige que a entrada possa executar FetchData(). Qualquer tipo que honre este 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 torna seu código mais testável também. Durante os testes, você pode criar um tipo mock que satisfaça 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 é cumprido.

Desafio

Fácil

Vamos construir um sistema de notificação 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á múltiplos canais de notificação que honram 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 satisfaçam este 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 aceita um slice de valores Notifier e uma string de mensagem. Esta função deve chamar Notify em cada notifier e imprimir os resultados. Leia a configuração da entrada, crie todos os três tipos de notifier e transmita um alerta através de todos eles.

As seguintes entradas serão fornecidas:

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

Seus métodos Notify devem retornar strings nestes formatos:

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

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

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

O poder deste design é que sua função BroadcastAlert não conhece nem se importa com os tipos específicos de notifier — ela apenas exige que cada um cumpra o contrato Notifier. Você poderia adicionar um SlackNotifier ou EmailNotifier mais tarde sem alterar a função de transmissão.

Folha de consulta

Interfaces em Go atuam como contratos que definem o comportamento necessário sem especificar tipos concretos. Quando uma função aceita um tipo de interface, qualquer tipo que implemente os métodos da interface pode ser usado.

Defina uma interface especificando as assinaturas dos métodos:

type DataSource interface {
    FetchData() string
}

Funções que aceitam interfaces funcionam com qualquer tipo que satisfaça o contrato:

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

Múltiplos tipos podem implementar a mesma interface:

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)   // Works!
    ProcessData(api)  // Also works!
}

Esta abordagem baseada em contratos permite:

Funções que focam no comportamento em vez de tipos específicos
Melhor testabilidade através de implementações mock
Extensibilidade sem modificar o código existente

Experimente você mesmo

package main

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

// BroadcastAlert envia uma mensagem através 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 cada resultado de notificação
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Lê o prefixo do console
	scanner.Scan()
	prefix := scanner.Text()
	
	// Lê o nome do arquivo
	scanner.Scan()
	filename := scanner.Text()
	
	// Lê a URL do webhook
	scanner.Scan()
	url := scanner.Text()
	
	// Lê 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 mensagem
	
	_ = prefix
	_ = filename
	_ = url
	_ = message
	fmt.Println("TODO: Implement the solution")
}