设计模式之七 --- 观察者模式(Observer)

http://blog.csdn.net/cjjky/article/details/7384951

 

 

【1】基本概念

          观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。观察者模式又叫发布-订阅(Publish/Subscribe)模式。

【2】简单分析

 我们先来看一下该设计模式的UML结构图

上图是Observer 模式的结构图,让我们可以进行更方便的描述:

Subject类，它把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察着。抽象主题提供一个接口，可以增加和删除观察着对象。

Observer类，抽象观察者，为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。

ConcreteSubject类，具体主题，将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。

ConcreteObserver类，具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。

【3】如何用java语言来实现该模式

下面以一个简单的例子来展示该模式，先看下代码结构图：

该例子是这样的情景：例如：老师有电话号码，学生需要知道老师的电话号码以便于在合适的时候拨打，在这样的组合中，老师就是一个被观察者（Subject），学生就是需要知道信息的观察者，当老师的电话号码发生改变时，学生得到通知，并更新相应的电话记录。

3.1 先创建一个Subject类：

[html] view plaincopyprint?

1. package com.andyidea.patterns.subject;  
2.   
3. import com.andyidea.patterns.observer.Observer;  
4.   
5. /**  
6.  * Subject(目标，Subject)：    
7.  * 目标知道它的观察者。可以有任意多个观察者观察同一个目标。  
8.  * 提供注册和删除观察者对象的接口。  
9.  * @author Andy.Chen  
10.  *  
11.  */  
12. public interface Subject {  
13.   
14.     public void attach(Observer mObserver);  
15.       
16.     public void detach(Observer mObserver);  
17.       
18.     public void notice();  
19. }  

package com.andyidea.patterns.subject;import com.andyidea.patterns.observer.Observer;/** * Subject(目标，Subject)：   * 目标知道它的观察者。可以有任意多个观察者观察同一个目标。 * 提供注册和删除观察者对象的接口。 * @author Andy.Chen * */public interface Subject {public void attach(Observer mObserver);public void detach(Observer mObserver);public void notice();}

3.2 创建Observer类：

[html] view plaincopyprint?

1. package com.andyidea.patterns.observer;  
2.   
3. /**  
4.  * Observer(观察者，Observer)：  
5.  * 为那些在目标发生改变时需要获得通知的对象定义一个更新接口。  
6.  * @author Andy.Chen  
7.  *  
8.  */  
9. public interface Observer {  
10.   
11.     public void update();  
12. }  

package com.andyidea.patterns.observer;/** * Observer(观察者，Observer)： * 为那些在目标发生改变时需要获得通知的对象定义一个更新接口。 * @author Andy.Chen * */public interface Observer {public void update();}

3.3 创建ConcreteSubject类：

[html] view plaincopyprint?

1. package com.andyidea.patterns.concretesubject;  
2.   
3. import java.util.Vector;  
4.   
5. import com.andyidea.patterns.observer.Observer;  
6. import com.andyidea.patterns.subject.Subject;  
7.   
8. /**  
9.  * ConcreteSubject(具体目标，Teacher)  
10.  * 将有关状态存入各ConcreteObserve对象。  
11.  * 当他的状态发生改变时，向他的各个观察者发出通知。  
12.  * @author Andy.Chen  
13.  *  
14.  */  
15. public class Teacher implements Subject{  
16.       
17.     private String phone;  
18.     private Vector students;  
19.       
20.     public Teacher(){  
21.         phone = "";  
22.         students = new Vector();  
23.     }  
24.   
25.     @Override  
26.     public void attach(Observer mObserver) {  
27.         students.add(mObserver);  
28.     }  
29.   
30.     @Override  
31.     public void detach(Observer mObserver) {  
32.         students.remove(mObserver);  
33.     }  
34.   
35.     @Override  
36.     public void notice() {  
37.         for(int i=0;i<students.size();i++){  
38.             ((Observer)students.get(i)).update();  
39.         }  
40.     }  
41.   
42.     public String getPhone() {  
43.         return phone;  
44.     }  
45.   
46.     public void setPhone(String phone) {  
47.         this.phone = phone;  
48.         notice();  
49.     }  
50.   
51. }  

package com.andyidea.patterns.concretesubject;import java.util.Vector;import com.andyidea.patterns.observer.Observer;import com.andyidea.patterns.subject.Subject;/** * ConcreteSubject(具体目标，Teacher) * 将有关状态存入各ConcreteObserve对象。 * 当他的状态发生改变时，向他的各个观察者发出通知。 * @author Andy.Chen * */public class Teacher implements Subject{private String phone;private Vector students;public Teacher(){phone = "";students = new Vector();}@Overridepublic void attach(Observer mObserver) {students.add(mObserver);}@Overridepublic void detach(Observer mObserver) {students.remove(mObserver);}@Overridepublic void notice() {for(int i=0;i<students.size();i++){((Observer)students.get(i)).update();}}public String getPhone() {return phone;}public void setPhone(String phone) {this.phone = phone;notice();}}

3.4 创建ConcreteObserver类：

[html] view plaincopyprint?

