이 글은 김영한님의 스프링 핵심 원리 - 기본편 강의를 수강하고 정리한 내용입니다.
강의 보러가기

📌 1. 빈 스코프란?

---

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

스프링 빈은 다양한 스코프를 지원한다.

• 싱글톤 : 기본 스코프로, 스프링 컨테이너의 시작과 종료까지 유지되는 가장 넓은 범위의 스코프
  -> 이제까지 계속 사용해온 스코프

• 프로토타입 : 스프링 컨테이너가 프로토타입 빈의 생성, 의존관계 주입과 초기화까지만 관여하고 더는 관리하지 않는 매우 짧은 범위의 스코프
  -> 종료 메서드 호출 안됨

• 웹 관련 스코프

  • request : 웹 요청이 들어오고 나갈 때까지 유지되는 스코프

  • session : 웹 세션이 생성되고 종료될 때까지 유지되는 스코프

  • application : 웹의 서블릿 컨텍스트(ServletContext)와 같은 범위로 유지되는 스코프

이렇게만 들어서는 이해가 잘 안되니 하나하나 살펴보자.

📌 2. 프로토타입 스코프

---

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

• 프로토타입 스코프의 빈을 조회하면 항상 새로운 인스턴스를 생성해서 반환한다.

프로토타입 빈 요청

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

2. 생성한 프로토타입 빈을 클라이언트에 반환하고, 더 이상 관리하지 않는다.

3. 이후 스프링 컨테이너에 같은 요청이 들어오면 항상 새로운 프로토타입 빈을 생성해서 반환한다.

프로토타입 스코프는 스프링 컨테이너가 빈 생성, 의존관계 주입, 초기화까지만 처리해주고 이후부턴 관리하지 않기 때문에 @PreDestroy 같은 종료 메서드가 호출되지 않는다.

코드로 살펴보자

package hello.core.scope;

import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Scope;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

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

public class PrototypeTest {

    @Test
    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");
        }
    }

}

• @Scope로 스코프를 지정해줄 수 있다.

  • 디폴트 값은 "singleton"

• PrototypeBean 클래스에 @Component를 붙이지 않아도 컨테이너 생성시 PrototypeBean.class로 설정 정보를 넘겨주면 자동으로 컴포넌트 스캔 대상이 된다.
  
  

출력결과

find prototypeBean1
PrototypeBean.init
find prototypeBean2
PrototypeBean.init
prototypeBean1 = hello.core.scope.PrototypeTest$PrototypeBean@13ad5cd3
prototypeBean2 = hello.core.scope.PrototypeTest$PrototypeBean@1c33c17b

• 싱클톤 빈은 스프링 컨테이너 생성 시점에 초기화 메서드가 한 번 실행되지만 프로토타입 스코프 빈은 스프링 컨테이너에서 빈을 조회할 때 빈이 생성되고 초기화 메서드가 실행된다.

  • 출력결과를 보면 System.out.println("find prototypeBean1"); 를 먼저 실행하고 ac.getBean() 을 만나 빈을 조회할 때 초기화를 실행했음을 알 수 있다.

• 프로토타입 빈을 두 번 조회했으므로 서로 다른 스프링 빈이 생성되며 초기화도 두 번 실행되었다.

• 스프링 컨테이너가 종료될 때 @PreDestroy 종료 메서드가 실행되지 않았다.

1) 프로토타입 빈의 특징 정리

• 스프링 컨테이너에 요청할 때마다 새로 생성된다.

• 스프링 컨테이너는 프로토타입 빈의 생성과 의존관계 주입 그리고 초기화까지만 관여한다.
  -> 이후 프로토타입 빈을 조회한 클라이언트가 관리해야 한다.

• 종료 메서드가 호출되지 않는다.

2) 싱글톤 빈과 함께 사용시 문제점

앞에서 스프링 컨테이너에 프로토타입 스코프의 빈을 요청하면 항상 새로운 객체를 생성해 반환한다고 했다.

하지만 싱글톤 빈과 함께 사용하면 의도한대로 잘 동작하지 않으므로 주의해야 한다.

