Bean은 무상태(stateless)로 설계하자

💡이 포스팅은 Spring Bean의 무상태(stateless)에 대해 정리한 포스팅입니다.

Spring Bean stateless에 대해 학습한 GitHub Repository입니다.

 

GitHub - kiekk/test-spring-bean-stateless

 

Spring Bean에 관해 찾아보면 무상태(stateless)로 설계해야 한다고 합니다. 무상태란 말 그대로 상태가 없는 것을 뜻하며 Bean이 특정 상태를 가지고 있지 않는 경우를 말합니다.

 

하지만 이 부분을 조금 더 설명해 보면 Bean이라서 무상태(statelss)여야 한다는 것은 아니고, Spring에서 Bean은 기본적으로 singleton 스코프로 생성되기 때문에 IoC 컨테이너에 단 한 개의 객체만 존재하게 됩니다.

그래서 Spring에서 Bean이 singleton이기 때문에 무상태여야 한다고 하는 것이며, 정리해 보면 singleton 패턴을 사용하는 경우에는 해당 클래스를 항상 무상태(statelss)로 설계해야 한다는 것입니다.

 

singleton

singleton 패턴은 객체의 인스턴스를 하나만 생성하고 이를 공유하여 사용합니다. Spring의 경우 IoC 컨테이너에 의해 Bean들이 관리됩니다.

사용자들이 Bean을 사용하려고 요청할 경우 IoC 컨테이너 있는 Bean을 사용자들이 서로 공유하여 사용하는데, 이 부분에서 Bean에 특정 값을 저장할 수 있다고 가정한다면, 사용자가 Bean을 사용할 때마다 값이 바뀌게 될 것입니다.

바로 이 부분을 '동시성' 이슈라고 하는데, 공유된 자원을 사용하는 경우에 반드시 뒤따라 오는 문제입니다.

 

// StatefulService Bean 등록 시 Singleton scope 로 등록했기 때문에
// UserA, UserB가 각각 StatefulService 에 접근할 때마다 값이 변경되어
// 동시성 이슈가 발생
@Test
void statefulServiceSingleton() {
    ApplicationContext ac = new AnnotationConfigApplicationContext(StatefulService.class);
    StatefulService statefulService1 = ac.getBean(StatefulService.class);
    StatefulService statefulService2 = ac.getBean(StatefulService.class);

    //ThreadA: A사용자 10000원 주문
    statefulService1.order("userA", 10000);
    //ThreadB: B사용자 20000원 주문
    statefulService2.order("userB", 20000);

    //ThreadA: 사용자A 주문 금액 조회
    int priceOfUserA = statefulService1.getPrice();
    System.out.println("priceOfUserA = " + priceOfUserA);

    //ThreadA: 사용자B 주문 금액 조회
    int priceOfUserB = statefulService1.getPrice();
    System.out.println("priceOfUserB = " + priceOfUserB);

    // UserA의 statefulService1, UserB의 statefulService2 비교
    System.out.println("statefulService1 : " + statefulService1);
    System.out.println("statefulService2 : " + statefulService2);
    System.out.println("statefulService1 == statefulService2 : " + (statefulService1 == statefulService2));
    Assertions.assertThat(statefulService1.getPrice()).isEqualTo(10000); // 에러발생
}

static class StatefulService {
    private int price; // 상태를 가지고 있는 필드

    public void order(String name, int price) {
        System.out.println("name = " + name + " price = " + price);
        this.price = price; // 문제가 발생할 수 있는 코드
    }

    public int getPrice() {
        return price;
    }
}

상태를 가지고 있는 StatefulService 객체를 생성했습니다. 내부에 price라는 필드를 통해 상태를 가지게 되었는데, statefulServiceSingleton() 메서드에서 확인할 수 있듯이 사용자 A와 사용자 B가 statefulService를 사용하여 상태(price)를 저장합니다.

 

위의 테스트로 보면 사용자B가 마지막에 statefulService를 사용했기 때문에 최종적으로는 사용자 B의 상태(price)가 저장되어 있을 것입니다.

문제는 사용자A가 다시 상태(price)를 조회했을 때 자신이 저장했던 상태가 아닌 사용자 B의 상태가 반환된다는 것입니다.

 

이처럼 상태가 있는 객체를 공유하여 사용하게 될 경우 특정 사용자의 상태를 보장할 수 없습니다.

그리고 만약 이 상태가 민감한 개인 정보라면 어떨까요? 보안에도 굉장히 취약하다고 할 수 있습니다.

 

이 문제를 해결하려는 방법으로는 먼저 scope를 변경하는 방법이 있습니다.

 

Scope 변경 - prototype

 

singleton의 경우 IoC 컨테이너가 인스턴스를 관리한다고 했는데, prototype의 경우 사용자가 Bean을 요청할 때마다 새로운 객체 인스턴스를 생성하여 반환하게 되며, 반환한 후에는 IoC 컨테이너가 더 이상 관리하지 않습니다.

따라서 사용자마다 서로 다른 객체를 사용하게 됨으로써 상태를 가지더라도 위와 같이 '동시성' 이슈는 발생하지 않습니다.

 

