빈 스코프(Bean Scope)

✅ 빈 스코프

• 빈 스코프란, 스프링 빈이 존재할 수 있는 범위를 뜻한다.

빈 스포크의 종류

• 싱글톤(Singleton) : 기본 Scope, 스프링 컨테이너의 시작과 종료까지 유지되는 가장 넓은 범위의 스코프
• 프로토타입(Prototype) : 스프링 컨테이너는 프로토타입 빈의 생성과 의존관계 주입까지만 관여하고 더는 관리하지 않는 매우 짧은 범위의 Scope이다.
• 웹 관련 스코프
  • request : 웹 요청이 들어오고 나갈때까지 유지되는 Scope
  • session : 웹 세션이 생성되고 종료될 때까지 유지되는 Scope
  • application : 웹의 서블릿 컨텍스트와 같은 범위로 유지되는 스코프

✅ 빈 스코프 지정 방법

• 컴포넌트 스캔 자동 등록

@Scope("prototype")
@Component
public class HelloBean {}

• 수동 등록

@Scope("prototype")
@Bean
PrototypeBean HelloBean() {
	return new HelloBean();
}

✅ Singleton Scope

• 싱글톤 스코프의 빈을 조회하면 스프링 컨테이너는 항상 같은 인스턴스의 빈을 반환한다.

1. 싱글톤 스코프 빈을 스프링 컨테이너에 요청
2. 스프링 컨테이너는 본인이 관리하는 스프링 빈을 반환
3. 이후에 스프링 컨테이너에 같은 요청이 와도 같은 객체 인스턴스의 스프링 빈을 반환
   

✅ Prototype Scope

• Prototype Scope를 스프링 컨테이너에 조회하면 스프링 컨테이너는 항상 새로운 인스턴스를 생성해서 반환한다.
• 스프링 컨테이너는 프로토타입 빈을 생성하고 의존관계 주입, 초기화까지만 처리한다.
• 이후 스프링 컨테이너는 생성된 프로토타입 빈을 관리하지 않는다.
• 프로토타입 빈을 관리할 책임은 빈을 받은 클라이언트에 있다. 그래서 @PreDestory 같은 종료 메소드가 호출되지 않는다. 따라서 종료 메소드에 대한 호출도 클라이언트가 직접 해야한다.

1. 프로토타입 스코프 빈을 스프링 컨테이너에 요청
2. 스프링 컨테이너는 이 시점에 프로토타입 빈을 생성하고 필요한 의존관계를 주입

public class SingletonTest {

    @Test
    public void singletonBeanFind() {
        AnnotationConfigApplicationContext ac = new
        AnnotationConfigApplicationContext(SingletonBean.class);
        SingletonBean singletonBean1 = ac.getBean(SingletonBean.class);
        SingletonBean singletonBean2 = ac.getBean(SingletonBean.class);

        System.out.println("singletonBean1 = " + singletonBean1);
        System.out.println("singletonBean2 = " + singletonBean2);

        assertThat(singletonBean1).isSameAs(singletonBean2);
        ac.close(); //종료
    }

    @Scope("singleton")
    static class SingletonBean {

        @PostConstruct
        public void init() {
            System.out.println("SingletonBean.init");
        }

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

3. 스프링 컨테이너는 생성한 프로토타입 빈을 클라이언트에 반환
4. 이후에 스프링 컨테이너에 같은 요청이 오면 항상 새로운 프로토타입 빈을 생성하여 반환

public class PrototypeTest {

    @Test
    public void prototypeBeanFind() {
    	AnnotationConfigApplicationContext ac = new
    	AnnotationConfigApplicationContext(PrototypeBean.class);
    	System.out.println("find prototypeBean1");
        
    	PrototypeBean prototypeBean1 = ac.getBean(PrototypeBean.class);
    System.out.println("find prototypeBean2");
    
    	PrototypeBean prototypeBean2 = ac.getBean(PrototypeBean.class);
    
    	System.out.println("prototypeBean1 = " + prototypeBean1);
    	System.out.println("prototypeBean2 = " + prototypeBean2);
    
    	assertThat(prototypeBean1).isNotSameAs(prototypeBean2);
    	ac.close(); //종료
    }
    
