빌더(Builder)패턴이란?

• 복잡한 객체의 생성 과정과 표현 방법을 분리하여 다양한 구성의 인스턴스를 만드는 생성패턴이다.
• 생성자에 들어갈 매개 변수를 메서드로 하나하나 받아들이고 마지막에 통합 빌드해서 객체를 생성하는 방식을 의미한다.

❗️ 예를 들어 스타벅스 음료 주문을 들 수 있다. 스타벅스에서 음료를 주문할 때 일반 아메리카노 이외에도 샷 추가, 우유 종류 변경, 시럽 추가, 얼음 양 조절 등 사람마다 여러 옵션을 선택할 수 있다. 어느 사람은 샷을 추가해달라고 할 수 있고, 또 어떤 사람은 우유를 오트밀크로 바꿔달라고 할 수도 있다. 이처럼 선택적 옵션들을 보다 유연하게 받아 다양한 타입의 인스턴스를 생성할 수 있어, 클래스의 선택적 매개변수가 많은 상황에서 유용하게 사용하기 위해 빌더 패턴을 사용한다.

빌더(Builder)패턴을 사용하는 이유?

빌더 패턴 적용 X ,생성자 오버로딩만 사용

class Coffee {

    // 필수 
    private String type;   // 예: "아메리카노", "라떼" 등
    private int size;      // 예: 1 (Short), 2 (Tall), 3 (Grande)

    // 선택 
    private boolean extraShot;  // 샷 추가 여부
    private String milk;        // 우유 종류 (예: "기본우유", "오트밀크", "두유")
    private boolean noIce;      // 얼음 제외 여부
    private String syrup;       // 시럽 종류 (예: "바닐라", "헤이즐넛", "없음")

    // 모든 옵션을 지정하는 생성자
    public Coffee(String type, int size, boolean extraShot, String milk, boolean noIce, String syrup) {
        this.type = type;
        this.size = size;
        this.extraShot = extraShot;
        this.milk = milk;
        this.noIce = noIce;
        this.syrup = syrup;
    }

    // 시럽 옵션 없이 (기본값 "없음"으로 설정)
    public Coffee(String type, int size, boolean extraShot, String milk, boolean noIce) {
        this(type, size, extraShot, milk, noIce, "없음");
    }

    // 얼음 옵션 없이 (기본 noIce = false, 시럽 "없음")
    public Coffee(String type, int size, boolean extraShot, String milk) {
        this(type, size, extraShot, milk, false, "없음");
    }

    // 우유 옵션 없이 (기본 milk = "기본우유", noIce = false, 시럽 "없음")
    public Coffee(String type, int size, boolean extraShot) {
        this(type, size, extraShot, "기본우유", false, "없음");
    }

    @Override
    public String toString() {
        return String.format("커피 타입: %s, 사이즈: %d, 샷 추가: %s, 우유: %s, 얼음 제외: %s, 시럽: %s",
                type, size, extraShot ? "예" : "아니오", milk, noIce ? "예" : "아니오", syrup);
    }
    
    public static void main(String[] args) {
        // 모든 옵션이 지정된 커피 주문
        Coffee coffee1 = new Coffee("아메리카노", 3, true, "오트밀크", true, "바닐라");

        // 샷 추가만 지정한 기본 커피 주문
        Coffee coffee2 = new Coffee("아메리카노", 2, true);

        // 우유 변경과 얼음 제외 옵션만 추가한 커피 주문
        Coffee coffee3 = new Coffee("라떼", 2, false, "두유", true);

        System.out.println(coffee1);
        System.out.println(coffee2);
        System.out.println(coffee3);
    }
}

• 매개변수가 여러 개일 때, 생성자 오버로딩 방식은 각 경우에 대해 별도의 생성자를 정의해야 하기 때문에 코드가 복잡해지고 관리하기 어려워질 수 있다.

빌더(Builder)패턴 도입

빌더 패턴은 이러한 문제들을 해결하기 위해 별도의 Builder 클래스를 만들어 메소드를 통해 step-by-step 으로 값을 입력받은 후에 최종적으로 build() 메소드로 하나의 인스턴스를 생성하여 리턴하는 패턴

 public static void main(String[] args) {
   // 생성자 방식
   Coffee coffee1 = new Coffee("아메리카노", 3, true, "오트밀크", true, "바닐라");

   // 빌더 방식
   Coffee coffee2 = new Coffee.Builder("라떼", 2)
          .extraShot(true)
          .milk("두유")
          .noIce(true)
          .build();
    }

