[Effective Java] Item 02 생성자에 매개변수가 많다면 빌더를 고려하라

썸네일

https://www.yes24.com/Product/Goods/65551284

이펙티브 자바 Effective Java 3/E - 예스24

 

정적 패터리와 생성자는 똑같은 제약이 있다.

“선택적 매개변수가 많을 때 적절히 대응하기 어렵다”

class Book{
    private String title;
    private String publisher;

    private String author;
    private String translator;
	private String painter;

    public Book(String title, String publisher, String author, String translator, String painter){
        this.title = title;
        this.publisher = publisher;
        this.author = author;
        this.translator = translator;
        this.painter = painter;
    }

    public Book(String title, String author, String translator, String publisher){
        this(title, author, translator, null, publisher);
    }

    public Book(String title, String author, String publisher){
        this(title, author, null, null, publisher);
    }

    public Book(String title, String publisher){
        this(title, "미상", null, null, publisher);
    }
}

위 경우에서는 author, translator는 선택적 매개변수이다.

Book book = new ("누가 내 머리에 똥쌌어?", "사계절", "베르너 홀츠바르트", null, "볼프 예를브루흐");

뭐가 작가고 그림작가고 null인 것은 무엇인지 알 수가 없다. 개수도 몇 개인지 알기 어렵다.

매개변수의 개수가 더 많아지면 클라이언트 코드를 작성하거나 읽기 어렵다.

이를 해결하기 위한 방법

• 자바 빈즈 패턴

class Book{
    private String title;
    private String publisher;

    private String author;
    private String translator;
    private String painter;

    public void setTitle(String title){this.title = title;}
    public void setPublisher(String publisher){this.publisher = publisher;}
    public void setAuthor(String author){this.author = author;}
    public void setTranslator(String translator){this.translator= translator;}
    public void setPainter(String painter){this.painter= painter;}
}

장점 : 앞에서의 문제는 더 이상 보이지 않음

단점 : 객체가 완전히 생성되기 전까진 일관성이 무너진 상태에 놓인다.

Book book = new Book();
book.setTitle("누가 내 머리에 똥 쌌어?");
book.setPublisher("사계절");

/*여기까지만 실행된 상태는 일관성이 깨진 상태이다.*/

book.setAuthor("베르너 홀츠바르트");
book.setPainter("볼프 예를브루흐");

 

• 빌더 패턴

점층적 생성자 패턴의 안전성과 자바 빈즈 배턴의 가독성 겸비

class Book{
    private final String title;
    private final String publisher;

    private final String author;
    private final String translator;
    private final String painter;
		
    public static class Builder{
        private final String title;
        private final String publisher;

        private String author;
        private String translator;
        private String painter;

        public Builder(String title, String publisher){
            this.title = title;
            this.publisher = publisher;
        }	

        public Builder author(String author){
            this.author= author;  return this;
        }
        public Builder translator(String translator){
            this.translator= translator;  return this;
        }
        public Builder painter(String painter){
            this.painter= painter;  return this;
        }

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

    public Book(Builder builder){
        title = builder.title;
        publisher = builder.publisher;
        author = builder.author;
        translator = builder.translator;
        painter = builder.painter;
    }
}

Book book = new Book("누가 내 머리에 똥 쌌어?", "사계절")
		.author("베르너 홀츠바르트")
		.painter("볼프 예를브루흐").build();

Book book = new ("누가 내 머리에 똥쌌어?", "사계절", "베르너 홀츠바르트", null, "볼프 예를브루흐");

모양 때문에 fluent API or method chaining 이라고도 한다.

잘못된 매개변수 감지(불변식 : 프로그램이 실행되는 동안 반드시 만족해야하는 규칙)를 위해 필드 검사 코드도 추가하면 좋다.

빌더 패턴은 특히 계층적으로 설계된 클래스와 쓰기 좋음

 

public abstract class Book{
    private final String title;
    private final String publisher;
    final Set<String> authors;

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

        private final String title;
        private final String publisher;
        Set<String> authors = Set.noneOf(String.class);

        public T addAuthors(String author){
            authors.add(Objects.requireNonNull(author));
            return self();
        }

	public Builder(String title, String publisher){
            this.title = title;
            this.publisher = publisher;
        }

        abstract Book build();

        protected abstract T self();

    }
    Book(Builder<?> builder){
        title = builder.title;
        publisher = builder.publisher;
        authors = builder.authors.clone();
    }
}

모양 때문에 fluent API or method chaining 이라고도 한다.빌더 패턴은 특히 계층적으로 설계된 클래스와 쓰기 좋음

public class PictureBook extends Book{
    private final String painter;

    public static class Builder extends Book.Builder<Builder>{
        private final String painter;
        public Builder(String title, String publisher, String painter){
            super(title, publisher);
            this.painter = painter;
        }

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

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

    private PictureBook(Builder builder){
        super(builder);
        painter = builder.painter;
    }
}

PictureBook book = new PictureBook.Builder("제목", "출판사", "그림작가")
            .addAuthors("작가1").addAuthors("작가2").addAuthors("작가3").build();

클라이언트는 형 변환에 신경쓰지 않고도 빌더를 사용할 수 있다. 아이디, 일련번호 같은 것을 알아서 채우도록 할 수도 있다.

장점 : 위 장점 + 빌더 하나로 여러 객체를 순회할수도, 매개변수에 따라 다른 객체를 만들 수도 있다.

단점 : 빌더를 만들어야 하는데 성능에 민감한 상황에서는 문제가 될 수 있다.