Padrões de Projeto em Go

Neste post, vamos explorar padrões de projeto comuns em Go, como Singleton, Builder, Factory, e como aplicá-los em projetos Go para melhorar a manutenibilidade e escalabilidade do código.

Padrão Singleton

O padrão Singleton em Go permite que uma classe tenha apenas uma instância global, garantindo que todas as solicitações de acesso a essa instância obtenham a mesma referência. Isso é útil em situações em que você deseja controlar estritamente o acesso a recursos compartilhados ou quando precisa garantir que um determinado objeto seja instanciado apenas uma vez durante o ciclo de vida do programa.

Exemplo:

package singleton

import "sync"

type Singleton struct {
    // Campos da instância
}

var instance *Singleton
var once sync.Once

func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{}
    })
    return instance
}

Padrão Builder

O padrão Builder em Go oferece uma maneira flexível de construir objetos complexos, permitindo a construção passo a passo e a criação de diferentes representações do mesmo objeto, sem poluir o código com uma interface complexa de construtor. Isso é útil quando você precisa criar objetos complexos com diferentes configurações ou quando a lógica de construção é complexa e merece ser encapsulada em um objeto separado

Exemplo:

package builder

type Product struct {
    // Campos do produto
}

type Builder interface {
    BuildPart1()
    BuildPart2()
    GetResult() *Product
}

type ConcreteBuilder struct {
    product *Product
}

func (b *ConcreteBuilder) BuildPart1() {
    // Implementação da construção da parte 1
}

func (b *ConcreteBuilder) BuildPart2() {
    // Implementação da construção da parte 2
}

func (b *ConcreteBuilder) GetResult() *Product {
    return b.product
}

type Director struct {
    builder Builder
}

func NewDirector(builder Builder) *Director {
    return &Director{builder: builder}
}

func (d *Director) Construct() *Product {
    d.builder.BuildPart1()
    d.builder.BuildPart2()
    return d.builder.GetResult()
}

Padrão de Factory

O padrão Factory em Go fornece uma maneira de criar objetos sem expor a lógica de criação diretamente no código. Isso é útil quando você tem várias implementações de uma mesma interface ou quando a lógica de criação de objetos é complexa e precisa ser isolada em um local centralizado.

Exemplo:

package factory

type Product interface {
    Operation()
}

type ConcreteProductA struct{}

func (p *ConcreteProductA) Operation() {
    // Implementação da operação do produto A
}

type ConcreteProductB struct{}

func (p *ConcreteProductB) Operation() {
    // Implementação da operação do produto B
}

type Factory interface {
    CreateProduct() Product
}

type ConcreteFactoryA struct{}

func (f *ConcreteFactoryA) CreateProduct() Product {
    return &ConcreteProductA{}
}

type ConcreteFactoryB struct{}

func (f *ConcreteFactoryB) CreateProduct() Product {
    return &ConcreteProductB{}
}

Esses são apenas exemplos simples dos padrões de projeto em Go. Você pode adaptá-los e aplicá-los em seus próprios projetos para melhorar a estrutura e a manutenibilidade do código.