[디자인패턴] 상태 패턴 , 스테이트 패턴 (State Pattern)

💡 상태 패턴 , 스테이트 패턴 (state pattern)
객체의 내부 상태가 바뀜에 따라서 객체의 행동을 바꿀 수 있다. 마치 객체의 클래스가 바뀌는 것과 같은 결과를 얻을 수 있다.

 

■ 예제 : 뽑기 자판기

(1) 요구사항

"다음과 같은 방식으로 작동하는 뽑기 기계의 자바코드를 작성해주세요. 나중에 다른 기능을 추가할 가능성도 있으니 최대한 유연하고 관리하기 용이한 디자인으로 해줬으면 합니다."

상태 다이어그램 (State Diagram)

상태 다이어그램을 바탕으로 상태를 정의하자.

• 상태정의
  • No Coin : 돈이 넣어져있지 않은 상태
  • Has Coin : 돈 넣어진 상태
  • Sold : 판매중의 상태
  • Sold Out : 매진 상태

 

(2) 문제인식

1. 다음과 같이 뽑기 자판기를 작성하면 될 것 같다.

public class GachaMachine {
    // 각 상태를 저장하기위한 인스턴스변수를 만들어 정의
    final static int SOLD_OUT = 0; // 매진
    final static int NO_COIN = 1; // 동전 없음
    final static int HAS_COIN = 2; // 동전 있음
    final static int SOLD = 3; // 판매

    int state = SOLD_OUT; // 현재 상태를 저장하는 인스턴스 변수
    int count = 0; // 뽑기 갯수

    public GachaMachine(int count) {
        this.count = count;
        if (count > 0) {
            state = NO_COIN;
        }
    }

    public void insertCoin() {
        if (state == HAS_COIN) {
            // 판매대기 상태 : 동전 O
            System.out.println("동전이 이미 있어요. 더 넣을 수 없어요.");
        } else if (state == NO_COIN) {
            // 판매대기 상태 : 동전 X
            state = HAS_COIN;
            System.out.println("동전을 넣었습니다.");
        } else if (state == SOLD_OUT) {
            // 매진 상태
            System.out.println("sold out! 다 팔렸어요. 돈 넣지마세요");
        } else if (state == SOLD) {
            // 판매중 상태
            System.out.println("잠시만 기다려주세요. 뽑기가 나올거에요");
        }
    }

    public void ejectCoin() { // 사용자가 동전 반환 하는 경우
        if (state == HAS_COIN) {
            // 판매대기 : 동전 O, 반환 O
            System.out.println("동전이 반환됩니다.");
            state = NO_COIN;
        } else if (state == NO_COIN) {
            // 판매대기 : 동전 X, 반환 X
            System.out.println("동전이 없어요");
        } else if (state == SOLD) {
            // 판매중 : 이미 판매되어 반환 X
            System.out.println("이미 구입 하셨어요");
        } else if (state == SOLD_OUT) {
            // 매진 : 동전 X, 반환 X
            System.out.println("동전 반환 안돼요. 매진으로 돈도 안받았어요");
        }
    }

    public void turnCrank() { // 사용자가 손잡이를 돌리는 경우
        if (state == SOLD) {
            System.out.println("손잡이는 한 번만 돌려주세요.");
        } else if (state == NO_COIN) {
            System.out.println("동전을 넣어주세요");
        } else if (state == SOLD_OUT) {
            System.out.println("매진 되었습니다");
        } else if (state == HAS_COIN) {
            System.out.println("손잡이를 돌렸습니다. 뽑기가 나올거에요");
            state = SOLD;
            dispense();
        }
    }

    private void dispense() {
        if (state == SOLD) {
            System.out.println("뽑기가 나가고 있어요");
            count = count - 1;
            if (count == 0) {
                System.out.println("뽑기 재고가 없어요");
                state = SOLD_OUT;
            } else {
                state = NO_COIN;
            }
        } else if (state == NO_COIN) {
            System.out.println("먼저 동전을 넣어주세요");
        } else if (state == SOLD_OUT) {
            System.out.println("매진 입니다.");
        } else if (state == HAS_COIN) {
            System.out.println("뽑기가 나갈 수 없어요.");
        }
    }
    // 이하 삭제
    public void refill(int numGumBalls) {
        this.count = numGumBalls;
        state = NO_COIN;
    }

