프로토타입 빈과 싱글톤 빈 겸용

해당 내용은 '스프링 입문을 위한 자바 객체 지향의 원리와 이해'와 인프런 김영한님의 '스프링 핵심 원리 - 기본편' 강의를 참고하였습니다.

프로토타입 빈과 싱글톤 빈을 함께 사용하면?

이전에 배웠듯, 스프링 컨테이너에 프로토타입 빈을 요청하면 항상 새로 생성해서 반환받는다.

그러나 이러한 프로토타입빈을 싱글톤 빈과 같이 사용하면 우리가 생각하는대로 동작하지 않을 수 있다.

예제를 통해서 확인해보자.

우선 간단하게 프로토타입 빈을 반환받는 예제를 만들어보자.

단순하게 매번 프로토타입 빈을 생성해서 해당 빈 안에 있는 변수에 1을 더해보고, 그게 매번 초기화되는지 확인해본다.

SingletonWithPrototypeTest1.java

public class SingletonWithPrototypeTest1 {

    @Test
    void prototypeFind(){
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PrototypeBean.class);
        PrototypeBean prototypeBean1 = ac.getBean(PrototypeBean.class);
        prototypeBean1.addCnt();
        Assertions.assertThat(prototypeBean1.getCnt()).isEqualTo(1);

        PrototypeBean prototypeBean2 = ac.getBean(PrototypeBean.class);
        prototypeBean2.addCnt();
        Assertions.assertThat(prototypeBean2.getCnt()).isEqualTo(1);
    }

    @Scope("prototype")
    static class PrototypeBean{
        private int cnt = 0;

        public void addCnt(){
            cnt++;
        }

        public int getCnt(){
            return cnt;
        }

        @PostConstruct
        public void init(){
            System.out.println("PrototypeBean.init : " + this);
        }

        @PreDestroy
        public void destroy(){
            System.out.println("PrototypeBean.destroy");
        }
    }
}

결과는 다음과 같다.

PrototypeBean.init : hello.core.scope.SingletonWithPrototypeTest1$PrototypeBean@1c9db850
PrototypeBean.init : hello.core.scope.SingletonWithPrototypeTest1$PrototypeBean@d1cdfeb4

그런데, 만약 싱글톤 빈에 내부에서 프로토타입 빈을 의존성 주입으로 받으면 어떻게 될까?

ClientBean이라는 싱글톤 빈 내부에 프로토타입 빈인 prototypeBean1을 주입받는 다음과 같은 상황을 생각해보자.

1. ClientBean은 싱글톤 빈이기에, 보통 스프링 컨테이너 생성 시점에 함께 생성될 것이고, 의존성도 그때 주입받을 것이다.
2. ClientBean은 의존성 주입 시점에 스프링 컨테이너에 prototypeBean1을 요청한다.
3. 스프링 컨테이너는 프로토타입 빈을 생성해서 ClientBean에 반환한다.
4. 외부에서 ClientBean을 요청해서 반환 받는다.
5. 외부에서 ClientBean 내부의 prototypeBean1의 cnt를 증가시키는 로직을 호출한다. 그럼 prototypeBean1의 cnt는 0에서 1로 변한다.
6. 외부에서 다른 호출을 통해서 ClientBean을 반환받는다. 이때 해당 호출 역시 내부 prototypeBean1의 cnt를 증가시키는 로직을 호출한다.

위와 같은 상황에서 두번째 호출한 쪽에서 반환받는 prototypeBean의 cnt는 몇일까?

정답은 2이다. 왜그럴까?

ClientBean 안에 있는 prototypeBean은 이미 과거에 의존성 주입이 끝난 빈이라고 할 수 있다. 그렇기에 주입 시점에 스프링 컨테이너에 요청해서 프로토타입 빈이 새로 생성된 것이지, 이전 예제처럼 사용할 때마다 생성되는 것이 아니다.

스프링 컨테이너에서 프로토타입 빈인 prototypeBean1이 생성됨과 동시에 스프링 컨테이너에서의 관리는 끝이났고, 이 prototypeBean1을 싱글톤 빈이 '보관'하고 있던 것이다.

위의 상황을 코드로 짜보자.

SingletonWithPrototypeTest1.java

import static org.assertj.core.api.AssertionsForClassTypes.assertThat;

public class SingletonWithPrototypeTest1 {

    @Test
    void prototypeFind() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PrototypeBean.class);
        PrototypeBean prototypeBean1 = ac.getBean(PrototypeBean.class);
        prototypeBean1.addCnt();
        Assertions.assertThat(prototypeBean1.getCnt()).isEqualTo(1);

        PrototypeBean prototypeBean2 = ac.getBean(PrototypeBean.class);
        prototypeBean2.addCnt();
        Assertions.assertThat(prototypeBean2.getCnt()).isEqualTo(1);
    }

    @Test
    void singletonClientUsePrototype() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PrototypeBean.class, ClientBean.class);
        ClientBean ClientBean1 = ac.getBean(ClientBean.class);
        int cnt1 = ClientBean1.logic();
        assertThat(cnt1).isEqualTo(1);

        ClientBean ClientBean2 = ac.getBean(ClientBean.class);
        int cnt2 = ClientBean2.logic();
        assertThat(cnt2).isEqualTo(2);
    }

    @Scope("singleton")
    static class ClientBean {
        private final PrototypeBean prototypeBean;

        @Autowired
        public ClientBean(PrototypeBean prototypeBean) {
            this.prototypeBean = prototypeBean;
        }

        public int logic() {
            prototypeBean.addCnt();
            return prototypeBean.getCnt();
        }
    }

    @Scope("prototype")
    static class PrototypeBean {
        private int cnt = 0;

        public void addCnt() {
            cnt++;
        }

        public int getCnt() {
            return cnt;
        }

        @PostConstruct
        public void init() {
            System.out.println("PrototypeBean.init : " + this);
        }

        @PreDestroy
        public void destroy() {
            System.out.println("PrototypeBean.destroy");
        }
    }
}

