s
s
spring
Search…
Bean Scope
1
@Scope("{스코프종류}")
2
@Component
3
public class prototypeBean {}
Copied!
  • 싱글톤 : 기본 스코프, 스프링 컨테이너의 시작과 종료까지 유지되는 가장 넓은 범위의 스코프
  • 프로토타입 : 스프링 컨테이너는 프로토타입 빈의 생성과 의존관리 주입까지만 관여하고 더는 관리하지 않는 매우 짧은 범위의 스코프
  • 웹 관련 스코프
    • request: 웹 요청이 들어오고 나갈때까지 유지
    • session: 웹 세션이 생성되고 종료될 때 까지 유지
    • application: 웹의 서블릿 컨텍스와 같은 범위로 유지

싱글톤

  1. 1.
    싱글톤 스코프의 빈을 스프링 컨테이너에 요청
  2. 2.
    스프링 컨테이너는 본인이 관리하는 스프링 빈 반환
  3. 3.
    스프링 컨테이너에 같은 요청이 와도 같은 인스턴스의 스프링 빈 반환
1
import org.junit.jupiter.api.Test;
2
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
3
import org.springframework.context.annotation.Scope;
4
5
import javax.annotation.PostConstruct;
6
import javax.annotation.PreDestroy;
7
8
import static org.assertj.core.api.Assertions.*;
9
10
public class SingletonTest {
11
12
@Test
13
void singletonBeanFile() {
14
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SingletonBean.class);
15
System.out.println("find singletonBean1");
16
SingletonBean singletonBean1 = ac.getBean(SingletonBean.class);
17
System.out.println("find singletonBean2");
18
SingletonBean singletonBean2 = ac.getBean(SingletonBean.class);
19
20
System.out.println("singletonBean1 = " + singletonBean1);
21
System.out.println("singletonBean2 = " + singletonBean2);
22
23
24
assertThat(singletonBean1).isSameAs(singletonBean2);
25
26
ac.close();
27
}
28
29
@Scope("singleton")
30
static class SingletonBean {
31
32
@PostConstruct
33
public void init() {
34
System.out.println("SingletonBean.init");
35
}
36
37
@PreDestroy
38
public void destroy() {
39
System.out.println("SingletonBean.destroy");
40
}
41
}
42
}
Copied!
1
org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'singletonTest.SingletonBean'
2
SingletonBean.init
3
find singletonBean1
4
find singletonBean2
5
singletonBean1 = dh0023.springcore.scope.SingletonTest$SingletonBean@37e4d7bb
6
singletonBean2 = dh0023.springcore.scope.SingletonTest$SingletonBean@37e4d7bb
7
22:55:36.852 [main] DEBUG org.springframework.context.annotation.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@193f604a, started on Mon May 17 22:55:36 KST 2021
8
SingletonBean.destroy
Copied!
싱글톤 스코프의 빈은 동일한 빈을 생성하는 것을 확인할 수 있다. 또한 스프링 컨테이너 생성 시점에 초기화 메서드가 실행되며, 스프링컨테이너 종료전 @PreDestroy 메서드가 호출되는 것을 확인할 수 있다.

프로토타입

스프링 컨테이너는 프로토타입 빈을 생성하고, 의존관계 주입, 초기화까지만 처리한다. 프로토타입 빈을 관리할 책음은 프로토타입 빈을 받은 클라이언트에 있다.(@PreDestroy 같은 종료 메서드가 호출되지 않음.)
  1. 1.
    프로토타입 스코프 빈을 스프링 컨테이너에 요청
  2. 2.
    스프링 컨테이너는 이 시점에 프로토 타입 빈을 생성하고, 필요한 의존관계를 주입
  3. 3.
    스프링 컨테이너는 생성한 프로토타입 빈을 클라이언트에 반환
  4. 4.
    같은 요청이 와도 항상 새로운 프로토타입 빈을 생성해서 반환