1. 프로토타입 빈 직접 요청 그림

• PrototypeBean에 count라는 필드가 있고 addCount() 호출시 1이 증가하는 코드가 있다.

• 클라이언트가 스프링 컨테이너에 프로토타입 빈을 요청하는데 항상 새로운 객체를 생성해 반환하므로 클라이언트A와 B의 count 필드 값은 서로 공유하지 않는다.

  • B에서 addCount()를 호출했다고 A의 빈 객체 count 필드도 1이 증가하고 그런 경우는 없다.

2. 싱글톤 빈에서 프로토타입 빈 사용

• clientBean이라는 싱글톤 빈이 프로토타입 빈을 주입받아 사용하는 예를 보자.
  

1. clientBean이라는 싱글톤 빈을 생성하는데 그 빈에는 프로토타입 빈을 내부 필드에 보관한다. (객체이므로 정확히는 참조값 보관)

2. 의존관계 자동 주입을 통해 스프링 컨테이너는 프로토타입 빈을 생성해서 clientBean 필드의 prototypeBean(변수명)에 주입한다.

3. 클라이언트가 clientBean.logic()을 호출한다. 이 메서드는 프로토타입 빈의 addCount() 메서드를 실행시킨다.

4. 그럼 prototypeBean이 addCount() 메서드를 실행해 프로토타입 빈의 count를 1만큼 증가시킨다.

5. 이제 다른 클라이언트 B가 clientBean을 요청해서 받는데 이 빈은 싱글톤이므로 A와 같은 객체를 반환받는다.

6. B가 clientBean.logic()을 실행한다.

7. clientBean의 프로토타입 빈의 count가 1이므로 2가 된다.
   
   

• 싱글톤인 clientBean의 프로토타입 빈은 스프링 컨테이너가 의존관계 주입을 하는 시점에 생성되고 그 이후로는 생성되지 않는다.
  -> A와 B가 같은 프로토타입 빈을 사용하게 되어 count를 공유하는 셈이 된 것이다.

이제 코드로 살펴보자

package hello.core.scope;

import lombok.RequiredArgsConstructor;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Scope;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

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

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);
    }

    // 생성자 주입
    @RequiredArgsConstructor
    static class ClientBean {
        private final PrototypeBean prototypeBean;

        public int logic() {
            prototypeBean.addCount();

            return prototypeBean.getCount();
        }
    }

    @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");
        }
    }

}

• clientBean1이 logic()을 실행하고 나서 count는 1

• 이후 clientBean2가 logic()을 실행하고 나서 count는 2임을 알 수 있다.
  
  

이렇게 같은 프로토타입 빈을 공유해서 사용할거면 그냥 싱글톤 빈을 쓰고말지..

항상 새로운 프로토타입 빈을 만들어서 사용하고 싶다면 어떻게 해야될까?

3) 싱글톤 빈과 함께 사용시 문제 해결

싱글톤 빈과 프로토타입 빈을 함께 사용할 때, 어떻게하면 항상 새로운 프로토타입을 만들어 사용할 수 있을까?

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

static class ClientBean {
    
    @Autowired
    private ApplicationContext ac;
    
    public int logic() {
        PrototypeBean prototypeBean = ac.getBean(PrototypeBean.class);
        
        prototypeBean.addCount();
        int count = prototypeBean.getCount();
        return count;
    }
    
}

• 기존에는 의존관계 주입을 하고나서 더이상 생성이 안됐지만 위 코드는 계속해서 스프링 컨테이너에 프로토타입 빈을 요청하고 있다.
  -> 이렇게 의존관계를 외부에서 주입(DI) 받는게 아니라 직접 필요한 의존관계를 찾는 것을 Dependency Lookup (DL) - 의존관계 조회라고 한다.

• 하지만 이렇게 스프링의 ApplicationContext 전체를 주입받게 되면 여러 단점이 있다.

  • 스프링 컨테이너에 종속적인 코드가 된다.
    -> 스프링 컨테이너가 아닌 다른 컨테이너로 바꿀 때, ClientBean의 코드를 수정해야 한다.

  • 단위 테스트도 어려워진다.