• 데이터의 순서에 상관없이 객체를 만들어내 생성자 인자 순서를 파악할 필요도 없고 잘못된 값을 넣는 실수도 하지 않게 된다

public class Coffee {


    private String type;      // 예: "아메리카노", "라떼" 등
    private int size;         // 예: 1 (Short), 2 (Tall), 3 (Grande)
    private boolean extraShot;  // 샷 추가 여부
    private String milk;        // 우유 종류 (예: "기본우유", "오트밀크", "두유")
    private boolean noIce;      // 얼음 제외 여부
    private String syrup;       // 시럽 종류 (예: "바닐라", "헤이즐넛", "없음")

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

    // private 생성자 (빌더를 통해서만 객체 생성)
    private Coffee(Builder builder) {
        this.type = builder.type;
        this.size = builder.size;
        this.extraShot = builder.extraShot;
        this.milk = builder.milk;
        this.noIce = builder.noIce;
        this.syrup = builder.syrup;
    }

    // 내부 빌더 클래스
    public static class Builder {
        private String type;
        private int size;
        private boolean extraShot; 
        private String milk;
        private boolean noIce; 
        private String syrup;

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

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

        public Builder extraShot(boolean extraShot) {
            this.extraShot = extraShot;
            return this;
        }

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

        public Builder noIce(boolean noIce) {
            this.noIce = noIce;
            return this;
        }

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

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

   
    public String getType() {
        return type;
    }

    public int getSize() {
        return size;
    }

    public boolean isExtraShot() {
        return extraShot;
    }

    public String getMilk() {
        return milk;
    }

    public boolean isNoIce() {
        return noIce;
    }

    public String getSyrup() {
        return syrup;
    }

    @Override
    public String toString() {
        return String.format("커피 [타입=%s, 사이즈=%d, 샷 추가=%s, 우유=%s, 얼음 제외=%s, 시럽=%s]",
                type, size, extraShot ? "예" : "아니오", milk, noIce ? "예" : "아니오", syrup);
    }
}

  public static void main(String[] args) {
  Coffee coffee1 = new Coffee("아메리카노", 3, true, "오트밀크", true, "바닐라"); 

   // 빌더 방식으로 만든 커피 객체
   Coffee coffee2 = Coffee.builder()
                .type("라떼")
                .size(2)
                .extraShot(true)
                .milk("두유")
                .noIce(true)
                .syrup("헤이즐넛")
                .build();
    }

@Builder

빌더 패턴을 수작업으로 구현할 때는 설정하고자 하는 각 필드에 대해 메서드를 하나씩 만들어줘야한다. 따라서 개발자가 좀더 편하게 빌더 패턴을 이용하기 위헤 Lombok에서는 별도의 어노테이션을 지원한다.

import lombok.Builder;
import lombok.Getter;
import lombok.ToString;

@Getter
@Builder
@AllArgsConstructor(access = AccessLevel.PRIVATE)
@ToString
public class Coffee {

    private String type;      // 예: "아메리카노", "라떼" 등
    private int size;         // 예: 1 (Short), 2 (Tall), 3 (Grande)
    private boolean extraShot;  // 샷 추가 여부
    private String milk;        // 우유 종류 (예: "기본우유", "오트밀크", "두유")
    private boolean noIce;      // 얼음 제외 여부
    private String syrup;       // 시럽 종류 (예: "바닐라", "헤이즐넛", "없음")
}

public static void main(String[] args) {

        Coffee coffee2 = Coffee.builder()
                .type("라떼")
                .size(2)
                .extraShot(true)
                .milk("두유")
                .noIce(true)
                .syrup("헤이즐넛")
                .build();
                
        System.out.println(coffee2);
    }

• @AllArgsConstructor(access = AccessLevel.PRIVATE) : @Builder와 함께 사용될 때 주로 선언되며, 전체 필드를 인자로 받는 생성자를 자동으로 만들되, 이를 private 생성자로 제한한다. 이렇게 하면 외부에서 생성자를 직접 호출할 수 없고, Builder를 통해서만 객체를 생성하도록 유도한다.

🤔 @NoArgsConstructor(access = AccessLevel.PROTECTED)는 빌더 패턴에 꼭 필요한 건 아니지만, JPA는 엔티티 객체를 리플렉션을 통해 생성하기 때문에 기본 생성자가 반드시 필요하다.
하지만 아무나 객체를 생성할 수 있게 하면 설계상 문제가 생길 수 있으므로,
생성자의 접근 범위를 protected로 제한해 외부에서는 직접 생성하지 못하게 막는다.

참고 :

• 빌더(Builder) 패턴 - 완벽 마스터하기