java8 consumer / supplier 를 이용한 builder pattern 구현

개요

java8 feature에 대하여 실무에서 활용 가능한 수준으로 best practice 제공

시작하는 말

디자인패턴에 대한 흔한 오해 중 대표적인 한 가지가 “디자인패턴은 프로그램 언어 독립적이다.” 입니다.

허나 실상은 그렇지 않으며, 매우 언어에 종속적이어서 특정 언어에서 제공하는 기능을 면밀히 살피지 않으면

의도한 대로 코드가 동작하지 않을 수도 있고, 해당 언어만의 장점을 살리지 못하는 반쪽짜리 코드가 될 수도 있습니다.

java8 에 추가된 functional interface 중 consumer / supplier 를 이용하면 보다 직관적인 builder pattern을 구현할 수 있습니다.

먼저, 종래에 java에서 builder pattern을 어떻게 구현하는지 살펴보고, 여기에 java8 feature 를 추가하여 어떻게 더 나아지는지 살펴보겠습니다.

builder pattern?

왜 쓰나

디자인패턴을 공부할 때 항상 염두에 두어야 할 것이 있습니다.

이 패턴을 왜 쓰나?

무엇이 좋아지나?

무엇이 안좋아지나?

 

모든 문제를 한방에 해결하는 만능의 해법이란 존재하지 않습니다.

어떤 문제를 해결하기 위한 선택을 하면 반드시 trade-off 가 발생합니다.

 

스타크래프트에서, 미네랄을 먼저 채취하여 후반에 많은 병력을 생산하기 위한 12드론 2해처리 빌드는 초반 러시에 취약하다는 단점이 존재합니다.

반대로 초반에 병력을 상대보다 먼저 뽑는 4드론 빌드는 초반러시에 강력하나 후반으로 갈수록 취약합니다.

초반에 병력도 많이 뽑고, 미네랄도 많이 캐고, 후반 병력도 많이 뽑는 그런 마법과도 같은 해법이 존재할까요?

아니면 그때 그때 상황에 맞는 적절한 젼략을 사용해야 할까요?

 

예시가 즈질스러우니 국민 패턴 싱글톤 패턴을 예로 들어봅시다.

싱글톤으로 생성된 객체는 어플리케이션 실행~종료 시까지 어디에서나 접근 가능합니다.

어플리케이션 내부에서 공유하여야 할 리소스 정보를 쉽게 참조 가능하다는 장점이 존재하지만,

싱글톤 객체는 객체지향 언어 버전의 전역변수나 마찬가지여서

1) 싱글톤 객체 – 다른 객체간 의존성이 높아짐,

2) 인스턴스 생성의 책임이 분리되지 않기 때문에 SRP 위반,

3) unittest객체가 싱글톤 객체에 종속성이 발생하기 때문에 단위 테스트 어려움

등의 단점이 있습니다.

객체지향 5원칙 (aka. S.O.L.I.D)에 만족하는 싱글톤 패턴은 존재하지 않습니다. 싱글톤 자체가 태생적으로 SRP를 위반하기 때문이죠.

허나 파일경로, ip주소 등 1) 쉽게 변경되지 않고, 2) 어플리케이션 영역 전체에 공유가 필요한 리소스는 싱글톤으로 구현하는 편이 유리합니다.

 

GoF 의 디자인패턴에 소개된 모든 패턴은 저마다 장/단점이 분명합니다.

각 패턴의 장/단점이 무엇인지 분명히 알면 장점은 부각시키고 단점은 최소화할 수 있습니다.

장점은 살리고, 단점은 감춘다. 이것이 좋은 소프트웨어 아키텍트가 갖추어야 할 설계 역량입니다.

 

이 글에서 소개할 디자인 패턴은 builder 패턴입니다. 빌더 패턴을 쓰는 이유는 크게 2가지입니다.

1) 귀찮아서

2) 보기 좋으라고

 

다음과 같은 class foo 를 가정해 봅시다.

귀찮은 class 생성
public class foo {
    private String a;
    private String b;
    private String c;
    private String d;
    private String e;
    private String f;
    private String g;
    private String h;
    private String i;
    private String j;
    private String k;
    private String l;
    public foo(String a, String b, String c, String d, String e, String f,
               String g, String h, String i, String j, String k, String l) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
        this.f = f;
        this.g = g;
        this.h = h;
        this.i = i;
        this.j = j;
        this.k = k;
        this.l = l;
    }
}

