생성자에게 매개변수가 많다면 빌더를 고려하라 - [2장 객체 생성과 파괴(아이템2)]

  아래 코드처럼 생성자와 생성자의 파라미터가 많은 경우에는 어떻게 해야 할까?

public class NutritionFacts{
    // 필드(기본값이 있다면) 기본값으로 초기화된다.
    private final int servingSize; // (mL, 1회 제공량) - 필수
    private final int servings; // (회, 총 n회 제공량) - 필수
    private final int calories; // (1회 제공량당) - 선택
    private final int fat; // (g/1회 제공량) - 선택
    private final int sodium; // (mg/1회 제공량) - 선택
    private fianl int carbohydrate; // (g/1회 제공량) - 선택
    
    public NutritionFacts(int servingSize, int servings){
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = 0;
        this.fat = 0;
        this.sodium = 0;
        this.carbohydrate = 0;
    }
    
    public NutritionFacts(int servingSize, int servings, int calories){
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = calories;
        this.fat = 0;
        this.sodium = 0;
        this.carbohydrate = 0;
    }
    
    public NutritionFacts(int servingSize, int servings, int calories, int fat){
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = calories;
        this.fat = fat;
        this.sodium = 0;
        this.carbohydrate = 0;
    }
    
    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium){
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = calories;
        this.fat = fat;
        this.sodium = sodium;
        this.carbohydrate = 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;
    }
}

  이런 경우 해당 단원에서는 빌더의 사용을 고려해보라고 하고 있다. 빌더를 사용하기에 앞서 현재 일반적으로 사용하고 있는 방법들을 알아보고 왜 빌더를 사용해야 하는지 생각해보자. 설명 순서는 1) 점층적 생성자 패턴(telescoping constructor pattern), 2) 자바빈즈(JavaBeans pattern), 3) 빌더 패턴(Builder pattern)으로 진행된다.

 

1. 점층적 생성자 패턴(telescoping constructor pattern)

  이 방식은 필수 매개 변수만 받는 생성자, 필수 매개변수와 선택 매개변수 1개를 받는 생성자, 선택 매개변수를 2개 받는 생성자,... , 형태로 선택 매개변수를 전부 다 받는 생성자까지 늘려가는 방식이다.

public class NutritionFacts{
    // 필드(기본값이 있다면) 기본값으로 초기화된다.
    private final int servingSize; // (mL, 1회 제공량) - 필수
    private final int servings; // (회, 총 n회 제공량) - 필수
    private final int calories; // (1회 제공량당) - 선택
    private final int fat; // (g/1회 제공량) - 선택
    private final int sodium; // (mg/1회 제공량) - 선택
    private fianl int carbohydrate; // (g/1회 제공량) - 선택
    
    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, servings, calories, fat, sodium, carbohydrate);
    }
}

  이 방법은 문제점은 인스턴스를 만들 때 어떤 파라미터를 줘야 하는지 알기 어렵다는 것이다. 예를 들어, 첫 번째 파라미터, 두 번째 파라미터, 세 번째 파라미터,..., n 번째 파라미터에 각각 무엇을 줘야 하는지 알기 어렵다는 것이다.

 

2. 자바빈즈 패턴(JavaBeans pattern)

public class NutritionFacts{
    // 필드(기본값이 있다면) 기본값으로 초기화된다.
    private final int servingSize; // (mL, 1회 제공량) - 필수
    private final int servings; // (회, 총 n회 제공량) - 필수
    private final int calories; // (1회 제공량당) - 선택
    private final int fat; // (g/1회 제공량) - 선택
    private final int sodium; // (mg/1회 제공량) - 선택
    private fianl int carbohydrate; // (g/1회 제공량) - 선택
    
    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 void setSodium(int sodium){
        this.sodium = sodium;
    }
    
    public void setCarbohydrate(int carbohydrate){
        this.carbohydrate = carbohydrate;
    }
}

  이 방법은 장점은 아래와 같이 객체 생성이 간단해진다. 하지만 필수 값들(servingSize, servings)이 설정이 되지 않은 상태로 그냥 사용될 수 있다는 단점이 있다. 즉, 불안정한 상태(일관성(consistency)이 무너진 상태)로 사용될 여지가 있다는 문제가 있다. 

public static void main(String[] args){
    NutritionFacts cocaCola = new NutritionFacts();
    cocaCola.setServingSize(240);
    // cocaCola.setServings(100); // 필수 값(servings)을 설정하지 않은 상태
    
    cocaCola.setCalories(100);
}

  또한, 자바빈즈 패턴을 사용하면 어디까지가 필수 값인지 알 수가 없다. 위의 코드처럼 servingSize까지 설정을 하면 필수 값을 모두 설정한 것인지, 아니면 servingSize와 servings를 모두 설정해야 필수 값들을 모두 설정한 것인지 알 수가 없다. 

 

3. 빌더 패턴(Builder pattern)

  마지막 대안이 바로 빌더 패턴이다. 이는 점층적 생성자 패턴의 안전성과 자바빈즈 패턴의 가독성을 겸비한 것이다.

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;
    }
}

public static main(String[] args){
    NutritionFacts cocaCola = new Builder(240, 8).caloreis(100).sodium(35).build();
}

 

  객체를 생성하는 방법은 다음과 같다.

1. 필수 매개 변수만으로 생성자(혹은 정적 팩터리)를 호출해 빌더 객체를 얻는다.
2. 빌더 객체가 제공하는 일종의 세터 메서드(세터는 아님)들로 원하는 선택 매개변수들을 설정한다.
3. 매개변수가 없는 build 메서드를 호출해 우리에게 필요한 객체를 얻는다.

  일종의 세터 메서드들을 사용함으로써 플루언트 API(fluent API) 혹은 메서드 연쇄(method chaining)를 사용할 수 있다.

 

 

  이상으로 생성자의 매개변수가 너무 많은 경우에 사용할 수 있는 1) 점층적 생성자 패턴(telescoping constructor pattern), 2) 자바빈즈(JavaBeans pattern), 3) 빌더 패턴(Builder pattern)을 알아보았다. 앞의 문제점들을 해결하는 방식으로 진행되었지만, 그렇다고 모든 경우에 빌더가 적절하다는 것은 아니다.  빌더는 코드를 이해하기 어렵게 만들고 필드가 중복된다는 문제가 있다. (물론 Lombok의 @Builder를 사용하는 방법이 있긴 하지만 이것 또한 부가적인 문제를 가지고 있다.)

  따라서 '필수적인 필드와 필수적이지 않은 필드가 있고 이것 때문에 생성자가 너무 많이 늘어나는 상황'과 '클래스를 불변으로 만들고 싶은 상황'에서 빌더 패턴의 사용을 한번 고려해보자!

 

해당 글은 백기선 님의 '이펙티브 자바 완벽 공략'을 수강하고 작성한 것입니다.