Builder 디자인 패턴은 복잡한 객체를 점진적으로 구축하는 데 사용되므로 동일한 구성 프로세스를 사용하여 객체의 다양한 표현을 생성할 수 있습니다. 이번 글에서는 Golang에서 Builder 패턴을 구현하는 방법과 그 이점을 이해하고 실제 사용 사례를 분석해 보겠습니다.

빌더란 무엇인가요?

빌더 패턴은 복잡한 객체의 구성과 표현을 분리하므로 동일한 구성 프로세스로 다양한 표현을 만들 수 있습니다. 이는 개체를 여러 단계로 생성해야 하거나 여러 가능한 구성으로 생성해야 하는 경우 특히 유용합니다.

빌더 혜택

• 구성과 표현의 분리: 객체의 구성을 최종 표현과 분리할 수 있습니다.
• 증분 구성: 복잡한 객체를 점진적으로, 단계별로 구성할 수 있습니다.
• 코드 재사용: 여러 방법으로 결합할 수 있는 공통 빌드 단계를 정의하여 코드 재사용을 촉진합니다.

빌더 구현

빌더를 구현하려면 여러 필드와 그룹화된 다른 객체를 초기화해야 하는 복잡한 객체를 상상해 봅시다. 집은 어때요? 여기서 우리는 두 가지 유형의 건축을 갖게 될 것입니다. 하나는 콘크리트와 벽돌을 사용하는 전통적인 건축이고 다른 하나는 목재로 건축하는 것입니다.

1 - 구조 정의

먼저 빌드하려는 객체의 구조를 정의해야 합니다. 앞서 말했듯이 우리는 집을 지을 예정입니다. 이 구조체 안에 구조체를 만드는 데 필요한 항목을 배치할 것입니다.

// house.go

package main

type House struct {
    Foundation string
    Structure  string
    Roof       string
    Interior   string
}

2 - 빌더 인터페이스 정의

여전히 동일한 파일에서 집의 다양한 부분을 구축하는 데 필요한 방법을 지정하는 빌더 인터페이스를 정의합니다.

//house.go

package main

type House struct {
    Foundation string
    Structure  string
    Roof       string
    Interior   string
}

type HouseBuilder interface {
    SetFoundation()
    SetStructure()
    SetRoof()
    SetInterior()
    GetHouse() House
}

3 - 빌더를 구체적으로 구현

concreteHouse와 woodHouse라는 두 개의 새 파일을 만들어 보겠습니다. 이는 HouseBuilder 인터페이스를 따르는 구체적인 클래스의 구현이 될 것입니다.

//concreteHouse.go

package main

type ConcreteHouseBuilder struct {
    house House
}

func (b *ConcreteHouseBuilder) SetFoundation() {
    b.house.Foundation = "Concrete, brick, and stone"
}

func (b *ConcreteHouseBuilder) SetStructure() {
    b.house.Structure = "Wood and brick"
}

func (b *ConcreteHouseBuilder) SetRoof() {
    b.house.Roof = "Concrete and reinforced steel"
}

func (b *ConcreteHouseBuilder) SetInterior() {
    b.house.Interior = "Gypsum board, plywood, and paint"
}

func (b *ConcreteHouseBuilder) GetHouse() House {
    return b.house
}

//woodHouse.go

package main

type WoodHouseBuilder struct {
    house House
}

func (b *WoodHouseBuilder) SetFoundation() {
    b.house.Foundation = "Wooden piles"
}

func (b *WoodHouseBuilder) SetStructure() {
    b.house.Structure = "Wooden frame"
}

func (b *WoodHouseBuilder) SetRoof() {
    b.house.Roof = "Wooden shingles"
}

func (b *WoodHouseBuilder) SetInterior() {
    b.house.Interior = "Wooden panels and paint"
}

func (b *WoodHouseBuilder) GetHouse() House {
    return b.house
}

4 - 이사 정의

디렉터(Director)는 객체 생성을 관리하여 생성 단계가 올바른 순서로 호출되도록 하는 클래스입니다. 특정 Builder 구현의 세부 사항에 대해 전혀 알지 못하며, 최종 제품을 생성하기 위해 논리적 순서로 Builder 메서드를 호출할 뿐입니다.

//director.go

package main

type Director struct {
    builder HouseBuilder
}

func (d *Director) Build() {
    d.builder.SetFoundation()
    d.builder.SetStructure()
    d.builder.SetRoof()
    d.builder.SetInterior()
}

func (d *Director) SetBuilder(b HouseBuilder) {
    d.builder = b
}

5 - 빌더 사용

마지막으로 디렉터와 콘크리트 빌더를 사용하여 다양한 유형의 집을 지을 것입니다.

//main.go

package main

import (
    "fmt"
)

func main() {
    cb := &builder.ConcreteHouseBuilder{}
    director := builder.Director{Builder: cb}

    director.Build()
    concreteHouse := cb.GetHouse()

    fmt.Println("Concrete House")
    fmt.Println("Foundation:", concreteHouse.Foundation)
    fmt.Println("Structure:", concreteHouse.Structure)
    fmt.Println("Roof:", concreteHouse.Roof)
    fmt.Println("Interior:", concreteHouse.Interior)
    fmt.Println("-------------------------------------------")

    wb := &builder.WoodHouseBuilder{}
    director.SetBuilder(wb)

    director.Build()
    woodHouse := wb.GetHouse()

    fmt.Println("Wood House")
    fmt.Println("Foundation:", woodHouse.Foundation)
    fmt.Println("Structure:", woodHouse.Structure)
    fmt.Println("Roof:", woodHouse.Roof)
    fmt.Println("Interior:", woodHouse.Interior)
}

요컨대

1. Struct House: 우리가 만들고 있는 최종 제품을 나타냅니다.
2. HouseBuilder 인터페이스: 집의 다양한 부분을 짓는 방법을 정의합니다.
3. 구체적인 구현(ConcreteHouseBuilder 및 WoodHouseBuilder): HouseBuilder 인터페이스를 구현하고 특정 구성 단계를 정의합니다.
4. 감독: 구성 프로세스를 관리하여 단계가 올바른 순서로 호출되도록 합니다.
5. 주요 기능: 빌더 패턴을 사용하여 다양한 유형의 주택을 짓고 프로세스를 관리하고 최종 제품을 얻기 위해 디렉터를 호출하는 방법을 보여줍니다.

결론

빌더 패턴은 점진적이고 유연한 방식으로 복잡한 객체를 구축하기 위한 도구입니다. Golang에서는 이 패턴의 구현이 직접적이고 효과적이므로 모듈식이며 유지 관리가 쉬운 시스템을 만들 수 있습니다. 구체적인 인터페이스와 클래스를 사용하면 새로운 요구 사항이 나타날 때 구성 논리를 중앙 집중화하고 코드 진화를 단순화할 수 있습니다.