1.初识状态模式

定义

运行一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

结构和说明
Context：环境（上下文），通常用来定义客户感兴趣的接口，同时维护一个来具体处理当前状态的实例对象。
State：状态接口，用来封装与上下文的一个特定状态所对应的行为。
ConcreteState：具体实现状态处理的类，每个类实现一个状态的具体处理。

2.体会状态模式

实现在线投票
考虑一个在线投票的应用，要实现控制同一个用户只能投一票，如果一个用户反复投票，而且投票次数超过5次，则判定为恶意刷票，要取消该用户投票的资格，当然同时也要取消他所投的票。如果一个用户的投票次数超过8次，将进入黑名单，禁止再登录和使用系统。
不用设计模式的解决方案
example1代码参考github

public class VoteManager {

    private Map<String,String> mapVote = new HashMap<String,String>();

    private Map<String,Integer> mapVoteCount = new HashMap<String,Integer>();

    public void vote(String user,String voteItem){

        Integer oldVoteCount = mapVoteCount.get(user);
        if(oldVoteCount==null){
            oldVoteCount = 0;
        }
        oldVoteCount = oldVoteCount + 1;
        mapVoteCount.put(user, oldVoteCount);

        if(oldVoteCount==1){

            mapVote.put(user, voteItem);
            System.out.println("恭喜你投票成功");
        }else if(oldVoteCount>1 && oldVoteCount<5){

            System.out.println("请不要重复投票");
        }else if(oldVoteCount >= 5 && oldVoteCount<8){

            String s = mapVote.get(user);
            if(s!=null){
                mapVote.remove(user);
            }
            System.out.println("你有恶意刷票行为，取消投票资格");
        }else if(oldVoteCount>=8){

            System.out.println("进入黑名单，将禁止登录和使用本系统");
        }
    }
}

测试代码：

    public void ex1Test(){
        VoteManager vm = new VoteManager();
        for(int i=0;i<8;i++){
            vm.vote("u1", "A");
        }
    }

使用设计模式来解决
example2代码参考github
把投票的状态和状态对于的行为从原来的大杂烩代码中分离出来，把每个状态所对应的功能处理封装在一个独立的类里面。

public class VoteManager {
    /**
     * 持有状态处理对象
     */
    private VoteState state = null;
    /**
     * 记录用户投票的结果,Map<String,String>对应Map<用户名称,投票的选项>
     */
    private Map<String,String> mapVote = new HashMap<String,String>();
    /**
     * 记录用户投票次数,Map<String,Integer>对应Map<用户名称,投票的次数>
     */
    private Map<String,Integer> mapVoteCount = new HashMap<String,Integer>();

    /**
     * 获取记录用户投票结果的Map
     * @return 记录用户投票结果的Map
     */
    public Map<String, String> getMapVote() {
        return mapVote;
    }

    /**
     * 投票
     * @param user 投票人，为了简单，就是用户名称
     * @param voteItem 投票的选项
     */
    public void vote(String user,String voteItem){
        //1：先为该用户增加投票的次数
        //先从记录中取出已有的投票次数
        Integer oldVoteCount = mapVoteCount.get(user);
        if(oldVoteCount==null){
            oldVoteCount = 0;
        }
        oldVoteCount = oldVoteCount + 1;
        mapVoteCount.put(user, oldVoteCount);

        //2：判断该用户投票的类型，就相当于是判断对应的状态
        //到底是正常投票、重复投票、恶意投票还是上黑名单的状态
        if(oldVoteCount==1){
            state = new NormalVoteState();
        }else if(oldVoteCount>1 && oldVoteCount<5){
            state = new RepeatVoteState();
        }else if(oldVoteCount >= 5 && oldVoteCount<8){
            state = new SpiteVoteState();
        }else if(oldVoteCount>=8){
            state = new BlackVoteState();
        }
        //然后转调状态对象来进行相应的操作
        state.vote(user, voteItem, this);
    }
}

3.理解状态模式

3.1 状态和行为

对象状态通常是指对象实例的属性值，行为值对于的功能，一般对应到方法。
状态模式的功能就是分离状态的行为，通过维护状态的变化，来调用不同状态对应的不同功能。
状态决定行为。
由于状态是在运行期被改变的，行为也会根据状态的改变而改变。看起来，在运行期不同时刻，同一对象的类就像是被修改了一样。

