Observer与Observable
2014-03-09 20:18
597 查看
本文整理自:http://dev.21tx.com/2004/07/26/10822.html
在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的实现。当然一个Observer也可以观察多个Observable。
Observer与Observable的简单使用可以参照实例1的SimpleObservable.java文件和SimpleObserver.java文件.
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时将参数传进去。
Observer接收到通知的顺序是越晚加入列表的越先通知。Observer的update方法会被依次调用,由于Observable的notifyObservers方法和Observer的update方法其实是在同一个线程中被调用而且调用一个update方法返回后才进行下一个update方法的调用,这样当update中有大量操作时,最好将其中的工作给另一个线程来做,具体可以参照实例1的SimpleObserver2.java文件。
实例1
SimpleObservable.java文件
package com.lenovo.robin;
import java.util.Observable;
public class SimpleObservable extends Observable{ private int data = 0; private String name; public SimpleObservable(String name) { this.name=name; } public String getName() { return name; } public int getData() { return data; }
public void setData(int i) { if (this.data != i) { this.data = i; /* 只有在setChange()被调用后,notifyObservers()才会去调用update(),否则什么都不干。 */ setChanged(); notifyObservers();
} }}
SimpleObserver.java文件
package com.lenovo.robin;
import java.util.Observable;import java.util.Observer; public class SimpleObserver implements Observer{ private String name; public SimpleObserver(String name){ this.name=name; } public void update(Observable o,Object arg){ SimpleObservable observable=(SimpleObservable)o; System.out.println(name+" found that Data of "+observable.getName()+" has changed to " + observable.getData()); }}
SimpleObserver2.java
package com.lenovo.robin;
import java.util.Observable;import java.util.Observer;import java.util.concurrent.ArrayBlockingQueue;
public class SimpleObserver2 implements Observer,Runnable{ private String name; public SimpleObserver2(String name){ this.name=name; } /* 利用一个消息队列来接收Observable的通知,保证消息不会丢失 */ ArrayBlockingQueue<Message> queue = new ArrayBlockingQueue<Message>(100); Thread thread=null; public void run() { while (true) { Message msg; try { msg = queue.take(); Observable o = msg.observable; Object obj = msg.object; SimpleObservable observable=(SimpleObservable)o; System.out.println(name+" found that Data of "+observable.getName()+" has changed to " + observable.getData()); // …执行相应的工作 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
public void update(Observable o, Object arg) { Message msg = new Message(o, arg); try { queue.put(msg); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } if(thread==null){ thread=new Thread(this); thread.start(); } }
class Message { Observable observable; Object object;
Message(Observable o, Object arg) { this.observable = o; this.object = arg; } }}
使用的代码片段
SimpleObservable observable01 = new SimpleObservable ("SimpleObservable01"); SimpleObservable observable02 = new SimpleObservable ("SimpleObservable02"); SimpleObserver observer1_0 = new SimpleObserver ("SimpleObserver1-0"); SimpleObserver observer1_1 = new SimpleObserver ("SimpleObserver1-1"); SimpleObserver2 observer2_0 = new SimpleObserver2 ("SimpleObserver2-0"); observable01.addObserver(observer1_0); observable01.addObserver(observer1_1); observable01.addObserver(observer2_0); observable02.addObserver(observer1_0); observable02.addObserver(observer1_1); observable02.addObserver(observer2_0); observable01.setData(1); observable01.setData(2); observable01.setData(2); observable01.setData(3); observable02.setData(100); observable02.setData(110);
运行结果
SimpleObserver1-1 found that Data of SimpleObservable01 has changed to 1SimpleObserver1-0 found that Data of SimpleObservable01 has changed to 1SimpleObserver1-1 found that Data of SimpleObservable01 has changed to 2SimpleObserver1-0 found that Data of SimpleObservable01 has changed to 2SimpleObserver1-1 found that Data of SimpleObservable01 has changed to 3SimpleObserver1-0 found that Data of SimpleObservable01 has changed to 3SimpleObserver1-1 found that Data of SimpleObservable02 has changed to 100SimpleObserver1-0 found that Data of SimpleObservable02 has changed to 100SimpleObserver2-0 found that Data of SimpleObservable01 has changed to 3SimpleObserver2-0 found that Data of SimpleObservable01 has changed to 3SimpleObserver2-0 found that Data of SimpleObservable01 has changed to 3SimpleObserver2-0 found that Data of SimpleObservable02 has changed to 110SimpleObserver2-0 found that Data of SimpleObservable02 has changed to 110SimpleObserver1-1 found that Data of SimpleObservable02 has changed to 110SimpleObserver1-0 found that Data of SimpleObservable02 has changed to 110
Observable.java源码
/* * @(#)Observable.java 1.39 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */
package java.util;
/** * This class represents an observable object, or "data" * in the model-view paradigm. It can be subclassed to represent an * object that the application wants to have observed. * <p> * An observable object can have one or more observers. An observer * may be any object that implements interface <tt>Observer</tt>. After an * observable instance changes, an application calling the * <code>Observable</code>'s <code>notifyObservers</code> method * causes all of its observers to be notified of the change by a call * to their <code>update</code> method. * <p> * The order in which notifications will be delivered is unspecified. * The default implementation provided in the Observable class will * notify Observers in the order in which they registered interest, but * subclasses may change this order, use no guaranteed order, deliver * notifications on separate threads, or may guarantee that their * subclass follows this order, as they choose. * <p> * Note that this notification mechanism is has nothing to do with threads * and is completely separate from the <tt>wait</tt> and <tt>notify</tt> * mechanism of class <tt>Object</tt>. * <p> * When an observable object is newly created, its set of observers is * empty. Two observers are considered the same if and only if the * <tt>equals</tt> method returns true for them. * * @author Chris Warth * @version 1.39, 11/17/05 * @see java.util.Observable#notifyObservers() * @see java.util.Observable#notifyObservers(java.lang.Object) * @see java.util.Observer * @see java.util.Observer#update(java.util.Observable, java.lang.Object) * @since JDK1.0 */public class Observable { private boolean changed = false; private Vector obs; /** Construct an Observable with zero Observers. */
public Observable() { obs = new Vector(); }
/** * Adds an observer to the set of observers for this object, provided * that it is not the same as some observer already in the set. * The order in which notifications will be delivered to multiple * observers is not specified. See the class comment. * * @param o an observer to be added. * @throws NullPointerException if the parameter o is null. */ public synchronized void addObserver(Observer o) { if (o == null) throw new NullPointerException(); if (!obs.contains(o)) { obs.addElement(o); } }
/** * Deletes an observer from the set of observers of this object. * Passing <CODE>null</CODE> to this method will have no effect. * @param o the observer to be deleted. */ public synchronized void deleteObserver(Observer o) { obs.removeElement(o); }
/** * If this object has changed, as indicated by the * <code>hasChanged</code> method, then notify all of its observers * and then call the <code>clearChanged</code> method to * indicate that this object has no longer changed. * <p> * Each observer has its <code>update</code> method called with two * arguments: this observable object and <code>null</code>. In other * words, this method is equivalent to: * <blockquote><tt> * notifyObservers(null)</tt></blockquote> * * @see java.util.Observable#clearChanged() * @see java.util.Observable#hasChanged() * @see java.util.Observer#update(java.util.Observable, java.lang.Object) */ public void notifyObservers() { notifyObservers(null); }
/** * If this object has changed, as indicated by the * <code>hasChanged</code> method, then notify all of its observers * and then call the <code>clearChanged</code> method to indicate * that this object has no longer changed. * <p> * Each observer has its <code>update</code> method called with two * arguments: this observable object and the <code>arg</code> argument. * * @param arg any object. * @see java.util.Observable#clearChanged() * @see java.util.Observable#hasChanged() * @see java.util.Observer#update(java.util.Observable, java.lang.Object) */ public void notifyObservers(Object arg) { /* * a temporary array buffer, used as a snapshot of the state of * current Observers. */ Object[] arrLocal;
synchronized (this) { /* We don't want the Observer doing callbacks into * arbitrary code while holding its own Monitor. * The code where we extract each Observable from * the Vector and store the state of the Observer * needs synchronization, but notifying observers * does not (should not). The worst result of any * potential race-condition here is that: * 1) a newly-added Observer will miss a * notification in progress * 2) a recently unregistered Observer will be * wrongly notified when it doesn't care */ if (!changed) return; arrLocal = obs.toArray(); clearChanged(); }
for (int i = arrLocal.length-1; i>=0; i--) ((Observer)arrLocal[i]).update(this, arg); }
/** * Clears the observer list so that this object no longer has any observers. */ public synchronized void deleteObservers() { obs.removeAllElements(); }
/** * Marks this <tt>Observable</tt> object as having been changed; the * <tt>hasChanged</tt> method will now return <tt>true</tt>. */ protected synchronized void setChanged() { changed = true; }
/** * Indicates that this object has no longer changed, or that it has * already notified all of its observers of its most recent change, * so that the <tt>hasChanged</tt> method will now return <tt>false</tt>. * This method is called automatically by the * <code>notifyObservers</code> methods. * * @see java.util.Observable#notifyObservers() * @see java.util.Observable#notifyObservers(java.lang.Object) */ protected synchronized void clearChanged() { changed = false; }
/** * Tests if this object has changed. * * @return <code>true</code> if and only if the <code>setChanged</code> * method has been called more recently than the * <code>clearChanged</code> method on this object; * <code>false</code> otherwise. * @see java.util.Observable#clearChanged() * @see java.util.Observable#setChanged() */ public synchronized boolean hasChanged() { return changed; }
/** * Returns the number of observers of this <tt>Observable</tt> object. * * @return the number of observers of this object. */ public synchronized int countObservers() { return obs.size(); }}
Observer.java源码
/* * @(#)Observer.java 1.20 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package java.util;
/** * A class can implement the <code>Observer</code> interface when it * wants to be informed of changes in observable objects. * * @author Chris Warth * @version 1.20, 11/17/05 * @see java.util.Observable * @since JDK1.0 */public interface Observer { /** * This method is called whenever the observed object is changed. An * application calls an <tt>Observable</tt> object's * <code>notifyObservers</code> method to have all the object's * observers notified of the change. * * @param o the observable object. * @param arg an argument passed to the <code>notifyObservers</code> * method. */ void update(Observable o, Object arg);}
结束!
在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的实现。当然一个Observer也可以观察多个Observable。
Observer与Observable的简单使用可以参照实例1的SimpleObservable.java文件和SimpleObserver.java文件.
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时将参数传进去。
Observer接收到通知的顺序是越晚加入列表的越先通知。Observer的update方法会被依次调用,由于Observable的notifyObservers方法和Observer的update方法其实是在同一个线程中被调用而且调用一个update方法返回后才进行下一个update方法的调用,这样当update中有大量操作时,最好将其中的工作给另一个线程来做,具体可以参照实例1的SimpleObserver2.java文件。
实例1
SimpleObservable.java文件
package com.lenovo.robin;
import java.util.Observable;
public class SimpleObservable extends Observable{ private int data = 0; private String name; public SimpleObservable(String name) { this.name=name; } public String getName() { return name; } public int getData() { return data; }
public void setData(int i) { if (this.data != i) { this.data = i; /* 只有在setChange()被调用后,notifyObservers()才会去调用update(),否则什么都不干。 */ setChanged(); notifyObservers();
} }}
SimpleObserver.java文件
package com.lenovo.robin;
import java.util.Observable;import java.util.Observer; public class SimpleObserver implements Observer{ private String name; public SimpleObserver(String name){ this.name=name; } public void update(Observable o,Object arg){ SimpleObservable observable=(SimpleObservable)o; System.out.println(name+" found that Data of "+observable.getName()+" has changed to " + observable.getData()); }}
SimpleObserver2.java
package com.lenovo.robin;
import java.util.Observable;import java.util.Observer;import java.util.concurrent.ArrayBlockingQueue;
public class SimpleObserver2 implements Observer,Runnable{ private String name; public SimpleObserver2(String name){ this.name=name; } /* 利用一个消息队列来接收Observable的通知,保证消息不会丢失 */ ArrayBlockingQueue<Message> queue = new ArrayBlockingQueue<Message>(100); Thread thread=null; public void run() { while (true) { Message msg; try { msg = queue.take(); Observable o = msg.observable; Object obj = msg.object; SimpleObservable observable=(SimpleObservable)o; System.out.println(name+" found that Data of "+observable.getName()+" has changed to " + observable.getData()); // …执行相应的工作 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
public void update(Observable o, Object arg) { Message msg = new Message(o, arg); try { queue.put(msg); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } if(thread==null){ thread=new Thread(this); thread.start(); } }
class Message { Observable observable; Object object;
Message(Observable o, Object arg) { this.observable = o; this.object = arg; } }}
使用的代码片段
SimpleObservable observable01 = new SimpleObservable ("SimpleObservable01"); SimpleObservable observable02 = new SimpleObservable ("SimpleObservable02"); SimpleObserver observer1_0 = new SimpleObserver ("SimpleObserver1-0"); SimpleObserver observer1_1 = new SimpleObserver ("SimpleObserver1-1"); SimpleObserver2 observer2_0 = new SimpleObserver2 ("SimpleObserver2-0"); observable01.addObserver(observer1_0); observable01.addObserver(observer1_1); observable01.addObserver(observer2_0); observable02.addObserver(observer1_0); observable02.addObserver(observer1_1); observable02.addObserver(observer2_0); observable01.setData(1); observable01.setData(2); observable01.setData(2); observable01.setData(3); observable02.setData(100); observable02.setData(110);
运行结果
SimpleObserver1-1 found that Data of SimpleObservable01 has changed to 1SimpleObserver1-0 found that Data of SimpleObservable01 has changed to 1SimpleObserver1-1 found that Data of SimpleObservable01 has changed to 2SimpleObserver1-0 found that Data of SimpleObservable01 has changed to 2SimpleObserver1-1 found that Data of SimpleObservable01 has changed to 3SimpleObserver1-0 found that Data of SimpleObservable01 has changed to 3SimpleObserver1-1 found that Data of SimpleObservable02 has changed to 100SimpleObserver1-0 found that Data of SimpleObservable02 has changed to 100SimpleObserver2-0 found that Data of SimpleObservable01 has changed to 3SimpleObserver2-0 found that Data of SimpleObservable01 has changed to 3SimpleObserver2-0 found that Data of SimpleObservable01 has changed to 3SimpleObserver2-0 found that Data of SimpleObservable02 has changed to 110SimpleObserver2-0 found that Data of SimpleObservable02 has changed to 110SimpleObserver1-1 found that Data of SimpleObservable02 has changed to 110SimpleObserver1-0 found that Data of SimpleObservable02 has changed to 110
Observable.java源码
/* * @(#)Observable.java 1.39 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */
package java.util;
/** * This class represents an observable object, or "data" * in the model-view paradigm. It can be subclassed to represent an * object that the application wants to have observed. * <p> * An observable object can have one or more observers. An observer * may be any object that implements interface <tt>Observer</tt>. After an * observable instance changes, an application calling the * <code>Observable</code>'s <code>notifyObservers</code> method * causes all of its observers to be notified of the change by a call * to their <code>update</code> method. * <p> * The order in which notifications will be delivered is unspecified. * The default implementation provided in the Observable class will * notify Observers in the order in which they registered interest, but * subclasses may change this order, use no guaranteed order, deliver * notifications on separate threads, or may guarantee that their * subclass follows this order, as they choose. * <p> * Note that this notification mechanism is has nothing to do with threads * and is completely separate from the <tt>wait</tt> and <tt>notify</tt> * mechanism of class <tt>Object</tt>. * <p> * When an observable object is newly created, its set of observers is * empty. Two observers are considered the same if and only if the * <tt>equals</tt> method returns true for them. * * @author Chris Warth * @version 1.39, 11/17/05 * @see java.util.Observable#notifyObservers() * @see java.util.Observable#notifyObservers(java.lang.Object) * @see java.util.Observer * @see java.util.Observer#update(java.util.Observable, java.lang.Object) * @since JDK1.0 */public class Observable { private boolean changed = false; private Vector obs; /** Construct an Observable with zero Observers. */
public Observable() { obs = new Vector(); }
/** * Adds an observer to the set of observers for this object, provided * that it is not the same as some observer already in the set. * The order in which notifications will be delivered to multiple * observers is not specified. See the class comment. * * @param o an observer to be added. * @throws NullPointerException if the parameter o is null. */ public synchronized void addObserver(Observer o) { if (o == null) throw new NullPointerException(); if (!obs.contains(o)) { obs.addElement(o); } }
/** * Deletes an observer from the set of observers of this object. * Passing <CODE>null</CODE> to this method will have no effect. * @param o the observer to be deleted. */ public synchronized void deleteObserver(Observer o) { obs.removeElement(o); }
/** * If this object has changed, as indicated by the * <code>hasChanged</code> method, then notify all of its observers * and then call the <code>clearChanged</code> method to * indicate that this object has no longer changed. * <p> * Each observer has its <code>update</code> method called with two * arguments: this observable object and <code>null</code>. In other * words, this method is equivalent to: * <blockquote><tt> * notifyObservers(null)</tt></blockquote> * * @see java.util.Observable#clearChanged() * @see java.util.Observable#hasChanged() * @see java.util.Observer#update(java.util.Observable, java.lang.Object) */ public void notifyObservers() { notifyObservers(null); }
/** * If this object has changed, as indicated by the * <code>hasChanged</code> method, then notify all of its observers * and then call the <code>clearChanged</code> method to indicate * that this object has no longer changed. * <p> * Each observer has its <code>update</code> method called with two * arguments: this observable object and the <code>arg</code> argument. * * @param arg any object. * @see java.util.Observable#clearChanged() * @see java.util.Observable#hasChanged() * @see java.util.Observer#update(java.util.Observable, java.lang.Object) */ public void notifyObservers(Object arg) { /* * a temporary array buffer, used as a snapshot of the state of * current Observers. */ Object[] arrLocal;
synchronized (this) { /* We don't want the Observer doing callbacks into * arbitrary code while holding its own Monitor. * The code where we extract each Observable from * the Vector and store the state of the Observer * needs synchronization, but notifying observers * does not (should not). The worst result of any * potential race-condition here is that: * 1) a newly-added Observer will miss a * notification in progress * 2) a recently unregistered Observer will be * wrongly notified when it doesn't care */ if (!changed) return; arrLocal = obs.toArray(); clearChanged(); }
for (int i = arrLocal.length-1; i>=0; i--) ((Observer)arrLocal[i]).update(this, arg); }
/** * Clears the observer list so that this object no longer has any observers. */ public synchronized void deleteObservers() { obs.removeAllElements(); }
/** * Marks this <tt>Observable</tt> object as having been changed; the * <tt>hasChanged</tt> method will now return <tt>true</tt>. */ protected synchronized void setChanged() { changed = true; }
/** * Indicates that this object has no longer changed, or that it has * already notified all of its observers of its most recent change, * so that the <tt>hasChanged</tt> method will now return <tt>false</tt>. * This method is called automatically by the * <code>notifyObservers</code> methods. * * @see java.util.Observable#notifyObservers() * @see java.util.Observable#notifyObservers(java.lang.Object) */ protected synchronized void clearChanged() { changed = false; }
/** * Tests if this object has changed. * * @return <code>true</code> if and only if the <code>setChanged</code> * method has been called more recently than the * <code>clearChanged</code> method on this object; * <code>false</code> otherwise. * @see java.util.Observable#clearChanged() * @see java.util.Observable#setChanged() */ public synchronized boolean hasChanged() { return changed; }
/** * Returns the number of observers of this <tt>Observable</tt> object. * * @return the number of observers of this object. */ public synchronized int countObservers() { return obs.size(); }}
Observer.java源码
/* * @(#)Observer.java 1.20 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package java.util;
/** * A class can implement the <code>Observer</code> interface when it * wants to be informed of changes in observable objects. * * @author Chris Warth * @version 1.20, 11/17/05 * @see java.util.Observable * @since JDK1.0 */public interface Observer { /** * This method is called whenever the observed object is changed. An * application calls an <tt>Observable</tt> object's * <code>notifyObservers</code> method to have all the object's * observers notified of the change. * * @param o the observable object. * @param arg an argument passed to the <code>notifyObservers</code> * method. */ void update(Observable o, Object arg);}
结束!