在慕课网上学习了观察者模式，故做个笔记温习巩固一下http://www.imooc.com/learn/415
自己写一个经典观察者模式
观察者模式定义
定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都得到了通知并自动更新。
好处：统一通知，各自处理。
认识观察者（六大方面）：
1、目标与观察者之间的关系(1VS1、1VSn、nVS1)
2、单向依赖（又称为订阅发布模式）
3、命名建议
1、目标接口的定义，建议在名称后跟Subject
2、观察者接口的定义，建议在名称后跟Observer
3、观察者接口的更新方法，建议命名为update，参数个数及类型不受限制。
4、触发通知的时机（完成状态维护后触发）
5、观察者模式的调用
6、通知的顺序（多个观察者之间的关系是平行的，不可以有依赖关系）
以下为一个经典的观察者模型。
package com.observer;
import com.subject.Subject;
/**
* 这是一个观察者接口，定义一个更新的接口给那些在目标发生改变的时候被通知的对象
*
* @author Administrator
*
*/
public interface Observer {
/**
* 更新的接口
* @param subject 传入目标对象，方便获取相应的目标对象的状态
*/
public void update(Subject subject);
}
package com.observer;
import com.subject.ConcreteSubject;
import com.subject.Subject;
/**
* 具体的观察者对象，实现更新的方法
* @author Administrator
*
*/
public class ConcreteObserver implements Observer {
//观察者的状态
private String observerState;
/**
* 获取目标类的状态同步到观察者的状态中
*/
@Override
public void update(Subject subject) {
observerState = ((ConcreteSubject) subject).getSubjectState();
}
}
package com.subject;
import java.util.ArrayList;
import java.util.List;
import com.observer.Observer;
/**
* 目标对象，它知道观察它的观察者，并提供注册（添加）和删除观察者的接口
* @author Administrator
*
*/
public class Subject {
//用来保存注册的观察者对象
private List<Observer> observers = new ArrayList<Observer>();
//attach detach notifyObservers
public void attach(Observer observer){
observers.add(observer);
}
/**
* 删除集合中的指定观察者
* @param observer
*/
public void detach(Observer observer){
observers.remove(observer);
}
/**
* 通知所有注册的观察者对象
*/
protected void notifyObservers(){
for (Observer observer : observers) {
observer.update(this);
}
}
}
package com.subject;
/**
* 具体的目标对象，负责把有关状态存入到相应的观察者对象中
* @author Administrator
*
*/
public class ConcreteSubject extends Subject{
//目标对象的状态
private String subjectState;
public String getSubjectState() {
return subjectState;
}
public void setSubjectState(String subjectState) {
this.subjectState = subjectState;
this.notifyObservers();//通知
}
}
推模型和拉模型
推模型：
目标对象主动向观察者推送目标的详细信息
推送的信息通常都是目标对象的全部或部分数据
拉模型：
目标对象在通知观察者时，只传递少量信息
如果观察者需要更具体的信息，由观察者主动到目标对象中获取，相当于是观察者从目标对象中拉数据
一般这种模型的实现，会把目标对象通过update方法传递给观察者
比较：
推模型是假定目标对象知道观察者需要的数据
拉模型是目标对象不知道观察者具体需要什么数据，因此把自身传给观察者，由观察者来取值
推模型会使观察者对象难以复用
拉模型下，update方法的参数是目标对象本身，基本上可以适应各种情况的需要。
一下是经典的观察者模型的一个实用的案例
package com.observer;
import com.subject.WeatherSubject;
/**
* 这是一个观察者接口，定义一个更新的接口给那些在目标发生改变的时候被通知的对象
*
* @author Administrator
*
*/
public interface Observer {
/**
* 更新的接口
* @param subject 传入目标对象，方便获取相应的目标对象的状态
*/
public void update(WeatherSubject subject);
}
package com.observer;
import com.subject.ConcreteWeatherSubject;
import com.subject.WeatherSubject;
/**
* 具体的观察者对象，实现更新的方法
*
* @author Administrator
*
*/
public class ConcreteObserver implements Observer {
// 观察者的名字，是谁收到了这个讯息
private String observerName;
// 天气内容的情况，这个消息从目标出获取
private String weatherContent;
// 提醒的内容
private String remindThing;
public String getObserverName() {
return observerName;
}
public void setObserverName(String observerName) {
this.observerName = observerName;
}
public String getWeatherContent() {
return weatherContent;
}
public void setWeatherContent(String weatherContent) {
this.weatherContent = weatherContent;
}
public String getRemindThing() {
return remindThing;
}
public void setRemindThing(String remindThing) {
this.remindThing = remindThing;
}
/**
* 获取目标类的状态同步到观察者的状态中
*/
@Override
public void update(WeatherSubject subject) {
weatherContent = ((ConcreteWeatherSubject) subject).getWearherContent();
System.out.println(observerName + "收到了" + weatherContent + "," + remindThing);
}
}
package com.subject;
import java.util.ArrayList;
import java.util.List;
import com.observer.Observer;
/**
* 目标对象，它知道观察它的观察者，并提供注册（添加）和删除观察者的接口
* @author Administrator
*
*/
public class WeatherSubject {
//用来保存注册的观察者对象
private List<Observer> observers = new ArrayList<Observer>();
//attach detach notifyObservers
/**
* 把订阅天气的人添加到观察者列表
* @param observer
*/
public void attach(Observer observer){
observers.add(observer);
}
/**
* 删除集合中的指定订阅天气的人
* @param observer
*/
public void detach(Observer observer){
observers.remove(observer);
}
/**
* 通知所有已经订阅天气的人
*/
protected void notifyObservers(){
for (Observer observer : observers) {
observer.update(this);
}
}
}
package com.subject;
/**
* 具体的目标对象，负责把有关状态存入到相应的观察者对象中
* @author Administrator
*
*/
public class ConcreteWeatherSubject extends WeatherSubject{
//获取天气的内容信息
private String wearherContent;
public String getWearherContent() {
return wearherContent;
}
public void setWearherContent(String wearherContent) {
this.wearherContent = wearherContent;
//内容有了，说明天气更新了，通知所有订阅的人
this.notifyObservers();
}
}
package com.test;
import com.observer.ConcreteObserver;
import com.subject.ConcreteWeatherSubject;
public class Client {
public static void main(String[] args) {
//1、创建目标
ConcreteWeatherSubject weather = new ConcreteWeatherSubject();
//2、创建观察者
ConcreteObserver observerGirl = new ConcreteObserver();
observerGirl.setObserverName("美女");
observerGirl.setRemindThing("约吗？");
ConcreteObserver observerGirl2 = new ConcreteObserver();
observerGirl2.setObserverName("美女2号");
observerGirl2.setRemindThing("约不约？");
//3、注册观察者
weather.attach(observerGirl);
weather.attach(observerGirl2);
//4、目标发布天气
weather.setWearherContent("明天天气晴朗，蓝天白云");
}
}
Java自身也提供了观察者模式
java.util包下的Observable类中含有观察者模式的大部分方法，Observer接口中含有update方法
java实现观察者模式与自身实现的对比：
1、不需要再定义观察者和目标的接口了，JDK帮忙定义了。
2、具体的目标实现里面不需要再维护观察者的注册信息了，这个在Java的Observable类里面已经帮忙实现好了。
3、触发通知的方法有一点变化，需要调用setChanged方法，这个是java为了帮助实现更精确的触发控制而提供的功能
4、具体的观察者实现里面，update方法其实能同时支持推模型和拉模型。这是java在定义的时候，就已经考虑进去了
观察者模式的有点：
1、观察者模式实现了观察者和目标之间的抽象耦合
2、观察者模式实现了动态联动
3、观察者模式支持广播通信
观察者模式的缺点：可能会引起无畏的操作。
以下是使用java自带的观察者模式的一个案例
import java.util.Observable;
//天气目标的具体实现类
public class ConcreteWeatherSubject extends Observable {
//天气情况的内容
private String content;
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
//天气情况有了要通知所有的观察者
//注意在通知之前，在调用Java中的Observer模式时，下面这句话必不可少
this.setChanged();
//主动通知，这里使用的是推模型
this.notifyObservers(content);
/*
* 拉方法，不带参数
* this.notifyObservers();
*/
}
}
import java.util.Observable;
import java.util.Observer;
//具体的观察者对象
public class ConcreteObserver implements Observer {
// 定义观察者名称的对象
private String observerName;
@Override
public void update(Observable o, Object arg) {
//推模式
System.out.println(observerName+"收到了消息，目标推送过来的是："+arg);
//拉模式
System.out.println(observerName+"收到了消息，主动去目标拉取过来的是："+((ConcreteWeatherSubject)o).getContent());
}
public String getObserverName() {
return observerName;
}
public void setObserverName(String observerName) {
this.observerName = observerName;
}
}
public class Client {
public static void main(String[] args) {
//创建天气作为一个目标，也可以说是被观察者
ConcreteWeatherSubject subject = new ConcreteWeatherSubject();
//创建具体的观察者
ConcreteObserver girl = new ConcreteObserver();
girl.setObserverName("美女");
//创建具体的观察者
ConcreteObserver girl2 = new ConcreteObserver();
girl2.setObserverName("美女2号");
//注册观察者
subject.addObserver(girl);
subject.addObserver(girl2);
//目标更新天气情况了。
subject.setContent("天气更新了。");
}
}
区别对待的观察者模式
观察者模式适用情况：
1、当一个抽象模型有两个方面，其中一个方面的操作依赖于两一个方面的状态变化
2、更改一个对象的时候，需要同时连带改变其他的对象，而且不知道究竟需要有多少对象需要被连带改变
3、当一个对象必须通知其他的对象，但是你又希望这个对象和其他被通知的对象是松散耦合的。
在以上的案例中，加入不同的观察者希望接收目标的天气预报，而非目标内的天气预报不被接收。可以采用以下的案例。
package com.observer;
import com.subject.WeatherSubject;
public interface Observer {
//更新的接口
public void update(WeatherSubject subject);
//设置观察者名称
public void setObserverName(String observerName);
//取得观察者名称
public String getObserverName();
}
package com.observer;
import com.subject.ConcreteWeatherSubject;
import com.subject.WeatherSubject;
public class ConcreteObserver implements Observer {
// 观察者的名称
private String observerName;
// 天气情况的内容
private String weatherContent;
// 提醒的内容
private String remindThing;
@Override
public void update(WeatherSubject subject) {
weatherContent = ((ConcreteWeatherSubject)subject).getWeatherContent();
System.out.println(observerName+"收到了"+weatherContent+","+remindThing);
}
@Override
public void setObserverName(String observerName) {
this.observerName = observerName;
}
@Override
public String getObserverName() {
return observerName;
}
public String getWeatherContent() {
return weatherContent;
}
public void setWeatherContent(String weatherContent) {
this.weatherContent = weatherContent;
}
public String getRemindThing() {
return remindThing;
}
public void setRemindThing(String remindThing) {
this.remindThing = remindThing;
}
}
package com.subject;
import java.util.ArrayList;
import java.util.List;
import com.observer.Observer;
public abstract class WeatherSubject {
//用来保存注册的观察者对象
public List<Observer> observers = new ArrayList<Observer>();
public void attach(Observer observer){
observers.add(observer);
}
public void detach (Observer observer){
observers.remove(observer);
}
protected abstract void notifyObserver();
}
package com.subject;
import com.observer.Observer;
public class ConcreteWeatherSubject extends WeatherSubject {
// 晴天、下雨、下雪
// 目标对象的状态
private String weatherContent;
@Override
protected void notifyObserver() {
// 循环所有注册的观察者
for (Observer observer : observers) {
// 规则是：
// 黄明的女朋友需要“下雨”的条件
// 黄明的老妈需要“下雪”或者“下雨”的条件
// 如果天气是晴天
// do nothing
// 如果天气是下雨
if ("下雨".equals(this.getWeatherContent())) {
if ("黄明的女朋友".equals(observer.getObserverName())) {
observer.update(this);
}
if ("黄明的老妈".equals(observer.getObserverName())) {
observer.update(this);
}
}
// 如果天气是下雪
if ("下雪".equals(this.getWeatherContent())) {
if ("黄明的老妈".equals(observer.getObserverName())) {
observer.update(this);
}
}
}
}
public String getWeatherContent() {
return weatherContent;
}
public void setWeatherContent(String weatherContent) {
this.weatherContent = weatherContent;
this.notifyObserver();
}
}
package com.test;
import com.observer.ConcreteObserver;
import com.subject.ConcreteWeatherSubject;
public class Client {
public static void main(String[] args) {
//1、创建目标
ConcreteWeatherSubject weatherSubject = new ConcreteWeatherSubject();
//2、创建观察者
ConcreteObserver observerGirl = new ConcreteObserver();
observerGirl.setObserverName("黄明的女朋友");
observerGirl.setRemindThing("下雨了，安静的呆在家里吧");
ConcreteObserver observerMum = new ConcreteObserver();
observerMum.setObserverName("黄明的老妈");
observerMum.setRemindThing("不管下雨还是下雪，都不出门了");
//3、注册观察者
weatherSubject.attach(observerGirl);
weatherSubject.attach(observerMum);
//4、目标发布天气
weatherSubject.setWeatherContent("下雨");
System.out.println("+++++++++++++++++");
weatherSubject.setWeatherContent("下雪");
System.out.println("+++++++++++++++++");
weatherSubject.setWeatherContent("晴天");
}
}
1937
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
