设计模式系列—状态模式

 模式定义

对有状态的设计对象，把复杂的模式模式“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。系列

状态模式把受环境改变的状态对象行为包装在不同的状态对象里，其意图是设计让一个对象在其内部状态改变的时候，其行为也随之改变。模式模式现在我们来分析其基本结构和实现方法。系列

模板实现如下：

package com.niuh.designpattern.state.v1; /**  * <p>  * 状态模式  * </p>  */ public class StatePattern {      public static void main(String[] args) {          //创建环境           Context context = new Context();         //处理请求         context.Handle();         context.Handle();         context.Handle();         context.Handle();     } } //抽象状态类 abstract class State {      public abstract void Handle(Context context); } //具体状态A类 class ConcreteStateA extends State {      public void Handle(Context context) {          System.out.println("当前状态是状态 A.");         context.setState(new ConcreteStateB());     } } //具体状态B类 class ConcreteStateB extends State {      public void Handle(Context context) {          System.out.println("当前状态是 B.");         context.setState(new ConcreteStateA());     } } //环境类 class Context {      private State state;     //定义环境类的初始状态     public Context() {          this.state = new ConcreteStateA();     }     //设置新状态     public void setState(State state) {          this.state = state;     }     //读取状态     public State getState() {          return (state);     }     //对请求做处理     public void Handle() {          state.Handle(this);     } } 

输出结果如下：

当前状态是 A. 当前状态是 B. 当前状态是 A. 当前状态是 B.

解决的问题

对象的行为依赖于它的状态(属性)，并且可以根据它的设计状态改变而改变它的相关行为。

模式组成

实例说明

实例概况

用“状态模式”设计一个多线程的模式模式状态转换程序。

分析：多线程存在 5 种状态，系列分别为新建状态、状态就绪状态、设计运行状态、香港云服务器模式模式阻塞状态和死亡状态，系列各个状态当遇到相关方法调用或事件触发时会转换到其他状态，其状态转换规律如下所示：

现在先定义一个抽象状态类(TheadState)，然后为上图的每个状态设计一个具体状态类，它们是新建状态(New)、就绪状态(Runnable )、运行状态(Running)、阻塞状态(Blocked)和死亡状态(Dead)，每个状态中有触发它们转变状态的方法，环境类(ThreadContext)中先生成一个初始状态(New)，并提供相关触发方法，下图所示是线程状态转换程序的结构图：

使用步骤

步骤1：定义抽象状态类：线程状态

abstract class ThreadState {      //状态名     protected String stateName; } 

步骤2：定义具体的状态类

//具体状态类：新建状态 class New extends ThreadState {      public New() {          stateName = "新建状态";         System.out.println("当前线程处于：新建状态.");     }     public void start(ThreadContext hj) {          System.out.print("调用start()方法-->");         if (stateName.equals("新建状态")) {              hj.setState(new Runnable());         } else {              System.out.println("当前线程不是新建状态，不能调用start()方法.");         }     } } //具体状态类：就绪状态 class Runnable extends ThreadState {      public Runnable() {          stateName = "就绪状态";         System.out.println("当前线程处于：就绪状态.");     }     public void getCPU(ThreadContext hj) {          System.out.print("获得CPU时间-->");         if (stateName.equals("就绪状态")) {              hj.setState(new Running());         } else {              System.out.println("当前线程不是就绪状态，不能获取CPU.");         }     } } //具体状态类：运行状态 class Running extends ThreadState {      public Running() {          stateName = "运行状态";         System.out.println("当前线程处于：运行状态.");     }     public void suspend(ThreadContext hj) {          System.out.print("调用suspend()方法-->");         if (stateName.equals("运行状态")) {              hj.setState(new Blocked());         } else {              System.out.println("当前线程不是运行状态，不能调用suspend()方法.");         }     }     public void stop(ThreadContext hj) {          System.out.print("调用stop()方法-->");         if (stateName.equals("运行状态")) {              hj.setState(new Dead());         } else {              System.out.println("当前线程不是运行状态，不能调用stop()方法.");         }     } } //具体状态类：阻塞状态 class Blocked extends ThreadState {      public Blocked() {          stateName = "阻塞状态";         System.out.println("当前线程处于：阻塞状态.");     }     public void resume(ThreadContext hj) {          System.out.print("调用resume()方法-->");         if (stateName.equals("阻塞状态")) {              hj.setState(new Runnable());         } else {              System.out.println("当前线程不是阻塞状态，不能调用resume()方法.");         }     } } //具体状态类：死亡状态 class Dead extends ThreadState {      public Dead() {          stateName = "死亡状态";         System.out.println("当前线程处于：死亡状态.");     } } 

步骤3：定义环境类

class ThreadContext {      private ThreadState state;     ThreadContext() {          state = new New();     }     public void setState(ThreadState state) {          this.state = state;     }     public ThreadState getState() {          return state;     }     public void start() {          ((New) state).start(this);     }     public void getCPU() {          ((Runnable) state).getCPU(this);     }     public void suspend() {          ((Running) state).suspend(this);     }     public void stop() {          ((Running) state).stop(this);     }     public void resume() {          ((Blocked) state).resume(this);     } } 

输出结果

当前线程处于：新建状态. 调用start()方法-->当前线程处于：就绪状态. 获得CPU时间-->当前线程处于：运行状态. 调用suspend()方法-->当前线程处于：阻塞状态. 调用resume()方法-->当前线程处于：就绪状态. 获得CPU时间-->当前线程处于：运行状态. 调用stop()方法-->当前线程处于：死亡状态.

优点

状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。 减少对象间的高防服务器相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。 有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。

缺点

状态模式的使用必然会增加系统的类与对象的个数。 状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。

应用场景

通常在以下情况下可以考虑使用状态模式。

当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。

状态模式的扩展

在有些情况下，可能有多个环境对象需要共享一组状态，网站模板这时需要引入享元模式，将这些具体状态对象放在集合中供程序共享，其结构图如下：

分析：共享状态模式的不同之处是在环境类中增加了一个 HashMap 来保存相关状态，当需要某种状态时可以从中获取，其程序代码如下：

package com.niuh.designpattern.state.v3; import java.util.HashMap; /**  * <p>  * 共享状态模式  * </p>  */ public class FlyweightStatePattern {      public static void main(String[] args) {          //创建环境          ShareContext context = new ShareContext();         //处理请求         context.Handle();         context.Handle();         context.Handle();         context.Handle();     } } //抽象状态类 abstract class ShareState {      public abstract void Handle(ShareContext context); } //具体状态1类 class ConcreteState1 extends ShareState {      public void Handle(ShareContext context) {          System.out.println("当前状态是： 状态1");         context.setState(context.getState("2"));     } } //具体状态2类 class ConcreteState2 extends ShareState {      public void Handle(ShareContext context) {          System.out.println("当前状态是： 状态2");         context.setState(context.getState("1"));     } } //环境类 class ShareContext {      private ShareState state;     private HashMap<String, ShareState> stateSet = new HashMap<String, ShareState>();     public ShareContext() {          state = new ConcreteState1();         stateSet.put("1", state);         state = new ConcreteState2();         stateSet.put("2", state);         state = getState("1");     }     //设置新状态     public void setState(ShareState state) {          this.state = state;     }     //读取状态     public ShareState getState(String key) {          ShareState s = (ShareState) stateSet.get(key);         return s;     }     //对请求做处理     public void Handle() {          state.Handle(this);     } } 

输出结果如下

当前状态是： 状态1 当前状态是： 状态2 当前状态是： 状态1 当前状态是： 状态2

源码中的应用

#JDK中的状态模式： java.util.Iterator # 通过FacesServlet控制, 行为取决于当前JSF生命周期的阶段(状态 javax.faces.lifecycle.LifeCycle#execute() 

PS：以上代码提交在 Github ：

https://github.com/Niuh-Study/niuh-designpatterns.git

很赞哦!（1）