    @Scope("prototype")
    static class PrototypeBean {
    
        @PostConstruct
        public void init() {
        	System.out.println("PrototypeBean.init");
        }
    
        @PreDestroy
        public void destroy() {
        	System.out.println("PrototypeBean.destroy");
        }
	}
}

• 싱글톤 빈은 스프링 컨테이너 생성 시점에 초기화 메소드가 실행되지만, 프로토타입 스코프 빈은 컨테이너 빈을 조회할 때 생성되고, 초기화 메소드도 실행된다.
• 조회한 프로토타입의 빈은 별개의 스프링 빈이 생성되고 초기화도 생성될 때 마다 실행된다.
• 싱글톤 빈은 스프링 컨테이너가 관리하기 때문에 스프링 컨테이너가 종료될 때 빈의 종료 메소드가 실행되지만, 프로토타입은 스프링 컨테이너가 빈의 생성과 의존관계 주입, 초기화 까지만 관여하고 더 이상 관리하지 않기 때문에 스프링 컨테이너가 종료될 때 @PreDestory 같은 종료 메소드가 실행되지 않는다.

❗ 프로토타입 스코프를 싱글톤 빈과 함께 사용시 문제점

• 싱글톤 빈에서 프로토타입 빈 사용 예시
  
• clientBean은 싱글톤이므로, 스프링 컨테이너 생성 시점에 함께 생성되고 의존관계 주입도 발생한다.
  1. clientBean은 의존관계 자동 주입을 사용한다. 주입 시점에 스프링 컨테이너에 프로토타입 빈을 요청한다.
  2. 스프링 컨테이너는 프로토타입 빈을 생성해서 clientBean에 반환한다. 프로토타입 빈의 count 필드 값은 0 이다.
• clientBean은 프로토타입 빈(참조 값)을 내부 필드에 보관한다.
  
• 클라이언트 A는 clientBean을 스프링 컨테이너에 요청해서 받는다. 싱글톤이므로 항상 같은 clientBean이 반한된다.
• 클라리언트 A는 clientBean.logic()을 호출하고 clientBean에서 addCount()를 호출해서 프로토타입 빈의 count를 증가한다. count 값은 1이 된다.
  
• 클라이언트 B가 clientBean을 스프링 컨테이너에 요청하면, 싱글톤이므로 같은 clientBean을 반환받는다.
  • 💡 여기서 중요한 점은, clientBean이 내부에 가지고 있는 프로토타입 빈은 이미 clientBean 생성 시점에 주입이 끝났으므로 이 프로토타입 빈은 사용할때마다 생성되는 것이 아니라 계속 같은 프로토타입 빈을 사용하는 것이다.
• 클라이언트 B는 clientBean.logic()을 호출하면, clientBean에서 addCount()를 호출한다. 이 때 새로 생성된 프로토타입 빈이 아니라 이미 생성되었던 빈을 그대로 사용하므로 원래 count 값이 1이였으므로 2로 증가된다.

public class SingletonWithPrototypeTest1 {

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

        ClientBean clientBean2 = ac.getBean(ClientBean.class);
        int count2 = clientBean2.logic();
        assertThat(count2).isEqualTo(2);
    }
    
	static class ClientBean {
		private final PrototypeBean prototypeBean;
        
        @Autowired
        public ClientBean(PrototypeBean prototypeBean) {
        	this.prototypeBean = prototypeBean;
        }
        
        public int logic() {
            prototypeBean.addCount();
            int count = prototypeBean.getCount();
            return count;
        }
	}

	@Scope("prototype")
	static class PrototypeBean {
		private int count = 0;
        
        public void addCount() {
        	count++;
        }
        
        public int getCount() {
        	return count;
        }
        
        @PostConstruct
        public void init() {
        	System.out.println("PrototypeBean.init " + this);
        }
        
