Java 实现观察者(Observer)模式

1. Java自带的实现

类图

[java] view plaincopyprint?

1. /** 
2.  * 观察目标 继承自 java.util.Observable 
3.  * 
4.  */  
5. public class UpdateObservable extends Observable {  
6.       
7.     private int data;  
8.       
9.     public UpdateObservable(Observer observer) {  
10.         addObserver(observer);  
11.         /* 
12.          * add other observer 
13.          */  
14.     }  
15.       
16.     public int getData() {  
17.         return data;  
18.     }  
19.       
20.     public void setData(int data) {  
21.         if (data != this.data) {  
22.             this.data = data;  
23.             setChanged(); //标记 改变, 只有标记后才能通知到  
24.             notifyObservers(); //通知  
25.         }  
26.           
27.     }  
28.   
29.     @Override  
30.     public synchronized void addObserver(Observer o) {  
31.         super.addObserver(o);  
32.     }  
33.   
34.     @Override  
35.     public synchronized void deleteObserver(Observer o) {  
36.         super.deleteObserver(o);  
37.     }  
38.   
39.     @Override  
40.     public void notifyObservers() {  
41.         super.notifyObservers();  
42.     }  
43.   
44.     @Override  
45.     public void notifyObservers(Object arg) {  
46.         super.notifyObservers(arg);  
47.     }  
48.   
49.     @Override  
50.     public synchronized void deleteObservers() {  
51.         super.deleteObservers();  
52.     }  
53.   
54.     @Override  
55.     protected synchronized void setChanged() {  
56.         super.setChanged();  
57.     }  
58.   
59.     @Override  
60.     protected synchronized void clearChanged() {  
61.         super.clearChanged();  
62.     }  
63.   
64.     @Override  
65.     public synchronized boolean hasChanged() {  
66.         return super.hasChanged();  
67.     }  
68.   
69.     @Override  
70.     public synchronized int countObservers() {  
71.         return super.countObservers();  
72.     }  
73.       
74. }  

[java] view plaincopyprint?

1. /** 
2.  * 观察者  实现 java.util.Observer接口 
3.  * 
4.  */  
5. public class UpdateObserver implements Observer {  
6.   
7.     @Override  
8.     public void update(Observable o, Object arg) {  
9.         System.out.println("接收到数据变化的通知:");  
10.         if (o instanceof UpdateObservable) {  
11.             UpdateObservable uo = (UpdateObservable) o;  
12.             System.out.print("数据变更为：" + uo.getData());  
13.         }  
14.     }  
15.   
16. }  

2. 自定义的观察模型

类图

[java] view plaincopyprint?

1. /** 
2.  * 抽象观察者    Observer 
3.  * 观察 更新         
4.  * 
5.  */  
6. public interface IWatcher {  
7.     /* 
8.      * 通知接口： 
9.      * 1. 简单通知 
10.      * 2. 观察者需要目标的变化的数据，那么可以将目标用作参数, 见Java的Observer和Observable 
11.      */  
12. //  void update(IWatched watched);  
13.       
14.     void update();  
15.       
16. }  

[java] view plaincopyprint?

1. /** 
2.  * 抽象目标 Subject 
3.  *  提供注册和删除观察者对象的接口, 及通知观察者进行观察的接口 
4.  *  及目标 自身被观察的业务的接口 
5.  * 
6.  */  
7. public interface IWatchedSubject {  
8.       
9.     public void add(IWatcher watch);  
10.   
11.     public void remove(IWatcher watch);  
12.       
13.     public void notifyWhatchers();  
14.       
15.     public void update();//被观察业务变化的接口  
16. }  

[java] view plaincopyprint?

1. /** 
2.  * 具体观察者        Concrete Observer 
3.  *  
4.  * 
5.  */  
6. public class UpdateWatcher implements IWatcher {  
7.   
8.     @Override  
9.     public void update() {  
10.         System.out.println(this + "观察到：目标已经更新了");  
11.     }  
12.   
13. }  

[java] view plaincopyprint?

