[디자인 패턴] 행위 패턴 - Status Pattern (상태 패턴)

목차

 

📇 개요

상태 패턴(State Pattern)은 객체의 내부 상태가 변경될 때 객체의 행동이 변경되도록 하는 행동 디자인 패턴이다. 즉, 객체의 상태에 따라 객체의 행동이 달라지게 하는 패턴으로, 마치 객체의 클래스가 변경되는 것처럼 보이게 한다.

 

특징

• 상태 전환 로직을 캡슐화하여 코드의 가독성과 유지보수성을 높인다.
• 상태별 동작을 별도의 클래스로 분리하여 단일 책임 원칙(SRP)을 준수한다.
• 조건문(if-else, switch)을 제거하고 객체지향적인 방식으로 상태 전환을 처리한다.

 

👩🏻‍💻 코드로 알아보자

자판기의 상태 변화를 구현하는 예제를 통해 상태 패턴을 살펴보자.

// 1. 상태 인터페이스
interface State {
    void insertCoin(VendingMachine vendingMachine);
    void selectProduct(VendingMachine vendingMachine);
    void dispense(VendingMachine vendingMachine);
    void refund(VendingMachine vendingMachine);
}

// 2. 구체적인 상태 클래스들
class NoCoinState implements State {
    @Override
    public void insertCoin(VendingMachine vendingMachine) {
        System.out.println("동전이 투입되었습니다.");
        vendingMachine.setState(vendingMachine.getHasCoinState());
    }
    
    @Override
    public void selectProduct(VendingMachine vendingMachine) {
        System.out.println("동전을 먼저 넣어주세요.");
    }
    
    @Override
    public void dispense(VendingMachine vendingMachine) {
        System.out.println("동전을 먼저 넣어주세요.");
    }
    
    @Override
    public void refund(VendingMachine vendingMachine) {
        System.out.println("반환할 동전이 없습니다.");
    }
}

class HasCoinState implements State {
    @Override
    public void insertCoin(VendingMachine vendingMachine) {
        System.out.println("이미 동전이 들어있습니다. 상품을 선택해주세요.");
    }
    
    @Override
    public void selectProduct(VendingMachine vendingMachine) {
        System.out.println("상품이 선택되었습니다.");
        vendingMachine.setState(vendingMachine.getProductSelectedState());
    }
    
    @Override
    public void dispense(VendingMachine vendingMachine) {
        System.out.println("상품을 먼저 선택해주세요.");
    }
    
    @Override
    public void refund(VendingMachine vendingMachine) {
        System.out.println("동전이 반환되었습니다.");
        vendingMachine.setState(vendingMachine.getNoCoinState());
    }
}

class ProductSelectedState implements State {
    @Override
    public void insertCoin(VendingMachine vendingMachine) {
        System.out.println("이미 상품이 선택되었습니다. 추가 동전은 필요 없습니다.");
    }
    
    @Override
    public void selectProduct(VendingMachine vendingMachine) {
        System.out.println("이미 상품이 선택되었습니다.");
    }
    
    @Override
    public void dispense(VendingMachine vendingMachine) {
        System.out.println("상품이 나왔습니다. 감사합니다!");
        vendingMachine.setState(vendingMachine.getNoCoinState());
    }
    
    @Override
    public void refund(VendingMachine vendingMachine) {
        System.out.println("상품 선택이 취소되었습니다. 동전이 반환됩니다.");
        vendingMachine.setState(vendingMachine.getNoCoinState());
    }
}

class SoldOutState implements State {
    @Override
    public void insertCoin(VendingMachine vendingMachine) {
        System.out.println("죄송합니다. 재고가 없습니다. 동전이 반환됩니다.");
    }
    
    @Override
    public void selectProduct(VendingMachine vendingMachine) {
        System.out.println("죄송합니다. 재고가 없습니다.");
    }
    
    @Override
    public void dispense(VendingMachine vendingMachine) {
        System.out.println("실패: 재고가 없습니다.");
    }
    
    @Override
    public void refund(VendingMachine vendingMachine) {
        System.out.println("반환할 동전이 없습니다.");
    }
}

// 3. 컨텍스트 클래스
class VendingMachine {
    private State noCoinState;
    private State hasCoinState;
    private State productSelectedState;
    private State soldOutState;
    
    private State currentState;
    private int count; // 상품 재고
    
    public VendingMachine(int count) {
        // 상태 객체들 초기화
        noCoinState = new NoCoinState();
        hasCoinState = new HasCoinState();
        productSelectedState = new ProductSelectedState();
        soldOutState = new SoldOutState();
        
        this.count = count;
        if (count > 0) {
            currentState = noCoinState;
        } else {
            currentState = soldOutState;
        }
    }
    
