状态模式，就是维护多种不同的状态，每种状态下可以去执行一些特殊的逻辑。然后由一个Context类负责根据请求参数调用，来维护这些状态之间的切换，形成一个状态机的概念。
状态模式里，非常重要的一点就是将状态之间流转的逻辑，封装在Context类里面。本来可能需要调用方自己维护复杂的状态流转逻辑，流转到不同的状态之后，执行状态对应的代码逻辑。
使用场景这个状态模式，在电商系统中有天然的运用场景，系统中很多数据都有大量的状态变更的逻辑，像订单，出库单等等，我们可以将状态变更的逻辑用状态模式来实现，将状态流转封装在一个地方，每次状态变更就通知那个组件，让状态流转，同时执行状态对应的代码逻辑
电商订单，状态需要从新建、待支付、支付、已完成，四个状态之间流转，流转到每个状态的时候，都需要执行那个状态对应的一个逻辑
代码示例package com.wc.designpattern.state;
public class StatePatternApplication {
private static final int TO_BE_PAY_STATE = 1;
private static final int PAY_STATE = 2;
private static final int FINISH_STATE = 3;
interface State {
void exec();
}
static class NewState implements State {
@Override
public void exec() {
System.out.println("执订单新建状态逻辑");
}
}
static class ToBePayState implements State {
@Override
public void exec() {
System.out.println("执行订单待支付状态逻辑");
}
}
static class PayState implements State {
@Override
public void exec() {
System.out.println("执行订单已支付状态逻辑");
}
}
static class FinishedState implements State {
public void exec() {
System.out.println("执行订单已完成状态的逻辑");
}
}
static class Context {
private State state;
public Context(State state) {
this.state = state;
this.state.exec();
}
public void exec(int stateType) {
if (stateType == TO_BE_PAY_STATE) {
this.state = new ToBePayState();
this.state.exec();
} else if (stateType == PAY_STATE) {
this.state = new PayState();
this.state.exec();
} else if (stateType == FINISH_STATE) {
this.state = new FinishedState();
this.state.exec();
}
}
}
public static void main(String[] args) {
Context context = new Context(new NewState());
context.exec(TO_BE_PAY_STATE);
context.exec(PAY_STATE);
context.exec(FINISH_STATE);
}
}
测试
执行Main函数，得到执行结果
执订单新建状态逻辑 执行订单待支付状态逻辑 执行订单已支付状态逻辑 执行订单已完成状态的逻辑 Process finished with exit code 0观察者模式 简介
观察者模式还是非常常用的，常见于基于zookeeper进行分布式系统之间的协调工作，比如分布式锁的注册以及监听是否释放。还有就是两个系统之间如果做了异步的处理，那么如果A系统发送异步请求给了B系统，但是要得到B系统的一个状态改变的消息，可以采用观察者模式。
使用场景在Zookeeper中的监听回调机制，以及分布式锁，都是使用了观察者模式。
基于zookeeper去做分布式锁
（1）系统A尝试获取zookeeper上的一个锁，获取到了
（2）系统B尝试获取zookeeper上的一个锁，被系统A给锁了，没有获取到锁，此时系统B在zookeeper上可以注册一个监听器（观察者）
（3）系统A一旦将锁给释放了，zookeeper感受到锁被释放了，就会立即通知系统B注册的那个监听器
（4）系统B就立即被通知到了，系统A释放了锁，系统B可以重新尝试在zookeeper上加锁
电商系统里，也有这种场景，如果两个系统之间走了异步请求，那么可以基于上面那种观察者模式现在一个进程内实现监听，以后拆分微服务分布式架构了，可以改成基于zookeeper来做分布式协调。
系统A发送了一条消息到内存队列，系统B获取了消息开始执行操作
但是系统A需要知道系统B的一个执行的结果如何，
此时系统A需要注册一个观察者到系统B上去，系统B执行完了之后，将执行的结果，反过来通知给系统
我们就可以基于观察者模式去做。
代码示例package com.wc.designpattern.observable;
import java.util.Observable;
import java.util.Observer;
public class ObservablePatternApplication {
static class Subject extends Observable {
private Integer state;
public Integer getState() {
return state;
}
public Subject(Integer state) {
this.state = state;
}
public void setState(Integer state) {
//在这里状态就改变了
this.state = state;
//这里状态发生改变之后，要通知关联的一些观察者，说状态发生了改变
this.setChanged();
this.notifyObservers();
}
}
static class ConcreteObserver implements Observer {
@Override
public void update(Observable o, Object arg) {
Subject subject = (Subject) o;
Integer state = subject.getState();
System.out.println("目标对象的状态已经改变为：" + state);
}
}
public static void main(String[] args) {
Subject subject = new Subject(0);
Observer observer = new ConcreteObserver();
subject.addObserver(observer);
subject.setState(5);
subject.setState(2);
}
}
测试
执行Main函数，得到执行结果
目标对象的状态已经改变为：5 目标对象的状态已经改变为：2 Process finished with exit code 0
