[Spring] 9.빈 스코프

1. 빈 스코프란?

- 스프링 빈이 스프링 컨테이너의 시작과 함께 생성되어 스프링 컨테이너가 종료될 때 까지 유지

-> 스프링 빈이 기본적으로 싱글톤 스코프로 생성되기 때문

-> 빈 스코프 : 빈이 존재할 수 있는 범위

스프링은 다음과 같은 다양한 스코프를 지원

- 싱글톤 : 기본 스코퍼, 스프링 컨테이너의 시작과 종료까지 유지되는 가장 넓은 범위의 스코프

- 프로토타입 : 스프링 컨테이너는 프로토 타입 빈의 생성과 의존관계 주입까지만 관여 / 더는 관리하지 않는 매우 짧은 스코프

- 웹 관련 스코프

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

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

> "application" : 웹의 서블릿 컨텍스와 같은 범위로 유지되는 스코프

빈 스코프 지정 방법

[컴포넌트 스캔 자동 등록]

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

[수동 등록]

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

2. 프로토타입 스코프

프로토타입 스코프

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

- 프로토타입 스코프를 스프링 컨테이너에 조회하면 스프링 컨테이너는 항상 새로운 인스턴스 생성해서 반환

싱글톤 빈 요청

- 싱글톤 스코프의 빈을 스프링 컨테이너에 요청한다

- 스프링 컨테이너는 본인이 관리하는 스프링 빈을 반환한다

- 이후에 스프링 컨테이너에 같은 요청이 와도 같은 객체 인스턴스의 스프링 빈으르 반환한다

프로토타입 빈 요청1

- 프로토타입 스코프의 빈을 스프링 컨테이너에 요청한다

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

프로토타입 빈 요청2

- 스프링 컨테이너는 생성한 프로토타입 빈을 클라이언트에 반환

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

정리

- 스프링 컨테이너는 프로토타입 빈을 생성하고, 의존관계 주입, 초기화까지만 처리

- 클라이언트에 빈을 반환하고 이후 스프링 컨테이너는 생성된 프로토타입 빈을 관리하지 않음

- 프로토타입 빈을 관리할 책임은 프로토타입 빈을 받은 클라이언트에 있다

- 그래서 @PreDestroy같은 종료 메서드가 호출되지 않음

싱글톤 스코프 빈 테스트

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

프로토타입 스코프 빈 테스트

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

* 각 빈에 @Component 없어도 AnnotaionConfigApplication 지정해주면 해당 클래스가 자동으로 컴포넌트 스캔처럼 동작

- 싱글톤 빈은 스프링 컨테이너 생성 시점에 초기화 메서드가 실행 되지만, 프로토타입 스코프의 빈은 스프링 컨테이너에서 빈을 조회할 때 생성되고, 초기화 메서드도 실행된다.
- 프로토타입 빈을 2번 조회했으므로 완전히 다른 스프링 빈이 생성되고, 초기화도 2번 실행된 것을 확인할 수 있다.
- 싱글톤 빈은 스프링 컨테이너가 관리하기 때문에 스프링 컨테이너가 종료될 때 빈의 종료 메서드가 실행되지만, 프로토타입 빈은 스프링 컨테이너가 생성과 의존관계 주입 그리고 초기화 까지만 관여하고, 더는 관리하지 않는다.
- 따라서 프로토타입 빈은 스프링 컨테이너가 종료될 때 @PreDestroy 같은 종료 메서드가 전혀 실행되지 않는다.

프로토타입 빈의 특징 정리

- 스프링 컨테이너에 요청할 때 마다 새로 생성된다.
- 스프링 컨테이너는 프로토타입 빈의 생성과 의존관계 주입 그리고 초기화까지만 관여한다.
- 종료 메서드가 호출되지 않는다.
- 그래서 프로토타입 빈은 프로토타입 빈을 조회한 클라이언트가 관리해야 한다.
- 종료 메서드에 대한 호출도 클라이언트가 직접 해야한다.

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

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

하지만 싱글톤 빈과 함께 사용할 땐 의도한대로 잘 동작하지 않음

[스프링 컨테이너에 프로토타입 빈을 직접 요청 예시]

스프링 컨테이너에 프로토타입 빈 직접 요청1