// scope를 prototype으로 설정하면
// UserA의 statefulService, UserB의 statefulService가 서로 다른 객체가 할당이 되어
// singleton에서의 동시성 이슈는 발생하지 않는다.
// 하지만 이런 방식은 Spring이 지향하는 것과 정반대로 가는 거라고 생각해서 옳지 않은 방법이라고 생각한다.
@Test
void statefulServicePrototype() {
    ApplicationContext ac = new AnnotationConfigApplicationContext(StatefulServiceV2.class);
    StatefulServiceV2 statefulService1 = ac.getBean(StatefulServiceV2.class);
    StatefulServiceV2 statefulService2 = ac.getBean(StatefulServiceV2.class);

    //ThreadA: A사용자 10000원 주문
    statefulService1.order("userA", 10000);
    //ThreadB: B사용자 20000원 주문
    statefulService2.order("userB", 20000);

    //ThreadA: 사용자A 주문 금액 조회
    int priceOfUserA = statefulService1.getPrice();
    System.out.println("priceOfUserA = " + priceOfUserA);

    //ThreadA: 사용자A 주문 금액 조회
    int priceOfUserB = statefulService2.getPrice();
    System.out.println("priceOfUserB = " + priceOfUserB);

    // UserA의 statefulService1, UserB의 statefulService2 비교
    System.out.println("statefulService1 : " + statefulService1);
    System.out.println("statefulService2 : " + statefulService2);
    System.out.println("statefulService1 == statefulService2 : " + (statefulService1 == statefulService2));

    Assertions.assertThat(statefulService1.getPrice()).isEqualTo(10000);
    Assertions.assertThat(statefulService2.getPrice()).isEqualTo(20000);
    Assertions.assertThat(statefulService1.getPrice()).isNotEqualTo(statefulService2.getPrice());
}

@Scope("prototype")
static class StatefulServiceV2 {
    private int price; // 상태를 가지고 있는 필드

    public void order(String name, int price) {
        System.out.println("name = " + name + " price = " + price);
        this.price = price;
        // 이제 Bean 을 요청할 때마다 객체를 생성하기 떄문에
        // 더 이상 동시성 이슈는 발생하지 않는다.
        // 하지만 사용자마다 객체를 생성해주기 때문에 불필요한 객체들이 너무 많이 생성된다.
    }

    public int getPrice() {
        return price;
    }
}

 

하지만 이 방법이 best라고 할 수는 없을 것입니다. 이유는 사용자의 Bean 요청 마다 새로운 객체 인스턴스를 반환한다는 점인데, 사용자의 수가 100만 명, 1000만 명이라고 극단적으로 가정을 해보면 그만큼의 Bean이 생성되기 때문에 불필요한 메모리가 너무 많아져 성능이 저하되거나 심할 때는 서버가 다운이 될 수도 있습니다.

그렇기 때문에 이 방법은 이렇게도 해결할 수가 있구나. 정도로만 알고 넘어가시면 될 것 같습니다.

 

가장 좋은 방법은 Spring의 권장 방법이자 이 포스팅의 제목인 Bean을 무상태(stateless)로 설계하는 것입니다.

무상태로 설계할 경우 상태를 가지는 price를 제거하게 되는 것입니다. 

상태를 저장하는 것이 아닌 상태를 반환함으로써 Bean을 사용하는 사용자 측에서 상태를 관리하게 하는 것입니다.

 

// 위 문제를 모두 충족하려면 Bean 이 더 이상 상태를 가지지 않도록 하면 된다.
// 상태를 가지지 않도록 하여 Spring 이 지향하는 singleton 방식도 해결하고 동시성 이슈도 해결할 수 있다.
@Test
void statelessService() {
    ApplicationContext ac = new AnnotationConfigApplicationContext(StatelessService.class);
    StatelessService statelessService1 = ac.getBean(StatelessService.class);
    StatelessService statelessService2 = ac.getBean(StatelessService.class);

    //ThreadA: A사용자 10000원 주문
    int priceOfUserA = statelessService1.order("userA", 10000);
    //ThreadB: B사용자 20000원 주문
    int priceOfUserB = statelessService2.order("userB", 20000);

    System.out.println("priceOfUserA = " + priceOfUserA);
    System.out.println("priceOfUserB = " + priceOfUserB);

    // UserA의 statelessService1, UserB의 statelessService2 비교
    System.out.println("statelessService1 : " + statelessService1);
    System.out.println("statelessService2 : " + statelessService2);
    System.out.println("statelessService1 == statelessService2 : " + (statelessService1 == statelessService2));

    Assertions.assertThat(priceOfUserA).isEqualTo(10000);
    Assertions.assertThat(priceOfUserB).isEqualTo(20000);
}

static class StatelessService {
    public int order(String name, int price) {
        System.out.println("name = " + name + " price = " + price);
        return price;
    }
}

이 코드의 다른 점은 StatelessService에서 price가 사라졌다는 점입니다. 즉, 더 이상 이 객체는 상태를 저장하고 있지 않습니다.

대신 전달 받은 price를 그대로 사용자에게 반환함으로써 이제 상태를 관리하는 주체가 Bean이 아닌 Bean을 사용하는 사용자 쪽으로 되게끔 하여 앞서 2개의 문제를 해결했습니다.

 

이와 같은 이유로 항상 Bean은 무상태(stateless)로 설계하는 것이 좋으며, Bean을 사용하는 쪽에서 상태를 관리할 수 있도록 설계하는 것이 좋습니다.