Java设计模式之Observer模式
副标题#e#
Observer模式也叫调查者模式，是由GoF提出的23种软件设计模式的一种。Observer模式是行为模式之一，它的浸染是当一个工具的状态产生变革时，可以或许自动通知其他关联工具，自动刷新工具状态。
本文先容设计模式中的（Observer）模式的观念，用法，以及实际应用中怎么样利用Observer模式举办开拓。
Observer模式的观念
Observer模式是行为模式之一，它的浸染是当一个工具的状态产生变革时，可以或许自动通知其他关联工具，自动刷新工具状态。
Observer模式提供应关联工具一种同步通信的手段，使某个工具与依赖它的其他工具之间保持状态同步。
Observer模式的典范应用
– 侦听事件驱动措施设计中的外部事件
– 侦听/监督某个工具的状态变革
– 宣布者/订阅者(publisher/subscriber)模子中，当一个外部事件（新的产物，动静的呈现等等）被触发时，通知邮件列表中的订阅者
Observer模式的利益
– 工具之间可以举办同步通信
– 可以同时通知一到多个关联工具
– 工具之间的干系以松耦合的形式组合，互不依赖
Observer模式的布局
#p#副标题#e#
Observer模式的脚色：
Subject（被调查者）
被调查的工具。当需要被调查的状态产生变革时，需要通知行列中所有调查者工具。Subject需要维持（添加，删除，通知）一个调查者工具的行列列表。
ConcreteSubject
被调查者的详细实现。包括一些根基的属性状态及其他操纵。
Observer（调查者）
接口或抽象类。当Subject的状态产生变革时，Observer工具将通过一个callback函数获得通知。
ConcreteObserver
调查者的详细实现。获得通知后将完成一些详细的业务逻辑处理惩罚。
JDK对Observer模式的支持
JDK提供了对observer设计模式的支持：
– 通过java.util.Observable类饰演Subject脚色，一个类只需通过担任java.util.Observable类便可继续ConcreteSubject脚色；
– 通过java.util.Observer接口饰演Observer脚色，一个类只需实现java.util.Observer接口便可继续ConcreteObserver脚色。
– java.util.Observable的实现类通过挪用setChanged()要领以及notifyObservers(Object)要领便可简朴地通知Observer。
虽然，我们也可以不利用JDK提供的类与接口而本身实现Observer模式。
Observer模式的应用典型
下面，我们利用JDK提供的接口与类来实现一个Observer模式用来模仿新闻订阅操纵：
当一个新闻被颁发时，系统一方面需要通知打点者审阅；另一方面需要通知订阅者。
文件一览：
Client
测试类。
NewsPublisher
相当于ConcreteSubject脚色。该类担任相当于Subject脚色的java.util.Observable类。
SubscriberObserver
相当于ConcreteObserver脚色。该类实现了相当于Observer脚色的java.util.Observer接口。当NewsPublisher工具产生变革时获得通知，并向订阅者发送订阅邮件。
ManagerObserver
相当于ConcreteObserver脚色。该类实现了相当于Observer脚色的java.util.Observer接口。当NewsPublisher工具产生变革时获得通知，并向打点者发送动静邮件。
News
封装了新闻数据的类，与Observer模式无直接干系。
代码：
import java.util.Observable;
import java.util.Observer;
public class Client {
/**
* Test Observer Pattern
* --
*
*/
public static void main(String[] args) {
NewsPublisher publisher = new NewsPublisher();
//添加调查者工具
publisher.addObserver(new SubscriberObserver());
publisher.addObserver(new ManagerObserver());
//宣布新闻，触发通知事件
publisher.publishNews("Hello news", "news body");
}
}
/**
* Subject ROLE
* NewsPublisher: news publisher
*
*/
class NewsPublisher extends Observable {
public void publishNews(String newsTitle, String newsBody) {
News news = new News(newsTitle, newsBody);
setChanged(); //通过setChanged()要领标明工具的状态已产生变革
System.out.println("News published:" + newsTitle);
this.notifyObservers(news); //通知各Observer，并发送一个名为news工具的动静
//other process ... such as save news to database
}
}
/**
* Observer ROLE
*
*/
class SubscriberObserver implements Observer {
public void update(Observable observee, Object param) {
if (param instanceof News) {
mail2Subscriber((News)param);
}
}
private void mail2Subscriber(News news) {
System.out.println("Mail to subscriber. A news published with title:" + news.getTitle());
}
}
/**
* Observer ROLE
*
*/
class ManagerObserver implements Observer {
public void update(Observable observee, Object param) {
if (param instanceof News) {
mail2Manager((News)param);
}
}
private void mail2Manager(News news) {
System.out.println("Mail to Manager. A news published with title:" + news.getTitle());
}
}
//data entity
class News {
private String title;
private String body;
public News(String title, String body) {
this.title = title;
this.body = body;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
}
执行Client，输出功效：
#p#分页标题#e#
C:Observer>javac *.java
C:Observer>java Client
News published:Hello news
Mail to Manager. A news published with title:Hello news
Mail to subscriber. A news published with title:Hello news
C:Observer>
NewsPublisher通过setChanged()与notifyObservers(Object)要领通知Observer工具SubscriberObserver与ManagerObserver。
不合用jdk支持的环境下的代码
Observer模式的长处是：它清除了调查者和方针之间的耦合干系。方针不需要知道它的调查者的任何信息。相反，方针只是答允调查者订阅事件。当方针发生一个事件时，它简朴地将事件传给每一个调查者。
看看下面的Java示例：
public interface Subject {
public void addObserver( Observer o );
public void removeObserver( Observer o );
}
上面的代码中，Subject接口界说了两个要领（method），每个Subject都必需实现它们，以使Observer可以在Subject中增加或删除自身。
public interface Observer {
public void update( Subject o );
}
Observer接口（如上）列出了一个要领（method），每个Observer都必需实现它，以使Subject可以发送更新动静给Observer。
下面看看Subject的一个简朴的实现–IntegerDataBag：
import java.util.ArrayList;
import java.util.Iterator;
public class IntegerDataBag implements Subject {
private ArrayList list = new ArrayList();
private ArrayList observers = new ArrayList();
public void add( Integer i ) {
list.add( i );
notifyObservers();
}
public Iterator iterator() {
return list.iterator();
}
public Integer remove( int index ) {
if( index < list.size() ) {
Integer i = (Integer) list.remove( index );
notifyObservers();
return i;
}
return null;
}
public void addObserver( Observer o ) {
observers.add( o );
}
public void removeObserver( Observer o ) {
observers.remove( o );
}
private void notifyObservers() {
// loop through and notify each observer
Iterator i = observers.iterator();
while( i.hasNext() ) {
Observer o = ( Observer ) i.next();
o.update( this );
}
}
}
IntegerDataBag合用于利用Integer的场所。IntegerDataBag也答允Observer增加和删除它们自身。
再看看两个Observer的实现–IntegerAdder和IntegerPrinter：
import java.util.Iterator;
public class IntegerAdder implements Observer {
private IntegerDataBag bag;
public IntegerAdder( IntegerDataBag bag ) {
this.bag = bag;
bag.addObserver( this );
}
public void update( Subject o ) {
if( o == bag ) {
System.out.println( "The contents of the IntegerDataBag have changed." );
int counter = 0;
Iterator i = bag.iterator();
while( i.hasNext() ) {
Integer integer = ( Integer ) i.next();
counter+=integer.intValue();
}
System.out.println( "The new sum of the integers is: " + counter );
}
}
}
import java.util.Iterator;
public class IntegerPrinter implements Observer {
private IntegerDataBag bag;
public IntegerPrinter( IntegerDataBag bag ) {
this.bag = bag;
bag.addObserver( this );
}
public void update( Subject o ) {
if( o == bag ) {
System.out.println( "The contents of the IntegerDataBag have changed." );
System.out.println( "The new contents of the IntegerDataBag contains:" );
Iterator i = bag.iterator();
while( i.hasNext() ) {
System.out.println( i.next() );
}
}
}
}
#p#分页标题#e#
IntegerAdder和IntegerPrinter将本身作为调查者增加到IntegerDataBag。当IntegerAdder吸收到一条更新动静时，它先统计bag中的总数，然后显示功效。同样，当IntegerPrinter吸收到一条更新动静时，它打印出bag中的 Interger。
下面是一个简朴的main()，它利用了上面的几个类：
public class Driver {
public static void main( String [] args ) {
Integer i1 = new Integer( 1 ); Integer i2 = new Integer( 2 );
Integer i3 = new Integer( 3 ); Integer i4 = new Integer( 4 );
Integer i5 = new Integer( 5 ); Integer i6 = new Integer( 6 );
Integer i7 = new Integer( 7 ); Integer i8 = new Integer( 8 );
Integer i9 = new Integer( 9 );
IntegerDataBag bag = new IntegerDataBag();
bag.add( i1 ); bag.add( i2 ); bag.add( i3 ); bag.add( i4 );
bag.add( i5 ); bag.add( i6 ); bag.add( i7 ); bag.add( i8 );
IntegerAdder adder = new IntegerAdder( bag );
IntegerPrinter printer = new IntegerPrinter( bag );
// adder and printer add themselves to the bag
System.out.println( "About to add another integer to the bag:" );
bag.add( i9 );
System.out.println("");
System.out.println("About to remove an integer from the bag:");
bag.remove( 0 );
}
}
运行main，你将看到：
c:javaworldjava Driver
About to add another integer to the bag:
The contents of the IntegerDataBag have changed.
The new sum of the intergers is: 45
The contents of the IntegerDataBag have changed.
The new contents of the IntegerDataBag contains:
1
2
3
4
5
6
7
8
9
About to remove an integer from the bag:
The contents of the IntegerDataBag have changed.
The new sum of the intergers is: 44
The contents of the IntegerDataBag have changed.
The new contents of the IntegerDataBag contains:
2
3
4
5
6
7
8
9
IntegerDataBag/IntegerAdder/IntegerPrinter是应用Observer模式的一个很简朴的例子。Java 自己有大量利用Observer模式的例子：AWT/Swing事件模子，尚有java.util.Observer和 java.util.Observable接口等，都是很好的例子。
