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

문제점

정적 팩토리, 생성자는 선택적 매개변수가 많을 때 적절하게 대응하기 어렵다.

예시 Code

식품 포장의 영양정보를 표현하는 클래스를 생각해보자. 영양정보는 1회 내용량, 총 n회 제공량, 1회 제공량당 칼로리 같은 필수 항목 몇 개와 총 지방, 트랜스 지방, 포화지방, 콜레스테롤, 나트륨 등 총 20개가 넘는 선택 항목으로 이뤄진다. 그런ㄴ데 대부분 제품은 이 선택항목 중 대다수의 값이 그냥 0이다.

 

1. 점층적 생성자 패턴

각 생성자의 매개변수 개수를 다르게 만들어, 여러 개의 생성자를 만드는 방식이다.

예시

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    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, servings, calories, fat, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) {
        this(servingSize, servings, calories, fat, sodium, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium,
        int carbohydrate) {
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = calories;
        this.fat = fat;
        this.sodium = sodium;
        this.carbohydrate = carbohydrate;
    }
}

단점

• 매개변수가 많아지면 많아질수록 클라이언트 코드 작성 및 읽기가 어렵다.
• 가독성이 떨어진다.
• 타입이 같은 매개변수가 늘어서 있으면 찾기 어려운 버그로 이어질 수 있다.

2. 자바빈즈 패턴

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

예시

public class NutritionFacts {
    private int servingSize = -1;
    private int servings = -1;
    private int calories = 0;
    private int fat = 0;
    private int sodium = 0;
    private int carbohydrate = 0;
    
    public NutritionFacts() { };
    
    public void setServingSize(int val) {
        servingSize = val;
    }
    
    public void setServings(int val) {
        servings = val;
    }
    
    public void setCalories(int val) {
        calories = val;
    }
    
    public void setFat(int val) {
        fat = val;
    }
    
    public void setSodium(int val) {
        sodium = val;
    }
    
    public void setCarbohydrate(int val) {
        carbohydrate = val;
    }
}

NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize(240);
cocaCola.setServings(8);
cocaCola.setCalories(100);
cocaCola.setSodium(35);
cocaCola.setCarbohydrate(27);

장점

점층적 생성자 패턴과 달리 인스턴스를 만들기 더욱 간편해졌으며 각 값의 의미 파악등이 수월해졌다.

단점

• 객체 하나를 만들기 위해서 setter 메서드를 여러 개를 호출해야 한다.
• 점층적 생성자 패턴과 달리 일관성을 지키기 힘들다. 점층적 생성자 패턴에서는 생성자 단에서만 매개변수가 유효한지 확인하면 되었는데 자바 빈즈 패턴에서는 객체가 완전히 생성되기 전까지는 일관성이 무너진 상태에 놓이게 된다. 
• 일관성이 보장되지 않는 문제 때문에, 자바빈즈 패턴에서는 클래스를 불변으로 만들 수 없다.

일관성 보장되지 않는 예시

    @GetMapping("/test")
    public void tester() throws InterruptedException{
        dto = new DTOtest(0);
        Thread.sleep(5000);
        log.info("check : "+ dto.getTest());
    }

    @GetMapping("/mytest")
    public void tester1() throws InterruptedException{
        dto.setTest(1);
    }

• 위 코드에서 test를 먼저 실행시킨 후 mytest를 실행시키면 test의 출력 결과가 1이 나온다.

 

3. 빌더 패턴

1) 클라이언트는 필요한 객체를 직접 만드는 대신, 필수 매개변수만으로 생성자(혹은 정적 팩터리)를 호출해 빌더 객체를 얻는다.

2) 빌더 객체가 제공하는 일종의 세터(setter) 메서드들로 원하는 선택 매개변수들을 설정한다.

3) 매개변수가 없는 build 메서드를 호출해 드디어 우리에게 필요한 불변인 객체를 얻는다.

예시

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;
    
    // 정적 멤버 클래스
    public static class Builder {
        // 필수 매개변수
        private final int servingSize;
        private final int servings;

        // 선택 매개변수 (+ 기본값으로 초기화)
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;
        private int carbohydrate = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }

        public Builder calories(int val) {
            calories = val;
            return this;
        }

        public Builder fat(int val) {
            fat = val;
            return this;
        }

        public Builder sodium(int val) {
            sodium = val;
            return this;
        }

        public Builder carbohydrate(int val) {
            carbohydrate = 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;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

 

 

빌더의 세터 메서드들(calories, fat, sodium, carbohydrate)은 Builder 인스턴스 자신(this)을 그대로 반환하기 때문에 밑의 코드와 같이 연쇄적으로 호출할 수 있다. 이런 방식을 메서드 호출이 흐르듯 연결된다는 뜻으로 플루언트 API(fluent API) 혹은 메서드 연쇄(method chaining)라 한다.

NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).calories(100).sodium(35).carbohydrate(27).build();

위의 코드에서도 볼 수 있다시피, 코드 작성이 쉽고 가독성이 좋다.

1. Builder를 통해 최종적으로 다 만들어진 NutritionFacts 객체를 반환하는 build 메서드를 만든다. 이렇게 만들어진 인스턴스는 매개변수를 변경하지 못하는 불변의 인스턴스이다.

장점

점층적 생성자 패턴고 자바빈즈 패턴의 장점만 취했다.

• API를 보고 코드를 사용하는 클라이언트 입장에서, 코드는 작성하기 쉽고 가독성이 좋다.

단점

• 객체를 만들려면, 그에 앞서 빌더(Builder) 정적 멤버 클래스부터 만들어야 한다.
• 점층적 생성자 패턴보다는 코드가 장황해서 매개변수가 4개 이상은 되어야 값어치를 한다.

정리

생성자나 정적 팩터리가 처리해야 할 매개변수가 많다면 빌더 패턴을 선택하는 게 더 낫다. 매개변수 중 다수가 필수가 아닌 선택인 경우가 많고, 매개변수들끼리 같은 타입인 것이 많다면 특히 더 그렇다. 빌더는 점층적 생성자보다 클라이언트 코드를 읽고 쓰기가 훨씬 간결하고, 자바빈즈 패턴보다 훨씬 안전하다.