- 클라이언트 A는 스프링 컨테이너에 프로토타입 빈을 요청

- 스프링 컨테이너는 프로토타입 빈을 새로 생성해서 반환(x01) = 해당 빈의 count필드 값은 0

- 클라이언트는 조회한 프로토타입 빈에 addCount()를 호출하면서 count 필드 +1

- 결과적으로 프로토타입 빈(x01)의 count는 1이 됨

스프링 컨테이너에 프로토타입 빈 직접 요청2

- 클라이언트B는 스프링 컨테이너에 프로토타입 빈을 요청

- 스프링 컨테이너는 프로토타입 빈을 새로 생성해서 반환(x02) 해당 빈의 count 필드 값은 0

- 클라이언트는 조회한 프로토타입 빈에 addCount()를 호출하면서 count필드 +1

- 결과적으로 프로토타입 빈(x02)의 count는 1이 됨

코드

public class SingletonWithPrototypeTest1 {
  @Test
  void prototypeFind() {
    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PrototypeBean.class);
    PrototypeBean prototypeBean1 = ac.getBean(PrototypeBean.class);
    prototypeBean1.addCount();
    assertThat(prototypeBean1.getCount()).isEqualTo(1);
    PrototypeBean prototypeBean2 = ac.getBean(PrototypeBean.class);
    prototypeBean2.addCount();
    assertThat(prototypeBean2.getCount()).isEqualTo(1);
  }
  
  @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");
    }
  } 
}

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

- clientBean이라는 싱글톤 빈이 의존관계 주입을 통해서 프로토타입 빈을 주입받아서 사용하는 예

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

- clientBean은 싱글톤이므로 보통 스프링 컨테이너 생성 시점에 함께 생성되고, 의존관계 주입도 발생

- clientBean은 의존관계 자동 주입 사용 / 주입 시점에 스프링 컨테이너에 프로토타입 빈을 요청

- 스프링 컨테이너는 프로토타입 빈을 생성해서 clientBean에 반환 / 프로토타입 빈의 count필드 값은 0

- clientBean은 프로토타입 빈을 내부 필드에 보관 (정확히는 참조값 보관)

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

- 클라이언트A는 clientBean을 스프링 컨테이너에 요청해서 받음 / 싱글톤이므로 항상 같은 clientBean이 반환됨

- 클라이언트A는 clientBean.logic()을 호출

- clientBean은 prototypeBean의 addCount()를 호출해서 프로토타입 빈의 count를 증가 / count 값이 1이 됨

테스트코드

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

* count 2가 됨 -> 프로토타입 빈은 새롭게 만들어지는 것 아닌가요? -> 클라이언트 빈 생성시점에 이미 프로토타입이 주입됨

4. 프로토타입 스코프 - 싱글톤 빈과 함께 사용시 Provider로 문제 해결

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

[스프링 컨테이너에 요청]

public class PrototypeProviderTest {
  @Test
  void providerTest() {
    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(1);
  }
      
  static class ClientBean {
    @Autowired
    private ApplicationContext ac;
    public int logic() {
      PrototypeBean prototypeBean = ac.getBean(PrototypeBean.class);
      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");
    }
  } 
}

- 실행해보면 ac.getBean() 을 통해서 항상 새로운 프로토타입 빈이 생성되는 것을 확인할 수 있다.
- 의존관계를 외부에서 주입(DI) 받는게 아니라 이렇게 직접 필요한 의존관계를 찾는 것을 Dependency Lookup (DL) 의존관계 조회(탐색) 이라한다.
- 그런데 이렇게 스프링의 애플리케이션 컨텍스트 전체를 주입받게 되면, 스프링 컨테이너에 종속적인 코드가 되고, 단위 테스트도 어려워진다.
- 지금 필요한 기능은 지정한 프로토타입 빈을 컨테이너에서 대신 찾아주는 딱! DL 정도의 기능만 제공하는 무언가가 있으면 된다.

ObjectFactory, ObjectProvider

- 지정한 빈을 컨테이너에서 대신 찾아주는 DL 서비스를 제공하는 것이 바로 ObjectProvider 이다.

- 참고로 과거에는 ObjectFactory 가 있었는데, 여기에 편의 기능을 추가해서 ObjectProvider 가 만들어졌다.

