Modello Abstract Factory

Fa parte della sezione Programmazione orientata agli oggetti del percorso GO di Coddy. Lezione 88 di 107.

Il pattern Abstract Factory estende il pattern Factory creando famiglie di oggetti correlati senza specificarne i tipi concreti. Invece di una singola funzione factory, definisci un'interfaccia factory che viene implementata da più factory concrete, ciascuna delle quali produce un insieme coerente di oggetti correlati.

Considera un toolkit per interfacce utente che deve creare pulsanti e caselle di controllo. I diversi sistemi operativi richiedono implementazioni diverse, ma i componenti devono funzionare insieme in modo coerente:

type Button interface {
    Render() string
}

type Checkbox interface {
    Check() string
}

// Interfaccia della fabbrica astratta
type GUIFactory interface {
    CreateButton() Button
    CreateCheckbox() Checkbox
}

Ogni fabbrica concreta produce una famiglia di componenti correlati:

// Famiglia Windows
type WindowsButton struct{}
func (w WindowsButton) Render() string { return "Windows Button" }

type WindowsCheckbox struct{}
func (w WindowsCheckbox) Check() string { return "Windows Checkbox" }

type WindowsFactory struct{}
func (w WindowsFactory) CreateButton() Button { return WindowsButton{} }
func (w WindowsFactory) CreateCheckbox() Checkbox { return WindowsCheckbox{} }

// Famiglia Mac
type MacButton struct{}
func (m MacButton) Render() string { return "Mac Button" }

type MacCheckbox struct{}
func (m MacCheckbox) Check() string { return "Mac Checkbox" }

type MacFactory struct{}
func (m MacFactory) CreateButton() Button { return MacButton{} }
func (m MacFactory) CreateCheckbox() Checkbox { return MacCheckbox{} }

Il codice client funziona con l’interfaccia della factory, rimanendo indipendente dalle implementazioni concrete:

func BuildUI(factory GUIFactory) {
    button := factory.CreateButton()
    checkbox := factory.CreateCheckbox()
    fmt.Println(button.Render(), checkbox.Check())
}

Usa Abstract Factory quando il tuo sistema deve funzionare con più famiglie di prodotti correlati e vuoi assicurarti che i componenti della stessa famiglia vengano utilizzati insieme. È più complesso di una semplice Factory, quindi ricorri a questo modello solo quando hai davvero bisogno di gestire famiglie di prodotti.

Sfida

Facile

Costruiamo un sistema per un negozio di mobili usando il pattern Abstract Factory! Creerai factory che producono famiglie di mobili correlati: ogni factory produce uno stile coerente (Modern o Vintage), assicurando che sedie e tavoli provenienti dalla stessa factory siano esteticamente coordinati.

Organizzerai il codice in tre file:

furniture.go: definisci le interfacce dei prodotti e i tipi concreti di mobili.
Crea due interfacce di prodotto:
- Chair con un metodo SitOn() string
- Table con un metodo PlaceItems() string
Implementa due famiglie di mobili:
- Famiglia Modern: ModernChair restituisce Sitting on a sleek modern chair e ModernTable restituisce Placing items on a glass modern table
- Famiglia Vintage: VintageChair restituisce Sitting on an ornate vintage chair e VintageTable restituisce Placing items on a wooden vintage table
factory.go: definisci l'interfaccia della factory astratta e le factory concrete.
Crea un'interfaccia FurnitureFactory con due metodi:
- CreateChair() Chair
- CreateTable() Table
Implementa due factory concrete:
- ModernFactory che produce ModernChair e ModernTable
- VintageFactory che produce VintageChair e VintageTable
Crea anche una funzione GetFactory(style string) FurnitureFactory che restituisce la factory appropriata in base allo stile (modern o vintage). Usa ModernFactory come valore predefinito per gli stili non riconosciuti.
main.go: usa le tue factory per arredare le stanze.
Crea una funzione FurnishRoom(factory FurnitureFactory) string che usa la factory per creare una sedia e un tavolo, quindi restituisce una stringa formattata che mostra entrambe le azioni su righe separate.

Leggi uno stile in input, ottieni la factory appropriata, arreda una stanza e stampa il risultato.

Verranno forniti i seguenti input:

Riga 1: stile dei mobili (modern, vintage o qualsiasi altro valore)

Per esempio, dato:

modern

L'output dovrebbe essere:

Sitting on a sleek modern chair
Placing items on a glass modern table

E dato:

vintage

L'output dovrebbe essere:

Sitting on an ornate vintage chair
Placing items on a wooden vintage table

E dato:

rustic

L'output dovrebbe essere:

Sitting on a sleek modern chair
Placing items on a glass modern table

Nota come la funzione FurnishRoom funzioni con qualsiasi factory tramite l'interfaccia. Non sa se sta creando mobili moderni o vintage. Questo assicura che tutti i mobili di una stanza provengano dalla stessa famiglia, mantenendo uno stile coerente!

Provalo tu

package main

import "fmt"

// FurnishRoom usa una factory per creare i mobili e restituisce il risultato
// TODO: Implementa questa funzione
// - Usa factory per creare una sedia e un tavolo
// - Restituisci una stringa con il risultato di SitOn() sulla prima riga e quello di PlaceItems() sulla seconda riga
func FurnishRoom(factory FurnitureFactory) string {
	// TODO: Crea una sedia e un tavolo usando factory
	// TODO: Restituisci una stringa formattata con le due azioni su righe separate
	return ""
}

func main() {
	var style string
	fmt.Scanln(&style)

	// TODO: Ottieni la factory appropriata in base a style
	// TODO: Arreda una stanza usando factory
	// TODO: Stampa il risultato
}