3.2 行为的平行性

平行性指的是各个状态的行为所处的层次是一样的，相互是独立的、没有关联的，是根据不同的状态来决定到底走平行线的哪一条，行为是不同的。相互之间不可替换。

平等性强调的是可替换性，是针对同一行为的不同描述或实现。

状态模式的结构和策略模式是一样的，但是它们的目的和本质是完全不一样的。

3.3 上下文和状态处理对象

在状态模式中，上下文是持有状态的对象，但是上下文自身并不处理跟状态相关的行为，而是把处理状态的功能委托给了状态对应的状态处理类来处理。

在具体的状态处理类中经常需要获取上下文自身的数据，甚至在必要时候会回调上下文的方法，因此，通常将上下文自身作为一个参数传递给具体的状态处理类。

客户端一般只和上下文交互，客户端可以用状态对象来配置一个上下文，一旦配置完毕，就不再需要和状态对象交互。

3.4 不完美的OCP

使用状态模式来修改和扩展功能，是没有完全遵守OCP原则的，由于状态的维护和转换在状态模式的结构里面，不管是扩展状态实现类，还是添加状态实现类，都需要修改状态维护和转换的地方。

3.5 创建和销毁对象

究竟何时创建和销毁状态对象：

1）当需要使用状态对象时创建，使用完后就销毁
2）提前创建并且始终不销毁
3）采用延迟加载和缓存合用的方式，当第一次需要使用时创建，使用完后并不销毁，而是缓存起来，等待下一次使用，在合适的时候，由缓存框架销毁。

怎样选择？

1）如果进入的状态在运行时是不可知的，而且上下文是比较稳定的，不会经常改变状态，使用也不频繁，建议选第一种
2）如果状态改变很频繁，也即需要频繁地创建状态对象，而且状态对象还存储着大量的信息数据，建议选第二种
3）如果无法确定状态改变是否频繁，而且有些状态对象的状态数据量大，有些比较小，一切都是未知的，建议选第三种。

事实上，在实际工程开发中，第三种方案是首选，因为其兼顾了前面两种方案的优点，几乎能适应各种情况的需要。
第三种方案在实现时，需要一个合理的缓存框架，并且要考虑多线程并发问题，实现难道稍高。
另外在实现中可以考虑结合享元模式，通过享元模式来共享状态对象。

3.6 状态的维护和转换控制

状态的维护，指的是维护状态的数据，就是给状态设置不同的状态值。
状态的转换，指的是根据状态的变化来选择不同的状态处理对象。
在状态模式中，通常有两个地方可以进行状态的维护和转换控制。

1）在上下文中，因为状态本身通常被实现为上下文对象的状态，因此可以在上下文中进行状态维护，当然也就可以控制状态的转换而来。
2）另外一个地方就是在状态的处理类里，当每个状态处理对象处理完自身状态所对应的功能后，可以根据需要指定后继的状态，以便让应用能正确处理后续的请求。

example3代码参考github

public class VoteManager {
    /**
     * 记录当前每个用户对应的状态处理对象，每个用户当前的状态是不同的
     * Map<String,VoteState>对应Map<用户名称,当前对应的状态处理对象>
     */
    private Map<String,VoteState> mapState = new HashMap<String,VoteState>();

    /**
     * 记录用户投票的结果,Map<String,String>对应Map<用户名称,投票的选项>
     */
    private Map<String,String> mapVote = new HashMap<String,String>();
    /**
     * 记录用户投票次数,Map<String,Integer>对应Map<用户名称,投票的次数>
     */
    private Map<String,Integer> mapVoteCount = new HashMap<String,Integer>();