    public String toString() {
        StringBuffer result = new StringBuffer();
        result.append("==== 뽑기 자판기 ==== \n");
        result.append("재고 : " + count + "  개");
        result.append("\n현재 자판기 상태는 ");
        if (state == SOLD_OUT) {
            result.append("매진 : sold out!!");
        } else if (state == NO_COIN) {
            result.append("판매대기(돈 X) : 동전 넣어주세요");
        } else if (state == HAS_COIN) {
            result.append("판매대기(돈 O) : 손잡이를 돌려주세요");
        } else if (state == SOLD) {
            result.append("판매중 : 뽑기가 나오고 있습니다.");
        }
        result.append("\n");
        return result.toString();
    }
}

2. 변경요청이 들어왔다. 뽑기에 1개를 더 받을 수 있는 기능을 추가해주세요.

"Buy 1 Get 1 : 도전하세요! 10분의 1 확률!"

위와같은 소스 작성방법으로는 다음과 같이 작성할 수 밖에 없다.

final static int SOLD_OUT = 0;
final static int NO_COIN = 1;
final static int HAS_COIN = 2;
final static int SOLD = 3;
// 1) 상태 값 저장을 위한 인스턴스 변수 선언 : WINNER 상태를 추가해야한다.

// 2) 각 상태 조건문 : 추가할 때마다 각 메소드에 if()를 이용하여 조건을 추가해야 한다.
public void insertCoin () {
    // 동전 투입시 해야 할 일 : 판매대기(동전o)
}
public void ejectCoin () {
    // 동전 반환시 해야 할 일 : 동전 반환후 판매대기(동전x) 상태설정
}
public void turnCrank() {
    // 손잡이를 돌렸을 때 해야 할 일
}
public void dispense() {
    // 뽑기 내보낼때 해야 할 일 : 남은 재고 파악후 상태설정
}

각 상태 값 저장을 위한 인스턴스 변수가 추가되고, 각 상태에 대한 if문의 조건을 추가해야한다. 차후 요구사항이 생기면 또 추가해야하고 그 수가 많아지면 지저분해진다.

 

(3) 문제점

구체적인 문제점 정리

• OCP 원칙을 지키지 않고 있다.
• 객체지향 디자인이라고 하기에 무리가 있다.
• 지저문한 조건문으로 인해 상태전환히 분명하게 드러나지 않는다.
• 다른 기능을 추가하는 과정에서 기존 코드에 없던 새로운 버그가 발생할 가능성이 크다.

즉, 각 상태의 행동을 별도의 클래스에 집에 넣고 모든 상태에서 각자 자기가 할 일을 구현해보자.

 

모든 상태를 캡슐화시켜 State 인터페이스를 구현해보자.

 

• State 인터페이스
  • 모든 상태 클래스에서 사용할 인터페이스
  • 메소드는 뽑기 기계에서 일어날 수 있는 모든 행동들에 직접적으로 대응된다.
• 각 상태를 나타내는 구체 클래스
  • 각 상태를 직접 클래스에 대응시켜 작성한다. 

 

 

■ 새로운 디자인

1. 뽑기 기계와 관련된 모든 행동에 대한 메소드가 들어있는 State 인터페이스를 정의한다.
2. 기계의 모든 상태에 대하여 상태 클래스를 구현해야 한다. 기계가 어떤 상태에 있다면, 그 상태에 해당하는 상태 클래스가 모든 작업을 책임지도록 한다.
3. 마지막으로 조건문 코드를 전부 없애고 상태 클래스에 모든 작업을 위임한다.

1. State 인터페이스

public interface State {
    void insertCoin();
    void ejectCoin();
    void turnCrank();
    void dispense();
    void refill();
}

2. 각 상태 클래스 구현

/**
 * 판매대기 상태 정보 : 동전 O
 */
public class HasCoinState implements State {

    GachaMachine gachaMachine;

    public HasCoinState(GachaMachine gachaMachine) {
        this.gachaMachine = gachaMachine;
    }

    @Override
    public void insertCoin() {
        System.out.println("동전을 넣을수 없어요. 이미 동전이 있습니다.");
    }

    @Override
    public void ejectCoin() {
        // 동전 반환
        System.out.println("동전을 반환합니다.");
        // 동전 반환 후 동전 없음 상태로 바꿔준다.
        gachaMachine.setState(gachaMachine.getNoCoinState());
    }

    @Override
    public void turnCrank() {
        // 손잡이 돌리기
        System.out.println("손잡이를 돌립니다.");
        // 손잡이 돌린 결과 : 뽑기 판매 시작
        gachaMachine.setState(gachaMachine.getSoldState());
    }

    @Override
    public void dispense() {
        System.out.println("뽑기 아직 나오지 않았어요.");
    }

    @Override
    public void refill() {

    }