1
import org.junit.jupiter.api.Test;
2
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
3
import org.springframework.context.annotation.Scope;
4
5
import javax.annotation.PostConstruct;
6
import javax.annotation.PreDestroy;
7
8
import static org.assertj.core.api.Assertions.assertThat;
9
10
public class PrototypeTest {
11
12
@Test
13
void PrototypeBeanFile() {
14
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PrototypeBean.class);
15
PrototypeBean prototypeBean1 = ac.getBean(PrototypeBean.class);
16
System.out.println("find prototypeBean1");
17
PrototypeBean prototypeBean2 = ac.getBean(PrototypeBean.class);
18
System.out.println("find prototypeBean2");
19
20
System.out.println("prototypeBean1 = " + prototypeBean1);
21
System.out.println("prototypeBean2 = " + prototypeBean2);
22
23
24
assertThat(prototypeBean1).isNotSameAs(prototypeBean2);
25
26
ac.close();
27
28
}
29
30
@Scope("prototype")
31
static class PrototypeBean {
32
33
@PostConstruct
34
public void init() {
35
System.out.println("PrototypeBean.init");
36
}
37
38
@PreDestroy
39
public void destroy() {
40
System.out.println("PrototypeBean.destroy");
41
}
42
}
43
}
Copied!
1
DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalCommonAnnotationProcessor'
2
PrototypeBean.init
3
find prototypeBean1
4
PrototypeBean.init
5
find prototypeBean2
6
prototypeBean1 = dh0023.springcore.scope.PrototypeTest$PrototypeBean@37e4d7bb
7
prototypeBean2 = dh0023.springcore.scope.PrototypeTest$PrototypeBean@6f7923a5
8
22:44:40.464 [main] DEBUG org.springframework.context.annotation.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@193f604a, started on Mon May 17 22:44:40 KST 2021
9
10
Process finished with exit code 0
Copied!
  • 스프링 컨테이너에서 빈을 조회할때 생성된다. (초기화 2번된 것 확인 가능)
  • prototypeBean1과 prototypeBean2의 주소가 다른것을 확인할 수 있다. 즉, 새로운 빈을 생성한다.
  • 또한, 프로토타입 빈은 스프링 컨테이너가 생성, 의존관계 주입, 초기화 까지 관여하므로 스프링 컨테이너 종료시 @PreDestroy 종료메서드인 destroy() 가 호출되지 않은 것을 확인할 수 있다.
만약 프로토타입 빈을 종료하고 싶은 경우에는 직접 아래와 같이 해당 메서드를 호출해줘야한다.
1
// destroy 필요시 직접 호출 필요
2
prototypeBean1.destroy();
3
prototypeBean2.destroy();
Copied!

프로토타입 스코프를 싱글톤 빈과 함께 사용하고 싶다면?

싱글톤 빈과 프로토타입 빈을 함께 사용할 때, 매번 새로운 프로토타입 빈을 생성하고 싶은 경우에는 Provider를 이용하면된다.

ObjectProvider

1
package org.springframework.beans.factory;
2
3
import java.util.Iterator;
4
import java.util.function.Consumer;
5
import java.util.function.Supplier;
6
import java.util.stream.Stream;
7
8
import org.springframework.beans.BeansException;
9
import org.springframework.lang.Nullable;
10
11
/**
12
* A variant of {@link ObjectFactory} designed specifically for injection points,
13
* allowing for programmatic optionality and lenient not-unique handling.
14
*
15
* <p>As of 5.1, this interface extends {@link Iterable} and provides {@link Stream}
16
* support. It can be therefore be used in {@code for} loops, provides {@link #forEach}
17
* iteration and allows for collection-style {@link #stream} access.
18
*
19
* @author Juergen Hoeller
20
* @since 4.3
21
* @param <T> the object type
22
* @see BeanFactory#getBeanProvider
23
* @see org.springframework.beans.factory.annotation.Autowired
24
*/
25
public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {
26
27
/**
28
* Return an instance (possibly shared or independent) of the object
29
* managed by this factory.
30
* <p>Allows for specifying explicit construction arguments, along the
31
* lines of {@link BeanFactory#getBean(String, Object...)}.
32
* @param args arguments to use when creating a corresponding instance
33
* @return an instance of the bean
34
* @throws BeansException in case of creation errors
35
* @see #getObject()
36
*/
37
T getObject(Object... args) throws BeansException;
38
39
...
40
}
Copied!
지정한 빈을 컨테이너에서 대신 찾아주는 DL(Dependency Lookup - 의존관계를 찾음) 서비스를 제공한다.
이때 ObjectProviderObjectFactory 를 상속받고 있다.

