模式定义
对有状态的对象,把复杂的“判断逻辑”提取到不同的状态对象中,允许状态对象在其内部状态发生改变时改变其行为。
状态模式把受环境改变的对象行为包装在不同的状态对象里,其意图是让一个对象在其内部状态改变的时候,其行为也随之改变。现在我们来分析其基本结构和实现方法。
模板实现如下:
- 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);
- }
- }
输出结果如下:
解决的问题
对象的行为依赖于它的状态(属性),并且可以根据它的状态改变而改变它的相关行为。
模式组成
实例说明
实例概况
用“状态模式”设计一个多线程的状态转换程序。
分析:多线程存在 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);
- }
- }
输出结果
优点
缺点
应用场景
通常在以下情况下可以考虑使用状态模式。
状态模式的扩展
在有些情况下,可能有多个环境对象需要共享一组状态,这时需要引入享元模式,将这些具体状态对象放在集合中供程序共享,其结构图如下:
分析:共享状态模式的不同之处是在环境类中增加了一个 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);
- }
- }
输出结果如下
源码中的应用
- #JDK中的状态模式:
- java.util.Iterator
- # 通过FacesServlet控制, 行为取决于当前JSF生命周期的阶段(状态
- javax.faces.lifecycle.LifeCycle#execute()
PS:以上代码提交在 Github :
https://github.com/Niuh-Study/niuh-designpatterns.git
01 设计模式的本质 说起设计模式,就不得不说起重构。在 2017 年,当我还是一个...
通过本文您可以了解表格存储Java SDK的使用前提条件、版本兼容性和历史迭代版本...
登录 腾讯云控制台,选择【云产品】【监控与运维】【云监控】,进入云监控控制台...
如何获取客户端访问的加速节点 IP? ECDN 平台默认使用 X-Forwarded-For 头部字...
新版实时监控页面支持按需调整指标面板,方便您查看所关注指标的监控曲线。 登录...
操作场景 WebShell 为腾讯云推荐的登录方式,您可以直接使用腾讯云 WebShell 工...
新买 域名 怎么实名认证?新买的域名实名认证,是通过 域名注册 服务商进行的。...
事实证明,2001年的人工智能和大数据的应用和发展并不被人关注,而到2025年将成...
在数据加密处理中有很多复杂的加密算法,这些加密算法往往会用到很多超大的整数...
面对海量的各种来源的数据,如何对这些零散的数据进行有效的分析,得到有价值的...