@Autowired
private ObjectProvider<PrototypeBean> prototypeBeanProvider;
public int logic() {
  PrototypeBean prototypeBean = prototypeBeanProvider.getObject();
  prototypeBean.addCount();
  int count = prototypeBean.getCount();
  return count;
}

- 실행해보면 prototypeBeanProvider.getObject() 을 통해서 항상 새로운 프로토타입 빈이 생성되는 것을 확인할 수 있다.
- ObjectProvider 의 getObject() 를 호출하면 내부에서는 스프링 컨테이너를 통해 해당 빈을 찾아서 반환한다. (DL)
- 스프링이 제공하는 기능을 사용하지만, 기능이 단순하므로 단위테스트를 만들거나 mock 코드를 만들기는 훨씬 쉬워진다.
- ObjectProvider 는 지금 딱 필요한 DL 정도의 기능만 제공한다.

특징

- ObjectFactory: 기능이 단순, 별도의 라이브러리 필요 없음, 스프링에 의존
- ObjectProvider: ObjectFactory 상속, 옵션, 스트림 처리등 편의 기능이 많고, 별도의 라이브러리 필요 없음, 스프링에 의존

JSR-330 Provider

- javax.inject.Provider 라는 JSR-330 자바 표준

- gradle에 라이브러리 추가

스프링부트 3.0 미만
javax.inject:javax.inject:1 라이브러리를 gradle dependencies에 추가해야 한다.

스프링부트 3.0 이상
jakarta.inject:jakarta.inject-api:2.0.1 라이브러리를 gradle dependencies에 추가해야 한다.

dependencies{
  implementation : 'javax.inject:javax.inject:1'
  ...
}

@Autowired
private Provider<PrototypeBean> provider;
public int logic() {
  PrototypeBean prototypeBean = provider.get();
  prototypeBean.addCount();
  int count = prototypeBean.getCount();
  return count;
}

- 실행해보면 provider.get() 을 통해서 항상 새로운 프로토타입 빈이 생성되는 것을 확인할 수 있다.
- provider 의 get() 을 호출하면 내부에서는 스프링 컨테이너를 통해 해당 빈을 찾아서 반환한다. (DL)
- 자바 표준이고, 기능이 단순하므로 단위테스트를 만들거나 mock 코드를 만들기는 훨씬 쉬워진다.
- Provider 는 지금 딱 필요한 DL 정도의 기능만 제공한다.

특징

- get() 메서드 하나로 기능이 매우 단순하다.
- 별도의 라이브러리가 필요하다.
- 자바 표준이므로 스프링이 아닌 다른 컨테이너에서도 사용할 수 있다.

참고:

실무에서 자바 표준인 JSR-330 Provider를 사용할 것인지, 아니면 스프링이 제공하는 ObjectProvider를 사용할 것인지 고민이 될 것이다. ObjectProvider는 DL을 위한 편의 기능을 많이 제공해주고 스프링 외에 별도의 의존관계 추가가 필요 없기 때문에 편리하다. 만약(정말 그럴일은 거의 없겠지만) 코드를 스프링이 아닌 다른 컨테이너에서도 사용할 수 있어야 한다면 JSR-330 Provider를 사용해야한다.

스프링을 사용하다 보면 이 기능 뿐만 아니라 다른 기능들도 자바 표준과 스프링이 제공하는 기능이

겹칠때가 많이 있다. 대부분 스프링이 더 다양하고 편리한 기능을 제공해주기 때문에, 특별히 다른 컨테이너를 사용할 일이 없다면, 스프링이 제공하는 기능을 사용하면 된다.

5. 웹 스코프

웹 스코프의 특징

- 웹 스코프는 웹 환경에서만 동작

- 웹 스코프는 프로토타입과 다르게 스프리이 해당 스코프의 종료시점까지 관리 (종료메서드 호출)

웹 스코프 종류

'request' : HTTP요청 하나가 들어오고 나갈때까지 유지되는 스코프 / 각각의 HTTP 요청마다 별도의 빈 인스턴스가 생성되고 관리됨

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

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

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

ex) request 스코프

HTTP request 요청 당 각각 할당되는 request 스코프

6. request 스코프 예제 만들기

웹 환경 추가

