chapter10_事务的状态——状态模式

• 策略模式和状态模式是极其相似的两种设计模式

• 在不使用状态模式前, 状态的转换需要通过多个if或者switch完成(这种做法叫做程序状态机PSM)

  GumballMachine.java

    public class GumballMachine {
  
        final static int SOLD_OUT = 0;
        final static int NO_QUARTER = 1;
        final static int HAS_QUARTER = 2;
        final static int SOLD = 3;
  
        int state = SOLD_OUT;
        int count = 0;
  
        public GumballMachine(int count) {
  
            this.count = count;
     
            if (count > 0) {
                state = NO_QUARTER;
            }
        }
  
        public void insertQuarter() {
  
            if (state == HAS_QUARTER) {
  
                System.out.println("You can't insert another quarter");
  
            } else if (state == NO_QUARTER) {
  
                state = HAS_QUARTER;
                System.out.println("You inserted a quarter");
  
            } else if (state == SOLD_OUT) {
  
                System.out.println("You can't insert a quarter, the machine is sold out");
  
            } else if (state == SOLD) {
  
                System.out.println("Please wait, we're already giving you a gumball");
            }
        }
  
        public void ejectQuarter() {
  
            if (state == HAS_QUARTER) {
  
                System.out.println("Quarter returned");
                state = NO_QUARTER;
  
            } else if (state == NO_QUARTER) {
  
                System.out.println("You haven't inserted a quarter");
  
            } else if (state == SOLD) {
        
                System.out.println("Sorry, you already turned the crank");
  
            } else if (state == SOLD_OUT) {
  
                System.out.println("You can't eject, you haven't inserted a quarter yet");
            }
        }
  
        ...
  
    }
  

  另外如果需要添加新的状态, 需要在现有的方法中增加很多新的代码, 容易出现问题

  (2) 状态模式会将每个状态封装成一个类的对象, 在进行状态转换时, 不再用if进行判断, 而是在状态对象内部进行转换

  State.java

    public interface State {
  
        void insertQuarter();
  
        void ejectQuarter();
  
        void turnCrank();
  
        void dispense();
  
        void refill();
    }
  

  State是一个接口, 它定义了几个状态转换方法

  GumballMachine.java

    public class GumballMachine {
  
        private State soldOutState;
        private State noQuarterState;
        private State hasQuarterState;
        private State soldState;
  
        private State state;
        private int count = 0;
  
        public GumballMachine(int numberGumballs) {
  
            soldOutState = new SoldOutState(this);
            noQuarterState = new NoQuarterState(this);
            hasQuarterState = new HasQuarterState(this);
            soldState = new SoldState(this);
  
            this.count = numberGumballs;
  
            if (numberGumballs > 0) {
                state = noQuarterState;
            } else {
                state = soldOutState;
            }
        }
  
        public void insertQuarter() {
            state.insertQuarter();
        }
  
        public void ejectQuarter() {
            state.ejectQuarter();
        }
  
        public void turnCrank() {
  
            state.turnCrank();
            state.dispense();
        }
  
        ...
    }
  

  GumballMachine是一个用户, 它内部包含了几种状态, 每个状态是一个对象, 在需要进行状态转换的时候, 将状态转换的任务__委托__给内部的state对象

  SoldState.java

    public class SoldState implements State {
  
        private GumballMachine gumballMachine;
  
        public SoldState(GumballMachine gumballMachine) {
  
            this.gumballMachine = gumballMachine;
        }
  
        public void insertQuarter() {
  
            System.out.println("Please wait, we're already giving you a gumball");
        }
  
        public void ejectQuarter() {
  
            System.out.println("Sorry, you already turned the crank");
        }
  
        public void turnCrank() {
  
            System.out.println("Turning twice doesn't get you another gumball!");
        }
  
        public void dispense() {
  
            gumballMachine.releaseBall();
  
            if (gumballMachine.getCount() > 0) {
                gumballMachine.setState(gumballMachine.getNoQuarterState());
            } else {
                System.out.println("Oops, out of gumballs!");
                gumballMachine.setState(gumballMachine.getSoldOutState());
            }
        }
  
        public void refill() {
        }
  
        public String toString() {
  
            return "dispensing a gumball";
        }
    }
  

  SoldState是State接口的一个具体的实现类, 它实现了在需要进行状态转换的时候, 当前的状态应该如何转换;

  在构造器中, SoldState关联了一个GumballMachine, 这样在某些状态转换时可以更改GumballMachine的状态, 例如gumballMachine.setState(gumballMachine.getSoldOutState());

  (3) 如果GumballMachine中增加了新的状态, 那么只需要添加一种新的状态类, 然后实现它, 并且改写和新状态关联的某些状态类的某些方法即可, 这样就实现了解耦

• 状态模式

  允许对象在内部状态改变时改变它的行为, 对象看起来好像修改了它的类

  说明:

  1° 外部操纵的类是__Context类__, 它包含了一些内部状态;

  2° __State接口__定义了所有状态必须实现的方法;

  3° 每添加一种状态, 就添加一种State的实现类;

  4° 不管什么时候, 只要调用了Context的方法, 都会__委托__给内部的State对象来处理

• 状态模式和策略模式的对比

  (1) 两者有着相同的类图

  (2) 两者的区别在于__意图__:

  状态模式是将一群行为封装在状态对象中, 对于Context的客户在调用Context的方法时甚至不知道内部的状态对象, 因为Context采取了委托的机制, 这样在Context中就不需要进行各种条件判断了;

  策略模式是客户要主动指定Context所要组合的策略对象是哪一个, 客户是很清楚它set的内部策略对象的

• 前面的示例其实是将各个State进行封闭, 但这样也造成了一个问题就是各个State的实现类是有依赖的;

  如果状态转换是固定的, 那么应该在Context类中决定状态转换的流向;

  如果转换是动态的, 那么应该放在各个State实现类中。

• 如果想让多个Context共享几个状态, 那么可以把几个State对象定义为static, 但是要注意多线程的同步问题