    /**
     * 获取记录用户投票结果的Map
     * @return 记录用户投票结果的Map
     */
    public Map<String, String> getMapVote() {
        return mapVote;
    }
    /**
     * 获取记录每个用户对应的状态处理对象的Map
     * @return 记录每个用户对应的状态处理对象的Map
     */
    public Map<String, VoteState> getMapState() {
        return mapState;
    }
    /**
     * 获取记录每个用户对应的投票次数的Map
     * @return 记录每个用户对应的投票次数的Map
     */
    public Map<String, Integer> getMapVoteCount() {
        return mapVoteCount;
    }
    /**
     * 投票
     * @param user 投票人，为了简单，就是用户名称
     * @param voteItem 投票的选项
     */
    public void vote(String user,String voteItem){
        //1：先为该用户增加投票的次数
        //先从记录中取出已有的投票次数
        Integer oldVoteCount = mapVoteCount.get(user);
        if(oldVoteCount==null){
            oldVoteCount = 0;
        }
        oldVoteCount = oldVoteCount + 1;
        mapVoteCount.put(user, oldVoteCount);

        //2：获取该用户的投票状态
        VoteState state = mapState.get(user);
        //如果没有投票状态，说明还没有投过票，就初始化一个正常投票状态
        if(state==null){
            state = new NormalVoteState();
        }

        //然后转调状态对象来进行相应的操作
        state.vote(user, voteItem, this);
    }
}

public class RepeatVoteState implements VoteState{
    public void vote(String user, String voteItem, VoteManager voteManager) {
        //重复投票
        //暂时不做处理
        System.out.println("请不要重复投票");
        
        //重复投票完成，维护下一个状态，重复投票到5次，就算恶意投票了
        //注意这里是判断大于等于4，因为这里设置的是下一个状态
        //下一个操作次数就是5了，就应该算是恶意投票了
        if(voteManager.getMapVoteCount().get(user) >= 4){
            voteManager.getMapState().put(user, new SpiteVoteState());
        }
    }
}

如何选择这两种方式？

1）一般情况下，如果状态转换的规则是一定的，一般不需要进行什么扩展规则，则适合在上下文中统一进行状态的维护
2）如果状态的转换取决于前一个状态动态处理的结果，或者是依赖于外部数据，为了增强灵活性，这种情况下，一般是在状态处理类里面进行状态的维护。

3.6.1 使用数据库来维护状态

在实际开发中，可以使用数据库来维护状态。在数据库中存储下一个状态的识别数据。也即，维护下一个状态，演化成了维护下一个状态的识别数据，比如状态编码。

在程序中，通过查询数据库中的数据来得到状态编码，然后再根据状态编码来创建出相应的状态对象，然后再委托相应的状态对象进行功能处理。

还有一种情况是直接将“转移”记录到数据库中，这样更灵活。

public class VoteManager {
    /**
     * 记录当前每个用户对应的状态处理对象，每个用户当前的状态是不同的
     * Map<String,VoteState>对应Map<用户名称,当前对应的状态处理对象>
     */
    private Map<String,VoteState> mapState = new HashMap<String,VoteState>();
    /**
     * 获取记录每个用户对应的状态处理对象的Map
     * @return 记录每个用户对应的状态处理对象的Map
     */
    public Map<String, VoteState> getMapState() {
        return mapState;
    }
    /**
     * 记录用户投票的结果,Map<String,String>对应Map<用户名称,投票的选项>
     */
    private Map<String,String> mapVote = new HashMap<String,String>();
    /**
     * 记录用户投票次数,Map<String,Integer>对应Map<用户名称,投票的次数>
     */
    private Map<String,Integer> mapVoteCount = new HashMap<String,Integer>();
    
    /**
     * 获取记录用户投票结果的Map
     * @return 记录用户投票结果的Map
     */
    public Map<String, String> getMapVote() {
        return mapVote;
    }

    /**
     * 获取记录每个用户对应的投票次数的Map
     * @return 记录每个用户对应的投票次数的Map
     */
    public Map<String, Integer> getMapVoteCount() {
        return mapVoteCount;
    }
    /**
     * 投票
     * @param user 投票人，为了简单，就是用户名称
     * @param voteItem 投票的选项
     */
    public void vote(String user,String voteItem)throws Exception{
        //1：先为该用户增加投票的次数
        //先从记录中取出已有的投票次数
        Integer oldVoteCount = mapVoteCount.get(user);
        if(oldVoteCount==null){
            oldVoteCount = 0;
        }
        oldVoteCount = oldVoteCount + 1;
        mapVoteCount.put(user, oldVoteCount);

        VoteState state = null;
        //2：直接从数据库获取该用户对应的下一个状态的状态编码
        String stateId = "从数据库中获取这个值";
        //开始根据状态编码来创建需用的状态对象
        
        //根据状态编码去获取相应的类
        String className = "根据状态编码去获取相应的类";
        //使用反射创建对象实例，简单示意一下
        Class c = Class.forName(className);
        state = (VoteState)c.newInstance();
        
//      if("正常投票".equals(stateId)){
//          state = new NormalVoteState();
//      }else if("重复投票".equals(stateId)){
//          state = new RepeatVoteState(); 
//      }else if("恶意投票".equals(stateId)){
//          state = new SpiteVoteState(); 
//      }else if("黑名单".equals(stateId)){
//          state = new BlackVoteState(); 
//      }
        //然后转调状态对象来进行相应的操作
        state.vote(user, voteItem, this);
    }
}