    @Override
    public String toString() {
        return "판매대기 상태입니다 : 손잡이를 돌려야 뽑기가 나옵니다.";
    }
}
/**
 * 판매대기 상태 정보 : 동전 X
 */
public class NoCoinState implements State {

    GachaMachine gachaMachine;

    public NoCoinState(GachaMachine gachaMachine) {
        this.gachaMachine = gachaMachine;
    }

    @Override
    public void insertCoin() {
        System.out.println("동전을 넣습니다.");
        gachaMachine.setState(gachaMachine.getHasCoinState());
    }

    @Override
    public void ejectCoin() {
        System.out.println("동전이 없습니다. 동전을 반환할 수 없어요.");
    }

    @Override
    public void turnCrank() {
        System.out.println("동전이 없습니다. 손잡이를 돌려도 뽑기가 나오지 않습니다.");
    }

    @Override
    public void dispense() {
        System.out.println("동전을 넣어주세요.");
    }

    @Override
    public void refill() {

    }

    @Override
    public String toString() {
        return "판매대기 상태입니다 : 동전을 넣어주세요.";
    }
}
/**
 * 매진 상태 정보
 */
public class SoldOutState implements State {

    GachaMachine gachaMachine;

    public SoldOutState(GachaMachine gachaMachine) {
        this.gachaMachine = gachaMachine;
    }

    @Override
    public void insertCoin() {
        System.out.println("매진입니다. 동전을 넣지마세요");
    }

    @Override
    public void ejectCoin() {
        System.out.println("넣은 동전이 없습니다.");
    }

    @Override
    public void turnCrank() {
        System.out.println("동전을 넣어주세요.");
    }

    @Override
    public void dispense() {
        System.out.println("뽑기가 없습니다.");
    }

    @Override
    public void refill() {
        gachaMachine.setState(gachaMachine.getNoCoinState());
    }

    @Override
    public String toString() {
        return "매진 상태입니다. sold out!!";
    }
}
/**
 * 판매중 상태
 */
public class SoldState implements State {

    GachaMachine gachaMachine;

    public SoldState(GachaMachine gachaMachine) {
        this.gachaMachine = gachaMachine;
    }

    @Override
    public void insertCoin() {
        System.out.println("잠시만 기다려주세요. 지금 뽑기가 나오고 있습니다.");
    }

    @Override
    public void ejectCoin() {
        System.out.println("죄송합니다. 이미 뽑기가 나오고있어 환불이 불가합니다.");
    }

    @Override
    public void turnCrank() {
        System.out.println("잠시만 기다려주세요. 이미 뽑기가 나오고 있습니다.");
    }

    @Override
    public void dispense() {
        // 뽑기 판매 처리
        gachaMachine.releaseBall();
        // 뽑기 판매 후 재고확인해서 상태를 바꿔준다.
        if (gachaMachine.getCount() > 0) {
            // 뽑기 재고가 있으면, 판매대기 상태
            gachaMachine.setState(gachaMachine.getNoCoinState());
        } else {
            // 뽑기 재고가 없으면, 매진 상태
            System.out.println("뽑기가 매진되었습니다.");
            gachaMachine.setState(gachaMachine.getSoldOutState());
        }
    }

    @Override
    public void refill() {
    }

    @Override
    public String toString() {
        return "판매중 상태입니다 : 뽑기 판매중!";
    }
}

3. 뽑기 기계 만들기

public class GachaMachine {

    State soldOutState; // 매진 상태
    State noCoinState; // 판매대기 상태 : 코인 없는 상태
    State hasCoinState; // 판매대기 상태 : 코인 넣어진 상태
    State soldState; // 판매중의 상태
    State state; // 상태 인스턴스
    int count = 0; // 뽑기 개수

    public GachaMachine(int numberGumballs) {
        soldOutState = new SoldOutState(this);
        noCoinState = new NoCoinState(this);
        hasCoinState = new HasCoinState(this);
        soldState = new SoldState(this);

        this.count = numberGumballs;
        if (numberGumballs > 0) {
            state = noCoinState;
        } else {
            state = soldOutState;
        }
    }

    public void insertCoin() {
        // 동전 넣음
        state.insertCoin();
    }

    public void ejectCoin() {
        // 동전 반환을 하면 반환
        state.ejectCoin();
    }

    public void turnCrank() {
        // 손잡이 돌림
        state.turnCrank();
        // 뽑기 판매여부
        state.dispense();
    }

    public void releaseBall() {
        System.out.println("뽑기가 나왔습니다.");
        if (count > 0) {
            count = count - 1;
        }
    }