        @PreDestroy
        public void destroy() {
        	System.out.println("PrototypeBean.destroy");
        }
	}
}

✔️ 정리하면, 싱글톤 빈과 프로토타입 빈을 함께 사용하면, 싱글톤 빈은 생성 시점에만 의존관계 주입을 받기 때문에, 프로토타입도 생성된 시점에 주입이 된 이후에 새로 생성되지 않고 계속 유지되는 것이 문제다.

🌟 프로토타입 스코프와 싱글톤 빈을 같이 사용 시 문제점 해결 방법

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

static class ClientBean {

    @Autowired
    private ApplicationContext ac;
    
    public int logic() {
    	//logic()이 실행될 때마다, 스프링 컨테이너에서 새로운 PrototypeBean을 요청하여 생성한다.
    	PrototypeBean prototypeBean = ac.getBean(PrototypeBean.class);
    	prototypeBean.addCount();
    	int count = prototypeBean.getCount();
    	return count;
    }
}

• 위 방법을 사용하게 되면, ApplicationContext 전체를 주입받게 되고 이는 스프링 컨테이너에 종속적인 코드가 된다.
• 또한, 단위 테스트도 어려워진다.
• Dependency Lookup(DI)는 의존관계를 외부에서 주입받지 않고 직접 필요한 의존관계를 찾는 것을 말한다.
• 여기서는 DI를 받는것이 아니라 DL 정도의 기능만 있으면 충분하다. 그 기능을 제공하는 것이 아래 ObjectFactory, ObjectProvider 이다.

2. ObjectFactory, ObjectProvider 사용

• ObjectFactory 와 ObjectProvider는 지정한 빈을 컨테이너에서 대신 찾아주는 DL 서비스를 제공하는 기능이다.
• ObjectProvider가 ObjectFactory보다 나중에 편의 기능이 추가되어 나왔다.

@Autowired
private ObjectProvider<PrototypeBean> prototypeBeanProvider;

public int logic() {
	PrototypeBean prototypeBean = prototypeBeanProvider.getObject();
    prototypeBean.addCount();
    int count = prototypeBean.getCount();
    return count;
}

• prototypeBeanProvider.getObject()를 통해서 항상 새로운 프로토타입 빈이 생성된다.
• ObjectyProvider의 getObect()를 호출하면 내부에서 스프링 컨테이너를 통해 해당 빈을 찾아서 반환한다. (DL)
• 스프링 기능을 사용하지만, 단순하므로 테스트하는데 용이하다.
• ObjectFactory : 기능이 단순, 별도의 라이브러리 필요 없음, 스프링에 의존
• ObjectProvider : ObjectFactory 상속, 옵션 스트림 처리 등 편의 기능이 많고, 별도의 라이브러리 필요 없음, 스프링에 의존

3. JSR-330 Prvider 사용

• javax.inject.Provider 라는 JSR-330 자바 표준을 사용하는 방법이다.
• 스프링 부트 3.0은 jakarta.inject.Provider를 사용한다.
• 해당 방법은 gradle에 라이브러리를 추가해야 한다.
  • Spring Boot 3.0 미만 : javax.inject:javax.inject:1
  • Spring Boot 3.0 이상 : jakarta.inject:jakarta.inject-api:2.0.1

@Autowired
private Provider<PrototypeBean> provider;

public int logic() {
    PrototypeBean prototypeBean = provider.get();
    prototypeBean.addCount();
    int count = prototypeBean.getCount();
	return count;
}

• 자바 표준이고 기능이 단순하므로 단위 테스트나 mock 코드를 작성하기 용이하다.
• 자바 표준이므로 스프링이 아닌 다른 컨테이너에서도 사용이 가능하다.

📝 참고

• 실무에서는 싱글톤 빈으로 대부분의 문제를 해결할 수 있으므로 프로토타입빈을 직접적으로 사용하는 경우는 드물다.
• JSR-330은 코드를 스프링이 아닌 다른 컨테이너에서도 사용할 수 있어야 할 때 사용하고, 아닌 경우 ObjectProvider를 주로 사용한다.
• 보통 자바 표준과 스프링이 제공하는 기능이 겹칠 때가 많은데, 다른 컨테이너를 사용할 일이 없다면, 스프링이 제공하는 기능을 사용하자.

✅ 웹 스코프

• 웹 스코프는 웹 환경에서만 동작한다.
• 프로토타입 스코프와 다르게 스프링이 해당 스코프의 종료 시점까지 관리한다. 즉, 종료 메소드가 호출된다.

웹 스코프의 종류

• request : HTTP 요청 하나가 들어오고 나갈 때까지 유지되는 스코프, 각각의 HTTP 요청마다 별도의 빈 인스턴스가 생성되고 관리된다.
• session : HTTP Session과 동일한 생명주기를 가지는 스코프
• application : ServletContext와 동일한 생명주기를 가지는 스코프
• websocket : Web Socket과 동일한 생명주기를 가지는 스코프

🔼 위의 각 종류들은 범위만 다르고 동작 방식은 비슷하다. request를 예로 정리한다.

request 사용 예시

✔️ 참고 : 스프링 부트는 웹 라이브러리가 없으면 AnnotationConfigApplicationContext 을 기반으로 어플리케이션을 구동한다. 웹 라이브러리가 추가되면 웹과 관련된 추가 설정과 환경들이 필요하므로 AnnotationConfigServletWebServerApplicationContext를 기반으로 어플리케이션을 구동한다.

@Component
//Scope를 request로 지정
@Scope(value = "request")
public class MyLogger {
    private String uuid;
    private String requestURL;

