Golang Padrão de Fábrica

1. O que é o padrão de método de fábrica

O padrão de método de fábrica é um padrão de design de criação que fornece uma maneira de encapsular o processo de criação de objetos em subclasses. Dessa forma, o cliente pode criar objetos chamando o método de fábrica sem se preocupar com o processo específico de criação de objetos.

2. Características e vantagens do padrão de método de fábrica

As características do padrão de método de fábrica incluem:

• Desacoplar a criação e o uso de objetos, em que o cliente só precisa se preocupar com o método de fábrica e a interface do produto abstrato.
• O sistema pode ser expandido adicionando novas classes de fábrica específicas e classes de produto específicas, conformando-se ao Princípio Aberto/Fechado.

As vantagens do padrão de método de fábrica incluem:

• Encapsular o processo de criação de objetos, tornando o sistema mais flexível e extensível.
• Ocultar os detalhes de implementação de classes de produto específicas, reduzindo a dependência e o acoplamento do cliente a classes específicas.
• Fornecer uma maneira padronizada de criar produtos, facilitando a manutenção e expansão do sistema.

3. Cenários de aplicação do padrão de método de fábrica

O padrão de método de fábrica é adequado para os seguintes cenários:

• O cliente não depende de classes de produto específicas, mas depende da interface do produto abstrato.
• O cliente precisa criar dinamicamente diferentes objetos de produto com base em condições diferentes.
• A necessidade de encapsular e ocultar o processo de criação do objeto do produto.

4. Implementação do padrão de método de fábrica em Golang

4.1 Diagrama de classe UML

4.2 Passo 1 de implementação: Definir a Interface do Produto Abstrato

pacote fábrica

// Product é a interface do produto abstrato
type Product interface {
	Operation() string
}

4.3 Passo 2 de implementação: Criar Classes de Implementação de Produto Concreto

pacote fábrica

// ConcreteProductA é a classe de produto concreta A
type ConcreteProductA struct{}

// Operation é o método da classe de produto concreto A
func (p *ConcreteProductA) Operation() string {
	return "ConcreteProductA"
}

// ConcreteProductB é a classe de produto concreta B
type ConcreteProductB struct{}

// Operation é o método da classe de produto concreto B
func (p *ConcreteProductB) Operation() string {
	return "ConcreteProductB"
}

4.4 Passo 3 de implementação: Definir a Interface da Fábrica Abstrata

pacote fábrica

// Factory é a interface da fábrica abstrata
type Factory interface {
	CreateProduct() Product
}

4.5 Passo 4 de implementação: Criar Classes de Implementação da Fábrica Concreta

pacote fábrica

// ConcreteFactoryA é a classe de fábrica concreta A
type ConcreteFactoryA struct{}

// CreateProduct é o método da classe de fábrica concreta A
func (f *ConcreteFactoryA) CreateProduct() Product {
	return &ConcreteProductA{}
}

// ConcreteFactoryB é a classe de fábrica concreta B
type ConcreteFactoryB struct{}

// CreateProduct é o método da classe de fábrica concreta B
func (f *ConcreteFactoryB) CreateProduct() Product {
	return &ConcreteProductB{}
}

4.6 Passo 5 de implementação: O Cliente Invoca o Método de Fábrica para Criar Objetos de Produto

pacote principal

import (
	"fmt"
	"github.com/seu/pacote/fábrica
)

func main() {
	// Criar Fábrica Concreta A
	fábricaA := &fábrica.ConcreteFactoryA{}
	// Invocar o método da fábrica para criar objetos de produto
	produtoA := fábricaA.CreateProduct()
	fmt.Println(produtoA.Operation())

	// Criar Fábrica Concreta B
	fábricaB := &fábrica.ConcreteFactoryB{}
	// Invocar o método da fábrica para criar objetos de produto
	produtoB := fábricaB.CreateProduct()
	fmt.Println(produtoB.Operation())
}

No código acima, definimos a interface do produto abstrato Product e as classes de produto concreto ConcreteProductA e ConcreteProductB. Em seguida, definimos a interface da fábrica abstrata Factory e as classes de fábrica concreta ConcreteFactoryA e ConcreteFactoryB. O cliente pode criar objetos de produto específicos invocando o método da fábrica da classe de fábrica concreta, implementando assim o padrão de método de fábrica.

Com os passos acima, concluímos a implementação do padrão de método de fábrica em Golang. Essa abordagem desacopla o cliente das classes de produto específicas, permitindo que o cliente se concentre apenas na interface do produto abstrato. Ao mesmo tempo, os detalhes de implementação de classes de produto específicas são encapsulados na classe de fábrica concreta, tornando o sistema mais flexível e extensível. O padrão de método de fábrica é muito comum em aplicações práticas, especialmente em cenários em que é necessária a criação dinâmica de diferentes tipos de objetos, melhorando efetivamente a reutilização e a manutenção do código.