    // 사용자 행동 메서드들
    public void insertCoin() {
        currentState.insertCoin(this);
    }
    
    public void selectProduct() {
        currentState.selectProduct(this);
    }
    
    public void dispense() {
        currentState.dispense(this);
        if (currentState != soldOutState) {
            count--;
            if (count == 0) {
                setState(soldOutState);
            }
        }
    }
    
    public void refund() {
        currentState.refund(this);
    }
    
    // 상태 변경 메서드
    public void setState(State state) {
        this.currentState = state;
    }
    
    // 상태 획득 메서드들
    public State getNoCoinState() {
        return noCoinState;
    }
    
    public State getHasCoinState() {
        return hasCoinState;
    }
    
    public State getProductSelectedState() {
        return productSelectedState;
    }
    
    public State getSoldOutState() {
        return soldOutState;
    }
    
    // 현재 상태 출력
    public void printStatus() {
        System.out.println("현재 상태: " + currentState.getClass().getSimpleName());
        System.out.println("남은 재고: " + count);
    }
}

// 4. 클라이언트 코드
public class StatePatternExample {
    public static void main(String[] args) {
        // 자판기 생성 (재고 3개)
        VendingMachine vendingMachine = new VendingMachine(3);
        
        // 정상 시나리오: 동전 투입 -> 상품 선택 -> 상품 배출
        System.out.println("----- 시나리오 1: 정상 구매 과정 -----");
        vendingMachine.printStatus();
        vendingMachine.insertCoin();
        vendingMachine.selectProduct();
        vendingMachine.dispense();
        vendingMachine.printStatus();
        
        // 동전 반환 시나리오: 동전 투입 -> 반환
        System.out.println("\n----- 시나리오 2: 동전 반환 -----");
        vendingMachine.insertCoin();
        vendingMachine.refund();
        vendingMachine.printStatus();
        
        // 상품 선택 취소 시나리오: 동전 투입 -> 상품 선택 -> 취소
        System.out.println("\n----- 시나리오 3: 상품 선택 취소 -----");
        vendingMachine.insertCoin();
        vendingMachine.selectProduct();
        vendingMachine.refund();
        vendingMachine.printStatus();
        
        // 재고 소진 시나리오
        System.out.println("\n----- 시나리오 4: 재고 소진 -----");
        vendingMachine.insertCoin();
        vendingMachine.selectProduct();
        vendingMachine.dispense();
        
        vendingMachine.insertCoin();
        vendingMachine.selectProduct();
        vendingMachine.dispense();
        vendingMachine.printStatus();
        
        // 재고 없음 시나리오
        System.out.println("\n----- 시나리오 5: 재고 없음 -----");
        vendingMachine.insertCoin();
        vendingMachine.printStatus();
    }
}

• State 인터페이스는 자판기의 모든 행동에 대한 메서드를 정의한다.
• 구체적인 상태 클래스들(NoCoinState, HasCoinState, ProductSelectedState, SoldOutState)은 각 상태에서의 행동을 구현한다.
• VendingMachine 클래스는 컨텍스트 역할을 하며, 현재 상태를 유지하고 사용자 행동을 현재 상태에 위임한다.
• 상태가 전환될 때마다 컨텍스트의 setState() 메서드를 통해 상태 객체가 변경된다.

 

☘️ 장/단점

✅ 장점

1. 조건문 제거
   • 복잡한 조건문(if-else, switch)을 제거하고 객체지향적인 방식으로 상태별 행동을 분리한다.
   • 이는 코드의 가독성과 유지보수성을 크게 향상시킨다.
2. 단일 책임 원칙(SRP) 준수
   • 각 상태의 행동을 별도의 클래스로 캡슐화하여 책임을 분산시킨다.
   • 특정 상태와 관련된 행동만 변경하면 되므로 코드 변경이 쉽다.
3. 개방/폐쇄 원칙(OCP) 준수
   • 기존 코드를 수정하지 않고도 새로운 상태와 행동을 추가할 수 있다.
   • 예: 자판기에 '점검 중' 상태를 추가하더라도 기존 상태 클래스는 변경할 필요가 없다.
4. 상태 전환 로직의 명확화
   • 상태 전환 로직이 각 상태 클래스 내부에 분산되어 있어 상태 관리가 명확해진다.
   • 디버깅과 코드 이해가 쉬워진다.

❌ 단점

