经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » Java相关 » Spring » 查看文章
三种方式实现观察者模式及事件编程模型
来源:cnblogs  作者:CodeBear  时间:2019/2/25 9:37:54  对本文有异议

观察者模式可以说是众多设计模式中,最容易理解的设计模式之一了,观察者模式在Spring中也随处可见,面试的时候,面试官可能会问,嘿,你既然读过Spring源码,那你说说Spring中运用的设计模式吧,你可以自信的告诉他,Spring中的ApplicationListener就运用了观察者模式。

让我们一步一步来,首先我们要知道到底什么是观察者模式,用Java是如何实现的,在这里,我将会用三种方式来实现观察者模式。

什么是观察者模式

在现实生活中,观察者模式处处可见,比如

  • 看新闻,只要新闻开始播放了,就会把新闻推送给订阅了新闻的用户,在这里,新闻就是【被观察者】,而用户就是【观察者】。

  • 微信公众号,如果一个用户订阅了某个公众号,那么便会收到公众号发来的消息,那么,公众号就是【被观察者】,而用户就是【观察者】。

  • 热水器,假设热水器由三部分组成,热水器,警报器,显示器,热水器仅仅负责烧水,当水温到达设定的温度后,通知警报器,警报器发出警报,显示器也需要订阅热水器的烧水事件,从而获得水温,并显示。热水器就是【被观察者】,警报器,显示器就是【观察者】。

在这里,可以看到,【观察者】已经失去自主的权利,只能被动的接收来自【被观察者】的事件,无法主动观察。【观察者】成为了“受”,而【被观察者】成为了“攻”。【被观察者】只是通知【观察者】,不关心【观察者】收到通知后,会执行怎样的动作。

而在设计模式中,又把【被观察者】称为【主题】。

在观察者设计模式中,一般有四个角色:

  • 抽象主题角色(Subject)

  • 具体主题角色(ConcreteSubject)

  • 抽象观察者角色(Observer)

  • 具体观察者角色(ConcreteObserver)

其中,【主题】需要有一个列表字段,用来保存【观察者】的引用,提供两个方法(虚方法),即【删除观察者】【增加观察者】,还需要提供一个给客户端调用的方法,通知各个【观察者】:你们关心(订阅)的事件已经推送给你们了。

下面,我就用三种方式来实现观察者模式。

经典

  1. public class News {
  2.     private String title;
  3.     private String content;
  4.  
  5.     public String getTitle() {
  6.         return title;
  7.     }
  8.  
  9.     public void setTitle(String title) {
  10.         this.title = title;
  11.     }
  12.  
  13.     public String getContent() {
  14.         return content;
  15.     }
  16.  
  17.     public void setContent(String content) {
  18.         this.content = content;
  19.     }
  20. }

此类不属于观察者模式必须的类,用来存放事件的信息。

  1. public interface Subject {
  2.     List<People> peopleList = new ArrayList<>();
  3.  
  4.     default void add(People people) {
  5.         peopleList.add(people);
  6.     }
  7.  
  8.     default void remove(People people) {
  9.         peopleList.remove(people);
  10.     }
  11.  
  12.     void update();
  13. }

抽象主题角色,在这个角色中,有一个字段peopleList,用来保存【观察者】的引用,同时定义了两个接口,这是Java8默认接口实现的写法。这两个接口是给客户端调用的,用来【删除观察者】【增加观察者】,还提供一个方法,此方法需要被【具体主题角色】重写,用来通知各个【观察者】。

  1. public class NewsSubject implements Subject{
  2.     public void update() {
  3.         for (People people : peopleList) {
  4.             News news = new News();
  5.             news.setContent("今日在大街上,有人躲在草丛中袭击路人,还大喊“德玛西亚万岁”");
  6.             news.setTitle("德玛西亚出现了");
  7.             people.update(news);
  8.         }
  9.     }
  10. }

具体主题角色,重写了【抽象主题角色】的方法,循环列表,通知各个【观察者】。

  1. public interface People {
  2.     void update(News news);
  3. }

抽象观察者角色,定义了一个接口,【具体观察者角色】需要重写这个方法。

下面就是【具体观察者角色】了:

  1. public class PeopleA implements People {
  2.     @Override
  3.     public void update(News news) {
  4.         System.out.println("这个新闻真好看");
  5.     }
  6. }
  1. public class PeopleB implements People {
  2.     @Override
  3.     public void update(News news) {
  4.         System.out.println("这个新闻真无语");
  5.     }
  6. }
  1. public class PeopleC implements People {
  2.     @Override
  3.     public void update(News news) {
  4.         System.out.println("这个新闻真逗");
  5.     }
  6. }