- build.gradle

//web 라이브러리 추가
implementation 'org.springframework.boot:spring-boot-starter-web'

이제 hello.cored.CoreApplication의 main메서드 실행하면 웹 애플리케이션 실행 확인

참고:
spring-boot-starter-web 라이브러리를 추가하면 스프링 부트는 내장 톰켓 서버를 활용해서 웹 서버와 스프링을 함께 실행시킨다.

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

request 스코프 예제 개발

- 동시에 여러 HTTP 요청이 오면 정확히 어떤 요청이 남긴 로그인지 구분 어려움

- 이럴때 사용하기 좋은 것이 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.class

ㄴhello.cored.common

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

- 로그를 출력하기 위한 MyLogger 클래스이다.
- @Scope(value = "request") 를 사용해서 request 스코프로 지정했다.
- 이제 이 빈은 HTTP 요청 당 하나씩 생성되고, HTTP 요청이 끝나는 시점에 소멸된다.
- 이 빈이 생성되는 시점에 자동으로 @PostConstruct 초기화 메서드를 사용해서 uuid를 생성해서 저장해둔다.
- 이 빈은 HTTP 요청 당 하나씩 생성되므로, uuid를 저장해두면 다른 HTTP 요청과 구분할 수 있다.
- 이 빈이 소멸되는 시점에 @PreDestroy 를 사용해서 종료 메시지를 남긴다.
- requestURL은 이 빈이 생성되는 시점에는 알 수 없으므로, 외부에서 setter로 입력 받는다.

LogDemoController

ㄴhello.cored.web

@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을 받았다.
- requestURL 값 http://localhost:8080/log-demo
이렇게 받은 requestURL 값을 myLogger에 저장해둔다.
- myLogger는 HTTP 요청 당 각각 구분되므로 다른 HTTP 요청 때문에 값이 섞이는 걱정은 하지 않아도 된다.
- 컨트롤러에서 controller test라는 로그를 남긴다.

LogDemoService

ㄴhello.cored.logdemo

@Service
@RequiredArgsConstructor
public class LogDemoService {
  private final MyLogger myLogger;
  public void logic(String id) {
  myLogger.log("service id = " + id);
  } 
}

- 비즈니스 로직이 있는 서비스 계층에서도 로그를 출력
- 중요) request scope를 사용하지 않고 파라미터로 이 모든 정보를 서비스 계층에 넘긴다면, 파라미터가 많아서 지저분해진다.
더 문제는 requestURL 같은 웹과 관련된 정보가 웹과 관련없는 서비스 계층까지 넘어가게 된다.
웹과 관련된 부분은 컨트롤러까지만 사용해야 한다.
서비스 계층은 웹 기술에 종속되지 않고, 가급적 순수하게 유지하는 것이 유지보수 관점에서 좋다.
- request scope의 MyLogger 덕분에 이런 부분을 파라미터로 넘기지 않고, MyLogger의 멤버변수에 저장해서 코드와 계층을 깔끔하게 유지할 수 있다.

* request 스코프 빈은 아직 생성되지 않는다. 이 빈은 실제 고객의 요청이 와야 생성할 수 있다!

7. 스코프와 Provider

위 문제 해결)

1) ObjdectProvider 사용

@Controller
@RequiredArgsConstructor
public class LogDemoController {
  private final LogDemoService logDemoService;
  private final ObjectProvider<MyLogger> myLoggerProvider;
  
  @RequestMapping("log-demo")
  @ResponseBody
  public String logDemo(HttpServletRequest request) {
    String requestURL = request.getRequestURL().toString();
    MyLogger myLogger = myLoggerProvider.getObject();
    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 = myLoggerProvider.getObject();
    myLogger.log("service id = " + id);
  } 
}

- ObjectProvider 덕분에 ObjectProvider.getObject() 를 호출하는 시점까지 request scope 빈의 생성을 지연할 수 있다.
- ObjectProvider.getObject() 를 호출하시는 시점에는 HTTP 요청이 진행중이므로 request scope 빈의 생성이 정상 처리된다.
- ObjectProvider.getObject() 를 LogDemoController , LogDemoService 에서 각각 한번씩 따로 호출해도 같은 HTTP 요청이면 같은 스프링 빈이 반환된다!

