[이팩티브자바] 아이템 02. 생성자에 매개변수가 많다면 빌더를 고려하라

💬 이팩티브자바 아이템 2을 읽고 정리한 글입니다.

---

 

✔️ 클래스에 멤버 변수가 많을 경우, 객체를 어떻게 생성할 수 있을까?

- 생성자를 여러 종류로 두어서, 필요한 매개변수만을 사용하는 생성자 여러 개를 만들 수 있다

- 그러나, 이 방법은 필드가 늘어나면 그만큼 관리해야 하는 생성자가 많아지기 때문에 좋지 않다.

- 또한, 매개변수로 전달하면 (인텔리제이의 파라미터 힌트를 사용하지 않는 이상) 각 값의 의미를 한눈에 알아보기가 힘들고, 버그가 발생할 확률이 높아질 수 있다.

  

    
    
    
    
  
public class Crew {
    private String name;
    private int age;
    private String course;
    private String nickname;
}

예시로, 크루에 대한 정보를 나타내는 다음과 같은 4가지 필드가 있다고 가정해보자.

 

 

💬 필요한 생성자를 전부 만들기

- 우리가 필요한 생성자에 따라 모든 종류의 생성자를 각각 생성하는 방법이다.

  

    
    
    
    
  
public class Crew {
    private String name;
    private int age;
    private String course;
    private String nickname;

    public Crew(String name, int age) {
        this(name, age, "", "");
    }

    public Crew(String name, String nickname, int age) {
        this(name, age, "", nickname);
    }

    public Crew(final String name, final int age, final String course, final String nickname) {
        this.name = name;
        this.age = age;
        this.course = course;
        this.nickname = nickname;
    }
}

이 방법에서 큰 특징은, 매개변수가 적은 생성자는 매개변수가 많은 생성자를 점진적으로 호출한다는 것이다.

이렇게 되면 초기값을 설정해두기 때문에 불변 객체로 생성할 수 있지만, 생성자의 개수가 필드에 따라서 계속 증가한다는 단점이 있고, 시그니처를 가진 매개변수의 경우 단순 생성자로서는 생성할 수 없다는 단점이 존재한다.

 

 

💬 자바빈즈 패턴

- 매개변수가 없는 생성자로 객체를 생성하고, setter를 통해서 각 변수의 값을 세팅하는 방식이다.

  

    
    
    
    
  
public class Crew {
    private String name;
    private int age;
    private String course;
    private String nickname;

    public void setName(final String name) {
        this.name = name;
    }

    public void setAge(final int age) {
        this.age = age;
    }

    public void setCourse(final String course) {
        this.course = course;
    }

    public void setNickname(final String nickname) {
        this.nickname = nickname;
    }
}

- 그러나, 이 방법은 객체 하나를 만들기 위해 여러 개의 메서드를 호출해야 되며, setter를 열어두게 된다면 객체에 대한 변경 가능성을 열어두어 불변함을 만들 수가 없어진다.

- 또한, 개발자가 명시적으로 setter를 활용하여 값을 넣어주어야 하기 때문에, setter를 호출하기 전까지 해당 객체는 불완전한 상태가 된다. : 상당히 위험하다. NPE의 가능성을 열어두는 것이며, 객체의 불변성을 해치기 때문에 오류 가능성도 높아진다.

 

 

💬 빌더 패턴

- 필수 매개변수로 생성자를 호출하여 빌더 객체를 얻고, 빌더 객체의 setter를 통해 선택 매개변수를 설정하는 방법이다.

- 이후, build를 통해서 불변 객체를 만드는 방법이다.

  

    
    
    
    
  
public class Crew {
    private String name;
    private int age;
    private String course;
    private String nickname;

    public static class Builder {
        // 필수 매개변수
        private final String name;
        private final String nickname;

        // 선택 매개변수는 기본값으로 초기화하기 
        private int age = 0;
        private String course = "";

        // 필수 값 생성자
        public Builder (String name, String nickname) {
            this.name = name;
            this.nickname = nickname;
        }

        // 선택 값 주입
        public Builder age(int age) {
            this.age = age;
            return this;
        }

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

        // 객체 생성하기
        public void build() {
            return new Crew(this);
        }
    }

    private Crew(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.course = builder.course;
        this.nickname = builder.nickname;
    }
}

 

객체는 다음과 같은 순서로 생성할 수 있다.