스프링 부트는 웹 라이브러리가 없으면 AnnotationConfigApplicationContext 을 기반으로 애플리케이션을 구동하기 때문에 이 구현체가 자동 주입된다.

그러면 이제 ApplicationContext를 주입받아 프로토타입 빈을 직접 컨테이너에서 찾아 오는 것이 아니라
프로토타입 빈을 컨테이너에서 대신 찾아주는 DL 기능만 제공하는 무언가가 필요하다.

-> 스프링에 이미 그런 기능을 제공하는 것이 존재한다.

1) ObjectFactory, ObjectProvider로 문제 해결

코드로 바로 확인하자

// 생성자 주입
@RequiredArgsConstructor
static class ClientBean {
    private final ObjectProvider<PrototypeBean> prototypeBeanProvider;

    public int logic() {
        PrototypeBean prototypeBean = prototypeBeanProvider.getObject();
        prototypeBean.addCount();

        return prototypeBean.getCount();
    }
}

• prototypeBeanProvider.getObject()를 통해 항상 새로운 프로토타입 빈이 생성된다.

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

• ObjectProvider는 지금 필요한 DL 정도의 기능만 제공한다.

• ObjectProvider를 ObjectFactory로 변경해도 잘 동작한다.
  • ObjectProvider는 ObjectFactory를 상속받아 기능이 몇 개 더 추가된 인터페이스이다.

하지만 이런 ObjectProvider도 스프링에 의존하고 있다는 단점이 있다.
-> 스프링 컨테이너 말고 다른 DI 컨테이너를 사용할 때 사용이 불가능하다.

(사실 다른 DI 컨테이너를 사용할 일이 거의 없다.)

2) JSR-330 Provider로 문제 해결

마지막 방법은 javax.inject.Provider라는 JSR-330 자바 표준을 사용하는 방법이다.

• 이 방법을 사용하려면 javax.inject:javax.inject:1 라이브러리를 gradle에 추가해야 한다.

코드로 확인해보자

// 생성자 주입
@RequiredArgsConstructor
static class ClientBean {
    private final Provider<PrototypeBean> prototypeBeanProvider;

    public int logic() {
        PrototypeBean prototypeBean = prototypeBeanProvider.get();
        prototypeBean.addCount();

        return prototypeBean.getCount();
    }
}

• ObjectProvider에서 Provider , getObject에서 get으로 바꾼게 끝이다.

• ObjectProvider의 장점은 그대로 가져가면서 단점은 보완했다.
  -> 단점 보완 : 자바 표준이기 때문에 스프링에 의존하지 않아 다른 컨테이너에서도 사용할 수 있다.

• 하지만 ObjectProvider는 별도의 라이브러리가 필요 없었지만 이 방법은 필요하다.

ObjectProvider , JSR-330 Provider 등은 프로토타입 뿐만 아니라 DL이 필요한 경우 언제든지 사용할 수 있다.

4) 프로토타입 빈은 언제 사용하는 것일까?

그럼 이제까지 배운 프로토타입 빈을 언제 사용하면 좋을까?

-> 매번 사용할 때마다 의존관계 주입이 완료된 새로운 객체가 필요할 때 사용한다.

ObjectProvider vs JSR-330 Provider 무엇을 써야할까?

-> 기본적으로 ObjectProvider를 사용하되, 다른 컨테이너에서도 사용해야 한다면 JSR-330 Provider를 사용하자.

사실 실무에서 프로토타입 빈은 잘 사용하지 않는다고 한다.
하지만 면접 단골 질문이므로 잘 기억해두자!

📌 3. 웹 스코프

---

웹 스코프의 특징

• 웹 환경에서만 동작한다.

• 프로토타입과 다르게 스프링 컨테이너가 종료 시점까지 관리해준다.
  -> 종료 메서드가 호출된다.
  
  

웹 스코프의 종류

• request : HTTP 요청이 들어오고 나갈 때까지 유지되는 스코프

  • 각각의 HTTP 요청마다 빈 인스턴스가 생성되고 관리된다.

