Golang Factory Pattern

1. Che cos'è il pattern Factory Method

Il pattern Factory Method è un pattern di design creazionale che fornisce un modo per incapsulare il processo di creazione degli oggetti nelle sottoclassi. In questo modo, il cliente può creare oggetti chiamando il metodo di fabbrica senza preoccuparsi del processo specifico di creazione dell'oggetto.

2. Caratteristiche e vantaggi del pattern Factory Method

Le caratteristiche del pattern Factory Method includono:

• Decoupling della creazione e dell'uso degli oggetti, dove al cliente interessa solo il metodo di fabbrica e l'interfaccia del prodotto astratto.
• Il sistema può essere espanso aggiungendo nuove classi di fabbrica specifiche e classi di prodotto specifiche, conformemente al Principio Aperto/Chiuso.

I vantaggi del pattern Factory Method includono:

• Incapsulamento del processo di creazione degli oggetti, rendendo il sistema più flessibile ed estensibile.
• Nascondere i dettagli implementativi delle classi di prodotto specifiche, riducendo la dipendenza e l'accoppiamento del cliente alle classi specifiche.
• Fornire un modo standardizzato per creare prodotti, facilitando la manutenzione e l'espansione del sistema.

3. Scenari di applicazione del pattern Factory Method

Il pattern Factory Method è adatto ai seguenti scenari:

• Il cliente non dipende da classi di prodotto specifiche, ma dipende dall'interfaccia del prodotto astratto.
• Il cliente ha bisogno di creare dinamicamente diversi oggetti di prodotto in base a diverse condizioni.
• La necessità di incapsulare e nascondere il processo di creazione dell'oggetto di prodotto.

4. Implementazione del pattern Factory Method in Golang

4.1 Diagramma delle classi UML

4.2 Passaggio 1 dell'implementazione: Definire l'interfaccia del prodotto astratto

package factory

// Product è l'interfaccia del prodotto astratto
type Product interface {
	Operation() string
}

4.3 Passaggio 2 dell'implementazione: Creare classi di implementazione del prodotto concreti

package factory

// ConcreteProductA è la classe di prodotto concreta A
type ConcreteProductA struct{}

// Operation è il metodo della classe di prodotto concreta A
func (p *ConcreteProductA) Operation() string {
	return "ConcreteProductA"
}

// ConcreteProductB è la classe di prodotto concreta B
type ConcreteProductB struct{}

// Operation è il metodo della classe di prodotto concreta B
func (p *ConcreteProductB) Operation() string {
	return "ConcreteProductB"
}

4.4 Passaggio 3 dell'implementazione: Definire l'interfaccia della fabbrica astratta

package factory

// Factory è l'interfaccia della fabbrica astratta
type Factory interface {
	CreateProduct() Product
}

4.5 Passaggio 4 dell'implementazione: Creare classi di implementazione della fabbrica concreta

package factory

// ConcreteFactoryA è la classe di fabbrica concreta A
type ConcreteFactoryA struct{}

// CreateProduct è il metodo della classe di fabbrica concreta A
func (f *ConcreteFactoryA) CreateProduct() Product {
	return &ConcreteProductA{}
}

// ConcreteFactoryB è la classe di fabbrica concreta B
type ConcreteFactoryB struct{}

// CreateProduct è il metodo della classe di fabbrica concreta B
func (f *ConcreteFactoryB) CreateProduct() Product {
	return &ConcreteProductB{}
}

4.6 Passaggio 5 dell'implementazione: Il cliente invoca il metodo di fabbrica per creare oggetti di prodotto

package main

import (
	"fmt"
	"github.com/your/package/factory"
)

func main() {
	// Creare Concrete Factory A
	factoryA := &factory.ConcreteFactoryA{}
	// Invocare il metodo di fabbrica per creare oggetti di prodotto
	prodottoA := factoryA.CreateProduct()
	fmt.Println(prodottoA.Operation())

	// Creare Concrete Factory B
	factoryB := &factory.ConcreteFactoryB{}
	// Invocare il metodo di fabbrica per creare oggetti di prodotto
	prodottoB := factoryB.CreateProduct()
	fmt.Println(prodottoB.Operation())
}

Nel codice sopra, definiamo l'interfaccia del prodotto astratto Product e le classi di prodotto concreto ConcreteProductA e ConcreteProductB. Poi definiamo l'interfaccia della fabbrica astratta Factory e le classi di fabbrica concreta ConcreteFactoryA e ConcreteFactoryB. Il cliente può creare oggetti di prodotto specifici invocando il metodo di fabbrica della classe di fabbrica concreta, implementando così il pattern Factory Method.

Con i passaggi sopra, abbiamo completato l'implementazione del pattern Factory Method in Golang. Questo approccio decoppia il cliente dalle classi di prodotto specifiche, consentendo al cliente di concentrarsi solo sull'interfaccia del prodotto astratto. Nel frattempo, i dettagli implementativi delle classi di prodotto specifiche sono incapsulati nella classe di fabbrica concreta, rendendo il sistema più flessibile ed estensibile. Il pattern Factory Method è molto comune nelle applicazioni pratiche, specialmente negli scenari in cui è necessaria la creazione dinamica di diversi tipi di oggetti, migliorando efficacemente la riutilizzabilità e la manutenibilità del codice.