- 浏览: 467815 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (272)
- java基础 (59)
- struts (8)
- spring (8)
- 数据库 (8)
- java 网络编程 (29)
- hibernate (3)
- JavaScript (10)
- 日志管理 (2)
- jsp (4)
- servlet (7)
- xml (4)
- ajax (2)
- web service (4)
- 算法与数据结构 (13)
- java 反射机制 (11)
- java 泛型 (3)
- java I/O (8)
- java 线程 (12)
- JavaEE (6)
- java解惑 (33)
- 工具 (5)
- MyEclipse编程实践 (1)
- OSGI (2)
- 设计模式 (9)
- 正则表达式 (0)
- EJB (3)
- Ubuntu linux (6)
- Android (1)
- web前端 (2)
- 找工作 (1)
- SCA (1)
- maven (1)
- 缓存 (1)
- json (1)
- javamail (1)
- 工作笔记 (2)
最新评论
-
霜花似雪:
博主可以分享一下源码吗?
使用maven构建web项目实例 -
王庆波-行:
很好的demo!
memcache使用实例 -
surpassno:
大写的牛逼
java可视化显示内存使用情况 -
zhulin0504:
怎么访问NetEcho.html页面呀???
applet与servlet的网络通信 -
springdata:
java多线程实例demo源代码下载:http://www.z ...
java多线程例子
问题引人:订阅报纸的过程:
订阅者---》邮局-----》报社 (订阅过程) ,当报社按照出报时间推出报纸时,将报纸交给邮局,邮局再交给订阅者,当报社有新报纸出版的时候,如何让多个订阅者知道呢?进一步抽象描述这个问题:当一个对象的状态发生改变的时候,如何让依赖于它的所有对象得到通知,并进行相应的处理呢?------》观察者模式
定义:定义对象间的一种一对多的关系,当一个对象状态发生变化,依赖于此对象的所有对象都会得到通知,并自动更新。
一个报纸对象会有多个人阅读,当报纸状态改变时,需要通知所有的订阅者。这就是典型的一对多关系。
观察者模式将多个订阅者称为观察者,obeserver,多个观察者观察的对象被称为目标:subject。
观察者模式的结构:
Subject:目标对象,一个目标可以被多个观察者观察,目标提供对观察者的注册和退订的维护,目标状态变化时,目标负责通知所有的观察者
Observer:定义观察者接口,提供目标通知时的更新方法。
ConcreteSubject:具体目标对象,用来维护目标状态。
ConcreteObserver:观察者具体实现对象,用来接收目标的通知,并进行相应的后续处理,比如更新自己的状态等。
其示例代码见包observer中。
解决上述问题:报纸为目标对象,阅报人为观察者,见observerSolve包
观察者和目标是单向的,即只有观察者依赖目标,目标是处于主动地位的,如果一个观察者观察多个目标,就需要定义多个回调函数,即多个update函数。
在观察者模式中,又存在推模型和拉模型
推:目标对象主动向观察者推送目标的详细信息,不管观察者是否需要,相当于在广播通信。
拉:目标对象通知观察者时,只传递少量信息。如果观察者需要更多,由观察者到目标对象主动获取。前面实例是典型的拉模型
推模型实例见pushObserver
java中的观察者模式,java.util包中的Observer接口,定义了update方法,就是观察者接口,Observable类,实现类大部分我们需要的目标的功能
本质:触发联动
swing就相当于观察者模式
简单变形示例=====区别对待观察者(前面的示例中,观察者对于目标对象而言都是平等的)
水质监测,涉及到监测员,预警人,和监测部门领导,水质正常污染,无需将状态传递给所有的观察者,传给监测员,以此类推。。。
见waterPollution包中示例
package waterPollution;
public class Client {
public static void main(String[] args) {
WaterQuality subject = new WaterQuality();//创建水质对象
// 创建几个观察者
WatcherObserver w1 = new Watcher();
w1.setJob("监测员");
WatcherObserver w2 = new Watcher();
w2.setJob("预警人员");
WatcherObserver w3 = new Watcher();
w3.setJob("监测部门领导");
// 注册观察者
subject.attach(w3);
subject.attach(w2);
subject.attach(w1);
System.out.println("当水质为正常的时候------------");
subject.setPolluteLevel(0);
System.out.println("当水质为轻度污染的时候------------");
subject.setPolluteLevel(1);
System.out.println("当水质为中度污染的时候------------");
subject.setPolluteLevel(2);
}
}
执行结果:
当水质为正常的时候------------
监测员获取到通知,当前污染级别为:0
当水质为轻度污染的时候------------
预警人员获取到通知,当前污染级别为:1
监测员获取到通知,当前污染级别为:1
当水质为中度污染的时候------------
监测部门领导获取到通知,当前污染级别为:2
预警人员获取到通知,当前污染级别为:2
监测员获取到通知,当前污染级别为:2
订阅者---》邮局-----》报社 (订阅过程) ,当报社按照出报时间推出报纸时,将报纸交给邮局,邮局再交给订阅者,当报社有新报纸出版的时候,如何让多个订阅者知道呢?进一步抽象描述这个问题:当一个对象的状态发生改变的时候,如何让依赖于它的所有对象得到通知,并进行相应的处理呢?------》观察者模式
定义:定义对象间的一种一对多的关系,当一个对象状态发生变化,依赖于此对象的所有对象都会得到通知,并自动更新。
一个报纸对象会有多个人阅读,当报纸状态改变时,需要通知所有的订阅者。这就是典型的一对多关系。
观察者模式将多个订阅者称为观察者,obeserver,多个观察者观察的对象被称为目标:subject。
观察者模式的结构:
Subject:目标对象,一个目标可以被多个观察者观察,目标提供对观察者的注册和退订的维护,目标状态变化时,目标负责通知所有的观察者
Observer:定义观察者接口,提供目标通知时的更新方法。
ConcreteSubject:具体目标对象,用来维护目标状态。
ConcreteObserver:观察者具体实现对象,用来接收目标的通知,并进行相应的后续处理,比如更新自己的状态等。
其示例代码见包observer中。
package observer; //观察者接口,定义一个更新的接口,当目标发生变化时,更新 public interface Observer { public void update(Subject subject); }
package observer; public class ConcreteObserver implements Observer { private String observerState; // 观察者状态 @Override public void update(Subject subject) { // 示意方法,使其与目标对象状态一致 observerState = ((ConcreteSubject) subject).getSubjectState(); } }
package observer; import java.util.ArrayList; import java.util.List; //目标对象,它知道观察它的观察者,如报社知道报纸订阅人 public class Subject { //用于保存注册的观察者对象,如报社包含报纸的订阅人列表 private List<Observer> observers = new ArrayList<Observer>(); // 注册观察者 public void attach(Observer observer){ observers.add(observer); } // 删除观察者 public void detach(Observer observer){ observers.remove(observer); } //通知所有注册的观察者对象, protected void notifyObservers(){ for(Observer observer:observers){ observer.update(this); } } }
package observer; //具体的目标对象 public class ConcreteSubject extends Subject { // 示意,目标对象的状态 private String subjectState; public String getSubjectState() { return subjectState; } public void setSubjectState(String subjectState) { this.subjectState = subjectState; // 状态发生变化,通知所有的观察者 this.notifyObservers(); } }
解决上述问题:报纸为目标对象,阅报人为观察者,见observerSolve包
package observerSolve; //观察者接口,定义一个更新的接口,当目标发生变化时,更新 public interface Observer { public void update(Subject subject); }
package observerSolve; public class Reader implements Observer { private String name; @Override public void update(Subject subject) { //被通知后执行的操作,这里是拉的方式,观察者会回调目标对象的方法 System.out.println(name+"收到报纸了,阅读它。内容是==="+((NewsPaper) subject).getContent()); } public String getName() { return name; } public void setName(String name) { this.name = name; } }
package observerSolve; import java.util.ArrayList; import java.util.List; //目标对象,它知道观察它的观察者,如报社知道报纸订阅人 public class Subject { //用于保存注册的观察者对象,如报社包含报纸的订阅人列表 private List<Observer> observers = new ArrayList<Observer>(); // 注册观察者,即订阅人 public void attach(Observer observer){ observers.add(observer); } // 删除观察者,可以取消订阅 public void detach(Observer observer){ observers.remove(observer); } //通知所有注册的观察者对象,每当报纸印刷出来后,就迅速通知读者 protected void notifyObservers(){ for(Observer observer:observers){ observer.update(this); } } }
package observerSolve; public class NewsPaper extends Subject { // 报纸的内容 private String content; public String getContent() { return content; } public void setContent(String content) { this.content = content; this.notifyObservers(); //内容有了,说明出了新报纸了,就通知所有的读者 } }
package observerSolve; public class Client { public static void main(String[] args){ //创建目标对象,报纸 NewsPaper news = new NewsPaper(); // 创建观察者,即阅读者 Reader r1 = new Reader(); r1.setName("张三"); Reader r2 = new Reader(); r2.setName("李四"); Reader r3 = new Reader(); r3.setName("王五"); // 将观察者注册到目标对象中去 news.attach(r3); news.attach(r2); news.attach(r1); // 目标对象内容改变,即要出报纸了 news.setContent("学习设计模式"); } }
观察者和目标是单向的,即只有观察者依赖目标,目标是处于主动地位的,如果一个观察者观察多个目标,就需要定义多个回调函数,即多个update函数。
在观察者模式中,又存在推模型和拉模型
推:目标对象主动向观察者推送目标的详细信息,不管观察者是否需要,相当于在广播通信。
拉:目标对象通知观察者时,只传递少量信息。如果观察者需要更多,由观察者到目标对象主动获取。前面实例是典型的拉模型
推模型实例见pushObserver
java中的观察者模式,java.util包中的Observer接口,定义了update方法,就是观察者接口,Observable类,实现类大部分我们需要的目标的功能
package javaObserver; import java.util.Observable; //报纸对象,具体的目标实现,利用java的类,无需Subject类 public class NewsPaper extends Observable { // 报纸的内容 private String content; public String getContent() { return content; } public void setContent(String content) { this.content = content; this.setChanged();//在用java中的观察者模式时,这句必不可少 this.notifyObservers(this.content); //内容有了,说明出了新报纸了,就通知所有的读者,推的方式 // this.notifyObservers();//拉的方式 } public String toString(){ return content; } }
package javaObserver; import java.util.Observable; import java.util.Observer; public class Reader implements Observer { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public void update(Observable o, Object arg) { System.out.println(name+"收到报纸了,阅读它。目标对象推过来的内容是==="+o); //推方式 System.out.println(name+"收到报纸了,阅读它。主动去目标对象去拉的内容是==="+((NewsPaper) o).getContent()); //拉方式 } }
package javaObserver; public class Client { public static void main(String[] args){ //创建目标对象,报纸 NewsPaper news = new NewsPaper(); // 创建观察者,即阅读者 Reader r1 = new Reader(); r1.setName("张三"); Reader r2 = new Reader(); r2.setName("李四"); Reader r3 = new Reader(); r3.setName("王五"); // 将观察者注册到目标对象中去,java中的类方法 news.addObserver(r1); news.addObserver(r2); news.addObserver(r3); // 目标对象内容改变,即要出报纸了 news.setContent("学习设计模式"); } }
本质:触发联动
swing就相当于观察者模式
简单变形示例=====区别对待观察者(前面的示例中,观察者对于目标对象而言都是平等的)
水质监测,涉及到监测员,预警人,和监测部门领导,水质正常污染,无需将状态传递给所有的观察者,传给监测员,以此类推。。。
见waterPollution包中示例
package waterPollution; //水质观察者的接口 public interface WatcherObserver { public void update(WaterQualitySubject subject); public void setJob(String job); //设置观察者职务 public String getJob(); }
package waterPollution; import javaObserver.NewsPaper; //具体的观察者实现 public class Watcher implements WatcherObserver { private String job; @Override public String getJob() { return job; } @Override public void setJob(String job) { this.job = job; } @Override public void update(WaterQualitySubject subject) { // 采用拉方式 System.out.println(job+"获取到通知,当前污染级别为:"+subject.getPolluteLevel()); //拉方式 } }
package waterPollution; import java.util.ArrayList; import java.util.List; import observer.Observer; public abstract class WaterQualitySubject { protected List<WatcherObserver> observers = new ArrayList<WatcherObserver>(); // 注册观察者 public void attach(WatcherObserver observer){ observers.add(observer); } // 删除观察者 public void detach(WatcherObserver observer){ observers.remove(observer); } //通知所有注册的观察者对象, public abstract void notifyWatchers(); public abstract int getPolluteLevel(); }
package waterPollution; //具体的水质监测对象 public class WaterQuality extends WaterQualitySubject { private int polluteLevel = 0; @Override public int getPolluteLevel() { return polluteLevel; } public void setPolluteLevel(int polluteLevel) { this.polluteLevel = polluteLevel; this.notifyWatchers(); } @Override public void notifyWatchers() { // 根据污染级别不同,通知的人员也不同,这里观察者不是同级的了 // 循环所有注册的观察者 for (WatcherObserver observer : observers) { // 根据污染级别判断是否需要通知, if (this.polluteLevel >= 0) { // 通知监测员做记录 if ("监测员".equals(observer.getJob())) { observer.update(this); } } if (polluteLevel >= 1) { // 通知预警人员 if ("预警人员".equals(observer.getJob())) { observer.update(this); } } if (this.polluteLevel >= 2) { // 通知监测部门领导 if ("监测部门领导".equals(observer.getJob())) { observer.update(this); } } } } }
package waterPollution;
public class Client {
public static void main(String[] args) {
WaterQuality subject = new WaterQuality();//创建水质对象
// 创建几个观察者
WatcherObserver w1 = new Watcher();
w1.setJob("监测员");
WatcherObserver w2 = new Watcher();
w2.setJob("预警人员");
WatcherObserver w3 = new Watcher();
w3.setJob("监测部门领导");
// 注册观察者
subject.attach(w3);
subject.attach(w2);
subject.attach(w1);
System.out.println("当水质为正常的时候------------");
subject.setPolluteLevel(0);
System.out.println("当水质为轻度污染的时候------------");
subject.setPolluteLevel(1);
System.out.println("当水质为中度污染的时候------------");
subject.setPolluteLevel(2);
}
}
执行结果:
当水质为正常的时候------------
监测员获取到通知,当前污染级别为:0
当水质为轻度污染的时候------------
预警人员获取到通知,当前污染级别为:1
监测员获取到通知,当前污染级别为:1
当水质为中度污染的时候------------
监测部门领导获取到通知,当前污染级别为:2
预警人员获取到通知,当前污染级别为:2
监测员获取到通知,当前污染级别为:2
- observer.rar (24.8 KB)
- 下载次数: 2
发表评论
-
中介者模式(mediator)
2011-05-06 15:37 842电脑的各个配件之间的 ... -
享元模式flyweight
2011-05-06 15:08 934问题引人:给系统加入权限控制,如普通人员可以查看本部门人员列表 ... -
责任链设计模式chainOfResponsibility
2011-05-06 14:50 1006问题引人:申请聚餐费用,申请人填写申请单,然后交给领导审阅,如 ... -
生成器模式builder
2011-05-06 14:37 1043问题引人:继续导出数据的应用框架 讨论工厂方法模式时,提到了一 ... -
外观模式facade
2011-05-06 14:24 941生活中的示例:组装电 ... -
适配器模式adapter,含源码下载
2011-05-06 12:49 939引出:组装电脑例子,向电脑加入新硬盘,但电源和新的硬盘的电源接 ... -
抽象工厂模式abstractFactory
2011-05-06 12:38 1017具体的实现代码见附件 ... -
原型设计模式prototype
2011-05-06 11:30 1332基于《研磨设计模式》,没什么实质突破,简单的记录一下 问题引人 ...
相关推荐
观察者模式(Observer)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式在软件开发中广泛应用于事件处理和实时...
Swift µframework 实现观察者模式Observer pattern
"ObserverPattern(订阅模式)3.zip"中的代码可能进一步阐述了观察者模式,这里的“订阅”一词可能意味着用户可以订阅特定的主题,只有当这些主题的状态改变时,用户才会收到通知。这与传统的观察者模式类似,但更加...
观察者模式(Observer)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式在C++中广泛应用,特别是在需要...
观察者模式(Observer)是软件设计模式中的一种行为模式,其主要目的是在对象之间建立一种松散耦合的关系,使得当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式广泛应用于事件驱动...
观察者模式(Observer)是一种行为设计模式,它允许你定义一个订阅机制,可以在对象状态变化时通知多个“观察”该对象的其他对象。这个模式在软件工程中扮演着重要角色,尤其是在事件驱动编程和发布/订阅系统中。...
观察者模式的核心概念是主体(Subject)和观察者(Observer)。主体是被观察的对象,它维护了一个观察者列表,并提供了添加、删除观察者以及通知所有观察者的接口。观察者关注主体的状态变化,并在主体状态改变时...
观察者模式(Observer)是一种行为设计模式,它允许你定义一个订阅机制,可以在对象状态变化时通知多个“观察”该对象的其他对象。这个模式在软件工程中广泛应用于事件驱动编程,例如用户界面组件的交互或者系统状态的...
观察者模式(Observer Pattern)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式常用于实现事件驱动的系统或者...
观察者模式通常的叫法叫做订阅-发布模式,类似于报刊杂志的订阅,观察者和被观察者就是读者和邮局的关系,读者先要在邮局订阅想要的报刊,当报刊发行时,邮局会将报刊邮寄到读者家里。观察者(Observer)和被观察者...
观察者模式(Observer Pattern)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式在软件开发中广泛应用于事件驱动...
**C#面向对象设计模式纵横谈(19)**:**观察者模式**(Observer Pattern)是行为型模式的一种,它在软件工程中扮演着至关重要的角色。观察者模式是一种设计模式,它定义了对象之间的一对多依赖关系,当一个对象的状态...
观察者模式 概述 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。 适用性 1.当一个抽象模型有两个方面,其中一个方面依赖于另一方面。 将这二者封装...
观察者模式(Observer)是一种设计模式,它定义了对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。在MFC(Microsoft Foundation Classes)框架中,我们可以...
观察者模式详解 观察者模式是23种设计模式中的一种,尤其是在软件设计过程中体现的更是立足无穷。本文将详细讲解观察者模式的概念和实现,通过代码注释来解释各个组件的作用。 一、观察者模式的定义 观察者模式是...
观察者模式(Observer Pattern)是一种行为设计模式,它允许你定义一个订阅机制,可以在对象状态改变时通知多个“观察”该对象的其他对象。在软件工程中,这常用于实现事件驱动编程,使得系统能够及时响应变化。 在...
观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动编程或者...
观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现发布-订阅...