设计模式之观察者模式

观察者模式

1: 定义

观察者模式是一种行为设计模式， 允许你定义一种订阅机制， 可在对象事件发生时通知多个 “观察” 该对象的其他对象是一种行为设计模式， 允许你定义一种订阅机制， 可在对象事件发生时通知多个 “观察” 该对象的其他对象

2: 示例

我们模拟下订单和支付的的动作，通过观察者模式实现。

/**
 * 事件处理抽象类
 * @author wei1.zhang
 * @date 2023/12/7 14:36
 */
public interface EventListener {

    /**
     * 事件处理抽象类
     */
    void doEvent(EventContext eventContext);
}

/**
 * 订单监听器
 * @author zhangwei09
 * @date 2023/12/7 14:37
 */
public class OrderListener implements EventListener{

    @Override
    public void doEvent(EventContext eventContext) {
        System.out.println("[用户]:"+ eventContext.getUserId()+"--[订单事件]:" + eventContext.getEventType()+"---[发生时间]:" + eventContext.getLocalDateTime());
    }
}

/**
 * 支付监听器
 * @author zhangwei09
 * @date 2023/12/7 14:37
 */
public class PayListener implements EventListener{

    @Override
    public void doEvent(EventContext eventContext) {
        System.out.println("[用户]:"+ eventContext.getUserId()+"--[支付事件]:" + eventContext.getEventType()+"---[发生时间]:" + eventContext.getLocalDateTime());
    }
}

/**
 * 事件监听器管理
 * @author zhangwei09
 * @date 2023/12/7 14:36
 */
public class EventManager {

    Map<String, List<EventListener>> listeners = new HashMap<>();

    /**
     *  事件监听器管理构造
     *
     * @param eventTypes
     */
    public EventManager(String... eventTypes) {
        for (String eventType : eventTypes) {
            this.listeners.put(eventType, new ArrayList<>());
        }
    }

    /**
     * 事件发布
     */
    public void subscribe(String eventType, EventListener listener) {
        List<EventListener> users = listeners.get(eventType);
        users.add(listener);
    }

    /**
     * 事件通知
     */
    public void notify(EventContext eventContext) {
        List<EventListener> eventListeners = listeners.get(eventContext.getEventType());
        for (EventListener listener : eventListeners) {
            listener.doEvent(eventContext);
        }
    }
}

/**
 *  事件上下文
 * @author zhangwei09
 * @date 2023/12/7 15:25
 */
public class EventContext {

    private String eventType;
    private String userId;
    private LocalDateTime localDateTime;


    public String getEventType() {
        return eventType;
    }

    public void setEventType(String eventType) {
        this.eventType = eventType;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public LocalDateTime getLocalDateTime() {
        return localDateTime;
    }

    public void setLocalDateTime(LocalDateTime localDateTime) {
        this.localDateTime = localDateTime;
    }
}

测试类

public class TestMain {
    public static void main(String[] args) {
        String userId = "wei1.zhang";
        Customer customer = new Customer(userId);
        customer.events.subscribe("order", new PayListener());
        customer.events.subscribe("pay", new OrderListener());

        try {
            EventContext eventContext = new EventContext();
            eventContext.setUserId(userId);
            eventContext.setEventType("order");
            eventContext.setLocalDateTime(LocalDateTime.now());
            customer.order(eventContext);

            eventContext.setEventType("pay");
            eventContext.setLocalDateTime(LocalDateTime.now());
            customer.payOrder(eventContext);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

以上是通过观察者模式模拟下订单，支付的场景。在生产环境，我们肯定不会这么写。主要是想通过代码让读者体会一下观察者模式。

3: 适用场景

1: 当一个对象状态的改变需要改变其他对象， 或实际对象是事先未知的或动态变化的时， 可使用观察者模式。

观察者模式允许任何实现了订阅者接口的对象订阅发布者对象的事件通知。 你可在按钮中添加订阅机制， 允许客户端通过自定义订阅类注入自定义代码。

4:优缺点

优点:

1: 开闭原则。 你无需修改发布者代码就能引入新的订阅者类 （如果是发布者接口则可轻松引入发布者类）。

2: 在运行时建立对象之间的联系。

缺点

1：订阅者的通知顺序是随机的。

5: 思考总结

所谓的观察者模式，就是生产者和消费者这种形式的抽象话。让发布事件的逻辑和消费事件的逻辑解耦合，并且异步化。由此我们是不是联想到了消息队列。没错，当我们跨JVM的时候，就需要这种消息中间件来管理事件。以上就是本次分享的内容，如有不足，请多指教