ObjectFactory

1
package org.springframework.beans.factory;
2
3
import org.springframework.beans.BeansException;
4
5
/**
6
* Defines a factory which can return an Object instance
7
* (possibly shared or independent) when invoked.
8
*
9
* <p>This interface is typically used to encapsulate a generic factory which
10
* returns a new instance (prototype) of some target object on each invocation.
11
*
12
* <p>This interface is similar to {@link FactoryBean}, but implementations
13
* of the latter are normally meant to be defined as SPI instances in a
14
* {@link BeanFactory}, while implementations of this class are normally meant
15
* to be fed as an API to other beans (through injection). As such, the
16
* {@code getObject()} method has different exception handling behavior.
17
*
18
* @author Colin Sampaleanu
19
* @since 1.0.2
20
* @param <T> the object type
21
* @see FactoryBean
22
*/
23
@FunctionalInterface
24
public interface ObjectFactory<T> {
25
26
/**
27
* Return an instance (possibly shared or independent)
28
* of the object managed by this factory.
29
* @return the resulting instance
30
* @throws BeansException in case of creation errors
31
*/
32
T getObject() throws BeansException;
33
34
}
Copied!
ObjectFactory의 getObject()를 호출하면 내부에서 스프링 컨테이너를 통해 해당 빈을 찾아서 반환한다.
1
package dh0023.springcore.scope;
2
3
import lombok.RequiredArgsConstructor;
4
import org.assertj.core.api.Assertions;
5
import org.junit.jupiter.api.Test;
6
import org.springframework.beans.factory.ObjectProvider;
7
import org.springframework.beans.factory.annotation.Autowired;
8
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
9
import org.springframework.context.annotation.Scope;
10
11
import javax.annotation.PostConstruct;
12
import javax.annotation.PreDestroy;
13
14
import static org.assertj.core.api.Assertions.*;
15
16
public class SingletonWithPrototypeTest {
17
18
19
@Test
20
void singletonClientUseObjectProvider() {
21
22
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(ClientBean.class, PrototypeBean.class);
23
24
ClientBean clientBean1 = ac.getBean(ClientBean.class);
25
int count1 = clientBean1.logic();
26
assertThat(count1).isEqualTo(1);
27
28
ClientBean clientBean2 = ac.getBean(ClientBean.class);
29
int count2 = clientBean2.logic();
30
assertThat(count2).isEqualTo(1);
31
32
}
33
34
35
@Scope("singleton")
36
static class ClientBean {
37
38
@Autowired
39
private ObjectProvider<PrototypeBean> prototypeBeanObjectProvider;
40
41
public int logic() {
42
PrototypeBean prototypeBean = prototypeBeanObjectProvider.getObject();
43
prototypeBean.addCount();
44
return prototypeBean.getCount();
45
}
46
}
47
48
@Scope("prototype")
49
static class PrototypeBean {
50
51
private int count = 0;
52
53
public void addCount() {
54
count++;
55
}
56
57
public int getCount() {
58
return count;
59
}
60
61
@PostConstruct
62
public void init() {
63
System.out.println("PrototypeBean.init " + this);
64
}
65
66
@PreDestroy
67
public void destroy() {
68
System.out.println("PrototypeBean.destroy");
69
}
70
}
71
72
73
74
}
Copied!

JSR-330 Provider