• session : HTTP Session과 동일한 생명주기를 가지는 스코프

• application : 서블릿 컨텍스트(ServletContext)와 동일한 생명주기를 가지는 스코프

• websocket : 웹 소켓과 동일한 생명주기를 가지는 스코프

클라이언트 A의 요청 과정

1. Controller 객체에서 request scope와 관련된 객체 조회한다.

2. 클라이언트 A전용으로 객체가 생성되어 사용된다.

3. Service 객체에서도 객체를 조회한다.
   -> HTTP Request가 같으면 이미 만들어둔 동일한 객체를 조회해온다.
   
   

클라이언트 B의 요청도 동일하게 진행되는데
핵심은 A와 B의 requet 요청 각각에 맞춰진 별도의 객체가 만들어진다는 것이다.

• 프로토타입은 요청할 때마다 새로 생성되었다면, request는 HTTP request 요청이 들어오고 나갈 때까지의 생명주기 동안은 같은 객체로 관리가 된다.
  
  

아직까지는 크게 와닿지 않을 수 있으니 예제를 통해 자세히 알아보자.
예제를 보고 그림을 다시 보면 이해가 쉬울 것이다.

request 스코프 예제

먼저 웹 스코프는 웹 환경에서만 동작하므로 다음 라이브러리를 추가해야 한다.

implementation 'org.springframework.boot:spring-boot-starter-web'

• 앞서 말했듯 스프링 부트는 웹 라이브러리가 없으면 AnnotationConfigApplicationContext 을 기반으로 애플리케이션을 구동한다.
• 웹 라이브러리가 추가되면 웹과 관련된 추가 설정과 환경들이 필요하므로 AnnotationConfigServletWebServerApplicationContext 를 기반으로 애플리케이션을 구동한다.
  
  -> @Autowired 로 자동 주입해보면 확인할 수 있다.

동시에 여러 HTTP 요청이 오면 정확히 어떤 요청이 남긴 로그인지 구분하기 어렵다.
-> 이럴때 request 스코프를 사용하기 좋다.

다음과 같은 로그가 남도록 request 스코프를 활용해 추가 기능을 개발해보자.

[d06b992f...] request scope bean create
[d06b992f...][http://localhost:8080/log-demo] controller test
[d06b992f...][http://localhost:8080/log-demo] service id = testId
[d06b992f...] request scope bean close

• 공통 포맷 : [UUID][requestURL]{message}

• UUID 사용 : HTTP 요청을 구분 가능

• requestURL : 어떤 URL을 요청해서 남은 로그인지 확인 가능
  
  

이제 코드를 작성해보자.

로그 출력을 위한 MyLogger 클래스 작성

package hello.core.common;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.UUID;

@Component
@Scope("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")를 사용해 request 스코프로 지정했다.

• @PostConstruct를 사용해 이 빈이 생성되는 시점에 자동으로 uuid를 생성하고 저장해둔다.

  • UUID.randomUUID().toString()는 거의 절대 겹치지 않는 UUID 값 만들어 String으로 바꾼다.

  • 이를 통해 다른 HTTP 요청과 구분할 수 있다.

• requestURL은 빈이 생성되는 시점에는 알 수 없으므로 외부에서 setter로 입력받는다.

• 이 빈이 소멸되는 시점에 @PreDestroy 를 사용해서 종료 메시지를 남긴다.
  
  

LogDemoController 작성

package hello.core.web;

import hello.core.common.MyLogger;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;

@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";
    }

}

• HttpServletRequest를 통해 요청 URL을 받아 myLogger에 저장해둔다.

  • requestURL 값 : http://localhost:8080/log-demo

  • myLogger는 request 스코프이기 때문에 HTTP 요청마다 각각 구분되므로 다른 HTTP 요청 때문에 값이 섞이는 일은 일어나지 않는다.

• 컨트롤러에서 controller test 라는 로그를 남긴다.

HttpServletRequest , @RequestMapping 등은 이후 스프링 MVC 1편에서 자세히 다룬다.

