http://blog.csdn.net/cjjky/article/details/7384951
【1】基本概念
观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一主题对象。这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己。观察者模式又叫发布-订阅(Publish/Subscribe)模式。
【2】简单分析
我们先来看一下该设计模式的UML结构图
上图是Observer 模式的结构图,让我们可以进行更方便的描述:
Subject类,它把所有对观察者对象的引用保存在一个聚集里,每个主题都可以有任何数量的观察着。抽象主题提供一个接口,可以增加和删除观察着对象。
Observer类,抽象观察者,为所有的具体观察者定义一个接口,在得到主题的通知时更新自己。
ConcreteSubject类,具体主题,将有关状态存入具体观察者对象;在具体主题的内部状态改变时,给所有登记过的观察者发出通知。
ConcreteObserver类,具体观察者,实现抽象观察者角色所要求的更新接口,以便使本身的状态与主题的状态相协调。
【3】如何用java语言来实现该模式
下面以一个简单的例子来展示该模式,先看下代码结构图:
该例子是这样的情景:例如:老师有电话号码,学生需要知道老师的电话号码以便于在合适的时候拨打,在这样的组合中,老师就是一个被观察者(Subject),学生就是需要知道信息的观察者,当老师的电话号码发生改变时,学生得到通知,并更新相应的电话记录。
3.1 先创建一个Subject类:
- 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();
- }
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类:
- package com.andyidea.patterns.observer;
- /**
- * Observer(观察者,Observer):
- * 为那些在目标发生改变时需要获得通知的对象定义一个更新接口。
- * @author Andy.Chen
- *
- */
- public interface Observer {
- public void update();
- }
package com.andyidea.patterns.observer;
/**
* Observer(观察者,Observer):
* 为那些在目标发生改变时需要获得通知的对象定义一个更新接口。
* @author Andy.Chen
*
*/
public interface Observer {
public void update();
}
3.3 创建ConcreteSubject类:
- 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();
- }
- @Override
- public void attach(Observer mObserver) {
- students.add(mObserver);
- }
- @Override
- public void detach(Observer mObserver) {
- students.remove(mObserver);
- }
- @Override
- public 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();
- }
- }
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();
}
@Override
public void attach(Observer mObserver) {
students.add(mObserver);
}
@Override
public void detach(Observer mObserver) {
students.remove(mObserver);
}
@Override
public 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类:
- 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);
- }
- @Override
- public void update() {
- phone = mTeacher.getPhone();
- }
- }
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);
}
@Override
public void update() {
phone = mTeacher.getPhone();
}
}
3.5 客户端测试类:ObserverClient.java.
- 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();
- }
- }
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】程序运行结果如下:
- Welcome to Andy.Chen Blog!
- Observer Patterns.
- -------------------------------
- Name:Andy.Chen0
- Teacher'sphone:12345678
- Name:Andy.Chen1
- Teacher'sphone:12345678
- Name:Andy.Chen2
- Teacher'sphone:12345678
- Name:Andy.Chen0
- Teacher'sphone:87654321
- Name:Andy.Chen1
- Teacher'sphone:87654321
- Name:Andy.Chen2
- Teacher'sphone:87654321
Welcome to Andy.Chen Blog!
Observer Patterns.
-------------------------------
Name:Andy.Chen0
Teacher'sphone:12345678
Name:Andy.Chen1
Teacher'sphone:12345678
Name:Andy.Chen2
Teacher'sphone:12345678
Name:Andy.Chen0
Teacher'sphone:87654321
Name:Andy.Chen1
Teacher'sphone:87654321
Name:Andy.Chen2
Teacher'sphone:87654321
总结:观察者模式何时适用?
1.当一个抽象模型有两个方面,其中一个方面依赖于另一方面。将这二者封装在独立的对象中可以使他们各自独立地改变和复用。
2.当对一个对象的改变需要同时改变其它对象,而不知道具体由多少对象有待改变。
3.当一个对象必须通知其他对象,而它又不能假定其他对象是谁,换言之,你不希望这些对象是紧密耦合的。让耦合的双方都依赖于抽象,而不是依赖于具体。