Pastāsti par Factory modeļa izmantošanu.

Fabrika — tas ir izstrādes modeļa šablons, kas nodrošina kopēju saskarni objektu radīšanai superklasē, kamēr apakšklases var mainīt radīto objektu tipu.

• Vienkārša fabrika (Simple Factory): nav tīrs šablons, drīzāk idioms. Klase ar metodi, kas rada objektus, pamatojoties uz ievades parametriem.

  package main
  
  import "fmt"
  
  type Product interface {
  	Use()
  }
  
  type ConcreteProductA struct{}
  
  func (p *ConcreteProductA) Use() {
  	fmt.Println("Izmanto konkrētu produktu A")
  }
  
  type ConcreteProductB struct{}
  
  func (p *ConcreteProductB) Use() {
  	fmt.Println("Izmanto konkrētu produktu B")
  }
  
  type SimpleFactory struct{}
  
  func (f *SimpleFactory) CreateProduct(t string) Product {
  	switch t {
  	case "A":
  		return &ConcreteProductA{}
  	case "B":
  		return &ConcreteProductB{}
  	default:
  		return nil
  	}
  }
  
  func main() {
  	factory := SimpleFactory{}
  	productA := factory.CreateProduct("A")
  	productA.Use()
  
  	productB := factory.CreateProduct("B")
  	productB.Use()
  }
  

• Fabrikas metode (Factory Method): nosaka saskarni objektu radīšanai, bet ļauj apakšklasēm izlemt, kuru klasi instancēt.

  package main
  
  import "fmt"
  
  // Produkta saskarne
  type Product interface {
  	Operation() string
  }
  
  // Konkrēts produkts A
  type ConcreteProduct1 struct{}
  
  func (p *ConcreteProduct1) Operation() string {
  	return "Rezultāts no ConcreteProduct1"
  }
  
  // Konkrēts produkts B
  type ConcreteProduct2 struct{}
  
  func (p *ConcreteProduct2) Operation() string {
  	return "Rezultāts no ConcreteProduct2"
  }
  
  // Radītāja saskarne
  type Creator interface {
  	FactoryMethod() Product
  	SomeOperation() string
  }
  
  // Bāzes radītājs
  type BaseCreator struct{}
  
  func (bc *BaseCreator) SomeOperation() string {
  	// Izsauc fabrika metodi, lai iegūtu produkta objektu
  	product := bc.FactoryMethod()
  	// Izmanto produktu
  	result := "Radītājs: tas pats kods ir tikko strādājis ar " + product.Operation()
  	return result
  }
  
  // Konkrēts radītājs A
  type ConcreteCreator1 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator1) FactoryMethod() Product {
  	return &ConcreteProduct1{} // Izveido konkrētu produktu A
  }
  
  // Konkrēts radītājs B
  type ConcreteCreator2 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator2) FactoryMethod() Product {
  	return &ConcreteProduct2{} // Izveido konkrētu produktu B
  }
  
  func main() {
  	// Piemērs izmantošanai
  	creator1 := &ConcreteCreator1{}
  	fmt.Println(creator1.SomeOperation())
  
  	creator2 := &ConcreteCreator2{}
  	fmt.Println(creator2.SomeOperation())
  }
  
  

• Abstrakta fabrika (Abstract Factory): nodrošina saskarni saistītu vai atkarīgu objektu ģimenes radīšanai bez to konkrētu klases norādīšanas.

  package main
  
  import "fmt"
  
  // Produkta A saskarne
  type AbstractProductA interface {
  	UseProductA() string
  }
  
  // Konkrēts produkts A1
  type ConcreteProductA1 struct{}
  
  func (*ConcreteProductA1) UseProductA() string {
  	return "A1 produkta rezultāts."
  }
  
  // Konkrēts produkts A2
  type ConcreteProductA2 struct{}
  
  func (*ConcreteProductA2) UseProductA() string {
  	return "A2 produkta rezultāts."
  }
  
  // Produkta B saskarne
  type AbstractProductB interface {
  	UseProductB() string
  	AnotherFunctionB(collaborator AbstractProductA) string // sadarbība ar produktu A
  }
  
  // Konkrēts produkts B1
  type ConcreteProductB1 struct{}
  
  func (*ConcreteProductB1) UseProductB() string {
  	return "B1 produkta rezultāts."
  }
  
  // B1 sadarbība ar jebkuru AbstractProductA tipu
  func (*ConcreteProductB1) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("B1 sadarbība ar (%s)", result)
  }
  
  // Konkrēts produkts B2
  type ConcreteProductB2 struct{}
  
  func (*ConcreteProductB2) UseProductB() string {
  	return "B2 produkta rezultāts."
  }
  
  // B2 sadarbība ar jebkuru AbstractProductA tipu
  func (*ConcreteProductB2) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("B2 sadarbība ar (%s)", result)
  }
  
  // Abstrakčās fabrika saskarne
  type AbstractFactory interface {
  	CreateProductA() AbstractProductA
  	CreateProductB() AbstractProductB
  }
  
  // Konkrēta fabrika 1
  type ConcreteFactory1 struct{}
  
  func (*ConcreteFactory1) CreateProductA() AbstractProductA {
  	return &ConcreteProductA1{}
  }
  
  func (*ConcreteFactory1) CreateProductB() AbstractProductB {
  	return &ConcreteProductB1{}
  }
  
  // Konkrēta fabrika 2
  type ConcreteFactory2 struct{}
  
  func (*ConcreteFactory2) CreateProductA() AbstractProductA {
  	return &ConcreteProductA2{}
  }
  
  func (*ConcreteFactory2) CreateProductB() AbstractProductB {
  	return &ConcreteProductB2{}
  }
  
  // Klienta kods, kas strādā ar fabriku
  func ClientCode(factory AbstractFactory) {
  	productA := factory.CreateProductA()
  	productB := factory.CreateProductB()
  
  	fmt.Println(productB.UseProductB())
  	fmt.Println(productB.AnotherFunctionB(productA))
  }
  
  func main() {
  	fmt.Println("Klients: Testē klienta kodu ar pirmo fabrikas tipu:")
  	ClientCode(&ConcreteFactory1{})
  
  	fmt.Println("Klients: Testē to pašu klienta kodu ar otro fabrikas tipu:")
  	ClientCode(&ConcreteFactory2{})
  }
  
  

Galvenā atšķirība starp Fabrikas metodi un Abstrakto fabriku: Fabrikas metode rada atsevišķus produktus, bet Abstraktā fabrika rada produktu ģimenes.

Modeļa nosaukums	Apraksts	Kad izmantot
Vienkārša fabrika	Metode vienā klasē, lai radītu dažādu tipu objektus.	Vienkāršai objektu radīšanai, kad nav nepieciešama hierarhija.
Fabrikas metode	Interfeiss objektu radīšanai, kas ļauj apakšklasēm izlemt, kuru klasi instancēt.	Kad klase nevar paredzēt, kāda veida objektus tā ir jāizveido.
Abstrakta fabrika	Interfeiss saistītu vai atkarīgu objektu ģimenes radīšanai.	Kad sistēma jābūt neatkarīgai no tās produktu radīšanas veida.

Fabrikas šablons veicina vāju saistību starp kodu un atvieglo jaunu produktu tipu pievienošanu bez klienta koda izmaiņām.