자바표준 Provider를 사용하려면, 해당 라이브러리를 추가해줘야한다.
  • build.gradle
    1
    implementation 'javax.inject:javax.inject:1'
    Copied!
1
public interface Provider<T> {
2
3
/**
4
* Provides a fully-constructed and injected instance of {@code T}.
5
*
6
* @throws RuntimeException if the injector encounters an error while
7
* providing an instance. For example, if an injectable member on
8
* {@code T} throws an exception, the injector may wrap the exception
9
* and throw it to the caller of {@code get()}. Callers should not try
10
* to handle such exceptions as the behavior may vary across injector
11
* implementations and even different configurations of the same injector.
12
*/
13
T get();
14
}
Copied!
1
package dh0023.springcore.scope;
2
3
import lombok.RequiredArgsConstructor;
4
import org.assertj.core.api.Assertions;
5
import org.junit.jupiter.api.Test;
6
import org.springframework.beans.factory.ObjectProvider;
7
import org.springframework.beans.factory.annotation.Autowired;
8
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
9
import org.springframework.context.annotation.Scope;
10
11
import javax.annotation.PostConstruct;
12
import javax.annotation.PreDestroy;
13
import javax.inject.Provider;
14
15
import static org.assertj.core.api.Assertions.*;
16
17
public class SingletonWithPrototypeTest {
18
19
@Test
20
void singletonClientUseObjectProvider() {
21
22
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(ClientBean.class, PrototypeBean.class);
23
24
ClientBean clientBean1 = ac.getBean(ClientBean.class);
25
int count1 = clientBean1.logic();
26
assertThat(count1).isEqualTo(1);
27
28
ClientBean clientBean2 = ac.getBean(ClientBean.class);
29
int count2 = clientBean2.logic();
30
assertThat(count2).isEqualTo(1);
31
32
}
33
34
@Scope("singleton")
35
static class ClientBean {
36
private final PrototypeBean prototypeBean;
37
38
// ClientBean은 싱글톤이고, 최초 주입시에만 PrototypeBean이 생성된다.
39
@Autowired
40
public ClientBean(PrototypeBean prototypeBean) {
41
this.prototypeBean = prototypeBean;
42
}
43
44
public int logic() {
45
prototypeBean.addCount();
46
return prototypeBean.getCount();
47
}
48
}
49
50
51
@Scope("singleton")
52
static class ClientBean {
53
54
@Autowired
55
private Provider<PrototypeBean> prototypeBeanProvider;
56
57
public int logic() {
58
PrototypeBean prototypeBean = prototypeBeanProvider.get();
59
prototypeBean.addCount();
60
return prototypeBean.getCount();
61
}
62
}
63
64
@Scope("prototype")
65
static class PrototypeBean {
66
67
private int count = 0;
68
69
public void addCount() {
70
count++;
71
}
72
73
public int getCount() {
74
return count;
75
}
76
77
@PostConstruct
78
public void init() {
79
System.out.println("PrototypeBean.init " + this);
80
}
81
82
@PreDestroy
83
public void destroy() {
84
System.out.println("PrototypeBean.destroy");
85
}
86
}
87
88
89
90
}
Copied!
prototypeBeanProvider.get() 을 통해서 항상 새로운 프로토타입 빈이 생성되는 것을 확인할 수 있다.(DL) 자바 표준이며, 기능이 단순하므로 단위테스트를 만들거나 mock 코드를 만들기는 훨씬 쉬워진다.
하지만, 별도 라이브러리가 필요하며, 자바 표준이므로 스프링이 아닌 다른 컨테이너에서도 사용할 수 있다.

웹 스코프

  • 웹 환경에서만 동작
  • 스프링 컨테이너가 해당 스코프의 종료시점까지 관리한다. ( 종료메서드 호출됨 )

