设计模式学习笔记(十九)观察者模式及应用场景

观察者模式(Observer Design Pattern),也叫做发布订阅模式(Publish-Subscribe Design Pattern)、模型-视图(Model-View)模式、源-监听器(Source-Listener)模式、从属者(Dependents)模式。指在对象之间定义一个一对多的依赖,当一个对象状态改变的时候,所有依赖的对象都会自动收到通知。

比如说Redis 中的基于频道的发布订阅就是观察者模式的应用:

image-20220212142801417

一、观察者模式的介绍

观察者模式是一种对象行为型模式,下面就来看看观察者模式的结构及其实现:

1.1 观察者模式的结构

观察者模式结构中主要包括观察目标(Object)和观察者(Observer)主要结构:

image-20220409112301928

  • Subject:主题抽象类,提供一系列观察者对象,以及对这些对象的增加、删除和通知的方法
  • ConcreteSubject:主题具体实现类,实现抽象主题中的通知方法,通知所有注册过的观察者对象
  • Observer:观察者抽象类,包含一个通知响应抽象方法
  • ConcreteObserver1、ConcreteObserver2:观察者实现类,实现抽象观察者中的方法,以便在得到目标的更改通知时更新自身的状态
  • Client:客户端,对主题及观察者进行调用

1.2 观察者模式的实现

根据上面的类图,我们可以实现对应的代码。

首先定义一个抽象目标类Subject,其中包括增加、注销和通知观察者方法

public abstract class Subject {

    protected List<Observer> observerList = new ArrayList<Observer>();

    /**
     * 增加观察者
     * @param observer 观察者
     */
    public void add(Observer observer) {
        observerList.add(observer);
    }

    /**
     * 注销观察者,从观察者集合中删除一个观察者
     * @param observer 观察者
     */
    public void remove(Observer observer) {
        observerList.remove(observer);
    }

    /**通知观察者*/
    public abstract void notifyObserver();
}

对应具体的目标类ConcreteSubject

public class ConcreteSubject extends Subject{

    @Override
    public void notifyObserver() {
        System.out.println("遍历观察者:");
        for (Observer observer : observerList) {
            observer.response();
        }
    }
}

此外需要定义抽象观察者Observer,它一般定义为一个接口,声明一个response()方法,为不同观察者的响应行为定义相同的接口:

public interface Observer {
    /**声明响应方法*/
    void response();
}

具体的观察者实现:

public class ConcreteObserver1 implements Observer{

    @Override
    public void response() {
        System.out.println("我是具体观察者ConcreteObserver1");
    }
}

public class ConcreteObserver2 implements Observer{

    @Override
    public void response() {
        System.out.println("我是具体观察者ConcreteObserver2");
    }
}

最后是客户端测试:

public class Client {
    public static void main(String[] args) {
        Subject concreteSubject = new ConcreteSubject();
        //具体观察者
        Observer concreteObserver1 = new ConcreteObserver1();
        Observer concreteObserver2 = new ConcreteObserver2();
        concreteSubject.add(concreteObserver1);
        concreteSubject.add(concreteObserver2);
        
        concreteSubject.notifyObserver();
    }
}

测试结果:

遍历观察者:
我是具体观察者ConcreteObserver1
我是具体观察者ConcreteObserver2

二、观察者模式的应用场景

在以下情况就可以考虑使用观察者模式:

  1. 一个对象的改变会导致一个或多个对象发生改变,而并不知道具体有多少对象将会发生改变,也不知道这些对象是谁
  2. 当一个抽象模型有两个方面,其中的一个方面依赖于另一个方面时,可将这两者封装在独立的对象中以使他们可以各自独立地改变和复用
  3. 需要在系统中创建一个触发链,使得事件拥有跨域通知(跨越两种观察者的类型)

2.1 观察者模式在java.util包中的应用

观察者模式在JDK中就有典型应用,比如java.util.Observablejava.util.Observer类。结构如下图所示:

image-20220409083948434

我们可以通过实现具体的ConcreteObserver和具体的ConcreteObservable完成观察者模式流程

2.2 观察者模式在MVC中的应用

MVC(Modew-View-Controller)架构中也应用了观察者模式,其中模型(Model)可以对应观察者模式中的观察目标,而视图(View)对应于观察者,控制器(Controller)就是中介者模式的应用:

image-20220409091533004

三、观察者模式实战

在本案例中模拟北京小客车指标摇号事件的通知场景(来源于《重学Java设计模式》)

image-20220409092520707

对于通知事件,可以将其分成三个部分:事件监听事件处理具体的业务流程,如下图所示:

image-20220409095032686

对于和核心流程和非核心流程的结构,非核心流程可以是异步的,在MQ以及定时任务的处理下,能够最终保证一致性。

具体代码实现

  1. 事件监听接口及具体实现

这个部分就相当于观察者(Observer)的角色

在接口中定义基本事件类方法doEvent()

public interface EventListener {

    void doEvent(LotteryResult result);

}

