Builder Pattern

빌더 패턴은 객체를 생성하는 방법과 표현하는 방법을 정의하는 클래스를 나누어 깔끔하고 유연하게 객체를 생성할 수 있는 패턴이다.

활용성

1. 각 인자가 어떤 의미인지 알고싶을 때
2. 여러개의 생성자를 생성하고 싶지 않을 때

빌더 패턴 사용에 따른 결과

생성과 표현에 필요한 코드 분리

빌더 패턴을 사용하면 복합 객체를 생성하고 복합 객체의 내부 표현 방법을 별도의 모듈로 정의할 수 있다. 사용자는 제품의 내부 구조를 정의한 클래스는 모른채 빌더와 상호작용을 통해 필요한 복합 객체를 생성해낸다.

유연한 객체의 생성

빌더 패턴을 사용하면 다양한 생성자를 정의하지 않고도 유연하게 객체를 생성할 수 있다. 또한 각 멤버 변수 할당시 의미가 명확해진다.

빌더

구조

빌더의 구조는 다음과 같다.

C++ 구현

void BuilderPattern::build()
{
    Pizza* pepperoniPizza = Pizza::Builder::builder()
            .setDough("Flour").setSauce("Tomato").setTopping("Pepperoni").build();
    Pizza* pineapplePizza = Pizza::Builder::builder()
            .setDough("Flour").setTopping("PineApple").build();
    pepperoniPizza->showPizzaInfo();
    pineapplePizza->showPizzaInfo();

}

class Pizza
{
    std::string topping;
    std::string dough;
    std::string sauce;

public:
    static class Builder
    {
    private:
        std::string topping;
        std::string dough;
        std::string sauce;

    public:
        static Builder builder()
        {
            Builder builder;
            return builder;
        }

        Builder setTopping(std::string topping)
        {
            this->topping = std::move(topping);
            return *this;
        }

        Builder setDough(std::string dough)
        {
            this->dough = std::move(dough);
            return *this;
        }

        Builder setSauce(std::string sauce)
        {
            this->sauce = std::move(sauce);
            return *this;
        }

        std::string getTopping()
        {
            return topping;
        }

        std::string getDough()
        {
            return dough;
        }

        std::string getSauce()
        {
            return sauce;
        }

        Pizza* build()
        {
            return new Pizza(*this);
        }
    };

public:
    Pizza(Builder builder) :
    topping(builder.getTopping()),
    dough(builder.getDough()),
    sauce(builder.getSauce()) {}

    void showPizzaInfo()
    {
        std::cout<<"Dough : "<<dough<<std::endl;
        std::cout<<"Sauce : "<<sauce<<std::endl;
        std::cout<<"Topping : "<<topping<<std::endl;
    }
};

java 구현

public class Client {
    static public void main(String[] args) {
        Pizza pepperoniPizza = new Pizza.Builder().dough("Flour").sauce("Tomato")
                .topping("Pepperoni").build();
        Pizza pineapplePizza = new Pizza.Builder().dough("Flour").topping("PineApple").build();
        System.out.println(pepperoniPizza.toString());
        System.out.println(pineapplePizza.toString());
    }
}

public class Pizza {
    private String topping;
    private String dough;
    private String sauce;

    public static class Builder {
        private String topping;
        private String dough;
        private String sauce;

        Builder topping(String topping) {
            this.topping = topping;
            return this;
        }

        Builder dough(String dough) {
            this.dough = dough;
            return this;
        }

        Builder sauce(String sauce) {
            this.sauce = sauce;
            return this;
        }

        Pizza build() {
            return new Pizza(this);
        }
    }

    private Pizza(Builder builder) {
        this.topping = builder.topping;
        this.dough = builder.dough;
        this.sauce = builder.sauce;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Dough : ");
        sb.append(dough);
        sb.append("\n");
        sb.append("Sauce : ");
        sb.append(sauce);
        sb.append("\n");
        sb.append("Topping : ");
        sb.append(topping);
        sb.append("\n");
        return sb.toString();
    }
}