1. 필요한 객체의 내부 Builder 클래스의 생성자를 호출하여, Builder 객체를 얻는다. (필수 매개변수 받기)
2. Builder 객체의 setter를 활용하여 선택 매개변수의 값을 할당한다.
3. build()를 호출하여 최종적으로 필요한 객체를 얻는다.

 

위 코드는 Crew의 생성자가 private으로 막혀 있고, Crew에 대한 불변성을 보장할 수 있다. (생성자를 통해 만들기 때문에)

- 이때, 추가적으로 검증 로직이 들어간다면 build가 호출하는 생성자에서 검사하는 것이 좋다. (혹은 builder의 생성자)

- 또한, 빌더의 setter 메서드들이 return this;를 통해서 자기 자신 (=Builder)를 반환하기 때문에, 또 다시 메서드를 연쇄적으로 호출이 가능하게 된다.

 

클라이언트의 코드로 본다면 다음과 같이 사용할 수 있게 되는 것이다.

  

    
    
    
    
  
Crew crew = new Crew
        .Builder(”이름”, “닉네임”)
        .age(23)
        .course(”백엔드”)
        .build();

이렇게 되면, 클라이언트는 내부에 필요한 각각의 값들이 무엇을 의미하는지 파악하기도 쉬워진다.

---

✔️ 어떻게 활용하면 좋을까?

또한, 계층적으로 설계된 클래스와 같이 사용하는 것도 좋다.

  

    
    
    
    
  
import java.util.EnumSet;
        import java.util.Objects;
        import java.util.Set;

public abstract class ConvenientStore {
    public enum Brand {CU, GS, SEVEN_ELEVEN, MINI_STOP}
    final Set<Brand> brands;

    abstract static class Builder<T extends Builder<T>> {
        EnumSet<Brand> brands = EnumSet.noneOf(Brand.class);

        public T addBrand(Brand brand) {
            brands.add(Objects.requireNonNull(brand));
            return self();
        }

        abstract ConvenientStore build();

        protected abstract T self();
    }

    ConvenientStore(Builder<?> builder) {
        brands = builder.brands.clone();
    }
}

간단한 예시를 들어보자. 편의점에 대한 추상클래스를 생성한 다음, 브랜드에 대한 enum 타입을 정의하였다.

위 코드의 특징을 들어보자면 다음과 같다.

 

1. 추상 클래스로 선언이 되어 있기 때문애, 직접적으로 인스턴스화가 불가능하다.

2. 제네릭 타입인 T가 사용되어 있으며, 여기서 T는 Builder 클래스를 상속받은 클래스의 타입이다.

3. brands의 경우 EnumSet<Brand> 타입으로, Brand라는 enum 타입의 값을 담는다.

4. addBrand는 Brand 타입의 값을 인수로 받아서 brands에 추가하며, self()를 통해 Builder 클래스를 상속받아 구현한 클래스에서 구현된 메서드의 반환값이 리턴된다.

 

 

💬 재귀적 타입 한정 

여기서 쓰인 Builder<T extends Builder<T>>는 재귀적 타입 한정이라고 한다.

타입 매개변수 T가 자신의 타입을 포함하는 상위 모듈에 한정되는 것을 의미한다.

-> T가 자신을 포함하는 수식인 Builder<T>에 의해 한정 (extends)된다.

: 말이 어렵지만, 쉽게 생각하면 T는 Builder 클래스를상속받은 클래스임을 의미한다는 뜻이다.

 

왜 사용하는 걸까?

  

    
    
    
    
  
class Builder<T extends Builder<T>> {
        ...
}

이렇게 되면 Builder 클래스를 상속받은 클래스에서, 해당 클래스의 타입을 정의할 때

자기 자신의 타입을 제공하면서 Builder 클래스의 메서드도 함께 사용할 수 있게 된다.

 

  

    
    
    
    
  
public static class Builder extends ConvenientStore.Builder<Builder> {
        ...
}

예를 들어, 여기서 ConvenientStore.Builder 클래스는 Builder<ConvenientStore.Builder> 타입이며, T는 Builder<ConvenientStore.Builder> 가 되는 것이기 때문에 Builder 클래스의 메서드를 사용할 수 있게 된다.

그렇기 때문에, 위에서 선언했던 addBrand(), build() 메서드는 ConvenientStore.Builder에서도 사용할 수 있게 된다.

 

 

