java_设计模式_状态模式_State Pattern（2016-08-16）

定义：

　　当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。

类图：

状态模式所涉及到的角色有：

　　●　　环境(Context)角色，也成上下文：定义客户端所感兴趣的接口，同时维护一个具体处理当前状态的实例对象。　　

　　●　　抽象状态(State)角色：定义一个接口，用以封装环境（Context）对象的一个特定的状态所对应的行为。　

　　●　　具体状态(ConcreteState)角色：每一个具体状态类都实现了环境（Context）的一个状态所对应的行为。

 

状态处理对象的创建和销毁：

　　① 当需要使用状态对象的时候创建，使用完后就销毁。

　　② 提前创建它们并永不销毁（单例）。

　　③ 采用延时加载 +  缓存的方式。就是当第一次使用的时候创建，使用完后并不销毁而是把它缓存起来，下一次使用时，从缓存中获取对象，并由缓存框架来销毁状态处理对象。

 

状态的维护和转换：

　　维护状态的数据，给状态设置不同的状态值；状态的转换，指的是根据状态的变化来选择不同的状态处理对象。

有两个地方可以进行状态的维护和转换：

　　① 在Context 中。

　　② 在状态的处理类中。

如何选择者两种方式：

　　● 如果状态转换的规则是一定的，一般不需要进行什么扩展规则，那么就适合在上下文中统一进行状态的维护。

　　● 如果状态的转换取决于前一个状态动态处理的结果，或者是依赖外部数据，为了增强灵活性，这种情况下，一般式在状态处理类中进行状态的维护。

使用场景：

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

　　要使用状态模式实现，首先需要把投票过程的各种状态定义出来，根据以上描述大致分为四种状态：正常投票、反复投票、恶意刷票、进入黑名单。然后创建一个投票管理对象（相当于Context）。

 

◆ 在Context 中进行状态的维护和转换

/**
 * 投票状态接口 <br>
 * 抽象状态(State)角色
 */
public interface VoteState {

    /**
     * 处理状态对应的行为
     * @param user 投票人
     * @param voteItem 投票项
     * @param manager 投票上下文，用来实现状态对应的功能处理的时候，可以回调上下文的数据
     */
     public void vote(String user, String voteItem, VoteManager manager);
}

/**
 * 正常投票状态 <br>
 * 具体状态(ConcreteState)角色
 */
public class NormalVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager manager) {
              manager.getMapVote().put(user, voteItem);
              System.out.println("恭喜你投票成功！");
    }
}

/**
 * 反复投票状态 <br>
 * 具体状态(ConcreteState)角色
 */
public class RepeatVoteState implements VoteState {

  @Override
   public void vote(String user, String voteItem, VoteManager manager) {
             System.out.println("请不要重复投票！");
   }
}

/**
 * 恶意刷票状态 <br>
 * 具体状态(ConcreteState)角色
 */
public class SpiteVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager manager) {
              String s = manager.getMapVote().get(user);
              if(s != null){
                       manager.getMapVote().remove(user);
              }
              System.out.println("你有恶意刷票行为，取消投票资格。");
    }
}

/**
 * 黑名单状态 <br>
 * 具体状态(ConcreteState)角色
 */
public class BlackVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager manager) {
              System.out.println("进入黑名单，将禁止登陆和使用本系统。");
    }
}

/**
 * 投票管理对象 <br>
 * 环境(Context)角色
 */
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;
    }
    /**
     * 投票
     * 在Context 中进行状态的维护和转换
     * @param user 投票人
     * @param voteItem 投票的选项
     */
    public void vote(String user, String voteItem){
              Integer oldVoteCount = mapVoteCount.get(user);
              if(oldVoteCount == null){
                     oldVoteCount = 0;
              }
              oldVoteCount++;
              mapVoteCount.put(user, oldVoteCount);
              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);
     }
}

/**
 * 客户端<br>
 */
public class Client {

    public static void main(String[] args) {
              VoteManager manager = new VoteManager();
              for(int i = 0; i < 8; i++){
                     manager.vote("JOE", "A");
              }
    }
}

◆ 在状态处理类中进行状态的维护和转换

/**
 * 投票状态接口 <br>
 * 抽象状态(State)角色
 */
public interface VoteState {

    /**
     * 处理状态对应的行为
     * @param user 投票人
     * @param voteItem 投票项
     * @param manager 投票上下文，用来实现状态对应的功能处理的时候，可以回调上下文的数据
     */
     public void vote(String user, String voteItem, VoteManager manager);
}

/**
 * 正常投票状态 <br>
 * 具体状态(ConcreteState)角色
 */