기존 코드에 ClientBean과 두번째 테스트인 singletonClientUsePrototype를 추가 했다.

실행해보면 결과는 다음과 같다.

PrototypeBean.init : hello.core.scope.SingletonWithPrototypeTest1$PrototypeBean@cc2fb972

init이 단 한번 호출되었다.

프로토타입 빈이 한번만 생성되었다는 의미다.

우리가 위에서 이야기한 대로다. 그럼 이걸 어떻게 해결할까?

어떻게 하면 프로토타입 빈을 매번 새로 생성할 수 있을까?

가장 간단한 방법은 ClientBean이(싱글톤 빈이) 프로토타입 빈을 사용할 때마다 스프링 컨테이너에 새로 요청하는 방법이다.

이전 예제에서 이 방법을 도입하면 다음과 같이 코드를 변경해야한다.

SingletonWithPrototypeTest1.java

...

	@Scope("singleton")
    static class ClientBean {
        @Autowired
        private ApplicationContext ac;

        public int logic() {
        	PrototypeBean prototypeBean = ac.getBean(PrototypeBean.class);
            prototypeBean.addCnt();
            return prototypeBean.getCnt();
        }
    }

...

이렇게 하면 매번 프로토타입 빈을 스프링 컨테이너에서 새로 생성받게 된다.

위와 같이 의존관계를 외부에서 주입(DI) 받는게 아니라, 직접 필요한 의존관계를 찾는 방법을 Dependency Lookup(DL - 의존관계 탐색) 이라고 한다.

그런데 이렇게 스프링의 ApplicationContext 전체를 매번 주입 받는다면, 스프링 컨테이너에 종속적인 코드가 되고, 단위테스트도 힘들어진다.

우리에게는 ApplicationContext를 매번 주입받지 않고, 단순하게 지정한 프로토타입의 빈만 컨테이너에서 찾아주는 DL 기능이 필요하다.

스프링에는 이런 적절한 기능이 있다.

ObjectProvider

지정한 빈을 컨테이너에서 대신 찾아주는, DL 서비스를 제공하는 인터페이스가 ObjectProvider 이다. (예전에는 ObjectFactory가 있었지만, 여기에 편의 기능을 더 한 것이 ObjectProvider 이다.)

• ObjectFactory
  • 기능이 단순
  • 별도 라이브러리 필요 X
  • 스프링에 의존
• ObjectProvider
  • ObjectFactory 상속
  • 옵션, 스트림 처리등의 편의 기능이 많다.
  • 별도의 라이브러리 필요 X
  • 스프링에 의존

그럼 ObjectProvider 를 사용해서 기존 코드를 변경해보자.

SingletonWithPrototypeTest1.java

...

        @Test
    void singletonClientUsePrototype() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PrototypeBean.class, ClientBean.class);
        ClientBean clientBean1 = ac.getBean(ClientBean.class);
        int cnt1 = clientBean1.logic();
        assertThat(cnt1).isEqualTo(1);

        ClientBean clientBean2 = ac.getBean(ClientBean.class);
        int cnt2 = clientBean2.logic();
        assertThat(cnt2).isEqualTo(1);
        ac.close();
    }
    
    @Scope("singleton")
    static class ClientBean {

        @Autowired
        private ObjectProvider<PrototypeBean> prototypeBeanObjectProvider;

        public int logic() {
            PrototypeBean prototypeBean = prototypeBeanObjectProvider.getObject();
            prototypeBean.addCnt();
            return prototypeBean.getCnt();
        }
    }

...

실행을 해보면,

PrototypeBean.init : hello.core.scope.SingletonWithPrototypeTest1$PrototypeBean@150ad410
PrototypeBean.init : hello.core.scope.SingletonWithPrototypeTest1$PrototypeBean@b1fa3dc9

다음과 같이 프로토타입 빈이 두 번 생성되었음을 알 수 있다.

ObjectProvider 의 getObject()메서드를 사용하면 내부에서는 스프링 컨테이너를 통해서 해당 빈을 찾아 반환한다.(DL)

JSR-330

위의 ObjectFactory 와 ObjectProvider 는 아주 간단히 사용할 수 있지만, 스프링에 의존적이라는 단점이 있다.

스프링이 아닌 다른 컨테이너에서 사용할 때, 우리는 JSR-330, 즉 javax.inject.Provider라는 자바 표준을 사용할 수 있다.

다만, 해당 방법을 사용하려면 gradle에 다음과 같이 별도의 라이브러리를 추가해야한다.

implementation'javax.inject:javax.inject:1'

그러면 다음과 같은 Provider 인터페이스를 확인할 수 있다.

public interface Provider<T> {
    T get();
}

이제 자바 표준을 사용해보자.

SingletonWithPrototypeTest1.java

...

    @Scope("singleton")
    static class ClientBean {

        @Autowired
        private Provider<PrototypeBean> prototypeBeanObjectProvider;

        public int logic() {
            PrototypeBean prototypeBean = prototypeBeanObjectProvider.get();
            prototypeBean.addCnt();
            return prototypeBean.getCnt();
        }
    }
    
...

이전과 동일하게 동작할 것이다.

정리

복잡하다 복잡해

이런 프로토타입 빈은 매번 사용할 때마다 의존관계 주입이 완료된 새로운 객체가 필요하면 그때 사용하면 된다.

(실제로 사용할 일이 있을까..)