Spring - 싱글톤 컨테이너(웹 애플리케이션과 싱글톤, 싱글톤 패턴)

웹 애플리케이션과 싱글톤

• 스프링은 기업용 온라인 서비스 기술 지원을 위해 탄생.
• 대부분 스프링은 웹 애플리케이션이다
  • 물론 웹이 아닌 애플리케이션 개발도 얼마든지 개발 가능
• 웹 애플리케이션은 보통 여러 고객이 동시에 요청함

스프링 없는 순수한 DI 컨테이너 테스트

    @Bean
    public MemberService memberService() {
        return new MemberServiceImpl(memberRepository());
    }

    @Bean
    public MemoryMemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }

public class SingletonTest {
    @Test
    @DisplayName("스프링 없는 순수한 DI 컨테이너")
    void pureContainer() {
        AppConfig appConfig = new AppConfig();
        // 1. 조회 : 호출할 때 마다 객체를 생성
        MemberService memberService1 = appConfig.memberService();
        // 2. 조회 : 호출할 때 마다 객체를 생성
        MemberService memberService2 = appConfig.memberService();
        // 참조 값이 다른 것을 확인
        System.out.println("memberService1 = " + memberService1);
        System.out.println("memberService2 = " + memberService2);
        // memberService1 != memberService2
        Assertions.assertThat(memberService1).isNotSameAs(memberService2);
    }
}

// 반환
memberService1 = hello.core.member.MemberServiceImpl@23348b5d
memberService2 = hello.core.member.MemberServiceImpl@70325e14

• 우리가 만든 순수한 DI 컨테이너 객체인 AppConfig는 요청을 할 때 마다 객체를 새로 생성
  • 위 SingletonTest코드는 요청이 들어올 때 마다 memberService 객체를 생성한다
    • 실질적으로 memberService를 생성하기 위해 memberRepository가 필요하므로 총 2개의 객체가 생성됨
  • 트래픽이 초당 100이 나오면 초당 100개의 객체가 생성되고 소멸
    • 메모리 낭비가 심하다
• 이를 위해서는 해당 객체는 딱 1개만 생성되게 하고, 공유하도록 설계하면 된다
  • 이를 싱글톤 패턴이라 한다

싱글톤 패턴

• 클래스의 인스턴스가 딱 1개만 생성되는 것을 보장하는 디자인 패턴이다.
• 객체 인스턴스를 2개 이상 생성하지 못 하도록 막아야 한다.
  • private 생성자를 사용해, 외부에서 임의로 new 키워드를 사용하지 못하도록 막아야 함.

package hello.core.singleton;

public class SingletonService {
    // 자기 자신을 static으로 내부에 private하게 하나 가지고 있다
    // 클래스 레벨에 올라가기 때문에 딱 하나만 존재하게 됨
    // 1. static영역에 객체를 딱 1개만 생성
    private static final SingletonService instance = new SingletonService();
    // 2. public으로 열어서 객체 인스턴스가 필요하면 static 메소드를 통해서만 조회하도록 허용
    public static SingletonService getInstance() {
        return instance;
    }
    // 3. 생성자를 private으로 선언해서 외부에서 new 키워드를 사용한 객체 생성을 못하게 막는다.
    private SingletonService() {
    }

    public void login() {
        System.out.println("싱글톤 객체 로직 호출");
    }
}

1. static 영역에 객체 instance를 미리 하나 생성해서 올려둔다
2. 이 객체 인스턴스가 필요하면 오직 getInstance()를 통해서만 조회할 수 있다. 이 메소드를 호출하면 항상 같은 인스턴스를 반환함
3. 딱 한 개의 객체 인스턴스만 존재해야 하므로 생성자를 private으로 막아서 혹시라도 외부에서 new 키워드로 객체 인스턴스가 생성되는 것을 막는다.

싱글톤 패턴을 사용하는 테스트 코드

    @Test
    @DisplayName("싱글톤 패턴을 적용한 객체 사용")
    void singletonServiceTest() {
        // private으로 생성자를 막아두었다. 컴파일 오류가 발생
        // new SingletonService();

        // 1. 조회 : 호출할 때 마다 같은 객체 반환
        SingletonService singletonService1 = SingletonService.getInstance();
        // 2. 조회 : 호출할 때 마다 같은 객체 반환
        SingletonService singletonService2 = SingletonService.getInstance();
        // 참조값이 같은 것 확인
        System.out.println("singletonService1 = " + singletonService1);
        System.out.println("singletonService2 = " + singletonService2);
        // singletonService1 == singletonService2
        assertThat(singletonService1).isSameAs(singletonService2);
        singletonService1.login();
    }

// 반환
singletonService1 = hello.core.singleton.SingletonService@7bedc48a
singletonService2 = hello.core.singleton.SingletonService@7bedc48a

• private으로 new 키워드를 막아두었다.
• 호출할 때 마다 같은 객체 인스턴스를 반환하는 것을 확인할 수 있음
• 참고 : 싱글톤 패턴을 구현하는 방법은 여러가지가 있으나, 여기선 객체를 미리 생성해두는 가장 단순하고 안전한 방법을 함

싱글톤 패턴을 적용하면 고객의 요청이 올 때 마다 객체를 생성하는 것이 아니라, 이미 만들어진 객체를 공유해 효율적으로 사용할 수 있다.

• 싱글톤 패턴 문제점
  • 구현하는 코드 자체가 많이 들어감
  • 의존관계상 클라이언트가 구체 클래스에 의존
    • DIP 위반
  • 클라이언트가 구체 클래스에 의존해서 OCP 원칙을 위반할 가능성 높음
  • 테스트하기 어려움
  • 내부 속성을 변경하거나 초기화 하기 어려움
  • private 생성자로 자식 클래스를 만들기 어려움
  • 결론적으로 유연성이 떨어진다
  • 안티패턴으로 불리기도 함!

출처 : 인프런 김영한 지식공유자님의 스프링 완전 정복 로드맵 강의