在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。
在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。
状态模式-允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类
设计背景
举个订单的例子，订单新建之后，需要对订单进行一个自动处理。
订单状态的变化，下单、待支付、支付、发货、待收货、收货、订单结束等等。
下单状态完成：订单状态=待支付
待支付状态完成：订单状态=支付
支付状态完成：订单状态=发货
发货状态完成：订单状态=收货
收货状态完成：订单状态=订单结束
每一个订单背后承载着很多不同的状态。每一个状态，都有不一样的业务逻辑。
状态码值：
0 下单
1 待支付
2 支付
3 发货
4 待收货
5 收货
6 订单结束
按照这个业务逻辑直接实现代码
/**
* @author shengyong.huang
* @date 2020-07-05
*/
public class StateExample {
/**
* 订单状态的变化，下单、待支付、支付、发货、待收货、收货、取消、待退款、已退款等等，每一个订单背后承载着很多不同的状态。每一个状态，都有不一样的业务逻辑。
* 0 下单
* 1 待支付
* 2 支付
* 3 发货
* 4 待收货
* 5 收货
* 6 订单结束
*/
private Integer state;
public void placeOrder() {
state = 0;
System.out.println("下单成功！");
}
public void orderHandleState() {
switch (state) {
case 0:
state = 1;
System.out.println("待支付状态,执行待支付的复杂逻辑");
break;
case 1:
state = 2;
System.out.println("支付成功状态,执行支付成功的复杂逻辑");
break;
case 2:
state = 3;
System.out.println("正在发货状态,执行正在发货的复杂逻辑");
break;
case 3:
state = 4;
System.out.println("待收货状态,执行待收货的复杂逻辑");
break;
case 4:
state = 5;
System.out.println("收货成功状态,执行收货成功的复杂逻辑");
break;
case 5:
state = 6;
System.out.println("订单已经结束,执行订单已经结束的复杂逻辑");
return;
default:
throw new RuntimeException("订单状态异常");
}
orderHandleState();
}
public static void main(String[] args) {
StateExample stateExample = new StateExample();
stateExample.placeOrder();
stateExample.orderHandleState();
}
}
所有的状态转换的逻辑都在一个方法里面，会存在很多个条件分支，有多少个状态就会有多少个条件分支。
现在来看一下如果使用状态模式：
[图片上传失败...(image-b80720-1596987077835)]
Order：订单对象，使用contextState对象进行状态的切换。handelOrder中调用状态对象的handel方法。
State：状态的抽象类或者是接口，将每一个条件分支放入一个独立的类中。可以根据对象自身的情况将对象的状态作为一个对象。
订单的状态==对象的状态
placeOrderState：下单状态（执行业务逻辑之后，将状态切换为待支付状态）
noPayState：待支付状态（执行业务逻辑之后，将状态切换为支付成功状态）
paymentSuccessState：支付成功状态（执行业务逻辑之后，将状态切换为发货状态）
shippingState：发货状态（执行业务逻辑之后，将状态切换为待收货状态）
WaitForReceivingState：待收货（执行业务逻辑之后，将状态切换为收货成功状态）
receivedSuccessState：收货成功（执行业务逻辑之后，将状态切换为订单结束状态）
orderEndState：订单结束
模式结构和定义
[图片上传失败...(image-1208b7-1596987077835)]
状态模式所涉及到的角色有：
环境(Context)角色，也成上下文：定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例给出此环境对象的现有状态。
抽象状态(State)角色：定义一个接口，用以封装环境（Context）对象的一个特定的状态所对应的行为。
具体状态(ConcreteState)角色：每一个具体状态类都实现了环境（Context）的一个状态所对应的行为。
应用实例
使用状态模式
/**
* 状态抽象类
*
* @author shengyong.huang
* @date 2020-07-05
*/
public abstract class State {
/**
* 订单对象
*/
protected Order order;
/**
* 状态处理抽象方法
*/
protected abstract void handle();
}
/**
* 下单状态
*
* @author shengyong.huang
* @date 2020-07-06
*/
public class PlaceOrderState extends State {
public PlaceOrderState(Order order) {
this.order = order;
}
@Override
protected void handle() {
System.out.println("下单成功！");
// 改变当前状态为"待支付"
order.setContextState(order.getNotPayState());
}
}
/**
* 待支付状态
* @author shengyong.huang
* @date 2020-07-06
*/
public class NotPayState extends State {
public NotPayState(Order order) {
this.order = order;
}
@Override
protected void handle() {
System.out.println("待支付状态,执行待支付的复杂逻辑");
// 改变当前状态为"支付成功"
order.setContextState(order.getPaymentSuccessState());
}
}
/**
* 支付成功状态
*
* @author shengyong.huang
* @date 2020-07-06
*/
public class PaymentSuccessState extends State {
public PaymentSuccessState(Order order) {
this.order = order;
}
@Override
protected void handle() {
System.out.println("支付成功状态,执行支付成功的复杂逻辑");
// 改变当前状态为"正在发货状态"
order.setContextState(order.getShippingState());
}
}
/**
* 正在发货状态
*
* @author shengyong.huang
* @date 2020-07-06
*/
public class ShippingState extends State {
public ShippingState(Order order) {
this.order = order;
}
@Override
protected void handle() {
System.out.println("正在发货状态,执行正在发货的复杂逻辑");
// 改变当前状态为"待收货"
order.setContextState(order.getWaitForReceivingState());
}
}
/**
* 待收货状态
*
* @author shengyong.huang
* @date 2020-07-06
*/
public class WaitForReceivingState extends State {
public WaitForReceivingState(Order order) {
this.order = order;
}
@Override
protected void handle() {
System.out.println("待收货状态,执行待收货的复杂逻辑");
// 改变当前状态为"收货成功"
order.setContextState(order.getReceivedSuccessState());
}
}
/**
* 收货成功状态
* @author shengyong.huang
* @date 2020-07-06
*/
public class ReceivedSuccessState extends State {
public ReceivedSuccessState(Order order) {
this.order = order;
}
@Override
protected void handle() {
System.out.println("收货成功状态,执行收货成功的复杂逻辑");
// 改变当前状态为"订单结束"
order.setContextState(order.getOrderEndState());
}
}
/**
* 订单结束状态
* @author shengyong.huang
* @date 2020-07-06
*/
public class OrderEndState extends State {
public OrderEndState(Order order) {
this.order = order;
}
@Override
protected void handle() {
System.out.println("订单已经结束,执行订单已经结束的复杂逻辑");
// 订单结束状态设置为空
order.setContextState(null);
}
}
/**
* 订单类
*
* @author shengyong.huang
* @date 2020-07-06
*/
public class Order {
/**
* 上下文状态对象
*/
private State contextState;
/**
* 下单状态
*/
private State placeOrderState = new PlaceOrderState(this);
/**
* 待支付状态
*/
private State notPayState = new NotPayState(this);
/**
* 支付成功状态
*/
private State paymentSuccessState = new PaymentSuccessState(this);
/**
* 正在发货状态
*/
private State shippingState = new ShippingState(this);
/**
* 待收货状态
*/
private State waitForReceivingState = new WaitForReceivingState(this);
/**
* 收货成功状态
*/
private State receivedSuccessState = new ReceivedSuccessState(this);
/**
* 订单结束状态
*/
private State orderEndState = new OrderEndState(this);
public State getContextState() {
return contextState;
}
public void setContextState(State contextState) {
this.contextState = contextState;
}
public State getPlaceOrderState() {
return placeOrderState;
}
public void setPlaceOrderState(State placeOrderState) {
this.placeOrderState = placeOrderState;
}
public State getNotPayState() {
return notPayState;
}
public void setNotPayState(State notPayState) {
this.notPayState = notPayState;
}
public State getPaymentSuccessState() {
return paymentSuccessState;
}
public void setPaymentSuccessState(State paymentSuccessState) {
this.paymentSuccessState = paymentSuccessState;
}
public State getShippingState() {
return shippingState;
}
public void setShippingState(State shippingState) {
this.shippingState = shippingState;
}
public State getWaitForReceivingState() {
return waitForReceivingState;
}
public void setWaitForReceivingState(State waitForReceivingState) {
this.waitForReceivingState = waitForReceivingState;
}
public State getReceivedSuccessState() {
return receivedSuccessState;
}
public void setReceivedSuccessState(State receivedSuccessState) {
this.receivedSuccessState = receivedSuccessState;
}
public State getOrderEndState() {
return orderEndState;
}
public void setOrderEndState(State orderEndState) {
this.orderEndState = orderEndState;
}
/**
* 订单下单
*/
public void placeOrder() {
this.contextState = this.placeOrderState;
}
/**
* 处理订单
*/
public void handelOrder() {
this.contextState.handle();
if (this.contextState != null) {
handelOrder();
}
}
}
/**
* 测试方法
*
* @author shengyong.huang
* @date 2020-07-06
*/
public class TestMain {
public static void main(String[] args) {
// 订单
Order order = new Order();
// 订单下单，当前状态=下单状态
order.placeOrder();
// 处理订单
order.handelOrder();
}
}
优点和不足
优点：
将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。
缺点：
状态模式的使用必然会增加系统类和对象的个数。
状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
状态模式对"开闭原则"的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态，而且修改某个状态类的行为也需修改对应类的源代码
使用场景
一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为。
-
操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。
这个状态通常用一个或多个枚举常量表示。通常,有多个操作包含这一相同的条件结构。
State模式将每一个条件分支放入一个独立的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象而独立变化。
和策略模式的对比
策略是将一种算法或者实现抽离，使得可以自由切换，每个策略互相独立，重在切换。
状态是整体与部分，每个状态都是必备的一环，每个状态拿出去后无法独立，重在状态的变化。
参考
https://cloud.tencent.com/developer/article/1458000
https://design-patterns.readthedocs.io/zh_CN/latest/behavioral_patterns/state.html#id10
https://cloud.tencent.com/developer/article/1431475
https://www.cnblogs.com/java-my-life/archive/2012/06/08/2538146.html