    public void setRequestURL(String requestURL) {
        this.requestURL = requestURL;
    }

    public void log(String message) {
        System.out.println("[" + uuid + "]" + "[" + requestURL + "]" + message);
    }

    @PostConstruct
    public void init() {
        uuid = UUID.randomUUID().toString();
        System.out.println("[" + uuid + "] request scope bean create:" + this);
    }

    @PreDestroy
    public void close() {
        System.out.println("[" + uuid + "] request scope bean close:" + this);
    }
}

• 위 예제는 로그를 출력하기 위한 클래스이고 Scope를 request 를 사용해서 이 빈은 HTTP 요청 당 하나씩 생성되고 HTTP 요청이 끝나는 시점에 소멸된다.
• 이 빈이 생성되는 시점에 @PostConstruct 초기화 메소드를 사용하여 uuid를 생성해서 저장해둔다.
• 이 빈은 HTTP 요청 당 하나씩 생성되므로 uuid를 통해 다른 HTTP 요청과 구분할 수 있다.
• 이 빈이 소멸되는 시점에 @PreDestroy를 사용해서 종료 메소드를 호출한다.
• requestURL은 이 빈이 생성되는 시점에는 알 수 없으므로, 외부에서 setter로 입력 받는다.

@Controller
@RequiredArgsConstructor
public class LogDemoController {
    private final LogDemoService logDemoService;
    private final MyLogger myLogger;

    @RequestMapping("log-demo")
    @ResponseBody
    public String logDemo(HttpServletRequest request) {
        String requestURL = request.getRequestURL().toString();
        myLogger.setRequestURL(requestURL);

        myLogger.log("controller test");
        logDemoService.logic("testId");
        return "OK";
    }
}

🔼 MyLogger가 잘 동작하는지 테스트하기 위한 컨트롤러이다.

@Service
@RequiredArgsConstructor
public class LogDemoService {
    private final MyLogger myLogger;

    public void logic(String id) {
        myLogger.log("service Id = " + id);
    }
}

🔼 서비스 계층에서도 로그를 기록하기 위해 작성한 서비스이다.

• 여기서 중요한 점은, request scope를 사용하지 않고 requestURL와 같은 웹과 관련된 정보를 파라미터를 통해 서비스로 넘기게 된다면 웹 기술에 종속적이게 되고 유지보수에 좋지 않다.
• 이러한 부분을 request scope으로 해결하여 코드와 계층을 깔끔하게 유지할 수도 있다.

실제 실행 결과

Error creating bean with name 'myLogger': Scope 'request' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton;

• 스프링 어플리케이션을 실행하면 위 오류가 발생한다.
• 위 오류는 MyLogger에서 발생하는 오류인데, 이유는 Controller에서 MyLogger를 주입받고 있는데 MyLogger는 request가 들어왔을 때 생성할 수 있다.
• 그러나 현재 상태는 스프링 어플리케이션을 실행만 한 시점이므로, MyLogger가 생성되지 않았고 의존관계 주입을 할 수 없기 때문에 오류가 발생한 것이다.
• 해당 문제를 Provider를 사용해서 해결할 수 있다.

✅ 스코프와 Provider

• 아래 예제와 같이 Provider를 사용하여 위 오류를 해결한다.

@Controller
@RequiredArgsConstructor
public class LogDemoController {
    private final LogDemoService logDemoService;
    //private final MyLogger myLogger;
    private final ObjectProvider<MyLogger> myLoggerProvider; //Provider를 주입받는다.