new foo(a,b,c,d,e,f…,z) 하기 귀찮습니다. 또 생성자의 parameter 가 길어지면 실수나 오타를 발견하기도 어렵습니다.

 

빌더 패턴은 new foo(a,b,c,d,e,f…,z) 를 new builder().a(a).b(b)…build() 로 보기 좋게 바꾸기 위하여 사용합니다.

‘보기 좋게 바꾼다’고 표현했지만 실제로는 부수적으로 따라오는 몇 가지 장점이 더 있습니다.

1) 실수, 오타의 여지를 줄여줌

2) 생성 parameter에 제약조건을 부여할 수 있습니다. (e.g. 타입, 필수 여부 등등)

 

java8 feature 를 사용하지 않은 builder pattern, Ver. 1

빌더 패턴의 가장 기본적인 아이디어는 객체 생성의 책임을 분리하는 데에 있습니다.

내가 만들려 하는 객체 생성의 역할을 다른 객체에 위임하는 것이죠.

 

builder pattern의 가장 기본적인 구현은 다음과 같습니다.

foo builder
public class fooBuilder {
    private String a;
    private String b;
    ...
    
    public fooBuilder setA(String a) {
        this.a = a;
        return this;
    }
    public fooBuilder setB(String b) {
        this.b = b;
        return this;
    }
    ...
    public foo build() {
        return new foo(this.a, this.b, ...);
}

 

위에서 작성한 fooBuilder class 를 사용하는 방법은 다음과 같습니다.

foo builder
//기존
foo myFoo = new foo(a,b,c,d,...);
 
//builder 사용
fooBuilder myFooBuilder = new fooBuilder();
foo myFoo = myFooBuilder.setA(a).setB(b)....build();

 

위에서 작성한 fooBuilder 클래스는 드닥 마음에 들지 않습니다. foo 객체를 생성하기 위해 불필요하게 fooBuilder 객체도 생성하여야 하니까요.

그러면 fooBuilder 의 메소드를 static으로 만들면 어떨까요? fooBuilder 객체를 생성하지 않아도 foo 객체를 생성할 수 있지 않을까요?

 

java8 feature 를 사용하지 않은 builder pattern, Ver. 2

fooBuilder class를 이렇게 바꿔봅시다.

foo builder
public class fooBuilder2 {
    private String a;
    private String b;
    ...
    
    public static fooBuilder setA(String a) {
        this.a = a;
        return this;
    }
    public static fooBuilder setB(String b) {
        this.b = b;
        return this;
    }
    ...
    public static foo build() {
        return new foo(this.a, this.b, ...);
}
foo builder
//기존
foo myFoo = new foo(a,b,c,d,...);
 
//builder 사용
fooBuilder myFooBuilder = new fooBuilder();
foo myFoo = myFooBuilder.setA(a).setB(b)....build();
 
//builder2 사용
foo myFoo = fooBuilder2.setA(a).setB(b)...build();

불필요한 builder 객체 생성을 없앴습니다. 어떤가요? 잘 작동할까요?

절대 이딴 식으로 프로그래밍 하시면 안됩니다. 오밤중에 서버실 끌려가 밤새도록 디버깅하는 수가 있어요.

fooBuilder2 는 thread safe 하지가 않습니다. 따라서 concurrent 환경에서 foo 객체가 지멋대로 만들어 지는 수가 있어요.

concurrent 와 thread safety 얘기는 길어지니 다음에 따로 다루기로 하고, 암튼 fooBuilder2 는 실패실패 대실패입니다. 절때 이딴식으로 개발하면 안되요.

 

java8 feature 를 사용하지 않은 builder pattern, Ver. 3

서두에 언급하였듯, 디자인패턴은 언어 종속적입니다.

java 언어에서만 지원하는 특별한 feature(inner class) 를 사용하면 builder pattern을 좀 더 아름답게 구현할 수 있어요.

fooBuilder를 foo class 내에 static inner class 로 구현하는 겁니다.

foo builder
public class foo {
    private String a;
    private String b;
    ...
    public foo(String a, String b, String c, String d, String e, String f,
               String g, String h, String i, String j, String k, String l) {
        this.a = a;
        this.b = b;
        ...
    }
    public static class fooBuilder {
        private String a;
        private String b;
        ...
        fooBuilder() {}
        public fooBuilder setA(String a) {
            this.a = a;
            return this;
        }
        public fooBuilder setB(String b) {
            this.b = b;
            return this;
        }
        ...
        public foo build() {
            return new foo(a, b,...);
        }
    }
}
foo builder
//기존
foo myFoo = new foo(a,b,c,d,...);
 
//builder 사용
fooBuilder myFooBuilder = new fooBuilder();
foo myFoo = myFooBuilder.setA(a).setB(b)....build();
 
//builder2 사용
foo myFoo = fooBuilder2.setA(a).setB(b)...build();
 
//static inner class builder 사용
foo myFoo = new foo.fooBuilder.setA(a).setB(b)...build();

static inner class 로 객체 생성 코드를 보기 좋게 바꾸었지만 여전히 단점은 존재합니다.

1개의 foo 객체 생성을 위하여 반드시 1개의 fooBuilder 객체를 생성해야 하는 문제는 남아 있습니다.

메모리를 효율적으로 사용해야 하는 환경에서는 적합하지 않습니다.

또한 builder class가 inner class 로 포함되면서 클래스 재사용성에 대한 고민을 다시 해야 합니다.

 

java8 feature 를 사용한 builder pattern

지금까지

1) GoF가 처음 제안한, 고전적 형태의 Builder pattern

2) java의 언어적 특징, static inner class 를 사용한 Builder pattern