다시 돌아와서, 편의점이 확장하여 외국으로 확장했다고 가정해보자. 

이때, 일본 편의점은 파라미터로 매장의 점원 수를 받는다면?

  

    
    
    
    
  
public class JapanConvenientStore extends ConvenientStore {
    public final int employeesCount;

    public static class Builder extends ConvenientStore.Builder<Builder> {
        private int employeesCount = 0;

        public Builder updateEmployeesCount(int employeeCount) {
            this.employeesCount = employeeCount;
            return this;
        }

        @Override
        public JapanConvenientStore build() {
            return new JapanConvenientStore(this);
        }

        @Override
        protected Builder self() {
            return this;
        }
    }

    private JapanConvenientStore(Builder builder) {
        super(builder);
        employeesCount = builder.employeesCount;
    }
}

 

하위 클래스의 build 메서드는 구체 하위 클래스를 반환하도록 선언했다.

-> 이런 식으로 하위 클래스의 메서드(build)가 상위 클래스의 메서드가 정의한 반환 타입 대신, 하위 타입(JapanConvenientStore)을 반환하는 것을 ‘공변 반환 타이핑’이라고 한다.

= 부모 클래스의 메서드를 오버라이딩 할 때, 부모 클래스의 반환 타입을 자식 클래스의 타입으로 변경하는 것.

 

이를 사용하게 되면, 클라이언트는 형 변환을 신경쓰지 않고 빌더를 사용할 수 있게 된다.

 

또한, self()는 자신의 인스턴스를 반환하고 있는 것을 볼 수 있다.

  

    
    
    
    
  
public T addBrand(Brand brand) {
        brands.add(Objects.requireNonNull(brand));
        return self();
}

반환 타입인 T는 재귀적 타입 한정에 의해서 자기 자신을 구현한 하위 클래스인데,

하위 클래스의 self()에서 this를 반환하여 상위 클래스에서 하위 클래스를 반환할 수 있도록 만들었다.

 

아무튼, 이 덕분에 클라이언트는 이러한 빌더 패턴을 활용하여 다음과 같이 선언이 가능하다.

  

    
    
    
    
  
JapanConvenientStore store = new JapanConvenientStore
        .Builder()
        .addBrand(ConvenientStore.Brand.LAWSON)
        .build();

이런 식으로 원하는 매개변수를 활용하여 객체를 생성할 수 있다는 장점이 있다.

그러나, 이 패턴은 생성 비용을 고려해야 하며, 매개변수가 많을 경우 더 잘 동작한다.

 

보통 프로그램이 커질수록 매개변수가 커지는 경우가 많기 때문에, 생성자자 정적 팩터리가 처리할 매개변수가 많을 경우 처음부터 빌더 패턴을 선택하는 게 나을 수 있다.

 

+ 만약, 재귀적 한정 타입을 사용하지 않았을 경우 어떻게 될까?

  

    
    
    
    
  
=public abstract class ConvenientStore {
    public enum Brand {CU, GS, SEVEN_ELEVEN, MINI_STOP, LAWSON}
    final Set<Brand> brands;

    abstract static class Builder {
        EnumSet<Brand> brands = EnumSet.noneOf(Brand.class);

        public Builder addBrand(Brand brand) {
            brands.add(Objects.requireNonNull(brand));
            return self();
        }

        abstract ConvenientStore build();

        protected abstract Builder self();
    }

    ConvenientStore(Builder builder) {
        brands = builder.brands.clone();
    }
}

public class JapanConvenientStore extends ConvenientStore {
    public final int employeesCount;

    public static class Builder extends ConvenientStore.Builder {
        private int employeesCount = 0;

        public Builder updateEmployeesCount(int employeeCount) {
            this.employeesCount = employeeCount;
            return this;
        }

        @Override
        public JapanConvenientStore build() {
            return new JapanConvenientStore(this);
        }

        @Override
        protected Builder self() {
            return this;
        }
    }

    private JapanConvenientStore(Builder builder) {
        super(builder);
        employeesCount = builder.employeesCount;
    }
}

이런 식으로 코드가 작성될 텐데, 그럼 클라이언트 측에서 명시적으로 형변환을 해줘야 한다.

  

    
    
    
    
  
JapanConvenientStore store = (JapanConvenientStore) new JapanConvenientStore
        .Builder()
        .addBrand(ConvenientStore.Brand.LAWSON)
        .build();