LogDemoService 작성

package hello.core.web;

import hello.core.common.MyLogger;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class LogDemoService {

    private final MyLogger myLogger;

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

}

• 서비스 계층에서도 로그를 출력할 수 있도록 logic() 메서드를 만들었다.

이제 실행해보자

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;

오류가 발생한다. 왜일까?

일단 문제는 아래 코드에서 발생한다.

private final MyLogger myLogger;

1. 스프링 컨테이너가 뜰 때, 스프링 빈을 등록한다. 이때 의존관계 주입이 일어난다.

2. 의존관계 주입은 스프링 컨테이너에서 myLogger를 찾아 주입해야 한다.

3. myLogger는 request 스코프이기 때문에 HTTP 요청이 들어와야 생성이 되고, 결과를 응답할 때 소멸된다.

4. 하지만 아직 HTTP 요청이 들어오지 않았으므로 Scope 'request'가 활성화되지 않았다는 에러가 나는 것이다.
   
   

그럼 이 오류를 어떻게 해결할 수 있을까?
-> 바로 앞서 배운 ObjectProvider를 사용하면 해결할 수 있다.

1) 스코프와 Provider

Controller, Service를 수정해보자

@Controller
@RequiredArgsConstructor
public class LogDemoController {

    private final LogDemoService logDemoService;
    private final ObjectProvider<MyLogger> myLoggerProvider;

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

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

        return "OK";
    }

}

@Service
@RequiredArgsConstructor
public class LogDemoService {

    private final ObjectProvider<MyLogger> myLoggerProvider;

    public void logic(String id) {
        MyLogger myLogger = this.myLoggerProvider.getObject(MyLogger.class);

        myLogger.log("service id = " + id);
    }

}

• 이렇게 하면 myLogger가 주입되는 것이 아니라 myLogger 스프링 컨테이너에서 찾을 수 있는 (DL) 프로바이더가 주입된다.

• 컨트롤러에서는 /log-demo 로 요청이 들어오는 시점에 빈이 생성되기 때문에 getObject()로 빈을 조회할 수 있다.
  
  

이제 다시 실행해보자