종류

  1. 1.
    request: HTTP 요청 하나가 들어오고 나갈 때까지 유지되는 스코프
  2. 2.
    session: HTTP Session과 동일한 생명주기
  3. 3.
    application: 서블릿 컨텍스트(ServletContext)와 동일 생명주기
  4. 4.
    websocket: 웹 소켓과 동일한 생명주기

request

1
implementation 'org.springframework.boot:spring-boot-starter-web'
Copied!
웹환경이 동작하도록, 해당 라이브러리를 우선 추가해준다.
request 스코프는 동시에 여러 HTTP 요청이 오면 정확히 어떤 요청이 남긴 로그인지 구분할 때 사용하기 좋다.
  • request scope object
1
package dh0023.springcore.common;
2
3
import org.springframework.context.annotation.Scope;
4
import org.springframework.stereotype.Component;
5
6
import javax.annotation.PostConstruct;
7
import javax.annotation.PreDestroy;
8
import java.util.UUID;
9
10
@Component
11
@Scope("request")
12
public class MyLogger {
13
14
private String uuid;
15
private String requestUrl;
16
17
public void setRequestUrl(String requestUrl) {
18
this.requestUrl = requestUrl;
19
}
20
21
22
public void log(String message) {
23
System.out.println("[" + uuid + "]" + " [" + requestUrl + "] " + message);
24
}
25
26
@PostConstruct
27
public void init() {
28
uuid = UUID.randomUUID().toString();
29
System.out.println("[" + uuid + "] request scope bean create: " + this);
30
}
31
32
@PreDestroy
33
public void close() {
34
System.out.println("[" + uuid + "] request scope bean close: " + this);
35
}
36
37
38
}
Copied!
@Scope("request") 이므로 HTTP 요청당 하나씩 생성되며, HTTP 요청이 끝나는 시점에 소멸된다.
  • controller
1
package dh0023.springcore.web;
2
3
import dh0023.springcore.common.MyLogger;
4
import lombok.RequiredArgsConstructor;
5
import org.springframework.beans.factory.ObjectProvider;
6
import org.springframework.stereotype.Controller;
7
import org.springframework.web.bind.annotation.RequestMapping;
8
import org.springframework.web.bind.annotation.ResponseBody;
9
10
import javax.servlet.http.HttpServletRequest;
11
12
@Controller
13
@RequiredArgsConstructor
14
public class LogDemoController {
15
16
private final LogDemoService logDemoService;
17
private final ObjectProvider<MyLogger> myLoggerObjectProvider;
18
19
@RequestMapping("log-demo")
20
@ResponseBody
21
public String logDemo(HttpServletRequest request) {
22
23
String requestUrl = request.getRequestURL().toString();
24
25
MyLogger myLogger = myLoggerObjectProvider.getObject();
26
myLogger.setRequestUrl(requestUrl);
27
myLogger.log("controller test");
28
29
30
logDemoService.logic("testId");
31
32
return "OK";
33
}
34
}
Copied!
  • service