客户端:

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         Subject subject = new NewsSubject();
  4.         subject.add(new PeopleA());
  5.         subject.add(new PeopleB());
  6.         subject.add(new PeopleC());
  7.         subject.update();
  8.     }
  9. }

运行:
image.png

我们学习设计模式,必须知道设计模式的优缺点,那么观察者设计模式的优缺点是什么呢?

优点:

  • 【主题】和【观察者】通过抽象,建立了一个松耦合的关系,【主题】只知道当前有哪些【观察者】,并且发送通知,但是不知道【观察者】具体会执行怎样的动作。这也很好理解,比如 微信公众号推送了一个消息过来,它不知道你会采取如何的动作,是 微笑的打开,还是愤怒的打开,或者是直接把消息删了,又或者把手机扔到洗衣机洗刷刷。

  • 符合开闭原则,如果需要新增一个【观察者】,只需要写一个类去实现【抽象观察者角色】即可,不需要改动原来的代码。

缺点:

  • 客户端必须知道所有的【观察者】,并且进行【增加观察者】和【删除观察者】的操作。

  • 如果有很多【观察者】,那么所有的【观察者】收到通知,可能需要花费很久时间。

当然以上优缺点,是最直观的,可以很容易理解,并且体会到的。其他优缺点,可以自行百度。

Lambda

在介绍这种写法之前,有必要介绍下函数式接口函数式接口的概念由来已久,一般来说只定义了一个虚方法的接口就叫函数式接口,在Java8中,由于Lambda表达式的出现,让函数式接口大放异彩。

我们仅仅需要修改客户端的代码就可以:

  1.     public static void main(String[] args) {
  2.         Subject subject = new NewsSubject();
  3.         subject.add(-> System.out.println("已阅这新闻"));
  4.         subject.add(-> System.out.println("假的吧"));
  5.         subject.add(-> System.out.println("昨天就看过了"));
  6.         subject.update();
  7.     }

运行结果:
image.png

利用Lambda表达式和函数式接口,可以省去【具体观察者角色】的定义,但是个人认为,这并非属于严格意义上的观察者模式,而且弊端很明显:

  • 客户端需要知道观察者的具体实现。

  • 如果观察者的具体实现比较复杂,可能代码并没有那么清晰。

所以这种写法,具有一定的局限性。

借用大神的一句话

设计模式的出现,是为了弥补语言的缺陷。

正是由于语言的升级,让某些设计模式发生了一定的变化,除了观察者模式,还有模板方法模式、责任链模式等,都由于 Lambda表达式的出现,而出现了一些变化。

JDK

在Java中,本身就提供了一个接口:Observer,一个子类:Observable,其中Observer表示【观察者】,Observable表示【主题】,可以利用这两个子类和接口来实现观察者模式:

  1. public class NewsObservable extends Observable {
  2.     public void update() {
  3.        setChanged();
  4.        notifyObservers();
  5.     }
  6. }
  1. public class People1 implements Observer {
  2.     @Override
  3.     public void update(Observable o, Object arg) {
  4.         System.out.println("小编真无聊");
  5.     }
  6. }
  1. public class People2 implements Observer {
  2.     @Override
  3.     public void update(Observable o, Object arg) {
  4.         System.out.println("开局一张图,内容全靠编");
  5.     }
  6. }

客户端:

  1.   public static void main(String[] args) {
  2.         NewsObservable newsObservable = new NewsObservable();
  3.         newsObservable.addObserver(new People1());
  4.         newsObservable.addObserver(new People2());
  5.         newsObservable.update();
  6.     }

运行结果:
image.png

在这里,我不打算详细介绍这种实现方式,因为从Java9开始,Java已经不推荐这种写法了,而推荐用消息队列来实现。是不是很开心,找到一个借口不去研究Observable,Observer 这两个东西了。

Spring中的事件编程模型

Spring中的事件编程模型就是观察者模式的实现,SpringBoot就利用了Spring的事件编程模型来完成一些操作,这里暂时不表。

在Spring中定义了一个ApplicationListener接口,从名字就知道它是一个监听器,是监听Application的事件的,那么Application又是什么,就是ApplicationContext,ApplicationContext内置了几个事件,其中比较容易理解的是:

  • ContextRefreshedEvent

  • ContextStartedEvent

  • ContextStoppedEvent

  • ContextClosedEvent
    从名称上来看,就知道这几个事件是什么时候被触发的了。