1. /** 
2.  * 具体目标角色   Concrete Subject 
3.  * 
4.  */  
5. public class UpdateWatchedSubject implements IWatchedSubject {  
6.     private List<IWatcher> list;  
7.       
8.     public UpdateWatchedSubject() {  
9.         this.list = new ArrayList<IWatcher>();  
10.     }  
11.       
12.     @Override  
13.     public void add(IWatcher watch) {  
14.         this.list.add(watch);  
15.     }  
16.   
17.     @Override  
18.     public void remove(IWatcher watch) {  
19.         this.list.remove(watch);  
20.     }  
21.   
22.     @Override  
23.     public void notifyWhatchers() {  
24.         for (IWatcher watcher : list) {  
25.             watcher.update();  
26.         }  
27.     }  
28.       
29.     @Override  
30.     public void update() {  
31.         System.out.println("目标更新中....");  
32.         notifyWhatchers();  
33.     }  
34.   
35. }  

监听器是观察者的一种实现

类图

[java] view plaincopyprint?

1. /** 
2.  * 监听 用户在注册后 
3.  * 
4.  */  
5. public interface IRegisterListener {  
6.     void onRegistered();  
7. }  

[java] view plaincopyprint?

1. /** 
2.  * 监听 当用户登录后 
3.  * 
4.  */  
5. public interface ILoginListener {  
6.     void onLogined();  
7. }  

[java] view plaincopyprint?

1. /* 
2.  * 监听器 是观察者模式的一种实现 
3.  * 一些需要监听的业务接口上添加 监听器，调用监听器的相应方法，实现监听 
4.  */  
5. public class User {  
6.       
7.     public void register(IRegisterListener register) {  
8.         /* 
9.          * do ... register 
10.          */  
11.         System.out.println("正在注册中...");  
12.         //注册后  
13.         register.onRegistered();  
14.     }  
15.   
16.     public void login(ILoginListener login) {  
17.         /* 
18.          * do ... login 
19.          */  
20.         System.out.println("正在登录中...");  
21.         //登录后  
22.         login.onLogined();  
23.     }  
24.   
25. }  

[java] view plaincopyprint?

1. /** 
2.  * 观察者(Observer)模式  行为型模式 
3.  *   观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时观察某一个目标对象。 
4.  *   这个目标对象在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己 
5.  * 目标对象中需要有添加、移除、通知 观察者的接口 
6.  *    
7.  */  
8. public class Test {  
9.       
10.     public static void main(String[] args) {  
11.         /* 
12.          * 使用Java自带的Observer接口和Observable类 
13.          */  
14.         UpdateObservable observable = new UpdateObservable(new UpdateObserver());  
15.         observable.setData(99);  
16.         System.out.println("");  
17.         System.out.println("");  
18.         /* 
19.          * 自定义的观察者模型 
20.          */  
21.         IWatchedSubject watched = new UpdateWatchedSubject();  
22.         watched.add(new UpdateWatcher());  
23.         watched.add(new UpdateWatcher());  
24.         watched.update();  
25.         System.out.println("");  
26.           
27.         /* 
28.          * 子模式-监听器 
29.          */  
30.           
31.         User user = new User();  
32.         user.register(new IRegisterListener() {  
33.               
34.             @Override  
35.             public void onRegistered() {  
36.                 System.out.println("监听到注册后。。。");  
37.             }  
38.         });  
39.         user.login(new ILoginListener() {  
40.               
41.             @Override  
42.             public void onLogined() {  
43.                 System.out.println("监听到登录后。。。");  
44.             }  
45.         });  
46.           
47.     }  
48. }  

打印

[plain] view plaincopyprint?

1. 接收到数据变化的通知:  
2. 数据变更为：99  
3.   
4. 目标更新中....  
5. observer.UpdateWatcher@457471e0观察到：目标已经更新了  
6. observer.UpdateWatcher@5fe04cbf观察到：目标已经更新了  
7.   
8. 正在注册中...  
9. 监听到注册后。。。  
10. 正在登录中...  
11. 监听到登录后。。。