3.7 模拟工作流

对于工作流，复杂的应用可能会使用工作流中间件，用工作流引擎来负责流程处理，会比较复杂。其实工作流引擎的实现也可以应用上状态模式。

简单点的，把流程数据存放在数据库里面，然后在程序进行流程控制。对于简单的业务流程控制，可以使用状态模式来辅助进行流程控制，因为大部分这种流程都是状态控制的。

请假流程实例

上面流程大致有如下状态：等待项目经理审核、等待部门经理审核、审核结束。

特别注意，使用Scanner进行测试时，不能用Junit框架，需要使用main函数才能进行测试。
example4代码参考github

    public static void main(String[] args) {
        //创建业务对象，并设置业务数据
        LeaveRequestModel lrm = new LeaveRequestModel();
        lrm.setUser("小李");
        lrm.setBeginDate("2010-02-08");
        lrm.setLeaveDays(5);

        //创建上下文对象
        LeaveRequestContext request = new LeaveRequestContext();
        //为上下文对象设置业务数据对象
        request.setBusinessVO(lrm);
        //配置上下文，作为开始的状态，以后就不管了
        request.setState(new ProjectManagerState());

        //请求上下文，让上下文开始处理工作
        request.doWork();
    }

public class ProjectManagerState implements LeaveRequestState{
    public void doWork(StateMachine request) {
        //先把业务对象造型回来
        LeaveRequestModel lrm = (LeaveRequestModel)request.getBusinessVO();

        System.out.println("项目经理审核中，请稍候......");

        //模拟用户处理界面，通过控制台来读取数据
        System.out.println(lrm.getUser()+"申请从"+lrm.getBeginDate()+
                "开始请假"+lrm.getLeaveDays()+"天,请项目经理审核(1为同意，2为不同意)：");
        //读取从控制台输入的数据
        Scanner scanner = new Scanner(System.in);
        if(scanner.hasNext()){
            int a = scanner.nextInt();
            //设置回到上下文中
            String result = "不同意";
            if(a==1){
                result = "同意";
            }
            lrm.setResult("项目经理审核结果："+result);
            //根据选择的结果和条件来设置下一步
            if(a==1){
                if(lrm.getLeaveDays() > 3){
                    //如果请假天数大于3天，而且项目经理同意了，就提交给部门经理
                    request.setState(new DepManagerState());
                    //继续执行下一步工作
                    request.doWork();
                }else{
                    //3天以内的请假，由项目经理做主,就不用提交给部门经理了，转向审核结束状态
                    request.setState(new  AuditOverState());
                    //继续执行下一步工作
                    request.doWork();
                }
            }else{
                //项目经理要是不同意的话，也就不用提交给部门经理了，转向审核结束状态
                request.setState(new  AuditOverState());
                //继续执行下一步工作
                request.doWork();
            }
        }
    }
}

4.思考状态模式

状态模式的优缺点
简化应用逻辑控制；
更好地分离状态和行为；
更好地扩展性；
显式化进行状态转换；
引入太多的状态类。
状态模式的本质
根据状态来分离和选择行为。
何时选用状态模式
1）如果一个对象的行为取决它的状态，而且它必须在运行时刻根据状态来改变它的行为。可以使用状态模式，来把状态和行为分离开，虽然分离开，但状态和行为是有对应关系的，可以在运行期间，通过改变状态，就能够调用到该状态对应的状态处理对象上去，从而改变对象的行为。
2）如果一个操作中含有庞大的分支语句，而且这些分支依赖于该对象的状态。可以使用状态模式，把各个分支的处理分散包装到单独的对象处理类里面，这样，这些分支对应的对象就可以不依赖于其他对象而独立变化。

参考

1）研磨设计模式——跟着cc学设计系列视频教程

22.状态模式State