下面我演示下具体的用法,比如我想监听ContextRefreshedEvent事件,如果事件发生了,就打印一句话。

  1. @Component
  2. public class MyListener implements ApplicationListener{
  3.     @Override
  4.     public void onApplicationEvent(ApplicationEvent applicationEvent) {
  5.         if(applicationEvent  instanceof ContextRefreshedEvent){
  6.             System.out.println("刷新了");
  7.         }
  8.     }
  9. }
  1. @Configuration
  2. @ComponentScan
  3. public class AppConfig {
  4. }
  1.     public static void main(String[] args) {
  2.         AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(AppConfig.class);
  3.     }

运行结果:
image.png

当时学习Spring,看到Spring提供了各式各样的接口来让程序员们对Spring进行扩展,并且没有任何侵入性,我不得不佩服Spring的开发者们。这里也是,我们可以看到在客户端找不到任何关于“订阅事件”的影子。

这种实现方式不是太好,可以看到我们在方法内部做了一个判断:接收到的事件是否为ContextRefreshedEvent。

伟大的Spring还提供了泛型的ApplicationListener,我们可以通过泛型的ApplicationListener来完善上面的代码:

  1. @Component
  2. public class MyListener implements ApplicationListener<ContextRefreshedEvent> {
  3.     @Override
  4.     public void onApplicationEvent(ContextRefreshedEvent event) {
  5.         System.out.println("刷新了");
  6.     }
  7. }

我们还可以利用Spring中的事件编程模型来自定义事件,并且发布事件:

首先,我们需要定义一个事件,来实现ApplicationEvent接口,代表这是一个Application事件,其实上面所说的四个内置的事件也实现了ApplicationEvent接口:

  1. public class MyEvent extends ApplicationEvent {
  2.     public MyEvent(Object source) {
  3.         super(source);
  4.     }
  5. }

还需要定义一个监听器,当然,在这里需要监听MyEvent事件:

  1. @Component
  2. public class MyListener implements ApplicationListener<MyEvent> {
  3.     @Override
  4.     public void onApplicationEvent(MyEvent event) {
  5.         System.out.println("我订阅的事件已经到达");
  6.     }
  7. }

现在有了事件,也有了监听器,是不是还少了发布者,不然谁去发布事件呢?

  1. @Component
  2. public class MyEventPublish implements ApplicationEventPublisherAware {
  3.  
  4.     private ApplicationEventPublisher publisher;
  5.  
  6.     @Override
  7.     public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
  8.         this.publisher = applicationEventPublisher;
  9.     }
  10.  
  11.     public void publish(Object obj) {
  12.         this.publisher.publishEvent(obj);
  13.     }
  14. }

发布者,需要实现ApplicationEventPublisherAware 接口,重写publish方法,顾名思义,这就是发布方法,那么方法的参数obj是干嘛的呢,作为发布者,应该需要知道我要发布什么事件,以及事件来源(是谁触发的)把,这个obj就是用来存放这样的数据的,当然,这个参数需要我们手动传入进去。setApplicationEventPublisher是Spring内部主动调用的,可以简单的理解为初始化发布者。

现在就剩最后一个角色了,监听器有了,发布者有了,事件也有了,对,没错,还少一个触发者,毕竟要有触发者去触发事件啊:

  1. @Component
  2. public class Service {
  3.  
  4.     @Autowired
  5.     private  MyEventPublish publish;
  6.  
  7.     public void publish() {
  8.         publish.publish(new MyEvent(this));
  9.     }
  10. }

其中publish方法就是给客户端调用的,用来触发事件,可以很清楚的看到传入了new MyEvent(this),这样发布者就可以知道我要触发什么事件和是谁触发了事件。

当然,还需要把一切交给Spring管理:

  1. @Configuration
  2. @ComponentScan
  3. public class AppConfig {
  4. }

客户端:

  1.     public static void main(String[] args) {
  2.         AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(AppConfig.class);
  3.         context.getBean(Service.class).publish();;
  4.     }

运行结果:
image.png

这一篇博客比较简单,只是简单的应用,但是只有会了应用,才能谈源码。

这篇博客到这里就结束了,谢谢大家。

原文链接:http://www.cnblogs.com/CodeBear/p/10423834.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号