观察者模式(Observer Pattern):定义对象间一对多的关系。当对象的状态发生改变时,使其所依赖的对象得到通知并自动更新。
优点:
a. 观察者和被观察者之间抽象耦合。
b. 建立一套触发机制。
缺点:
a. 开发效率和运行效率。
b. 调试复杂,消息的通知是按顺序的,如果有一个观察者卡壳,会影响到整体效率,考虑使用异步解决。
使用场景:
a. 关联的行为场景。
b. 事件多级触发。
c. 跨系统的消息交换。如消息队列处理机制。
注意事项:
a. 广播链的问题:一个观察者有可能是被观察者,在观察者模式中最多只能出现一对既是观察者又是被观察者。
b. 异步处理的问题。
项目中真实的观察者模式:
a. 观察者和被观察者间的消息沟通:即观察者的update方法中接受两个参数,一个是被观察者自己,二是DTO(Data Transfer Object,数据传输对象),若远程传输,可考虑XML格式。
b. 观察者的响应问题:观者者较多时,需考虑性能问题,解决方法:
a) 多线程。
b) 缓存技术,即同步结构。
c) 被观察者尽量自己做主:在doingSomething(boolean isNotifyObs),做为判断是否向观察者发布消息。
订阅发布模型:如EJB 3.0中的消息驱动Bean便是观察者模式的升级版。
实践:
a. 文件系统。如新建一个文件,通知目录管理器增加目录,通知磁盘管理器减少磁盘空间。
b. 猫鼠游戏。猫叫一声,老鼠跑,主人醒等。
c. ATM机取钱。多次输入错误密码,吞卡时触发:一连续快拍,二通知监控系统,吞卡发生,三初始化ATM屏幕。前两个由观察者模式,后一个由异常完成。
d. 广播收音机。电台是被观察者,收音机是观察者。
package org.observer;
//观察者接口
public interface Observer {
public void update();
}
package org.observer;
public class ConcreteObserver1 implements Observer {
// 具体观察者的业务逻辑
public void update() {
System.out.println("我是ConcreteObserver1");
}
}
package org.observer;
public class ConcreteObserver2 implements Observer {
public void update() {
System.out.println("我是ConcreteObserver2");
}
}
package org.observer;
import java.util.Iterator;
import java.util.Vector;
// 被观察者的抽象类,功能:添加观察者,删除观察者,向所有观察者发布广播信息
// 类似JAVA中的事件驱动
public class Subject {
private Vector<Observer> observers = new Vector<Observer>();
public void addObserver(Observer o) {
this.observers.add(o);
}
public void delObserver(Observer o) {
this.observers.remove(o);
}
public void notifyObservers() {
for (Observer o : this.observers) {
o.update();
}
}
}
package org.observer;
// 被观察者,也有自己的方法接口
public interface ConcreteSubjectImp {
public void firstMethod();
public void secondMethod();
}
package org.observer;
public class ConcreteSubject1 extends Subject implements ConcreteSubjectImp {
// 当调用第一个方法时,会向所有观察者发布消息
public void firstMethod() {
System.out.println("第一个方法");
super.notifyObservers();
System.out.println("-------------------------");
System.out.println();
}
// 当调用第二个方法时,会向所有观察者发布消息
public void secondMethod() {
System.out.println("第二个方法");
super.notifyObservers();
System.out.println("-------------------------");
System.out.println();
}
}
package org.observer;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
Observer concreteObserver1 = new ConcreteObserver1();
Observer concreteObserver2 = new ConcreteObserver2();
ConcreteSubject1 subject = new ConcreteSubject1();
subject.addObserver(concreteObserver1);
subject.addObserver(concreteObserver2);
subject.firstMethod();
subject.secondMethod();
}
}
通过java.util中的类实现观察者模式
package org.observer.jdk;
// 被观察者,也有自己的方法接口
public interface ConcreteSubjectImp {
public void firstMethod();
public void secondMethod();
}
package org.observer.jdk;
import java.util.Observable;
public class ConcreteSubject1 extends Observable implements ConcreteSubjectImp {
// 当调用第一个方法时,会向所有观察者发布消息
public void firstMethod() {
System.out.println("第一个方法");
super.setChanged();
super.notifyObservers("第一个方法");
System.out.println("-------------------------");
System.out.println();
}
// 当调用第二个方法时,会向所有观察者发布消息
public void secondMethod() {
System.out.println("第二个方法");
super.setChanged();
super.notifyObservers("第二个方法");
System.out.println("-------------------------");
System.out.println();
}
}
package org.observer.jdk;
import java.util.Observable;
import java.util.Observer;
public class ConcreteObserver1 implements Observer {
public void update(Observable o, Object arg) {
System.out.println("我是ConcreteObserver1"+"-----"+arg.toString());
}
}
package org.observer.jdk;
import java.util.Observable;
import java.util.Observer;
public class ConcreteObserver2 implements Observer {
public void update(Observable o, Object arg) {
System.out.println("我是ConcreteObserver2" + "-----" + arg.toString());
}
}
package org.observer.jdk;
public class Client {
public static void main(String[] args) {
ConcreteObserver1 concreteObserver1 = new ConcreteObserver1();
ConcreteObserver2 concreteObserver2 = new ConcreteObserver2();
ConcreteSubject1 subject = new ConcreteSubject1();
subject.addObserver(concreteObserver1);
subject.addObserver(concreteObserver2);
subject.firstMethod();
subject.secondMethod();
}
}
- 大小: 29.8 KB
分享到:
相关推荐
Swift µframework 实现观察者模式Observer pattern
设计模式之观察者模式ObserverPattern
我们说学习Java应该从Swing开始,那么学习Swing最重要的思想就是对于观察者模式的理解(Observer Pattern)。因为,该设计模式在Java Swing框架中贯穿了始终。对于C#的委托、代理概念所使用的Callback(回调模式--...
1、策略模式STRATEGY PATTERN ...16、观察者模式OBSERVER PATTERN 17、责任链模式 18、访问者模式VISITOR PATTERN 19、状态模式 20、原型模式 21、中介者模式 22、解释器模式 23、亨元模式 24、备忘录模式
定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。
从生活中的例子可以看出,只要对订阅号... 观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象,这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己的行为。
在设计一组依赖的对象与它们所依赖的对象之间一致(同步)的交流模型时,观察者模式(Observer Pattern)很有用。它可以使依赖对象的状态与它们所依赖的对象的状态保持同步。这组依赖的对象指的是观察者(Observer)...
观察者模式(Observer Pattern)是一种对象行为型设计模式,它定义了对象之间的一对多依赖关系。 当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式通常用于实现分布式事件处理系统...
observer-pattern-demo 观察者模式示例
主要介绍了C#观察者模式(Observer Pattern),主要以一个实例的形式讲述了C#观察者模式的实现过程,详细讲述了接口的定义、通知及动作的实现方法,需要的朋友可以参考下
主要介绍了JavaScript编程设计模式之观察者模式(Observer Pattern),简单说明了观察者模式的概念、原理并结合实例形式详细给出了观察者模式的相关实现与使用技巧,需要的朋友可以参考下
当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知它的依赖对象。观察者模式属于行为型模式。
ObserverPattern.unitypackage是一个以unity为例写的观察者模式的应用举例。有需要的同学请下载!
matlab开发-Observerpattern。观察者模式示例
我们某个报表界面现在有个dashboard的数据发生变化,需要在它更新的时候去更新此页面上其它几个报表的数据那么可以使用观察者模式来实现。观察者模式有个很好的特点是能够对观察者的add/remve有很大的灵活性
工厂方法模式(Factory Method Pattern) 观察者模式(Observer Pattern) 建造者模式(Builder Pattern) 解释器模式(Interpreter Pattern) 命令模式(Command Pattern) 模板方法模式(Template Method Pattern) 桥接模式...
开发中常用 设计模式 开发者模式,欢迎大家学习。 博客:http://blog.csdn.net/q610098308/article/details/76143959