监听事件的具体实现MessageEventListener(短消息事件)和MQEventListener(MQ发送事件)

public class MessageEventListener implements EventListener{

    private Logger logger = LoggerFactory.getLogger(MessageEventListener.class);

    @Override
    public void doEvent(LotteryResult result) {
        logger.info("给用户 {} 发送短信通知(短信):{}", result.getuId(), result.getMsg());
    }
}

public class MQEventListener implements EventListener{

    private Logger logger = LoggerFactory.getLogger(MQEventListener.class);

    @Override
    public void doEvent(LotteryResult result) {
        logger.info("记录用户 {} 摇号结果(MQ):{}", result.getuId(), result.getMsg());
    }
}
  1. 事件处理类

该部分就相当于主题(Object)部分

对于不同的事件类型(MQ和Message)进行枚举处理,并提供三个方法:subscribe()unsubscribe()notify()用于对监听事件的注册和使用:

public class EventManager {

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

    public EventManager(Enum<EventType>... operations) {
        for (Enum<EventType> operation : operations) {
            listeners.put(operation, new ArrayList<>());
        }
    }

    public enum EventType {
        MQ,
        Message
    }

    /**
     * 订阅
     * @param eventType 事件类型
     * @param listener  监听
     */
    public void subscribe(Enum<EventType> eventType, EventListener listener) {
        List<EventListener> eventListeners = listeners.get(eventType);
        eventListeners.add(listener);
    }

    /**
     * 取消订阅
     * @param eventType 事件类型
     * @param listener 监听
     */
    public void unsubscribe(Enum<EventType> eventType, EventListener listener) {
        List<EventListener> eventListeners = listeners.get(eventType);
        eventListeners.remove(listener);
    }

    /**
     * 通知
     * @param eventType 事件类型
     * @param result    结果
     */
    public void notify(Enum<EventType> eventType, LotteryResult result) {
        List<EventListener> eventListeners = listeners.get(eventType);
        for (EventListener eventListener : eventListeners) {
            eventListener.doEvent(result);
        }
    }
}
  1. 业务抽象类接口及其实现

使用抽象类的方式实现方法,好处是可以在方法中扩展额外的调用,并提供抽象方法doDraw,让继承者去实现具体逻辑

public abstract class LotteryService {

    private EventManager eventManager;

    public LotteryService() {
        eventManager = new EventManager(EventManager.EventType.MQ, EventManager.EventType.Message);
        eventManager.subscribe(EventManager.EventType.MQ, new MQEventListener());
        eventManager.subscribe(EventManager.EventType.Message, new MessageEventListener());
    }

    public LotteryResult draw(String uId) {
        LotteryResult lotteryResult = doDraw(uId);
        eventManager.notify(EventManager.EventType.MQ, lotteryResult);
        eventManager.notify(EventManager.EventType.Message, lotteryResult);
        return lotteryResult;
    }

    protected abstract LotteryResult doDraw(String uId);
}

public class LotteryServiceImpl extends LotteryService{

    private MinibusTargetService minibusTargetService = new MinibusTargetService();

    @Override
    protected LotteryResult doDraw(String uId) {
        //摇号测试
        String lottery = minibusTargetService.lottery(uId);
        return new LotteryResult(uId, lottery, new Date());
    }
}
  1. 其他的类

摇号服务接口:

/**
 * 小客车指标调控服务
 */
public class MinibusTargetService {

    /**
     * 模拟摇号,但不是摇号算法
     *
     * @param uId 用户编号
     * @return 结果
     */
    public String lottery(String uId) {
        return Math.abs(uId.hashCode()) % 2 == 0 ? "恭喜你,编码".concat(uId).concat("在本次摇号中签") : "很遗憾,编码".concat(uId).concat("在本次摇号未中签或摇号资格已过期");
    }

}

事件信息返回类:

public class LotteryResult {

    private String uId;
    private String msg;
    private Date dateTime;

    //get set constructor... 
}
  1. 测试类
public class ApiTest {

    private Logger logger = LoggerFactory.getLogger(ApiTest.class);

    @Test
    public void test() {
        LotteryServiceImpl lotteryService = new LotteryServiceImpl();
        LotteryResult result = lotteryService.draw("1234567");
        logger.info("摇号结果:{}", JSON.toJSONString(result));
    }
}

测试结果:

11:43:09.284 [main] INFO  c.e.d.event.listener.MQEventListener - 记录用户 1234567 摇号结果(MQ):恭喜你,编码1234567在本次摇号中签
11:43:09.288 [main] INFO  c.e.d.e.l.MessageEventListener - 给用户 1234567 发送短信通知(短信):恭喜你,编码1234567在本次摇号中签
11:43:09.431 [main] INFO  ApiTest - 摇号结果:{"dateTime":1649475789279,"msg":"恭喜你,编码1234567在本次摇号中签","uId":"1234567"}

参考资料

《重学Java设计模式》

《设计模式》

http://c.biancheng.net/view/1390.html

 4 total views,  1 views today

页面下部广告