设计模式---观察者模式(Observer Pattern with java)

最新推荐文章于 2024-09-07 07:00:00 发布
最新推荐文章于 2024-09-07 07:00:00 发布
阅读量356 收藏
点赞数
分类专栏： Java 文章标签： 设计


概述

观察者模式(有时又被称为发布/订阅模式)是软体设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。

 

先看一个例子

有个小孩在睡觉，醒来之后要喂奶。

我们使用的是java，所以不要闹出下面的笑话（披着面向对象的面向过程）：

?
1
2
3
4
5
6
7
public class Simulation {
     public static void main(String... args) {
         //小孩睡觉
         //起来之后爸爸喂奶
         //...
     }
}

 

我们根据面向对象思想，加上多线程模拟Child和Dad，小孩在睡觉，随时可以起来，Dad隔一段时间看下小孩是否醒来。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package observer;
import java.util.Random;
class Child implements Runnable {
     public static Random r = new Random();
     private boolean wake = false ;
     public Child() {
         new Thread( this ).start();
     }
     @Override
     public void run() {
         while (!wake) {
             System.out.println( "Child:I am sleeping..." );
             try {
                 Thread.sleep( 1000 );
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             if (r.nextInt( 10 ) > 8 ) {
                 wakeUp();
             }
         }
     }
     public void wakeUp() {
         wake = true ;
     }
     public boolean isWake() {
         return wake;
     }
}
 
class Dad implements Runnable {
     private Child c;
     public Dad(Child c) {
         new Thread( this ).start();
         this .c = c;
     }
     @Override
     public void run() {
         while (!c.isWake()) {
             System.out.println( "Dad:child is sleeping..." );
             try {
                 Thread.sleep( 1000 );
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         feed(c);
     }
     private void feed(Child c2) {
         System.out.println( "feed child!" );
     }
}
 
public class FirstQuestion {
     public static void main(String[] args) {
         new Dad( new Child());
     }
}

这样可以实现功能，但造成资源的浪费。开了这么多线程，Dad时间都用在看小孩身上了,Dad下午打牌的计划泡汤了。我们可以很容易的把Dad解放出来：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class Child implements Runnable {
     public static Random r = new Random();
     private Dad d;
     private boolean wake = false ;
     public Child(Dad d) {
         this .d = d;
     }
     @Override
     public void run() {
         while (!wake) {
             System.out.println( "Child:I am sleeping..." );
             try {
                 Thread.sleep( 1000 );
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             if (r.nextInt( 10 ) > 8 ) {
                 wakeUp();
             }
         }
     }
     public void wakeUp() {
         wake = true ;
         d.feed( this );
     }
     public boolean isWake() {
         return wake;
     }
}
class Dad {
     public void feed(Child c) {
         System.out.println( "feed child!" );
     }
 
}
public class FirstQuestion {
     public static void main(String[] args) {
         new Thread( new Child( new Dad())).start();
     }
}

这样基本已经实现功能，稍微完善下，假如想知道小孩什么时候起来等一些信息，如果我们写在小孩类中就不太合适，所以我们抽象出类中WakenUpEvent:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class WakenUpEvent {
     private Date date;
     private String loc;
     private Dad dad;
     public WakenUpEvent(Date date, String loc, Dad dad) {
         super ();
         this .date = date;
         this .loc = loc;
         this .dad = dad;
     }
}
class Child implements Runnable {
     private Dad d;
     public Child(Dad d) {
         this .d = d;
     }
     @Override
     public void run() {
         try {
             Thread.sleep( 5000 );
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         wakeUp();
     }
     public void wakeUp() {
         d.actionToWakenUp( new WakenUpEvent( new Date(), "child" , d));
     }
}
 
class Dad {
     public void actionToWakenUp(WakenUpEvent wakenUpEvent) {
         System.out.println( "child feed!" );
     }
}
public class FirstQuestion {
     public static void main(String[] args) {
         new Thread( new Child( new Dad())).start();
     }
}

 

这样Dad可以做自己事，只要听到孩子声音，就过来喂奶。似乎问题已经解决，假如小孩醒后，小孩的爷爷想抱下，小孩家的小狗要叫下，等等，如果按照上面的设计，小孩需要持有爷爷GrandFather、狗Dog等的引用，再调用用响应的处理方法…需要修改较大的篇幅。实际上我们可以在小孩中使用一个集合存储所有监听小孩的对象，当小孩醒后，小孩依次调用监听者处理方法。要实现统一的接口，以可以被小孩监听器集合引用和调用相应方法，我们使用接口interface。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class WakenUpEvent {
     private Date date;
     private String eventType;
     private Object source;
     public WakenUpEvent(Date date, String eventType, Object source) {
         this .date = date;
         this .eventType = eventType;
         this .source = source;
     }
}
 
class Child implements Runnable {
     private List<WakenUpListener> list = new ArrayList<WakenUpListener>();
     public void addWakenUpListener(WakenUpListener l) {
         list.add(l);
     }
     @Override
     public void run() {
         System.out.println( "child is sleeping..." );
         try {
             Thread.sleep( 2000 );
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         wakeUp();
     }
     public void wakeUp() {
         for (WakenUpListener l : list) {
             l.actionWakenUp( new WakenUpEvent( new Date(), "" , this ));
         }
     }
}
interface WakenUpListener {
     void actionWakenUp(WakenUpEvent e);
}
class Dad implements WakenUpListener {
     @Override
     public void actionWakenUp(WakenUpEvent e) {
         System.out.println( "dad feed child!" );
     }
}
class GrandFather implements WakenUpListener {
     @Override
     public void actionWakenUp(WakenUpEvent e) {
         System.out.println( "grandfather holl child!" );
     }
}
public class FirstQuestion {
     public static void main(String[] args) {
         Child c = new Child();
         c.addWakenUpListener( new Dad());
         c.addWakenUpListener( new GrandFather());
         new Thread(c).start();
     }
}

 

这个时候再看概述的例子，比较容易理解了吧！

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。[GOF 《设计模式》]

 

观察者模式中的推模式与拉模式[摘录]

在Observer模式中区分推模式和拉模式，先简单的解释一下两者的区别：推模式是当有消息时，把消息信息以参数的形式传递（推）给所有观察者，而拉模式是当有消息时，通知消息的方法本身并不带任何的参数，是由观察者自己到主体对象那儿取回（拉）消息。知道了这一点，大家可能很容易发现上面我所举的例子其实是一种推模式的Observer模式。我们先看看这种模式带来了什么好处：当有消息时，所有的观察者都会直接得到全部的消息，并进行相应的处理程序，与主体对象没什么关系，两者之间的关系是一种松散耦合。但是它也有缺陷，第一是所有的观察者得到的消息是一样的，也许有些信息对某个观察者来说根本就用不上，也就是观察者不能“按需所取”；第二，当通知消息的参数有变化时，所有的观察者对象都要变化。鉴于以上问题，拉模式就应运而生了，它是由观察者自己主动去取消息，需要什么信息，就可以取什么，不会像推模式那样得到所有的消息参数。OK，说到这儿，你是否对于推模式和拉模式有了一点了解呢？

实际上上面的代码中，因java中awt事件的影响，我在Event中加入了source字段，这算是拉模式的一种体现。我们可以得到公共的事件信息，也可以通过source得到发出事件对象的信息。

 

AWT事件模拟

说到AWT事件，我们根据上面的思路模拟下awt事件处理，观察者模式实现awt事件功能更加简单优雅，然而真正的awt也需要windows本身的事件驱动的支持，比如你按下某个button，首先windows捕获这个消息，把消息分发给java虚拟机，虚拟机在调用button相应的处理，button调用监听器处理（个人理解）。一般awt事件处理：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class AwtButton extends Frame {
     public void lanch() {
         Button b = new Button( "test" );
         b.addActionListener( new MyActionListener());
         b.addActionListener( new MyActionListener1());
         this .add(b);
         this .addWindowListener( new WindowAdapter() {
             @Override
             public void windowClosing(WindowEvent e) {
                 System.exit( 0 );
             }
         });
         setSize( 100 , 100 );
         setVisible( true );
     }
     public static void main(String[] args) {
         new AwtButton().lanch();
     }
     class MyActionListener implements ActionListener {
         @Override
         public void actionPerformed(ActionEvent e) {
             System.out.println( "button pressed!" );
         }
     }
     class MyActionListener1 implements ActionListener {
         @Override
         public void actionPerformed(ActionEvent e) {
             System.out.println( "button pressed1!" );
         }
     }
}

 

结合上面的孩子的例子，我们使用控制台模拟awt事件：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class SimulationAwtButton {
     public static void main(String[] args) {
         Button b = new Button();
         b.addActionListener( new MyActionListener1());
         b.addActionListener( new MyActionListener2());
         b.pressed();
     }
}
class Button {
     private List<ActionListener> list = new ArrayList<ActionListener>();
     public void addActionListener(ActionListener l) {
         list.add(l);
     }
     public void pressed() {
         ActionEvent e = new ActionEvent( this );
         for (ActionListener l : list) {
             l.actionPerform(e);
         }
     }
}
interface ActionListener {
     void actionPerform(ActionEvent e) ;
}
class ActionEvent {
     private long time;
     private Object source;
     public ActionEvent(Object source) {
         this .time = System.currentTimeMillis();
         this .source = source;
     }
     public long getTime() {
         return time;
     }
     public Object getSource() {
         return source;
     }
}
class MyActionListener1 implements ActionListener {
     @Override
     public void actionPerform(ActionEvent e) {
         System.out.println( "SimulationButton ActionPerformed:" +e.getTime() + e.getSource());
     }
}
class MyActionListener2 implements ActionListener {
     @Override
     public void actionPerform(ActionEvent e) {
         System.out.println( "SimulationButton ActionPerformed:" +e.getTime() + e.getSource());
     }
}

 

这样，对java送awt事件处理有了更深的认识。

 

适用性

1．当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

2．当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。

3．当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

总结

通过Observer模式，把一对多对象之间的通知依赖关系的变得更为松散，大大地提高了程序的可维护性和可扩展性，也很好的符合了开放-封闭原则。

freellf
关注
专栏目录
Java 设计模式——观察者模式（Observer Pattern）
斌林诚上的博客
11-24 545
    前言 一、简介 二、实现步骤 （1）实现方式： （2）举例： （3）步骤简化版： 三、代码实现 四、总结 五、Demo地址 六、参考文档 七、内容推荐 前言 本来没想写前言的，感觉就是一堆废话。那就当废话浏览一下吧，只是提醒一下自己一些注意的东西。 在许多博客当中看到把观察者模式又称呼为发布-订阅模式。其实我感觉两者确实很相似，但还是有一丢丢的区别： 在...
设计模式(二) - 观察者模式(Observer Pattern)
Eric Chan's blog
01-28 300
一、什么是观察者模式？ 观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。 观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。 [观察者模式-类图] 观察者模式(Observe
设计模式-观察者模式-Observer Pattern
wesigj的博客
09-07 830
观察者模式的优点包括实现了观察者和被观察者之间的解耦，增加了程序的可扩展性，并且可以动态地添加或移除观察者。：观察者模式能够将被观察者（Subject）和观察者（Observer）解耦，使得被观察者的改变不会直接影响到观察者，两者之间的依赖关系降低。：在需要实现通知和消息传递的系统中，观察者模式可以用来通知用户或系统组件关于状态变化的信息，如电子邮件客户端中的新邮件通知。：在观察者模式中，如果一个观察者在更新时发生错误，可能会影响到其他观察者的更新，这需要在设计时考虑错误处理机制。
设计模式-观察者模式（Observer Pattern）
YUMIAloogy的博客~
05-31 978
本文结合代码详细地介绍了观察者模式的概念，适用场景，优缺点、实现方式，可以帮助读者更好地理解观察者模式
设计模式-观察者模式-作业-observer.zip
08-27
观察者模式（Observer Pattern）是软件设计模式中的行为模式之一，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动或发布-...
java常用设计模式-观察者模式
08-28
观察者模式（Observer Pattern）是一种行为设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。该模式适用于需要在对象间建立动态的、松散耦合的关系的...
observer-pattern-demo 观察者模式示例
02-18
观察者模式（Observer Pattern）是一种行为设计模式，它允许你定义一个订阅机制，可以在对象状态改变时通知多个“观察”该对象的其他对象。在Java中，我们可以利用Java的内置接口`java.util.Observer`和`java.util....
design-pattern-observer:GOF观察者行为设计模式示例
05-02
观察者模式 行为模式 在对象之间定义一对多的依赖关系，以便当一个对象更改状态时，将自动通知和更新其所有依赖关系。 在此示例中，我们要监视节点上的子创建/删除事件（可用于监视文件夹） 源代码源于以下UML图：
设计模式--观察者模式java例子
02-06
观察者模式（Observer Pattern）是软件设计模式中的一种行为模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于事件驱动的系统或者...
网易招聘的scrapy spider
09-18
网易招聘的scrapy spider
ACM计算两整数相加的多语言代码示例与注解
最新发布
09-18
内容概要：提供了基于不同编程语言的一个简单的 ACN（以计算两个整数的和为例）源代码，涉及三种语言：C++, Java 和 Python。每个示例都包含了详细的步骤来演示用户输入是如何接收和进行运算以及结果显示出来的。 适用人群：编程初学者、有一定编程经验希望熟悉多种语言实现方式的技术爱好者。 使用场景及目标：帮助理解不同编程语言基本操作方法，包括输入获取、数据处理、输出结果展示及其语法差异等知识点的运用。 其他补充：由于例子较为简易，便于作为教学案例或是新手练习之用，亦可用于快速对比几种主流编程语言的基础应用形式和技术特点。
java-ssm+vue健身房管理系统实现源码(项目源码-说明文档)
09-18
会员管理页面提供给管理员的功能有：对会员信息的一个管理，不同会员看到的页面是不一样的，会员信息也是不同 健身房信息管理页面提供给管理员的功能有：查看已发布的健身房区域数据，修改健身房区域信息或更换健身房区域内容，健身房区域信息作废，即可删除。 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：ssm 前端技术：Vue 关键技术：springboot、SSM、vue、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
51Proteus仿真LCD1602+定时计数器实现可调电子时钟的编程
09-18
51Proteus仿真LCD1602+定时计数器实现可调电子时钟的编程
【高创新】基于侏儒猫鼬优化算法DMO-Transformer-BiLSTM实现故障识别Matlab实现.rar
09-18
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
Linux安装python3_脚本_linux_install_py3.zip
09-18
Linux安装python3_脚本_linux_install_py3
BWO-Catboost白鲸算法优化Catboost分类预测，优化前后对比（Matlab完整源码和数据）
09-18
1.Matlab实现BWO-Catboost白鲸算法优化Catboost分类预测，优化前后对比，Matlab调用Python的Catboost库（完整源码和数据）。 2.输出对比图、混淆矩阵图、预测准确率，运行环境Matlab2023及以上，配置Python的Catboost库。兼容测试链接：https://ww2.mathworks.cn/support/requirements/python-compatibility.html 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：机器学习之心，博客专家认证，机器学习领域创作者，2023博客之星TOP50，主做机器学习和深度学习时序、回归、分类、聚类和降维等程序设计和案例分析，文章底部有博主联系方式。从事Matlab、Python算法仿真工作8年，更多仿真源码、数据集定制私信
4-3_Business_GREEN_2017_02-CL-20180524MTAX.potx
09-18
微软演示材料
Java设计模式：实例解析观察者模式与应用
观察者模式（Observer Pattern），也称作订阅-发布模式，是设计模式之一，用于描述对象之间的一对多依赖关系。在这种模式中，主题（Subject）对象维护着一组观察者（Observer）对象，并在自身状态发生改变时主动通知...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值