敏捷软件开发（1）--- STATE 模式

　　如果状态在运行过程中，不停的切换和改变，我们怎么办？

状态的迁移是我们生活和工程中非常普遍的一个概念。于是在数学上有一种理论来分析和解决这个问题。

有限状态机理论是一个非常成熟的理论，所有动作和流程的迁移可以归结为状态的迁移。

这个理论的前提是：

状态的数目是确定的，或者说是有限的。

状态的迁移方向是固定的，也就是有向的。　　

状态存储关于过去的信息，就是说：它反映从系统开始到现在时刻的输入变化。转移指示状态变更，并且用必须满足来确使转移发生的条件来描述它。动作是在给定时刻要进行的活动的描述。有多种类型的动作：

进入动作（entry action）：在进入状态时进行

退出动作：在退出状态时进行

输入动作：依赖于当前状态和输入条件进行

转移动作：在进行特定转移时进行

下面我们将按照一个地铁轧机的操作来讲解有线状态机理论。

地铁轧机的整体状态图如上。基本就是开和关2种行为。

关于FSM，可以有3种实现方式。

1.switch case方式

package com.joyfulmath.state.switchcase;

/**
 * @author deman.lu
 * @version on 2016-05-18 09:43
 */
public class Turnstile {

    //status
    public static final int LOCKED      = 0;
    public static final int UNLOCKED    = 1;

    //events
    public static final int COIN        = 0;
    public static final int PASS        = 1;

    int state = LOCKED;

    private TurnstileController turnstileController;

    public Turnstile(TurnstileController turnstileController) {
        this.turnstileController = turnstileController;
    }

    public void enent(int event)
    {
        switch (state)
        {
            case LOCKED:
                switch (event)
                {
                    case COIN:
                        state = UNLOCKED;
                        turnstileController.unlock();
                        break;
                    case PASS:
                        turnstileController.alarm();
                        break;
                }
                break;
            case UNLOCKED:
                switch (event)
                {
                    case COIN:
                        turnstileController.thankYou();
                        break;
                    case PASS:
                        state = LOCKED;
                        turnstileController.lock();
                        break;
                }
                break;
        }
    }
}

/**
 * @author deman.lu
 * @version on 2016-05-18 09:47
 */
public interface TurnstileController {
    void lock();
    void unlock();
    void alarm();
    void thankYou();
}

状态的迁移在switch-case语句里面进行。当前是2种状态 & 2种触发条件。

switch-case 就是2*2 的结果。可以相见，如果情况复杂化，switch-case将呈现爆炸式增长。

2.解释迁移表

该方法在很早以前的C语言中很常见，我个人也经历过这样的代码，并且维护过一段时间。

说句实话，这个东西有点C语言实现面向对象的思想。当然和Java语言没法比较。

package com.joyfulmath.state.switchcase;

import java.util.ArrayList;
import java.util.List;

/**
 * @author deman.lu
 * @version on 2016-05-18 10:05
 */
public class TurnStyle {
    int state = Turnstile.LOCKED;
    TurnstileController turnstileController;
    List<Transition> mTransitions = new ArrayList<>();
    public TurnStyle(final TurnstileController turnstileController) {
        this.turnstileController = turnstileController;
        addTransition(Turnstile.LOCKED, Turnstile.COIN, Turnstile.UNLOCKED, new Runnable() {
            @Override
            public void run() {
                turnstileController.unlock();
            }
        });
    }

    private void addTransition(int state, int event, int nextstate, Runnable runnable) {
        Transition transition = new Transition();
        transition.currentState = state;
        transition.event = event;
        transition.nextState = nextstate;
        transition.runnable = runnable;
        mTransitions.add(transition);
    }

    public void event(int event)
    {
        for(Transition transition:mTransitions)
        {
            if(transition.currentState == state && event == transition.event)
            {
                state = transition.nextState;
                transition.runnable.run();
            }
        }
    }
}

迁移表的维护，有些困难。一点大量状态 & 事件存在，该表将非常复杂。

3.state 模式

好在软件开发中，还有设计模式这个礼物。使用state模式，是目前实现FSM来说，非常适合的一种方式。

package com.joyfulmath.state.statemode;

/**
 * @author deman.lu
 * @version on 2016-05-18 10:43
 */
public interface ITurnstitleState {
    void coin(TurnsStatus t);
    void pass(TurnsStatus t);
}

这是event事件。

状态的实现：

package com.joyfulmath.state.statemode;

/**
 * @author deman.lu
 * @version on 2016-05-18 10:52
 */
public class LockedStatus implements ITurnstitleState {
    @Override
    public void coin(TurnsStatus t) {
        t.setUnLock();
        t.unlock();
    }

    @Override
    public void pass(TurnsStatus t) {
        t.alarm();
    }
}

package com.joyfulmath.state.statemode;

/**
 * @author deman.lu
 * @version on 2016-05-18 10:53
 */
public class UnLockedStatus implements ITurnstitleState {
    @Override
    public void coin(TurnsStatus t) {
        t.thankyou();
    }

    @Override
    public void pass(TurnsStatus t) {
        t.setLock();
        t.lock();
    }
}

TurnsStatus是驱动状态迁移的关键。在有些介绍状态模式的书里面，这个类一般定义为context

package com.joyfulmath.state.statemode;

import com.joyfulmath.state.switchcase.TurnstileController;

/**
 * @author deman.lu
 * @version on 2016-05-18 10:52
 */
public class TurnsStatus {
    private static ITurnstitleState lockedStatus = new LockedStatus();
    private static ITurnstitleState unlockedStatus = new UnLockedStatus();

    private TurnstileController controller;
    private ITurnstitleState state = lockedStatus;
    public TurnsStatus(TurnstileController controller) {
        this.controller = controller;
    }

    public void coin()
    {
        state.coin(this);
    }

    public void pass()
    {
        state.pass(this);
    }

    public void setLock()
    {
        state  = lockedStatus;
    }

    public void setUnLock()
    {
        state = unlockedStatus;
    }

    void thankyou()
    {
        controller.thankYou();
    }

    void alarm()
    {
        controller.alarm();
    }

    void lock()
    {
        controller.lock();
    }

    void unlock()
    {
        controller.unlock();
    }
}

其中coin & pass 方法是供外部类进行调用的，而

void unlock()
    {
        controller.unlock();
    }

这些方法是给state做处理的。

状态模式彻底的分离了状态机的逻辑和动作。

动作在Context类中实现，而逻辑在各个state中实现。

从个人经验来讲，状态模式适合状态会反复切换的场景。

参考：

《敏捷软件开发》 BOb大叔著。