public class NormalVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                    manager.getMapVote().put(user, voteItem);
                    System.out.println("投票成功！");
                    manager.getMapState().put(user, new RepeatVoteState());//在状态处理类中进行状态的维护和转换
         }
}

/**
 * 反复投票状态 <br>
 * 具体状态(ConcreteState)角色
 */
public class RepeatVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                    System.out.println("请不要重复投票。");
                    if(manager.getMapVoteCount().get(user) >= 4){
                             manager.getMapState().put(user, new SpiteVoteState());//在状态处理类中进行状态的维护和转换
                    }
         }
}

/**
 * 恶意刷票状态 <br>
 * 具体状态(ConcreteState)角色
 */
public class SpiteVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                    String s = manager.getMapVote().get(user);
                    if(s != null){
                             manager.getMapVote().remove(user);
                    }
                    System.out.println("你有恶意刷票行为，取消投票资格。");
                   if(manager.getMapVoteCount().get(user) >= 7){
                              manager.getMapState().put(user, new BlackVoteState());//在状态处理类中进行状态的维护和转换
                   }
         }
}

/**
 * 黑名单状态 <br>
 * 具体状态(ConcreteState)角色
 */
public class BlackVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                     System.out.println("你进入了黑名单。");
          }
}

/**
 * 投票管理对象 <br>
 * 环境(Context)角色
 */
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;
          }
          /**
           * 获取记录当前每个用户对应的状态处理对象
           * @return
           */
          public Map<String, VoteState> getMapState() {
                    return mapState;
          }
          /**
           * 获取记录每个用户对应的投票次数的Map
           * @return
           */
          public Map<String, Integer> getMapVoteCount() {
                    return mapVoteCount;
          }

          /**
           * 投票
           * @param user 投票人
           * @param voteItem 投票的选项
           */
          public void vote(String user, String voteItem){
                    Integer oldVoteCount = mapVoteCount.get(user);
                    if(oldVoteCount == null){
                             oldVoteCount = 0;
                    }
                   oldVoteCount++;
                   mapVoteCount.put(user, oldVoteCount);

                   VoteState state = mapState.get(user);
                   if(state == null){
                           state = new NormalVoteState();
                   }
                   state.vote(user, voteItem, this);
          }
}

/**
 * 客户端<br>
 */
public class Client {

          public static void main(String[] args) {
                    VoteManager manager = new VoteManager();
                    for(int i = 0; i < 8; i++){
                           manager.vote("JOE", "A");
                    }
          }
}

 认识状态模式

　　●　　状态和行为

　　所谓对象的状态，通常指的就是对象实例的属性的值；而行为指的就是对象的功能，再具体点说，行为大多可以对应到方法上。

　　状态模式的功能就是分离状态的行为，通过维护状态的变化，来调用不同状态对应的不同功能。也就是说，状态和行为是相关联的，它们的关系可以描述为：状态决定行为。

　　由于状态是在运行期被改变的，因此行为也会在运行期根据状态的改变而改变。

　　●　　行为的平行性

　　注意平行线而不是平等性。所谓平行性指的是各个状态的行为所处的层次是一样的，相互独立的、没有关联的，是根据不同的状态来决定到底走平行线的哪一条。行为是不同的，当然对应的实现也是不同的，相互之间是不可替换的。

　　aaarticlea/png;base64,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" alt="" />

　　而平等性强调的是可替换性，大家是同一行为的不同描述或实现，因此在同一个行为发生的时候，可以根据条件挑选任意一个实现来进行相应的处理。

　　aaarticlea/png;base64,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" alt="" />

　　大家可能会发现状态模式的结构和策略模式的结构完全一样，但是，它们的目的、实现、本质却是完全不一样的。还有行为之间的特性也是状态模式和策略模式一个很重要的区别，状态模式的行为是平行的，不可相互替换的；而策略模式的行为是平等性的，是可以相互替换的。

　　● 　　环境和状态处理对象

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

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

　　客户端一般只和环境(Context)交互。客户端可以用状态对象来配置一个环境(Context)，一旦配置完毕，就不再需要和状态对象打交道了。客户端通常不负责运行期间状态的维护，也不负责决定后续到底使用哪一个具体的状态处理对象。

适用场景：

　　1.一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为。

　　2.一个操作中含有庞大的多分支结构，并且这些分支决定于对象的状态。

参考粘贴来自：

http://www.cnblogs.com/java-my-life/archive/2012/06/08/2538146.html

http://joe5456536.blog.163.com/blog/static/85374773201192252829941/

http://www.cnblogs.com/BenWong/archive/2012/12/12/2813982.html