1
package dh0023.springcore.web;
2
3
import dh0023.springcore.common.MyLogger;
4
import lombok.RequiredArgsConstructor;
5
import org.springframework.beans.factory.ObjectProvider;
6
import org.springframework.stereotype.Service;
7
8
@Service
9
@RequiredArgsConstructor
10
public class LogDemoService {
11
private final ObjectProvider<MyLogger> myLoggerObjectProvider;
12
13
public void logic(String id){
14
15
MyLogger myLogger = myLoggerObjectProvider.getObject();
16
myLogger.log("logdemoservice: " + id);
17
}
18
}
Copied!
1
44ebd516-6ce7-40ac-8838-1483bd875f17] request scope bean create: [email protected]
2
[ac6e0274-80da-4051-9f07-b61e01c6e261] request scope bean create: [email protected]
3
[ac6e0274-80da-4051-9f07-b61e01c6e261] [http://localhost:8080/log-demo] controller test
4
[44ebd516-6ce7-40ac-8838-1483bd875f17] [http://localhost:8080/log-demo] controller test
5
[5c0902a9-4401-4629-9bb1-f865d6bda02a] request scope bean create: [email protected]
6
[5c0902a9-4401-4629-9bb1-f865d6bda02a] [http://localhost:8080/log-demo] controller test
7
[4b601885-6795-42e6-a58e-f9ed92dbb819] request scope bean create: [email protected]
8
[4b601885-6795-42e6-a58e-f9ed92dbb819] [http://localhost:8080/log-demo] controller test
9
[cf41f0c2-05f8-4922-818d-10294f5ea708] request scope bean create: [email protected]
10
[cf41f0c2-05f8-4922-818d-10294f5ea708] [http://localhost:8080/log-demo] controller test
11
[44ebd516-6ce7-40ac-8838-1483bd875f17] [http://localhost:8080/log-demo] logdemoservice: testId
12
[ac6e0274-80da-4051-9f07-b61e01c6e261] [http://localhost:8080/log-demo] logdemoservice: testId
13
[ac6e0274-80da-4051-9f07-b61e01c6e261] request scope bean close: [email protected]
14
[44ebd516-6ce7-40ac-8838-1483bd875f17] request scope bean close: [email protected]
15
[5c0902a9-4401-4629-9bb1-f865d6bda02a] [http://localhost:8080/log-demo] logdemoservice: testId
16
[5c0902a9-4401-4629-9bb1-f865d6bda02a] request scope bean close: [email protected]
17
[4b601885-6795-42e6-a58e-f9ed92dbb819] [http://localhost:8080/log-demo] logdemoservice: testId
18
[4b601885-6795-42e6-a58e-f9ed92dbb819] request scope bean close: [email protected]
19
[cf41f0c2-05f8-4922-818d-10294f5ea708] [http://localhost:8080/log-demo] logdemoservice: testId
20
[cf41f0c2-05f8-4922-818d-10294f5ea708] request scope bean close: [email protected]
Copied!
각각 요청별로 log가 남는것을 볼 수 있다.

프록시

1
package dh0023.springcore.common;
2
3
import org.springframework.context.annotation.Scope;
4
import org.springframework.context.annotation.ScopedProxyMode;
5
import org.springframework.stereotype.Component;
6
7
import javax.annotation.PostConstruct;
8
import javax.annotation.PreDestroy;
9
import java.util.UUID;
10
11
@Component
12
@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
13
public class MyLogger {
14
15
}
Copied!
proxyMode = ScopedProxyMode.TARGET_CLASS 추가로 가짜 프록시 클래스를 만들어두고, HTTP request와 상관없이 가짜 프록시 클래스를 다른 빈에 미리 주입해둘 수 있다.

ScopedProxyMode

1
package org.springframework.context.annotation;
2
3
/**
4
* Enumerates the various scoped-proxy options.
5
*
6
* <p>For a more complete discussion of exactly what a scoped proxy is, see the
7
* section of the Spring reference documentation entitled '<em>Scoped beans as
8
* dependencies</em>'.
9
*
10
* @author Mark Fisher
11
* @since 2.5
12
* @see ScopeMetadata
13
*/
14
public enum ScopedProxyMode {
15
16
/**
17
* Default typically equals {@link #NO}, unless a different default
18
* has been configured at the component-scan instruction level.
19
*/
20
DEFAULT,
21
22
/**
23
* Do not create a scoped proxy.
24
* <p>This proxy-mode is not typically useful when used with a
25
* non-singleton scoped instance, which should favor the use of the
26
* {@link #INTERFACES} or {@link #TARGET_CLASS} proxy-modes instead if it
27
* is to be used as a dependency.
28
*/
29
NO,
30
31
/**
32
* Create a JDK dynamic proxy implementing <i>all</i> interfaces exposed by
33
* the class of the target object.
34
*/
35
INTERFACES,
36
37
/**
38
* Create a class-based proxy (uses CGLIB).
39
*/
40
TARGET_CLASS
41
42
}
Copied!
  • DEFAULT: 컴포넌트 스캔 레벨
  • NO: 프록시를 생성하지 않는다.
  • INTERFACES : 적용대상이 인터페이스인 경우
  • TARGET_CLASS : 적용 대상이 클래스인 경우
1
package dh0023.springcore.web;
2
3
import dh0023.springcore.common.MyLogger;
4
import lombok.RequiredArgsConstructor;
5
import org.springframework.stereotype.Controller;
6
import org.springframework.web.bind.annotation.RequestMapping;
7
import org.springframework.web.bind.annotation.ResponseBody;
8
9
import javax.servlet.http.HttpServletRequest;
10
11
@Controller
12
@RequiredArgsConstructor
13
public class LogDemoController {
14
15
private final LogDemoService logDemoService;
16
private final MyLogger myLogger;
17
18
@RequestMapping("log-demo")
19
@ResponseBody
20
public String logDemo(HttpServletRequest request) throws InterruptedException {
21
22
String requestUrl = request.getRequestURL().toString();
23
24
System.out.println("myLogger = " + myLogger.getClass());
25
26
myLogger.setRequestUrl(requestUrl);
27
myLogger.log("controller test");
28
29
logDemoService.logic("testId");
30
31
return "OK";
32
}
33
}
Copied!
1
package dh0023.springcore.web;
2
3
import dh0023.springcore.common.MyLogger;
4
import lombok.RequiredArgsConstructor;
5
import org.springframework.stereotype.Service;
6
7
@Service
8
@RequiredArgsConstructor
9
public class LogDemoService {
10
private final MyLogger myLogger;
11
12
public void logic(String id){
13
System.out.println("myLogger = " + myLogger.getClass());
14
myLogger.log("logdemoservice: " + id);
15
}
16
}
Copied!
http://localhost:8080/log-demo 요청 로그 확인
1
myLogger = class dh0023.springcore.common.MyLogger$EnhancerBySpringCGLIB$db714d07
2
[65e23cc1-382e-4f2d-9500-f18d1b894b9f] request scope bean create: [email protected]
3
[65e23cc1-382e-4f2d-9500-f18d1b894b9f] [http://localhost:8080/log-demo] controller test
4
myLogger = class dh0023.springcore.common.MyLogger$EnhancerBySpringCGLIB$db714d07
5
[65e23cc1-382e-4f2d-9500-f18d1b894b9f] [http://localhost:8080/log-demo] logdemoservice: testId
6
[65e23cc1-382e-4f2d-9500-f18d1b894b9f] request scope bean close: [email protected]
Copied!
클래스를 확인해보녀 순수한 MyLogger 클래스가 아니라 MyLogger$EnhancerBySpringCGLIB​ 이라는 클래스로 만들어진 객체가 대신 등록되었다.
또한, 스프링 컨테이너에 프록시 객체를 등록하며, 의존 관계 주입도 프록시 객체가 주입된다.

동작 원리

  1. 1.
    CGLIB 라이브러리로 내 클래스를 상속 받은 프록시 객체를 만들어서 주입
  2. 2.
    프록시 객체는 실제 요청이 들어오면 내부에서 실제 빈을 요청하는 위임 로직이 들어있다.
  3. 3.
    프록시 객체는 실제 request scope와 관계 없으며, 내부에 단순한 위임 로직만 있고, 싱글톤처럼 동작한다.
즉, 프록시 객체를 사용하여 클라이언트는 싱글톤 빈을 사용하듯이 request scope를 사용할 수 있다. 어노테이션 설정 변경만으로 원본 객체를 프록시 객체로 대체할 수 있으며, 이는 다형성과 DI 컨테이너가 가진 가장 큰 강점이다.
하지만, 싱글톤을 사용하는 것처럼 느껴지지만 싱글톤과는 다르게 동작하기 때문에 주의해서 사용해야한다. 특별한 곳에서만 최소화해서 사용해야한다. 만약 무분별하게 사용하게 된다면 유지보수 및 테스트가 어려워진다.

참고