빌더(Builder) 패턴

1. 빌더 패턴이란?

빌더 패턴(Builder Pattern)은 복잡한 객체의 생성 과정을 단계별로 나누어 처리할 수 있도록 하는 생성 패턴입니다. 객체의 생성 과정이 복잡하거나 다양한 설정이 필요할 때 빌더 패턴을 사용하면 코드의 가독성을 높이고 유연성을 제공합니다.

빌더 패턴은 객체를 생성할 때 필요한 설정 값을 메서드 체이닝 방식으로 지정할 수 있어 가독성이 높은 코드를 작성할 수 있습니다.

---

2. 빌더 패턴의 필요성

2.1 복잡한 객체 생성의 어려움

• 객체를 생성할 때 생성자의 파라미터가 너무 많거나, 서로 다른 조합으로 객체를 생성해야 할 때 코드가 복잡해질 수 있습니다.
• 모든 매개변수를 포함한 생성자를 만들거나 오버로딩된 여러 생성자를 정의하면 유지보수와 사용이 어렵습니다.

2.2 해결책: 빌더 패턴

빌더 패턴을 사용하면:

• 객체 생성 과정을 분리할 수 있습니다.
• 유연하게 객체를 생성할 수 있습니다. (예: 필요한 속성만 설정 가능)
• 메서드 체이닝을 통해 직관적이고 가독성 높은 코드 작성이 가능합니다.

---

3. 빌더 패턴 클래스 다이어그램

                     +----------------+
                     |    Product     |
                     +----------------+
                     | - field1       |
                     | - field2       |
                     | - field3       |
                     +----------------+
                              ^
                              |
                     +----------------+
                     |    Builder     |
                     +----------------+
                     | + setField1()  |
                     | + setField2()  |
                     | + setField3()  |
                     | + build()      |
                     +----------------+
                              ^
                              |
                     +----------------+
                     | ConcreteBuilder|
                     +----------------+
                     |                |
                     | 구현된 setFieldX()|
                     | 구현된 build()    |
                     +----------------+
                              ^
                              |
                     +----------------+
                     |    Client      |
                     +----------------+
                     | - main()       |
                     +----------------+

---

4. 빌더 패턴 실제 사례

Java에서는 대표적으로 StringBuilder 클래스가 빌더 패턴의 예입니다.

• StringBuilder는 문자열을 효율적으로 추가하거나 수정할 수 있도록 지원합니다.
• 메서드 체이닝 방식으로 객체의 상태를 설정합니다.

---

5. 예제 코드: 빌더 패턴 구현

아래는 빌더 패턴을 사용하여 복잡한 객체를 생성하는 예제입니다.

5.1 Product 클래스

public class Product {
    private String field1;
    private String field2;
    private int field3;

    // Private Constructor
    private Product(Builder builder) {
        this.field1 = builder.field1;
        this.field2 = builder.field2;
        this.field3 = builder.field3;
    }

    @Override
    public String toString() {
        return "Product{" +
                "field1='" + field1 + '\'' +
                ", field2='" + field2 + '\'' +
                ", field3=" + field3 +
                '}';
    }

    // Builder 클래스 (Static Inner Class)
    public static class Builder {
        private String field1;
        private String field2;
        private int field3;

        public Builder setField1(String field1) {
            this.field1 = field1;
            return this;
        }

        public Builder setField2(String field2) {
            this.field2 = field2;
            return this;
        }

        public Builder setField3(int field3) {
            this.field3 = field3;
            return this;
        }

        public Product build() {
            return new Product(this);
        }
    }
}

5.2 Client 코드

public class Client {
    public static void main(String[] args) {
        Product product = new Product.Builder()
                .setField1("Value 1")
                .setField2("Value 2")
                .setField3(100)
                .build();

        System.out.println(product);
    }
}

5.3 출력 결과

Product{field1='Value 1', field2='Value 2', field3=100}

---

6. 결론

빌더 패턴은 복잡한 객체를 유연하고 가독성 있게 생성할 수 있도록 돕습니다. 특히 필드가 많은 객체나 설정이 다양할 때 유용합니다.

• 객체 생성의 유연성: 필요한 속성만 설정 가능
• 가독성: 메서드 체이닝을 통해 직관적으로 객체를 생성

Java의 StringBuilder처럼 빌더 패턴을 적용하면 코드 품질과 유지보수성을 높일 수 있습니다.

"복잡한 객체 생성으로 고민이 된다면 빌더 패턴을 사용해 보세요!"