8. 스코프와 Proxy

위 문제 해결)

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

핵심)
- proxyMode = ScopedProxyMode.TARGET_CLASS 를 추가.
적용 대상이 인터페이스가 아닌 클래스면 TARGET_CLASS 를 선택
적용 대상이 인터페이스면 INTERFACES 를 선택
- 이렇게 하면 MyLogger의 가짜 프록시 클래스를 만들어두고 HTTP request와 상관 없이 가짜 프록시 클래스를 다른 빈에 미리 주입해 둘 수 있다.

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

@Service
@RequiredArgsConstructor
public class LogDemoService {
  private final MyLogger myLogger;
  public void logic(String id) {
   myLogger.log("service id = " + id);
  }
}

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

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

- @Scope 의 proxyMode = ScopedProxyMode.TARGET_CLASS) 를 설정하면 스프링 컨테이너는 CGLIB라는 바이트코드를 조작하는 라이브러리를 사용해서, MyLogger를 상속받은 가짜 프록시 객체를 생성한다.

- 결과를 확인해보면 우리가 등록한 순수한 MyLogger 클래스가 아니라 MyLogger$ $EnhancerBySpringCGLIB 이라는 클래스로 만들어진 객체가 대신 등록된 것을 확인할 수 있다.
- 그리고 스프링 컨테이너에 "myLogger"라는 이름으로 진짜 대신에 이 가짜 프록시 객체를 등록한다.
- ac.getBean("myLogger", MyLogger.class) 로 조회해도 프록시 객체가 조회되는 것을 확인할 수 있다.
- 그래서 의존관계 주입도 이 가짜 프록시 객체가 주입된다.

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

- 가짜 프록시 객체는 내부에 진짜 myLogger를 찾는 방법을 알고 있다.
- 클라이언트가 myLogger.logic() 을 호출하면 사실은 가짜 프록시 객체의 메서드를 호출한 것이다.
- 가짜 프록시 객체는 request 스코프의 진짜 myLogger.logic() 를 호출한다.
- 가짜 프록시 객체는 원본 클래스를 상속 받아서 만들어졌기 때문에 이 객체를 사용하는 클라이언트 입장에서는 사실 원본인지 아닌지도 모르게, 동일하게 사용할 수 있다(다형성)

동작 정리

- CGLIB라는 라이브러리로 내 클래스를 상속 받은 가짜 프록시 객체를 만들어서 주입한다.
- 이 가짜 프록시 객체는 실제 요청이 오면 그때 내부에서 실제 빈을 요청하는 위임 로직이 들어있다.
- 가짜 프록시 객체는 실제 request scope와는 관계가 없다. 그냥 가짜이고, 내부에 단순한 위임 로직만 있고, 싱글톤 처럼 동작한다.

특징 정리

- 프록시 객체 덕분에 클라이언트는 마치 싱글톤 빈을 사용하듯이 편리하게 request scope를 사용할 수 있다.
- 사실 Provider를 사용하든, 프록시를 사용하든 핵심 아이디어는 진짜 객체 조회를 꼭 필요한 시점까지 지연처리 한다는 점이다.

- 단지 애노테이션 설정 변경만으로 원본 객체를 프록시 객체로 대체할 수 있다. 이것이 바로 다형성과 DI 컨테이너가 가진 큰 강점이다.
- 꼭 웹 스코프가 아니어도 프록시는 사용할 수 있다.

주의점

- 마치 싱글톤을 사용하는 것 같지만 다르게 동작하기 때문에 결국 주의해서 사용해야 한다.
- 이런 특별한 scope는 꼭 필요한 곳에만 최소화해서 사용하자, 무분별하게 사용하면 유지보수하기 어려워진다.

저작자표시

'👨‍💻 Web Development > Spring - 기본' 카테고리의 다른 글

[Spring] 8.빈 생명주기 콜백 (0)	2023.02.28
[Spring] 7.다양한 의존관계 주입 방법 (0)	2023.02.28
[Spring] 6.컴포넌트 스캔 (0)	2023.02.24
[Spring] 5.싱글톤 컨테이너 (0)	2023.02.22
[Spring] 4.스프링 컨테이너와 스프링 빈 (0)	2023.02.20

[Spring] 9.빈 스코프