[33756bdc-ba7e-41a4-aff3-6cadd0a557f7] request scope bean create:hello.core.common.MyLogger@2e5a17af
[33756bdc-ba7e-41a4-aff3-6cadd0a557f7][http://localhost:8080/log-demo]controller test
[33756bdc-ba7e-41a4-aff3-6cadd0a557f7][http://localhost:8080/log-demo]service id = testId
[33756bdc-ba7e-41a4-aff3-6cadd0a557f7] request scope bean close:hello.core.common.MyLogger@2e5a17af

[7cac9fd7-28cc-46ce-b7df-851383280c42] request scope bean create:hello.core.common.MyLogger@4ced3bf
[7cac9fd7-28cc-46ce-b7df-851383280c42][http://localhost:8080/log-demo]controller test
[7cac9fd7-28cc-46ce-b7df-851383280c42][http://localhost:8080/log-demo]service id = testId
[7cac9fd7-28cc-46ce-b7df-851383280c42] request scope bean close:hello.core.common.MyLogger@4ced3bf

[2d09913c-b211-4421-a8f0-ab6d3e629f40] request scope bean create:hello.core.common.MyLogger@6f9cd69c
[2d09913c-b211-4421-a8f0-ab6d3e629f40][http://localhost:8080/log-demo]controller test
[2d09913c-b211-4421-a8f0-ab6d3e629f40][http://localhost:8080/log-demo]service id = testId
[2d09913c-b211-4421-a8f0-ab6d3e629f40] request scope bean close:hello.core.common.MyLogger@6f9cd69c

localhost:8080/log-demo 에 요청을 세 번 보냈더니 위와 같은 출력결과를 얻었다.

• 먼저 ObjectProvider 덕분에 스프링 컨테이너에서 빈 조회 하는 작업을 지연시킬 수 있었다.

• getObject() 를 컨트롤러와 서비스에 에 한번씩 호출했는데 서로 같은 객체를 조회해 사용하는 것을 알 수 있다.
  -> 같은 HTTP 요청이면 같은 myLogger 빈을 조회해 사용한다.

• 요청별로 UUID가 다름을 확인할 수 있다.

사실 여기까지만 해도 편리하지만, 더 편리한 방법이 존재한다.
정말 대단한 개발자들이다..

2) 스코프와 프록시

프록시 방식을 사용해보자.

MyLogger 코드 수정

@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)

• 기존의 코드에서 @Scope를 위의 코드로 변경해준게 전부이다.
  • 원래는 value 생략이 가능했는데 또 다른 옵션을 주려면 적어주어야 한다.
• 적용 대상이 클래스면 TARGET_CLASS , 인터페이스면 INTERFACES를 선택해야 한다.

그리고 컨트롤러와 서비스를 처음에 실행 오류났던 코드로 되돌리자.

package hello.core.web;

import hello.core.common.MyLogger;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;

@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";
    }

}

package hello.core.web;

import hello.core.common.MyLogger;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class LogDemoService {

    private final MyLogger myLogger;

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

}

• 실행해보면 정상적으로 잘 작동한다.

Provider 사용 전, 오류나는 코드와 동일하고 단지 MyLogger @Scope에 proxyMode 옵션만 추가했다.

어떻게 된걸까?

3) 웹 스코프와 프록시 동작 원리

먼저 주입된 myLogger를 확인해보자.

System.out.println("myLogger = " + myLogger.getClass());

출력 결과

myLogger = class hello.core.common.MyLogger$$EnhancerBySpringCGLIB$$3511709

결국 CGLIB 라는 라이브러리로 내 클래스를 상속받은 가짜 프록시 객체를 만들어 주입한 것이다.

• 먼저 스프링 컨테이너에 myLogger라는 이름으로 가짜 프록시 객체를 등록한다.

  • 그래서 의존관계 주입에서도 이 가짜 프록시 객체가 주입된다.

• 이 가짜 프록시 객체 내부에는 myLogger의 기능을 호출하는 요청이 오면 그제서야 진짜 빈을 요청하는 로직이 들어있다.

  • 사실 myLogger.logic() 호출은 가짜 프록시 객체의 메서드를 호출한 것이다.

  • 이제 그 가짜 프록시 객체에서 request 스코프의 진짜 myLogger.logic()을 호출한다.

CGLIB 라는 바이트 코드 조작 라이브러리는 이전에 @Configuration을 공부할 때도 등장했었다.

동작 원리 정리

• CGLIB 라는 라이브러리로 내 클래스를 상속 받은 가짜 프록시 객체를 만들어 주입한다.

• 이 가짜 프록시 객체는 실제 요청이 오면 그때 내부에서 실제 빈을 요청하는 위임 로직이 들어있다.

• 가짜 프록시 객체는 당연히 request 스코프 와는 관계가 없으며, 싱글톤 빈처럼 동작한다.

  • 스프링 컨테이너가 생성되고, 빈이 생성되며 의존관계 주입을 한다.

  • 그래서 그냥 생성해서 주입하는 것이 가능하다.

특징 정리

• 프록시 객체 덕분에 클라이언트는 마치 싱글톤 빈을 사용하듯이 편리하게 request 스코프를 사용할 수 있다.

• ❗사실 Provider를 사용하든, 프록시를 사용하든 핵심 아이디어는 진짜 객체 조회를 꼭 필요한 시점까지 지연처리 한다는 점이다❗

• 단지 어노테이션 설정 변경만으로 원본 객체를 프록시 객체로 대체할 수 있다.

• 웹 스코프가 아니어도 프록시는 사용할 수 있다.

주의점

• 싱글톤을 사용하는 것 같지만 결국 다르게 동작하므로 주의해서 사용해야 한다.

  • 사실 HTTP 요청마다 새로운 객체가 생성되기 때문이다.

• 이런 특별한 스코프는 꼭 필요한 곳에만 최소화해서 사용하자, 무분별하게 사용하면 유지보수하기 어려워진다.