设计模式-观察者模式

观察者模式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;
    }
}