을 살펴 보았습니다.

이번에는 java8에 추가된 functional interface 를 사용하여 builder pattern을 구현하는 방법을 소개할건데요.

시작하기에 앞서, java8의 Consumer / Supplier 가 무엇인지 알아보도록 합시다.

 

functional interface?

functional interface에 대하여 잘 모르는 분들이 많이 계시리라 생각되어 간단히 소개합니다.

함수형 언어의 가장 큰 특징 중 하나가 function(=method) 을 변수처럼 사용하는겁니다.

 

예를 들면,

var foo = someFunction(); //함수 definition에 대한 reference
 
var foo = (x) -> x*x; //definition이 없는 함수(=익명함수)에 대한 reference

 

예제에서의 var foo 처럼 function을 저장하는 방법이 언어적으로 제공되어야 하는데요.

java8 이전의 java에서 L-value 에 위치할 수 있는 type 들(Object나 primitive type 등)은 function reference 에 대한 저장을 고려하지 않았습니다.

때문에 함수형 언어로의 확장을 위하여 java8은

1) var foo 와 같은 역할을 제공하는 새로운 type을 정의하던가

2) 아니면 기존에 제공하던 언어 기반을 크게 변경하지 않으면서 꼼수를 쓰던가

둘 중 하나를 선택하여야 했습니다.

 

java8 은 2) 를 선택하는 꼼수를 두었는데요. 그 꼼수가 functional interface 입니다.

java compiler는 @FunctionalInterface 라는 Annotation 이 포함된 다음 조건을 충족하는 interface를 위 예제의 var foo 처럼 취급하기로 약속하였습니다.

1) non-static method

2) non-default method

3) only 1 method in interface

@FunctionalInterface
interface var {
    void execute(String arg);
}
 
var foo = (x) -> System.out.println(x);
 
foo.execute("Hello");

참 쉽죠?

 

java8에선 기본적인 형태의 functional interface 를 미리 정의해 두었습니다.

Consumer / Supplier / Function / Predicate 4가지인데요.

각각 용도가 다릅니다만 자세한 것은 다음 기회에 다루도록 하겠습니다.

 

Consumer 를 사용한 builder pattern

기본적인 아이디어는 이렇습니다.

1) 생성하고자 하는 객체의 setter method 를 변수로 저장

2) 객체 생성 시 저장해 두었던 setter method를 실행하여 객체 생성

 

구현체는 다음과 같습니다.

foo builder
public class foo {
    private String a;
    private String b;
    ...
    public foo(String a, String b, String c, String d, String e, String f,
               String g, String h, String i, String j, String k, String l) {
        this.a = a;
        this.b = b;
        ...
    }
    public static class fooBuilder {
        private foo _myFoo;
        private List<Consumer<foo>> _setters = new ArrayList<>();
        public <T> fooBuilder with(BiConsumer<foo, T> setter, T val) {
          if (_myFoo == null)
               _myFoo = new foo();
         Consumer<foo> c = _myFoo -> setter.accept(_myFoo, val);
         _setters.add(c);
         return this;
       }
       public foo build() {
           foo val = _myFoo;
           _setters.forEach(_setters -> _setters.accept(val));
           _setters.clear();
           return _myFoo;
       }
    }
}
foo builder
//function interface 로 구현한 builder class 사용
foo myFoo = new foo.fooBuilder().with(foo::setA, "A").with(foo::setB, "B")...build();

 