1. package com.andyidea.patterns.concreteobserver;  
2.   
3. import com.andyidea.patterns.concretesubject.Teacher;  
4. import com.andyidea.patterns.observer.Observer;  
5.   
6. /**  
7.  * ConcreteObserver(具体观察者, Student)：  
8.  * 维护一个指向ConcreteSubject对象的引用。  
9.  * 存储有关状态，这些状态应与目标的状态保持一致。  
10.  * 实现Observer的更新接口以使自身状态与目标的状态保持一致。  
11.  * @author Andy.Chen  
12.  *  
13.  */  
14. public class Student implements Observer{  
15.   
16.     private String name;  
17.     private String phone;  
18.     private Teacher mTeacher;  
19.       
20.     public Student(String name,Teacher t){  
21.        this.name = name;  
22.        mTeacher = t;  
23.     }  
24.       
25.     public void show(){  
26.        System.out.println("Name:"+name+"\nTeacher'sphone:" + phone);  
27.     }  
28.       
29.     @Override  
30.     public void update() {  
31.         phone = mTeacher.getPhone();  
32.     }  
33.   
34. }  

package com.andyidea.patterns.concreteobserver;import com.andyidea.patterns.concretesubject.Teacher;import com.andyidea.patterns.observer.Observer;/** * ConcreteObserver(具体观察者, Student)： * 维护一个指向ConcreteSubject对象的引用。 * 存储有关状态，这些状态应与目标的状态保持一致。 * 实现Observer的更新接口以使自身状态与目标的状态保持一致。 * @author Andy.Chen * */public class Student implements Observer{private String name;    private String phone;    private Teacher mTeacher;        public Student(String name,Teacher t){       this.name = name;       mTeacher = t;    }        public void show(){       System.out.println("Name:"+name+"\nTeacher'sphone:" + phone);    }@Overridepublic void update() {phone = mTeacher.getPhone();}}

3.5 客户端测试类:ObserverClient.java.

[html] view plaincopyprint?

1. package com.andyidea.patterns.client;  
2.   
3. import java.util.Vector;  
4.   
5. import com.andyidea.patterns.concreteobserver.Student;  
6. import com.andyidea.patterns.concretesubject.Teacher;  
7.   
8. /**  
9.  * 观察者(Observer)模式测试类  
10.  * @author Andy.Chen  
11.  *  
12.  */  
13. public class ObserverClient {  
14.   
15.     public static void main(String[] args) {  
16.        Vector students = new Vector();  
17.        Teacher t = new Teacher();  
18.        for(int i= 0 ;i<10;i++){  
19.            Student st = new Student("Andy.Chen"+i,t);  
20.            students.add(st);  
21.            t.attach(st);  
22.        }  
23.          
24.         System.out.println("Welcome to Andy.Chen Blog!" +"\n"   
25.                    +"Observer Patterns." +"\n"  
26.                    +"-------------------------------");  
27.          
28.        t.setPhone("12345678");  
29.        for(int i=0;i<3;i++)  
30.            ((Student)students.get(i)).show();  
31.          
32.        t.setPhone("87654321");  
33.        for(int i=0;i<3;i++)  
34.            ((Student)students.get(i)).show();  
35.     }  
36.       
37. }  

package com.andyidea.patterns.client;import java.util.Vector;import com.andyidea.patterns.concreteobserver.Student;import com.andyidea.patterns.concretesubject.Teacher;/** * 观察者(Observer)模式测试类 * @author Andy.Chen * */public class ObserverClient {public static void main(String[] args) {   Vector students = new Vector();       Teacher t = new Teacher();       for(int i= 0 ;i<10;i++){           Student st = new Student("Andy.Chen"+i,t);           students.add(st);           t.attach(st);       }       System.out.println("Welcome to Andy.Chen Blog!" +"\n"            +"Observer Patterns." +"\n"           +"-------------------------------");              t.setPhone("12345678");       for(int i=0;i<3;i++)           ((Student)students.get(i)).show();              t.setPhone("87654321");       for(int i=0;i<3;i++)           ((Student)students.get(i)).show();}}

【4】程序运行结果如下：

[html] view plaincopyprint?

1. Welcome to Andy.Chen Blog!  
2. Observer Patterns.  
3. -------------------------------  
4. Name:Andy.Chen0  
5. Teacher'sphone:12345678  
6. Name:Andy.Chen1  
7. Teacher'sphone:12345678  
8. Name:Andy.Chen2  
9. Teacher'sphone:12345678  
10. Name:Andy.Chen0  
11. Teacher'sphone:87654321  
12. Name:Andy.Chen1  
13. Teacher'sphone:87654321  
14. Name:Andy.Chen2  
15. Teacher'sphone:87654321  

Welcome to Andy.Chen Blog!Observer Patterns.-------------------------------Name:Andy.Chen0Teacher'sphone:12345678Name:Andy.Chen1Teacher'sphone:12345678Name:Andy.Chen2Teacher'sphone:12345678Name:Andy.Chen0Teacher'sphone:87654321Name:Andy.Chen1Teacher'sphone:87654321Name:Andy.Chen2Teacher'sphone:87654321

总结：观察者模式何时适用？

1.当一个抽象模型有两个方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中可以使他们各自独立地改变和复用。

2.当对一个对象的改变需要同时改变其它对象，而不知道具体由多少对象有待改变。

3.当一个对象必须通知其他对象，而它又不能假定其他对象是谁，换言之，你不希望这些对象是紧密耦合的。让耦合的双方都依赖于抽象，而不是依赖于具体。