1. 클래스 수 증가
   • 각 상태마다 별도의 클래스가 필요하므로 전체 클래스 수가 많아질 수 있다.
   • 간단한 상태 관리에는 과도한 디자인이 될 수 있다.
2. 상태 간 의존성 관리
   • 상태 전환 로직이 상태 클래스에 분산되어 있기 때문에 상태 간 의존성이 생길 수 있다.
   • 이로 인해 한 상태를 변경할 때 다른 상태도 함께 변경해야 할 수 있다.
3. 컨텍스트 종속성
   • 상태 클래스가 컨텍스트(VendingMachine)에 강하게 결합되어 있어 재사용성이 제한될 수 있다.
   • 상태 클래스는 컨텍스트의 메서드와 속성에 접근해야 할 수 있다.
4. 상태 객체 관리 오버헤드
   • 모든 상태 객체를 미리 생성하고 유지해야 하므로 메모리 사용량이 증가할 수 있다.
   • 특히 상태가 많고 복잡한 시스템에서는 이 문제가 두드러질 수 있다.

 

📌 정리

상태 패턴은 객체의 내부 상태가 변경될 때 객체의 행동이 변경되도록 하는 디자인 패턴이다.

이 패턴은 상태별 행동을 별도의 클래스로 캡슐화하여 조건문을 제거하고, 객체지향적인 방식으로 상태 전환을 관리한다. 상태 전환 로직을 분산시키고 각 상태가 자신만의 행동을 책임지게 함으로써 코드의 가독성과 유지보수성을 향상시킨다.

 

✅ 언제 사용하면 좋을까?

• 객체의 행동이 상태에 따라 크게 달라질 때
• 객체 상태 변화에 따른 조건문(if-else, switch)이 복잡해질 때
• 상태 전환 로직을 더 명확하게 표현하고 싶을 때
• 객체 지향적인 방식으로 상태 관리를 구현하고 싶을 때

❌ 언제 피해야 할까?

• 간단한 상태 관리만 필요한 경우(오버엔지니어링 가능성)
• 상태와 전환이 적고 변경이 거의 없는 경우
• 성능이 중요한 상황에서 상태 객체 생성 오버헤드가 문제가 될 때
• 메모리 사용량이 중요한 제한된 환경에서

 

💡 자바/스프링 프레임워크에서의 상태 패턴

1. 스프링 스테이트 머신(Spring Statemachine)

스프링에서는 상태 패턴을 구현하기 위한 전용 프레임워크인 Spring Statemachine을 제공한다.

import org.springframework.statemachine.StateMachine;
import org.springframework.statemachine.config.StateMachineBuilder;
import org.springframework.statemachine.config.StateMachineBuilder.Builder;

public class OrderStateMachineExample {
    // 주문 상태 열거형
    public enum OrderStates {
        CREATED, PAID, PROCESSING, SHIPPED, DELIVERED, CANCELLED
    }
    
    // 주문 이벤트 열거형
    public enum OrderEvents {
        PAY, PROCESS, SHIP, DELIVER, CANCEL
    }
    
    public static void main(String[] args) throws Exception {
        // 상태 머신 빌더 생성
        Builder<OrderStates, OrderEvents> builder = StateMachineBuilder.builder();
        
        // 상태 머신 구성
        builder.configureStates()
            .withStates()
            .initial(OrderStates.CREATED)
            .states(EnumSet.allOf(OrderStates.class));
        
        // 상태 전환 정의
        builder.configureTransitions()
            .withExternal()
                .source(OrderStates.CREATED).target(OrderStates.PAID)
                .event(OrderEvents.PAY)
                .and()
            .withExternal()
                .source(OrderStates.PAID).target(OrderStates.PROCESSING)
                .event(OrderEvents.PROCESS)
                .and()
            .withExternal()
                .source(OrderStates.PROCESSING).target(OrderStates.SHIPPED)
                .event(OrderEvents.SHIP)
                .and()
            .withExternal()
                .source(OrderStates.SHIPPED).target(OrderStates.DELIVERED)
                .event(OrderEvents.DELIVER)
                .and()
            .withExternal()
                .source(OrderStates.CREATED).target(OrderStates.CANCELLED)
                .event(OrderEvents.CANCEL)
                .and()
            .withExternal()
                .source(OrderStates.PAID).target(OrderStates.CANCELLED)
                .event(OrderEvents.CANCEL);
        
        // 상태 머신 생성
        StateMachine<OrderStates, OrderEvents> stateMachine = builder.build();
        stateMachine.start();
        
        // 상태 머신 사용
        System.out.println("Current state: " + stateMachine.getState().getId());
        
        stateMachine.sendEvent(OrderEvents.PAY);
        System.out.println("Current state: " + stateMachine.getState().getId());
        
        stateMachine.sendEvent(OrderEvents.PROCESS);
        System.out.println("Current state: " + stateMachine.getState().getId());
        
        stateMachine.sendEvent(OrderEvents.SHIP);
        System.out.println("Current state: " + stateMachine.getState().getId());
        
        stateMachine.sendEvent(OrderEvents.DELIVER);
        System.out.println("Current state: " + stateMachine.getState().getId());
    }
}

 

