2. 생성자에 매개변수가 많다면 빌더를 고려하라

정적 팩토리와 생성자에는 똑같은 제약이 있다.
매개변수가 많을 때 적절히 대응하기 어렵다는 점이다.

옛 프로그래머들은 이럴 때 점층적 생성자 패턴(telescoping constructor pattern)을 주로 사용했다.

public class NutritionFacts {

    private final int servingSize;  // required

    private final int servings;     // required

    private final int calories;     // optional

    private final int fat;          // optional

     

    public NutritionFacts(int servingSize, int servings) {

        this(servingSize, servings, 0);

    }

     

    public NutritionFacts(int servingSize, int servings, int calories) {

        this(servingSize, servings, calories, 0);

    }

     

    public NutritionFacts(int servingSize, int servings, int calories, int fat) {

        this.servingSize = servingSize;

        this.servings = servings;

        this.calories = calories;

        this.fat = fat;

    }

}

이번에는 선택 매개변수가 많을 때 활용할 수 있는 자바빈즈(JavaBeans)패턴을 알아보자.이 예제에서는 매개변수가 4개 밖에 없지만 수가 늘어나면 걷잡을 수 없게 된다.
결국 점층적 생성자 패턴은 매개변수의 개수가 많아질수록 코드를 작성하거나 읽기 어렵다.

매개변수가 없는 생성자로 객체를 만든 후 setter메서드를 호출해 원하는 매개변수의 값을 설정하는 방식이다.

 

public class NutritionFacts {

    private int servingSize;    // required

    private int servings;       // required

    private int calories;       // optional

    private int fat;            // optional

     

    public NutritionFacts() {

    }

     

    public void setServingSize(int servingSize) {

        this.servingSize = servingSize;

    }

    public void setServings(int servings) {

        this.servings = servings;

    }

    public void setCalories(int calories) {

        this.calories = calories;

    }

    public void setFat(int fat) {

        this.fat = fat;

    }

}

그럼 이번 장의 주제인 빌더 패턴을 알아보자.자바빈즈 패턴에서는 코드가 길어지긴 했지만, 인스턴스를 만들기 쉽고, 더 읽기 쉬운코드가 되었다.
그러나 자바빈즈 패턴에서는 객체 하나를 완성하기위해서는 메서드를 여러 개 호출해야 하고, 객체가 완전히 생성되기 전까지는 일관성이 무너진 상태에 놓이게 된다.
또한 자바빈즈는 클래스를 불변으로 생성할 수 없으며, 스레드에 대한 안정성을 얻으려면 추가 작업을 해줘야만 한다.

 

public class NutritionFacts {

    private final int servingSize;  // required

    private final int servings;     // required

    private final int calories;     // optional

    private final int fat;          // optional



    public static class Builder {

        private final int servingSize;

        private final int servings;

         

        private int calories = 0;

        private int fat = 0;

         

        public Builder(int servingSize, int servings) {

            this.servingSize = servingSize;

            this.servings = servings;

        }

         

        public Builder calories(int val) {

            this.calories = val;

            return this;

        }

         

        public Builder fat(int val) {

            this.fat = val;

            return this;

        }

         

        public NutritionFacts build() {

            return new NutritionFacts(this);

        }

    }

     

    private NutritionFacts(Builder builder) {

        servingSize = builder.servingSize;

        servings = builder.servings;

        calories = builder.calories;

        fat = builder.fat;

    }

}





public class main {

    public static void main(String[] args) {

        NutritionFacts coke = new NutritionFacts

                                        .Builder(240, 9)

                                        .calories(100)

                                        .fat(12)

                                        .builder();

    }

}

빌더 패턴은 계층적으로 설계된 클래스와 함께 사용하기 좋다.이 방식은 메서드 호출이 물 흐르듯 연결된다는 뜻으로 플루언트 API(fluent API) 또는 메서트 체이닝(method chaining)이라 한다.
이 코드는 쓰기 쉽고, 읽기가 굉장히 쉬워진다.

아래는 상속관계인 클래스들을 빌더 패턴을 이용하여 생성하는 예제이다.

 

public abstract class Pizza {

    public enum Topping { HAM, ONION, PEPPER, POTATO }

    final Set<Topping> toppings;

     

    abstract static class Builder<T extends Builder<T>> {

        EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);

         

        public T addTopping(Topping topping) {

            toppings.add(Objects.requireNonNull(topping));

            return self();

        }

         

        abstract Pizza build();

         

        // 하위 클래스에서 이 메서드를 재정의하여 this를 반환하면 된다.

        protected abstract T self();

    }

     

    Pizza(Builder<?> builder) {

        toppings = builder.toppings.clone();

    }

}​

public class KoreaPizza extends Pizza {

    public enum Size { SMALL, MEDIUM, LARGE }

    private final Size size;

     

    public static class Builder extends Pizza.Builder<Builder> {

        private final Size size;

         

        public Builder(Size size) {

            this.size = size;

        }

         

        @Override

        Pizza build() {

            return new KoreaPizza(this);

        }

         

        @Override

        protected Builder self() {

            return this;

        }

    }

     

    KoreaPizza(Builder builder) {

        super(builder);

        size = builder.size;

    }

}

 

public class main {
    public static void main(String[] args) {
        KoreaPizza pizza = new KoreaPizza

                                .Builder(Size.SMALL)

                                .addTopping(Topping.HAM)

                                .addTopping(Topping.POTATO)

                                .build();

    }
}

또한 매개변수가 4개 이상은 되어야 값어치를 한다. (하지만 API는 항상 운영할수록 매개변수가 많아짐을 명심하자)
빌더 패턴은 생성비용이 크지 않지만, 성능에 민감한 상황에서는 문제가 될 수 있다.

 

---

 

결론

왠만하면 빌더패턴을 쓰자