在Java中通过Observable类和Observer接口实现了观察者模式。一个Observer对象监视着一个Observable对象的变化,当Observable对象发生变化时,Observer得到通知,就可以进行相应的工作。例如在文档/视图结构中,文档被修改了,视图就会得到通知。
java.util.Observable中有两个方法对Observer特别重要,一个是setChange()方法用来设置一个内部标志位注明数据发生了变化;一个是notifyObservers()方法会去调用一个列表中所有的Observer的update()方法,通知它们数据发生了变化。
Observer通过Observable的addObserver()方法把自己添加到这个列表中。这个列表虽然由Observable拥有,但Observable并不知道到底有哪些Observer正在观察等待通知。Observable只提供一个方法让Observer能把自己添加进列表,并保证会去通知Observer发生了变化。通过这种机制,可以有任意多个Observer对Observable进行观察,而不影响Observable的实现。
一个简单例子:
import java.util.Observable;
public class SimpleObservable extends Observable
{
private int data = 0;
public int getData(){
return data;
}
public void setData(int i){
if(this.data != i){ this.data = i; setChange();}
notifyObservers();
//只有在setChange()被调用后,notifyObservers()才会去调用update(),否则什么都不干。
}
}
}
import java.util.Observable;
import java.util.Observer;
public class SimpleObserver implements Observer
{
public SimpleObserver(SimpleObservable so){
so.addObserver(this );
}
public void update(Observable o,Object arg/*任意对象,用于传递参数*/){
System.out.println(“Data has changed to” + (SimpleObservable)o.getData());
}
}
public class SimpleTest
{
public static void main(String[] args){
SimpleObservable doc = new SimpleObservable ();
SimpleObserver view = new SimpleObserver (doc);
doc.setData(1);
doc.setData(2);
doc.setData(2);
doc.setData(3);
}
}
Data has changed to 1
Data has changed to 2 //第二次setData(2)时由于没有setChange,所以update没被调用
Data has changed to 3
Observable类有两个私有变量。一个boolean型的标志位,setChange()将它设为真,只有它为真时,notifyObservers方法才会调用Observer的update方法,clearChange()设标志位为假,hasChange返回当前标志位的值。另一个是一个Vector,保存着一个所有要通知的Observer列表,addObserver添加Observer到列表,deleteObserver从列表中删除指定Observer,deleteObservers清空列表,countObservers返回列表中Observer的数目,在Observer对象销毁前一定要用deleteObserver将其从列表中删除,不然因为还存在对象引用的关系,Observer对象不会被垃圾收集,造成内存泄漏,并且已死的Observer仍会被通知到,有可能造成意料外的错误,而且随着列表越来越大,notifyObservers操作也会越来越慢。
Observable的所有方法都是同步的,保证了在一个线程对其标志位、列表进行操作时,不会有其它线程也在操作它。
Observable的notifyObservers(Object obj)形式可以再调用update时将参数传进去。
通知顺序通常时越晚加入列表的越先通知。update会被依次调用,由于一个update返回后下一个update才被调用,这样当update中有大量操作时,最好将其中的工作拿到另一个线程或者Observer本身同时也是一个Thread类,Observer先挂起,在update中被唤醒,这样会有一个隐患,Observer线程还没来得及挂起,update就被调用了,通知消息就这样被错过了,一种解决办法是在Observer中实现一个同步的队列结构,并有一个类来封装参数,update实现一个参数类的对象把接收到的通知消息的参数封装在里面,然后把其加进队列,run方法从队列中移除参数对象,并进行处理,这保证了没有通知信息被丢失。
在多线程时,只有Observer会与单线程不同,Observable不需任何改变来支持多线程,因为它又很多作为单独线程运作的Observer。
一个多线程例子:
import java.util.*;
public class SimpleObserverEx extends Thread implements Observer
{
Queue queue;//利用一个消息队列来接收Observable的通知,保证消息不会丢失
public void run(){
while(true){
ArgPack a = (ArgPack) queue.dequeue();
Observable o = a.o;
Object obj = a.arg;
//…执行相应的工作
}
}
public void update(Observable o, Object arg){
ArgPack a = new ArgPack (o,arg);
queue.queue(a);
}
}
import java.util.*;
public class Queue extends LinkedList{
public synchronized void queue(Object o){
addLast(o);
notify();
}
public synchronized void dequeue(){
while(this.isEmpty()){
try{
wait();
}
catch(InterruptedException el){
}
}
Object o;
try{
o =this.removeFirst();
}
catch(NoSuchElementException){
o = null;
}
return o;
}
}
public class ArgPack
{
public Observable o;
public Object obj;
public ArgPack (Observable o,Object obj){
this.o = o;this.obj = obj;
}
}
Observable是一个类而不是一个接口这限制了它的使用,一个解决的办法是在一个Observable类中把我们的类包装进去(把我们的类实例当作Observable的域),因为Observable中的setChange是一个protected方法,我们没法在外面调用它。所以没法在我们的类中包装一个Observable,但是如果我们的类中同样也有protected方法,那这个办法就无法使用
分享到:
相关推荐
观察者模式介绍:Observable和Observer原理分析,手动实现简单MyObservable和MyObserver
Java内置的Observable类和Observer接口提供了基本的观察者模式功能,你可以通过继承Observable类和实现Observer接口来使用
这个工程是Observable与Observer的经典运用,是android实现拖拽图片的操作
这个工程是Observable与Observer的经典运用,是android实现的单指拖动放大缩小图片的操作
主要介绍了 Java观察者设计模式(Observable和Observer)的相关资料,需要的朋友可以参考下
这是最简单的一个MVC实例,通过它你可以了解MVC的基本工作原理。
禅宗可观察 Observables for JavaScript的... let observable = new Observable ( observer => { // Emit a single value after 1 second let timer = setTimeout ( ( ) => { observer . next ( 'hello' ) ; obs
这个现在对人来说都是相当特定的 - 理想情况下它应该支持 ES7 observable 接口,但这是有效的。 请参阅的讨论。去做 测试 可运行的例子 包含invariant用法在 DOM 元素上使用它。 import observer from 'react-...
从Observer到Observable:使用Functional Swift提升复杂iOS项目的可维护性
从Observer到Observable:使用Functional Swift提升复杂iOS项目的可维护性.pdf
观察者设计模式,java语言实现,完全自己代码实现,未使用observable和observer
手工实现一个Observer也不是多复杂的一件事,只是因为这个设计模式实在太常用了,Java就把它放到了JDK里面:Observable和Observer,从JDK 1.0里,它们就一直在那里。从某种程度上说,它简化了Observer模式的开发,...
rxjs文件rxjs文档可观察的可观察特性Observable是惰性的,可以同步或者异步返回零个或多个值的对象惰性的:被动的,只有被观察者订阅才会执行多值的:在observable中包含的订阅某些函数中,可以发送多个值observer ....
这样一来 当一个对象改变状态时 依赖它的对象都会收到通知并自动跟新 Java已经提供了对观察者Observer模式的默认实现 Java对观察者模式的支持主要体现在Observable类和Observer接口 ">观察者 Observer 模式定义:在...
而今就是要探讨什么是Observable、observer、operator、Submit、EventEmmit,以及如何去使用它们。 什么是Observable? Observable只是一个普通函数,要想让他有所作为,就需要跟observer一起使用;前者是受后者是攻...
上游和下游就分别对应着RxJava中的Observable和Observer;两者之间的连接就对应着subscribe() 只有当上游和下游建立连接后(调用subscribe()),上游才会开始发送事件 Demo //创建一个上游Observable. Observable...
JDK里提供的observer设计模式的实现由java.util.Observable类和 java.util.Observer接口组成。从名字上可以清楚的看出两者在Observer 设计模式中分别扮演的角色:Observer是观察者角色,Observable是被观察目标...
Python-observable-collections介绍这是 Python 可观察集合的实现,它允许将处理程序附加到 Python 集合,以便在底层数据发生更改时收到通知。 目前支持 ObservableSet、ObservableList 和 ObservableDict。 所有三...
// Create an `Observable` from a single item and subscribe to the observer. sub := observable.Just(1).Subscribe(watcher) fmt.Println(score) // 20 } 标签:RxGo