위 패턴의 장단점을 살펴 볼까요?

장점은

1) 코드 재사용 : 생성할 Class 에 존재하는 setter 를 Builder Class에 중복으로 생성하지 않고 변수에 담아 재사용

 

단점은

1) 대동소이한 Builder를 매번 재구현하여야 함

 

Supplier / Consumer 를 사용한 builder pattern

위의 단점을 개선하여 봅시다.

Builder 코드를 재사용하여 생산성을 높이는 데에는 다음 두 가지 방법이 있습니다.

1) 상속을 통한 재사용

2) Generic을 통한 재사용

 

여기선 2) 방법으로 builder pattern을 고쳐 보겠습니다.

 

구현체는 다음과 같습니다.

generic builder
public class GenericBuilder<T> {
    private final Supplier<T> _instance;
    private List<Consumer<T>> _setters = new ArrayList<>();
    private GenericBuilder(Supplier<T> instance) {
        this._instance = instance;
    }
    public static <T> GenericBuilder<T> of(Supplier<T> instance) {
        return new GenericBuilder<T>(instance);
    }
    public <U> GenericBuilder<T> with(BiConsumer<T, U> consumer, U value) {
        Consumer<T> c = setter -> consumer.accept(setter, value);
        _setters.add(c);
        return this;
    }
    public T build() {
        T value = _instance.get();
        _setters.forEach(iter -> iter.accept(value));
        _setters.clear();
        return value;
    }
}
foo builder
//Generic builder class 사용
foo myFoo4 = GenericBuilder.of(foo::new)
        .with(foo::setA, "A")
        .with(foo::setB, "B")
        .with(foo::setC, "C")
        ...
        .build();

 

위 패턴의 장단점은 다음과 같습니다.

장점은

1) 코드 재사용 : GenericBuilder 클래스를 범용적으로 재사용 가능

 

단점은

1) inner class 를 사용할 때 보다 직관적이지 않다.

 

결론

여기서는 builder 패턴만 다루었지만 다른 패턴 공부도 위와 비슷하게 진행하시면 많은 도움이 될 겁니다.

이 패턴을 왜 쓰는지

내가 사용하는 언어에 특화된 구현 방법은 없는지

특히 java8 feature 를 사용할 여지가 있는지

java8 consumer / supplier 를 이용한 builder pattern 구현”에 대한 2개의 생각

  1. 안녕하세요. 좋은 아이디어 잘 보고 갑니다. 한가지 궁금한점이 있습니다.
    맨처음 제시한 빌더는 immutable 객체를 만드는데, 맨 아래에 제시한 GenericBuilder는 mutable한 객체인 듯합니다. Builder 패턴의 장점중 하나가 immutable객체를 생성을 하는것으로 생각되는데요.
    GenericBuilder로 immutable한 객체는 만들수 없을까요?

    Liked by 1명

  2. 좋은 댓글 감사합니다. 저 글을 작성할 당시 immutability 는 미처 고려하지 않았는데 좋은 점을 지적해 주셨네요. GenericBuilder는 java8 기능인 Consumer / Supplier 를 사용하여 빌더를 만든다는게 기본 아이디어였기 때문에 immutable 객체 생성 목적으로 사용은 어렵겠네요. 역시 모든 설계에는 장단점이 존재하는 것 같습니다.

    좋아요

답글 남기기

아래 항목을 채우거나 오른쪽 아이콘 중 하나를 클릭하여 로그 인 하세요:

WordPress.com 로고

WordPress.com의 계정을 사용하여 댓글을 남깁니다. 로그아웃 /  변경 )

Google+ photo

Google+의 계정을 사용하여 댓글을 남깁니다. 로그아웃 /  변경 )

Twitter 사진

Twitter의 계정을 사용하여 댓글을 남깁니다. 로그아웃 /  변경 )

Facebook 사진

Facebook의 계정을 사용하여 댓글을 남깁니다. 로그아웃 /  변경 )

w

%s에 연결하는 중