    @RequestMapping("log-demo")
    @ResponseBody
    public String logDemo(HttpServletRequest request) {
        String requestURL = request.getRequestURL().toString();
        //Provider를 통해서 등록된 MyLogger 빈을 찾아서 넣어준다.
        MyLogger myLogger = myLoggerProvider.getObject();
        myLogger.setRequestURL(requestURL);

        myLogger.log("controller test");
        logDemoService.logic("testId");
        return "OK";
    }
}

• ObjectProbiver를 통해서 ObjectProvider.getObject() 를 호출하는 시점까지 request scope 빈의 생성을 지연(정확히는 스프링 컨테이너에게 빈 생성 요청하는 시기)할 수 있다.
• ObjectProvider.getObject() 을 호출하는 시점에는 HTTP 요청이 진행중이므로 request scope 빈이 정상적으로 생성된다.

✅ 스코프와 프록시

• 위의 Provider를 사용해도 request 스코프 빈의 호출 시점을 지연하도록 처리할 수 있는데, 이보다 코드를 더 간결하게 작성하여 처리할 수 있는 방법이 있다.
• 그 것이 Proxy를 사용하는 방법이다.

@Component
@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class MyLogger {
}

• proxyMode = ScopedProxyMode.TARGET_CLASS 와 같이 Scope에 적용할 수 있다.
  • 적용 대상이 클래스이면, TARGET_CLASS, 인터페이스면 INTERFACES를 사용하면 된다.
• 이렇게 적용하면, 적용 대상 클래스(MyLogger)의 가짜 프록시 클래스를 만들어두고 HTTP 요청과 상관 없이 가짜 프록시 클래스를 다른 빈에 미리 주입해둘 수 있다.
• 실제로 MyLogger 클래스를 호출해보면 아래와 같은 결과가 나온다.
  myLogger = class hello.core.common.MyLogger$$EnhancerBySpringCGLIB$$b68b726d
  -이 것은 스프링 컨테이너가 CGLIB라는 라이브러리를 사용해서 MyLogger를 상속받은 가짜 프록시 객체를 생성한다.
• 그리고 스프링 컨테이너에 생성된 이 가짜 프록시 객체를 빈으로 등록한다.

• 가짜 프록시 객체는 실제 타겟 객체를 사용할 수 있고, 관련 로직을 실행하면 실제 타겟 객체의 메소드를 호출한다.
• 클라이언트 입장에서는 사용하는 객체가 실제 객체인지 가짜 객체인지 몰라도 되고 동일하게 사용할 수 있게 된다. (다형성)

동작 정리

1. CGLIB 라이브러리가 타겟 클래스에 대한 가짜 프록시 객체를 만들어서 주입한다.
2. 이 가짜 프록시 객체는 실제 요청이 오면 내부에서 실제 타겟 객체를 요청한다.
3. 가짜 프록시 객체는 실제 request scope와는 관계가 없다. 단지 가짜 객체이고 싱글톤처럼 동작한다.
4. 프록시 객체로 싱글톤 빈을 사용하듯이 request scope를 사용할 수 있다.
5. 중요한 핵심은, Provider나 Proxy나 실제 객체 조회를 꼭 필요한 시점까지 지연할 수 있다는 점이다.

주의점

• 마치 싱글톤처럼 동작하는 것 같지만 실제로는 다르게 동작하므로 주의해서 사용해야 한다.
• 이런 특별한 scope는 필요한 곳에만 최소화해서 사용하는 것이 좋다. 그렇지 않으면 유지보수하기 어려워진다.

참고 Reference

• 인프런 강의