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");
                    }
          } 
}

 认识状态模式

　　●　　状态和行为

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

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

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

　　●　　行为的平行性

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

　　

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

　　

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

　　● 　　环境和状态处理对象

　　在状态模式中，环境(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