2. JPA Entity 상태 관리

아래와 같이 JPA 엔티티의 상태를 관리할 때도 상태 패턴을 응용할 수 있다.

import javax.persistence.*;
import java.time.LocalDateTime;

@Entity
public class Order {
    @Id
    @GeneratedValue
    private Long id;
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    
    private LocalDateTime orderDate;
    private LocalDateTime paidDate;
    private LocalDateTime shippedDate;
    private LocalDateTime deliveredDate;
    private LocalDateTime cancelledDate;
    
    // 상태에 따른 행동을 처리하는 상태 객체
    @Transient
    private OrderState state;
    
    public Order() {
        this.orderDate = LocalDateTime.now();
        this.status = OrderStatus.CREATED;
        this.state = new CreatedOrderState();
    }
    
    // 상태 변경 메서드
    public void setState(OrderState state) {
        this.state = state;
        this.status = state.getStatus();
    }
    
    // 주문 처리 행동
    public void pay() {
        state.pay(this);
    }
    
    public void ship() {
        state.ship(this);
    }
    
    public void deliver() {
        state.deliver(this);
    }
    
    public void cancel() {
        state.cancel(this);
    }
    
    // getter/setter
    // ...
}

// 상태 인터페이스
interface OrderState {
    OrderStatus getStatus();
    void pay(Order order);
    void ship(Order order);
    void deliver(Order order);
    void cancel(Order order);
}

// 주문 생성 상태
class CreatedOrderState implements OrderState {
    @Override
    public OrderStatus getStatus() {
        return OrderStatus.CREATED;
    }
    
    @Override
    public void pay(Order order) {
        order.setPaidDate(LocalDateTime.now());
        order.setState(new PaidOrderState());
    }
    
    @Override
    public void ship(Order order) {
        throw new IllegalStateException("Created order cannot be shipped directly");
    }
    
    @Override
    public void deliver(Order order) {
        throw new IllegalStateException("Created order cannot be delivered directly");
    }
    
    @Override
    public void cancel(Order order) {
        order.setCancelledDate(LocalDateTime.now());
        order.setState(new CancelledOrderState());
    }
}

// 지불 완료 상태
class PaidOrderState implements OrderState {
    // 구현...
}

// 주문 상태 열거형
enum OrderStatus {
    CREATED, PAID, SHIPPED, DELIVERED, CANCELLED
}

 

📚 실제 사용 사례

1. 워크플로우 관리 시스템
   • 비즈니스 프로세스의 다양한 단계와 상태 전환을 관리
   • 예: JIRA와 같은 이슈 트래킹 시스템의 티켓 상태 관리
2. 주문 처리 시스템
   • 주문 생성, 결제, 처리, 배송, 완료 등의 상태 관리
   • 각 상태에서 허용되는 작업과 다음 상태로의 전환 제어
3. 게임 캐릭터 AI
   • 캐릭터의 상태(대기, 순찰, 추격, 공격 등)에 따른 행동 제어
   • 상황에 따라 상태를 동적으로 전환
4. 네트워크 연결 관리
   • TCP 연결 상태(연결 중, 연결됨, 종료 중 등) 관리
   • 상태에 따른 패킷 처리 로직 구현
5. 문서 관리 시스템
   • 문서의 상태(초안, 검토 중, 승인됨, 게시됨 등) 관리
   • 상태에 따른 접근 권한 및 작업 제어
6. UI 상태 관리
   • 사용자 인터페이스 구성 요소의 상태(활성화, 비활성화, 선택됨 등) 관리
   • React, Vue.js와 같은 프론트엔드 프레임워크에서의 상태 관리
7. 전자 상거래 결제 처리
   • 결제 프로세스의 다양한 상태(결제 요청, 승인 대기, 승인됨, 거부됨 등) 관리
   • 상태에 따른 결제 시스템 동작 제어

 

 

📋 참고

• https://refactoring.guru/ko/design-patterns/state