java设计模式--观察者模式(Observer)
java设计模式--观察者模式(Observer)
观察者模式的定义:
定义对象间的一种一对多的依赖关系。当一个对象的状态发生改变时，所有依赖于它的对象
都得到通知并被自动更新。
认识观察者模式:
1.目标和观察者之间的关系:
按照模式的定义,目标和观察者之间是典型的一对多的关系。
但是要注意，如果观察者只有一个，也是可以的，这样就变相的实现了目标和观察者之间
一对一的关系。
2.观察者模式中有四种对象：
Subject(目标对象),
Observer(定义观察者接口),
ConcreteSubject(具体的目标实现对象),
ConcreteObserver(观察者的具体实现对象)
一个目标可以有任意多个观察者对象，一旦目标的状态发生了改变，所有注册的观察者都会等到通知，
然后各个观察者会对通知作出相应的响应，执行相应的业务功能处理，并使自己的状态和目标的状态保存一致。
Subject:目标对象接口，提供如下功能：
a.一个目标可以被多个观察者观察
b.目标提供对观察者注册和退订的维护
c.当目标的状态发生变化时,目标负责通知所有注册的，有效的观察者
Observer:观察者的接口，提供目标通知时对应的更新方法，这个方法进行相应的业务处理，可以在这个方法
里面回调目标对象，以获取目标对象的数据。
ConcreteSubject：具体的目标实现对象，用来维护目标状态，当目标对象的状态发生改变时，通知
所有注册的、有效的观察者，让观察者执行相应的处理。
ConcreteObserver：观察者的具体实现对象，用来接收目标的通知，并进行相应的后续处理，比如更新
自身的状态以保持和目标的相应状态一致。
举例：
import java.util.ArrayList; import java.util.List; /** * 功能: * 目标对象,作为被观察者,它知道观察它的观察者,并提供注册和删除观察者的接口 * @author Administrator * */ public class Subject { //用来保存注册的观察者对象,也就是报纸的订阅者 private List<Observer> readers = new ArrayList<Observer>(); /** * 功能: * 注册观察者对象（报纸的读者需要向报社订阅,先要注册） * @param observer 观察者对象 */ public void attach(Observer reader) { readers.add(reader); } /** * 功能: * 删除观察者对象（报纸的读者可以取消订阅） * @param observer */ public void detach(Observer reader) { readers.remove(reader); } /** * 功能: * 通知所有的观察者 * （当有报纸出版后，就要主动的送到读者手中，相当于通知读者） */ protected void notifyAllObservers() { for(Observer reader : readers) { reader.update(this); } } }
/** * 功能: * 具体的目标对象,负责把有关状态存入到相应的观察者对象 * 并在自己状态发生改变时,通知各个观察者 * （报纸对象） * @author Administrator * */ public class NewPaper extends Subject { //报纸的具体内容 private String content; /** * 功能: * 获取报纸的具体内容 * @return */ public String getContent() { return content; } /** * 功能: * 设置报纸的具体内容，相当于出版报纸 * @param content */ public void setContent(String content) { this.content = content; //通知所有注册的读者 this.notifyAllObservers(); } }
/** * 功能: * 观察者接口,定义一个更新的接口给那些在目标发生改变的时候被通知的对象 * （报纸的读者） * @author Administrator * */ public interface Observer { /** * 功能: * 更新的接口 * @param subject 传入目标对象,方便获取相应的目标对象的状态 */ public void update(Subject subject); }
/** * 功能: * 具体的观察者对象,实现更新的方法,使自身的状态和目标的状态保存一致 * （真正的读者） * @author Administrator * */ public class Reader implements Observer { //读者的姓名 private String name; @Override public void update(Subject subject) { //这里采用拉的方式 System.out.println(name + "收到报纸，内容为: "+ ((NewPaper)subject).getContent()); } public String getName() { return name; } public void setName(String name) { this.name = name; } }
public class Client { public static void main(String[] args) { //创建一个报纸，作为被观察者 NewPaper subject = new NewPaper(); //创建阅读者,也就是观察者 Reader reader1 = new Reader(); reader1.setName("罗纳尔多"); Reader reader2 = new Reader(); reader2.setName("贝克汉姆"); //注册观察者 subject.attach(reader1); subject.attach(reader2); subject.setContent("世界杯要开始了哦....."); } }
对上面的模式进行讲解：
一、目标和观察者之间的关系
按照模式的定义，目标和观察者之间是典型的一对多的关系。
但是，观察者也可以只有一个，这样就实现了目标和观察者之间一对一的关系。
同样，一个观察者可以观察多个目标。
观察者模式中的: 推模型和拉模型
推模型：
目标对象主动向观察者推送目标的详细信息，不管观察者是否需要，推送的信息通常是
目标对象的全部或部分数据
拉模型：
目标对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，
由观察者主动到目标对象中获取，相当于观察者从目标对象中拉数据。
将上面的代码通过推模型进行实现：
import java.util.ArrayList; import java.util.List; /** * 功能: * 目标对象，作为被观察者，使用推模型 * @author Administrator * */ public class Subject { //用来保存注册的观察者对象（报纸订阅者） private List<Observer> readers = new ArrayList<Observer>(); /** * 功能: * 注册观察者对象（报纸的读者需要向报社订阅,先要注册） * @param observer 观察者对象 */ public void attach(Observer reader) { readers.add(reader); } /** * 功能: * 删除观察者对象（报纸的读者可以取消订阅） * @param observer */ public void detach(Observer reader) { readers.remove(reader); } /** * 功能: * 通知所有的观察者 * （当有报纸出版后，就要主动的送到读者手中，相当于通知读者） */ protected void notifyAllObservers(String content) { for(Observer reader : readers) { reader.update(content); } } }
public class NewsPaper extends Subject { private String content; public String getContent() { return content; } public void setContent(String content) { this.content = content; //通知所有注册的观察者(读者) this.notifyAllObservers(content); } }
/** * 功能: * 观察者（报纸的读者） * @author Administrator * */ public interface Observer { /** * 功能: * 被通知的方法,直接把报纸的内容推送过来 * @param content */ public void update(String content); }
public class Reader implements Observer { //读者的姓名 private String name; @Override public void update(String content) { //这里采用推的方式 System.out.println(name + "收到报纸了，内容是:" + content); } public String getName() { return name; } public void setName(String name) { this.name = name; } }
public class Client { public static void main(String[] args) { //创建一个报纸，作为被观察者 NewsPaper subject = new NewsPaper(); //创建阅读者,也就是观察者 Reader reader1 = new Reader(); reader1.setName("罗纳尔多"); Reader reader2 = new Reader(); reader2.setName("贝克汉姆"); //注册观察者 subject.attach(reader1); subject.attach(reader2); subject.setContent("世界杯要开始了哦....."); } }
两种模型的比较： （1）推模型是假定目标对象知道观察者需要的数据；而拉模型是目标对象不知道观察者具体 需要什么数据，没有办法的情况下，把自身传给观察者，让观察者自己去按需取值。 （2）推模型可能会使得观察者对象难以复用，因为观察者定义的update方法是按需而定义的， 可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能需要提供新的update方法， 或者干脆重新实现观察者。 java中的观察者 在java.util包里面有一个类Observable,实现了大部分目标的功能。 java.util包里面有一个类Observer，其中定义了update的方法，就是观察者的接口
import java.util.Observable; public class NewsPaper extends Observable { //报纸的具体内容 private String content; /** * 功能: * 获取报纸的具体内容 * @return */ public String getContent() { return content; } /** * 功能: * 设置报纸的具体内容,相当于出版报纸 * @param content */ public void setContent(String content) { this.content = content; //通知观察者 this.setChanged(); this.notifyObservers(this.content);//采用推的方法 } }
import java.util.Observable; import java.util.Observer; /** * 功能: * 观察者（读者） * @author Administrator * */ public class Reader implements Observer { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public void update(Observable arg0, Object obj) { System.out.println(name + "收到报纸了，内容为:"+obj); } }
public class Client { public static void main(String[] args) { //创建一个报纸，作为被观察者 NewsPaper subject = new NewsPaper(); //创建阅读者，也就是观察者 Reader reader1 = new Reader(); reader1.setName("罗纳尔多"); Reader reader2 = new Reader(); reader2.setName("贝克汉姆"); //注册阅读者 subject.addObserver(reader1); subject.addObserver(reader2); //出版报纸 subject.setContent("世界杯要开始了咯"); } }
观察者模式的本质：触发联动
当修改目标对象的状态的时候，就会触发相应的通知，然后会循环的调用所有注册的观察者对象
的相应方法，其实就相当于联动调用这些观察者的方法。
这个联动还是动态的，可以通过注册和取消注册来控制观察者，因而可以可以在程序运行期间，
通过动态的控制观察者，来变相地实现添加和删除某些功能处理，这些功能就是观察者在update的
时候执行的功能。
