设计模式13-状态模式

最新推荐文章于 2024-09-08 23:22:43 发布

原创最新推荐文章于 2024-09-08 23:22:43 发布 · 238 阅读

0 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

19 篇文章

订阅专栏

状态模式和策略模式是孪生兄弟。他们都是为了解决产生多重if，else这种判断下形成的设计模式。为了让系统充满弹性和可维护性。策略模式是围绕互换的算法来创建业务，解决这个问题。而状态模式跟策略模式更不一样了，他是通过改变对象内部的状态来帮助对象控制自己的行为。

概念

定义

状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。本质：“根据状态分离和选择行为”

结构

这里写图片描述
状态模式有三个角色。“状态接口”和”状态实体类”和”上下文环境”。
Context(上下文环境)一般是用来定义客户感兴趣的接口，同时维护一个来具体处理当前状态的实例对象。
state(状态接口)用来封装与上下文交互的状态行为，约束状态实体类应该如何处理的方法
ConcreteState(状态实体类)具体实现状态处理的类，每个类实现一个跟上下文相关的状态的具体处理。

关键说明

状态模式我认为是活用了里氏代换和单一职责的一个模式。在使用者看来，他是换了一个对象来实现更改了内部的状态调用，其实是巧用了里氏代换，面向接口编程的思想。使用者只需简单的向上转型即可。其关键处我觉得是在Context上，该类必须把持State接口，且需要有一个允许外界注入State的入口，还需要一个给予用户调用的方法，该方法转接不同状态下的处理。

小实例

State类，状态接口。约束不同状态的实现继承，同时供上下文调用。

/**
 * 封装与Context的一个特定状态相关的行为
 */
public interface State {
    /**
     * 状态对应的处理
     * @param sampleParameter 示例参数，说明可以传入参数，具体传入
     *             什么样的参数，传入几个参数，由具体应用来具体分析
     */
    public void handle(String sampleParameter);
}

ConcreteState。实体状态类，每个类表示一种状态，实现State接口，受它约束。根据State接口的要求，实现在该状态下对应的处理方式


/**
 * 实现一个与Context的一个特定状态相关的行为
 */
public class ConcreteStateA implements State {
    public void handle(String sampleParameter) {
       //实现具体的处理
    }
}

/**
 * 实现一个与Context的一个特定状态相关的行为
 */
public class ConcreteStateB implements State {
    public void handle(String sampleParameter) {
       //实现具体的处理
    }
}

Context类，上下文环境类。我觉得最重要是因为它是与外界交互的一个大门。定义了客户需要使用的接口，转接给不同状态下的处理。同时它维护一个处理当前状态的实例对象


/**
 * 定义客户感兴趣的接口，通常会维护一个State类型的对象实例
 */
public class Context {
    /**
     * 持有一个State类型的对象实例
     */
    private State state;
    /**
     * 设置实现State的对象的实例
     * @param state 实现State的对象的实例
     */
    public void setState(State state) {
       this.state = state;
    }
    /**
     * 用户感兴趣的接口方法
     * @param sampleParameter 示意参数
     */
    public void request(String sampleParameter) {
       //在处理中，会转调state来处理
       state.handle(sampleParameter);
    }
}

具体实例

投票系统。每个用户只能投一票。如果一个用户反复投票次数超过五次，则判定为恶意刷票，要取消该用户投票的资格，当然同时也要取消他所投的票。如果一个用户的投票次数超过8次，将进入黑名单，禁止再登录和使用系统。

这里有四种状态
一是用户是正常投票
二是用户正常投票过后，有意或者无意的重复投票
三是用户恶意投票
四是黑名单用户

我们先用传统的不使用模式的解决方案和用模式的解决方案来做一个对比。

不用状态模式的解决方案

/**
 * 投票管理
 */
public class VoteManager {
    /**
     * 记录用户投票的结果,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>();
    /**
     * 投票
     * @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){
           //正常投票
           //记录到投票记录中
           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("进入黑名单，将禁止登录和使用本系统");
       }
    }
}

看到上面的大量if和else没有。每个都代表一种状态，即使只为演示，省略了不同状态下的处理行为，仍然是长篇。而状态模式就是封装不同状态下内部的一个处理行为。接下来使用设计模式

使用状态模式的解决方案

state状态接口

/**
 * 封装一个投票状态相关的行为
 */
public interface VoteState {
    /**
     * 处理状态对应的行为
     * @param user 投票人
     * @param voteItem 投票项
     * @param voteManager 投票上下文，用来在实现状态对应的功能处理的时候，
     *                    可以回调上下文的数据
     */
    public void vote(String user,String voteItem
,VoteManager voteManager);
}

实现状态接口。每个类代表了投票下的不同状态即其相应的处理。

    先看正常投票状态对应的处理，示例代码如下：

public class NormalVoteState implements VoteState{
    public void vote(String user, String voteItem
,VoteManager voteManager) {
       //正常投票
       //记录到投票记录中
       voteManager.getMapVote().put(user, voteItem);
       System.out.println("恭喜你投票成功");
    }
}

   接下来看看重复投票状态对应的处理，示例代码如下：

public class RepeatVoteState implements VoteState{
    public void vote(String user, String voteItem
,VoteManager voteManager) {
       //重复投票
       //暂时不做处理
       System.out.println("请不要重复投票");
    }
}

    接下来看看恶意投票状态对应的处理，示例代码如下：

public class SpiteVoteState implements VoteState{
    public void vote(String user, String voteItem
,VoteManager voteManager) {
       //恶意投票
       //取消用户的投票资格，并取消投票记录
       String s = voteManager.getMapVote().get(user);
       if(s!=null){
           voteManager.getMapVote().remove(user);
       }
       System.out.println("你有恶意刷票行为，取消投票资格");
    }
}

    接下来看看黑名单状态对应的处理，示例代码如下：

public class BlackVoteState implements VoteState{
    public void vote(String user, String voteItem
,VoteManager voteManager) {
       //黑名单
       //记入黑名单中，禁止登录系统了
       System.out.println("进入黑名单，将禁止登录和使用本系统");
    }
}

最后是重要的投票管理，相当于状态模式中的上下文。投票管理的投票方法，根据不同的投票行为转给不同的状态处理方法

/**
 * 投票管理
 */
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 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);
    }
}