გააზიარეთ დიზაინის ნიმუში 'მშენებელი'.

დიზაინის ნიმუში "მშენებელი" (Builder) — ეს არის შექმნის ნიმუში, რომელიც საშუალებას აძლევს რთული ობიექტების ეტაპობრივად შექმნას. იგი გამოყოფს რთული ობიექტის მშენებლობის პროცესს მისი წარმოდგენიდან, რათა ერთსა და იმავე მშენებლობის პროცესი შექმნას სხვადასხვა წარმოდგენებს.

ძირითადი კომპონენტები:

• მშენებელი (Builder): ინტერფეისი ან აბსტრაქტული კლასი, რომელიც განსაზღვრავს მეთოდებს რთული ობიექტის ნაწილების შესაქმნელად.
• კონკრეტული მშენებელი (Concrete Builder): ახორციელებს მშენებლის ინტერფეისს და უზრუნველყოფს კონკრეტულ რეალიზაციას ობიექტის ნაწილების მშენებლობისთვის. ინახავს შუამავლურ შედეგს და უზრუნველყოფს მეთოდს მზად ობიექტის მიღებისთვის.
• დირექტორი (Director): არასავალდებულო კომპონენტი. განსაზღვრავს მშენებლის მეთოდების გამოძახების წესს ობიექტის შესაქმნელად. არ იცის კონკრეტული მშენებლების შესახებ.
• პროდუქტი (Product): რთული ობიექტი, რომელიც მშენებელი ქმნის.

გამოყენება:

• როდესაც ობიექტის შექმნის პროცესი რთულია და მოიცავს მრავალ არჩევით ნაბიჯებს.
• როდესაც საჭიროა ერთსა და იმავე პროცესის გამოყენებით შექმნათ სხვადასხვა წარმოდგენები ერთსა და იმავე ობიექტზე.
• როდესაც ობიექტის კონსტრუქტორს აქვს დიდი რაოდენობით პარამეტრები.

Go-ის მაგალითი:

// პროდუქტი - რთული ობიექტი
type Product struct {
	PartA string
	PartB string
	PartC string
}

// მშენებელი - ინტერფეისი
type Builder interface {
	BuildPartA()
	BuildPartB()
	BuildPartC()
	GetProduct() *Product
}

// კონკრეტული მშენებელი
type ConcreteBuilder struct {
	product *Product
}

func NewConcreteBuilder() *ConcreteBuilder {
	return &ConcreteBuilder{product: &Product{}}
}

func (cb *ConcreteBuilder) BuildPartA() {
	cb.product.PartA = "ნაწილი A აშენდა"
}

func (cb *ConcreteBuilder) BuildPartB() {
	cb.product.PartB = "ნაწილი B აშენდა"
}

func (cb *ConcreteBuilder) BuildPartC() {
	cb.product.PartC = "ნაწილი C აშენდა"
}

func (cb *ConcreteBuilder) GetProduct() *Product {
	return cb.product
}

// დირექტორი - არასავალდებულო)
type Director struct {
	builder Builder
}

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

func (d *Director) Construct() {
	d.builder.BuildPartA()
	d.builder.BuildPartB()
	d.builder.BuildPartC()
}

// გამოყენება
// concreteBuilder := NewConcreteBuilder()
// director := NewDirector(concreteBuilder)
// director.Construct()
// product := concreteBuilder.GetProduct()
// fmt.Printf("შექმნილი პროდუქტი: %+v\n", product)

უპირატესობები:

• კოდის გამოყოფა ობიექტის მშენებლობის კოდიდან.
• საშუალებას აძლევს შეცვალოს პროდუქტის შიდა წარმოდგენა, გარეშე შეცვალოს კლიენტის კოდი.
• ნაბიჯ-ნაბიჯ მშენებლობა.
• გამარტივება დიდი რაოდენობით პარამეტრებით ობიექტების შექმნისას.

მოხერხებულობა:

• ზრდის კლასების/ინტერფეისების რაოდენობას ობიექტის შექმნისთვის.
• შეიძლება იყოს ზედმეტი მარტივი ობიექტებისთვის.