    public void refill(int count) {
        this.count = this.count + count;
        System.out.println("뽑기 " + count + " 개 리필!, 현재 " + this.count + " 개 입니다.");
        state.refill();
    }

    public void setState(State state) {
        this.state = state;
    }

    public int getCount() {
        return count;
    }

    public State getState() {
        return state;
    }

    public State getSoldOutState() {
        return soldOutState;
    }

    public State getNoCoinState() {
        return noCoinState;
    }

    public State getHasCoinState() {
        return hasCoinState;
    }

    public State getSoldState() {
        return soldState;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("===== Gumball Machine =====\n");
        sb.append("머신 상태 : " + state + "\n");
        sb.append("재고 : " + count + " 개\n");
        return sb.toString();
    }
}

 

정리하면

• 각 State 의 행동 (Behavior) 을 별개의 클래스로 국지화 시켰다.
• 지저분한 if문들을 삭제했다.
• 각 State 를 변경하는 것에 대해서는 닫혀있으면서 GachaMachine 자체는 새로운 상태 클래스를 추가하는 확장에 대해서는 열려있다. (OCP 원칙)
• 처음에 요구받은 상태 다이어그램에 훨씬 가까우면서도 이해하기 좋은 코드 베이스와 클래스 구조를 만들었다.

 

■ 스테이트 패턴의 적용 효과

1. 내부 상태가 바뀜에 따라서 객체의 행동을 바꿀 수 있다.
   상태를 별도의 클래스로 캡슐화한 다음 현재 상태에 있는 객체에게 행동을 위임하기 때문에 내부 상태가 바뀜에 따라서 행동이 달라지게 되는 것이다.
2. 클래스가 바뀌는 것 같은 결과를 얻는다.
   클라이언트 입장에서 클라이언트에서 사용하는 객체의 행동이 완전히 달라질 수 있다면 마치 그 객체가 다른 클래스로부터 만들어진 객체처럼 느껴질 수 있다. 실제로는 다른 클래스로 만들어져 변신하는 것이 아니라 구성을 통해 여러 상태 객체를 바꿔가면서 사용하기 때문에 바뀌는 것과 같은 결과를 얻을 수 있는 것이다.

 

 

■ UML Diagram

Strategy Pattern (전략 패턴 , 스트래티지 패턴) 과 UML Diagram 이 동일하다.

 

■ Strategy Pattern 과 차이

용도에 있어서 차이점이 있다.

Strategy 패턴	State 패턴
일반적으로 Client 에서 Context 객체한테 어떤 전략을 사용할지 지정해준다. 주로 실행시에 전략 객체 (Strategy Object) 를 변경할 수 있는 유연성을 제공하기 위한 용도로 쓰인다.	State 객체에 행동이 캡슐화 된다. 상황에 따라 Context 객체에서 여러 State 객체 중 하나의 객체에게 모든 행동을 맡기게 된다. 즉, Client 는 State 객체에 대해 자세히 몰라도 된다.
SubClass 를 만드는 방법을 대신하여 유연성을 극대화 하기 위한 용도로 사용한다. 상속을 이용해서 클래스의 행동을 정의하다보면 행동을 쉽게 변경하기 어렵지만, Strategy 패턴을 사용하면 구성을 통해 행동을 정의하는 객체를 유연하게 바꿀 수 있다.	Context 객체에 지저분하게 조건문을 넣는 대신 사용할 수 있는 패턴이라 할 수 있다.

 

■ 정리

• State 패턴을 이용하면 내부 상태를 바탕으로 여러 다른 행동을 사용할 수 있다.
• 조건문 등을 이용하여 지저분하게 상태를 나타내지 않고 각 상태를 클래스를 이용하여 표현하게된다.
• 각 상태를 클래스로 캡슐화 함으로써 나중에 변경시켜야 할 내용을 국지화 할 수 있다.
• 일반적으로 행동 또는 알고리즘을 Context 클래스를 만들 때 설정한다.
• 상태 전환은 State 클래스에 의해서 제어할 수도 있고, Context 클래스에 의해서 제어할 수도 있다.
• 상태를 클래스로 생성하기때문에 클래스의 개수가 늘어날 수 있지만 상황에 따라 클래스의 수가 더 많은편이 나을 수 있다.
• State 클래스를 여러 Context 객체의 인스턴스에서 공유하도록 할 수도 있다.

 

---

참고
헤드 퍼스트 디자인 패턴 (Head First Design Patterns) - 에릭 프리먼,엘리자베스 롭슨,케이시 시에라,버트 베이츠