观察者模式UML类图:
观察者模式类图角色说明:
Subject被观察者抽象角色:该类负责定义用于通知观察者的方法(被观察者,是自愿被观察的,会主动通知观察者进行相关操作),并且能够动态地增加、移除观察者
ConcreteSubject具体被观察者角色:具体被观察者,实现通知观察者的具体方法逻辑
Observer观察者抽象角色:定义观察者的职责方法,观察者的职责是什么,当观察者接收到被观察者的通知后,会展开一系列的处理逻辑,因此需要定义观察者的职责方法
ConcreteObserver具体观察者角色:具体观察者,实现观察者职责方法的代码逻辑
一、创建抽象观察者
package com.example.demo.observer;
public abstract class AbstractObserver {
//订单状态发生变更时,调用此方法
public abstract void orderStateHandle(String orderId, String orderState);
}
二、创建具体观察者
观察者公共类:
package com.example.demo.observerModel;
import java.util.List;
import java.util.Vector;
public class Constants {
public static List<AbstractObserver> OBSERVER_LIST = new Vector<>();
}
订单创建:
package com.example.demo.observerModel.observer;
import com.example.demo.observerModel.Constants;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
public class CreateObserver extends AbstractObserver {
@PostConstruct
public void init() {
Constants.OBSERVER_LIST.add(this);
}
@Override
public void orderStateHandle(String orderId, String orderState) {
if(!orderState.equals("ORDER_WAIT_PAY")) {
return;
}
//通过命令模式进行后续处理
System.out.println("监听到 :订单创建成功。通过命令模式做后续处理。");
}
}
订单支付:
package com.example.demo.observerModel.observer;
import com.example.demo.observerModel.Constants;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
public class PayObserver extends AbstractObserver {
@PostConstruct
public void init() {
Constants.OBSERVER_LIST.add(this);
}
@Override
public void orderStateHandle(String orderId, String orderState) {
if(!orderState.equals("ORDER_WAIT_SEND")) {
return;
}
//通过命令模式进行后续处理
System.out.println("监听到 :订单支付成功。通过命令模式做后续处理。");
}
}
订单发送:
package com.example.demo.observerModel.observer;
import com.example.demo.observerModel.Constants;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
public class SendObserver extends AbstractObserver {
@PostConstruct
public void init() {
Constants.OBSERVER_LIST.add(this);
}
@Override
public void orderStateHandle(String orderId, String orderState) {
if(!orderState.equals("ORDER_WAIT_RECEIVE")) {
return;
}
//通过命令模式进行后续处理
System.out.println("监听到 :订单发送成功。通过命令模式做后续处理。");
}
}
......
三、创建抽象被观察者
package com.example.demo.observerModel.subject;
import com.example.demo.observerModel.Constants;
import com.example.demo.observerModel.observer.AbstractObserver;
import java.util.List;
public abstract class AbstractOrderState {
protected final String ORDER_WAIT_PAY = "ORDER_WAIT_PAY";
protected final String ORDER_WAIT_SEND = "ORDER_WAIT_SEND";
protected final String ORDER_WAIT_RECEIVE = "ORDER_WAIT_RECEIVE";
protected List<AbstractObserver> observersList = Constants.OBSERVER_LIST;
//创建订单
protected Order createOrder(String orderId, String productId, OrderContext context) {
throw new UnsupportedOperationException();
}
//订单支付
protected Order payOrder(String orderId, OrderContext context) {
throw new UnsupportedOperationException();
}
//订单发送
protected Order sendOrder(String orderId, OrderContext context) {
throw new UnsupportedOperationException();
}
public void notifyObserver(String orderId, String orderState) {
for(AbstractObserver observer : this.observersList) {
observer.orderStateHandle(orderId, orderState);
}
}
public void addObserver(AbstractObserver observer){
this.observersList.add(observer);
}
public void removeObserver(AbstractObserver observer) {
this.observersList.remove(observer);
}
}
四、创建具体被观察者
订单类:
package com.example.demo.observerModel.subject;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Order {
private String orderId;
private String productId;
private String state;
}
创建订单:
package com.example.demo.observerModel.subject;
import org.springframework.stereotype.Component;
@Component
public class CreateOrder extends AbstractOrderState {
@Override
protected Order createOrder(String orderId, String productId, OrderContext context) {
//创建订单对象,设置状态为 ORDER_WAIT_PAY
Order order = Order.builder()
.orderId(orderId)
.productId(productId)
.state(ORDER_WAIT_PAY)
.build();
//观察者模式:发送订单创建
super.notifyObserver(orderId, ORDER_WAIT_PAY);
return order;
}
}
订单支付:
package com.example.demo.observerModel.subject;
import org.springframework.stereotype.Component;
@Component
public class PayOrder extends AbstractOrderState {
@Override
protected Order payOrder(String orderId, OrderContext context) {
//判断当前订单状态是否为 待支付 状态
// ...
//支付完成后,修改订单状态为 待发货
// ...
//观察者模式:发送订单支付
super.notifyObserver(orderId, ORDER_WAIT_SEND);
return order;
}
}
订单发送:
package com.example.demo.observerModel.subject;
import org.springframework.stereotype.Component;
@Component
public class SendOrder extends AbstractOrderState {
@Override
protected Order sendOrder(String orderId, OrderContext context) {
//判断当前订单状态是否为 待发货 状态
// ...
//发货后,修改订单状态为 待收货
// ...
//观察者模式:发送订单发货
super.notifyObserver(orderId, ORDER_WAIT_RECEIVE);
return order;
}
}
.....
五、订单上下文类
package com.example.demo.observerModel.subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class OrderContext {
@Autowired
private CreateOrder createOrder;
@Autowired
private PayOrder payOrder;
@Autowired
private SendOrder sendOrder;
public Order createOrder(String orderId, String productId) {
//创建订单,使用createOrder
Order order = createOrder.createOrder(orderId, productId, this);
return order;
}
public Order payOrder(String orderId) {
//支付订单,使用payOrder
Order order = payOrder.payOrder(orderId, this);
return order;
}
public Order sendOrder(String orderId) {
//订单发货,使用sendOrder
Order order = sendOrder.sendOrder(orderId, this);
return order;
}
}