`

观察者模式observer

阅读更多
问题引人:订阅报纸的过程:
订阅者---》邮局-----》报社  (订阅过程) ,当报社按照出报时间推出报纸时,将报纸交给邮局,邮局再交给订阅者,当报社有新报纸出版的时候,如何让多个订阅者知道呢?进一步抽象描述这个问题:当一个对象的状态发生改变的时候,如何让依赖于它的所有对象得到通知,并进行相应的处理呢?------》观察者模式
定义:定义对象间的一种一对多的关系,当一个对象状态发生变化,依赖于此对象的所有对象都会得到通知,并自动更新。
一个报纸对象会有多个人阅读,当报纸状态改变时,需要通知所有的订阅者。这就是典型的一对多关系。
观察者模式将多个订阅者称为观察者,obeserver,多个观察者观察的对象被称为目标:subject。
观察者模式的结构
Subject:目标对象,一个目标可以被多个观察者观察,目标提供对观察者的注册和退订的维护,目标状态变化时,目标负责通知所有的观察者
Observer:定义观察者接口,提供目标通知时的更新方法。
ConcreteSubject:具体目标对象,用来维护目标状态。
ConcreteObserver:观察者具体实现对象,用来接收目标的通知,并进行相应的后续处理,比如更新自己的状态等。
其示例代码见包observer中。
package observer;
//观察者接口,定义一个更新的接口,当目标发生变化时,更新
public interface Observer {

	public void update(Subject subject);
}


package observer;

public class ConcreteObserver implements Observer {

	private String observerState; // 观察者状态

	@Override
	public void update(Subject subject) {
		// 示意方法,使其与目标对象状态一致
		observerState = ((ConcreteSubject) subject).getSubjectState();
	}

}


package observer;

import java.util.ArrayList;
import java.util.List;

//目标对象,它知道观察它的观察者,如报社知道报纸订阅人
public class Subject {

	//用于保存注册的观察者对象,如报社包含报纸的订阅人列表
	private List<Observer> observers = new ArrayList<Observer>();
	
//	注册观察者
	public void attach(Observer observer){
		observers.add(observer);
	}
	
//	删除观察者
	public void detach(Observer observer){
		observers.remove(observer);
	}
	
	//通知所有注册的观察者对象,
	protected void notifyObservers(){
		for(Observer observer:observers){
			observer.update(this);
		}
	}
}


package observer;
//具体的目标对象
public class ConcreteSubject extends Subject {

//	示意,目标对象的状态
	private String subjectState;

	public String getSubjectState() {
		return subjectState;
	}

	public void setSubjectState(String subjectState) {
		this.subjectState = subjectState;
//		状态发生变化,通知所有的观察者
		this.notifyObservers();
	}
	
	
}


解决上述问题:报纸为目标对象,阅报人为观察者,见observerSolve包
package observerSolve;
//观察者接口,定义一个更新的接口,当目标发生变化时,更新
public interface Observer {

	public void update(Subject subject);
}

package observerSolve;

public class Reader implements Observer {

	private String name;
	@Override
	public void update(Subject subject) {

		//被通知后执行的操作,这里是拉的方式,观察者会回调目标对象的方法
		
		System.out.println(name+"收到报纸了,阅读它。内容是==="+((NewsPaper) subject).getContent());
		
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	

}


package observerSolve;

import java.util.ArrayList;
import java.util.List;

//目标对象,它知道观察它的观察者,如报社知道报纸订阅人
public class Subject {

	//用于保存注册的观察者对象,如报社包含报纸的订阅人列表
	private List<Observer> observers = new ArrayList<Observer>();
	
//	注册观察者,即订阅人
	public void attach(Observer observer){
		observers.add(observer);
	}
	
//	删除观察者,可以取消订阅
	public void detach(Observer observer){
		observers.remove(observer);
	}
	
	//通知所有注册的观察者对象,每当报纸印刷出来后,就迅速通知读者
	protected void notifyObservers(){
		for(Observer observer:observers){
			observer.update(this);
		}
	}
}

package observerSolve;

public class NewsPaper extends Subject {

//	报纸的内容
	private String content;

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
		this.notifyObservers(); //内容有了,说明出了新报纸了,就通知所有的读者
	}
	
	
}


package observerSolve;

public class Client {

	public static void main(String[] args){
		//创建目标对象,报纸
		NewsPaper news  = new NewsPaper();
		
//		创建观察者,即阅读者
		Reader r1 = new Reader();
		r1.setName("张三");
		
		Reader r2 = new Reader();
		r2.setName("李四");
		
		Reader r3 = new Reader();
		r3.setName("王五");
		
//		将观察者注册到目标对象中去
		news.attach(r3);
		news.attach(r2);
		news.attach(r1);
		
//		目标对象内容改变,即要出报纸了
		news.setContent("学习设计模式");
		
	}
}

观察者和目标是单向的,即只有观察者依赖目标,目标是处于主动地位的,如果一个观察者观察多个目标,就需要定义多个回调函数,即多个update函数。
在观察者模式中,又存在推模型和拉模型
推:目标对象主动向观察者推送目标的详细信息,不管观察者是否需要,相当于在广播通信。
拉:目标对象通知观察者时,只传递少量信息。如果观察者需要更多,由观察者到目标对象主动获取。前面实例是典型的拉模型
推模型实例见pushObserver
java中的观察者模式,java.util包中的Observer接口,定义了update方法,就是观察者接口,Observable类,实现类大部分我们需要的目标的功能
package javaObserver;

import java.util.Observable;

//报纸对象,具体的目标实现,利用java的类,无需Subject类
public class NewsPaper extends Observable {

//	报纸的内容
	private String content;

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
		
		
		this.setChanged();//在用java中的观察者模式时,这句必不可少
		this.notifyObservers(this.content); //内容有了,说明出了新报纸了,就通知所有的读者,推的方式
//		this.notifyObservers();//拉的方式
	}
	
	public String toString(){
		return content;
	}
	
	
}

package javaObserver;

import java.util.Observable;
import java.util.Observer;

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 o, Object arg) {

		System.out.println(name+"收到报纸了,阅读它。目标对象推过来的内容是==="+o); //推方式
		System.out.println(name+"收到报纸了,阅读它。主动去目标对象去拉的内容是==="+((NewsPaper) o).getContent()); //拉方式

	}
}

package javaObserver;

public class Client {

	public static void main(String[] args){
		//创建目标对象,报纸
		NewsPaper news  = new NewsPaper();
		
//		创建观察者,即阅读者
		Reader r1 = new Reader();
		r1.setName("张三");
		
		Reader r2 = new Reader();
		r2.setName("李四");
		
		Reader r3 = new Reader();
		r3.setName("王五");
		
//		将观察者注册到目标对象中去,java中的类方法
		news.addObserver(r1);
		news.addObserver(r2);
		news.addObserver(r3);
		
//		目标对象内容改变,即要出报纸了
		news.setContent("学习设计模式");
		
	}
}


本质:触发联动
swing就相当于观察者模式
简单变形示例=====区别对待观察者(前面的示例中,观察者对于目标对象而言都是平等的)
水质监测,涉及到监测员,预警人,和监测部门领导,水质正常污染,无需将状态传递给所有的观察者,传给监测员,以此类推。。。
见waterPollution包中示例
package waterPollution;
//水质观察者的接口
public interface WatcherObserver {
	public void update(WaterQualitySubject subject);
	public void setJob(String job); //设置观察者职务
	public String getJob();
}


package waterPollution;

import javaObserver.NewsPaper;

//具体的观察者实现
public class Watcher implements WatcherObserver {
	
	private String job;

	@Override
	public String getJob() {
		return job;
	}

	@Override
	public void setJob(String job) {

		this.job = job;
	}

	@Override
	public void update(WaterQualitySubject subject) {
//   采用拉方式
		System.out.println(job+"获取到通知,当前污染级别为:"+subject.getPolluteLevel()); //拉方式
	}

}

package waterPollution;

import java.util.ArrayList;
import java.util.List;

import observer.Observer;

public abstract class WaterQualitySubject {

	

	protected List<WatcherObserver> observers = new ArrayList<WatcherObserver>();
	
	
//	注册观察者
	public void attach(WatcherObserver observer){
		observers.add(observer);
	}
	
//	删除观察者
	public void detach(WatcherObserver observer){
		observers.remove(observer);
	}
	
	//通知所有注册的观察者对象,
	public abstract void notifyWatchers();
	public abstract int getPolluteLevel();
	
}


package waterPollution;

//具体的水质监测对象
public class WaterQuality extends WaterQualitySubject {

	private int polluteLevel = 0;

	@Override
	public int getPolluteLevel() {
		return polluteLevel;
	}

	public void setPolluteLevel(int polluteLevel) {
		this.polluteLevel = polluteLevel;
		this.notifyWatchers();
	}

	@Override
	public void notifyWatchers() { // 根据污染级别不同,通知的人员也不同,这里观察者不是同级的了
		// 循环所有注册的观察者
		for (WatcherObserver observer : observers) {
			// 根据污染级别判断是否需要通知,
			if (this.polluteLevel >= 0) {
				// 通知监测员做记录
				if ("监测员".equals(observer.getJob())) {
					observer.update(this);
				}
			}
			if (polluteLevel >= 1) {
				// 通知预警人员
				if ("预警人员".equals(observer.getJob())) {
					observer.update(this);
				}
			}
			if (this.polluteLevel >= 2) {
				// 通知监测部门领导
				if ("监测部门领导".equals(observer.getJob())) {
					observer.update(this);
				}
			}

		}

	}

}


package waterPollution;

public class Client {

public static void main(String[] args) {

WaterQuality subject = new WaterQuality();//创建水质对象

// 创建几个观察者
WatcherObserver w1 = new Watcher();
w1.setJob("监测员");
WatcherObserver w2 = new Watcher();
w2.setJob("预警人员");
WatcherObserver w3 = new Watcher();
w3.setJob("监测部门领导");

// 注册观察者
subject.attach(w3);
subject.attach(w2);
subject.attach(w1);

System.out.println("当水质为正常的时候------------");
subject.setPolluteLevel(0);

System.out.println("当水质为轻度污染的时候------------");
subject.setPolluteLevel(1);

System.out.println("当水质为中度污染的时候------------");
subject.setPolluteLevel(2);

}

}
执行结果:
当水质为正常的时候------------
监测员获取到通知,当前污染级别为:0
当水质为轻度污染的时候------------
预警人员获取到通知,当前污染级别为:1
监测员获取到通知,当前污染级别为:1
当水质为中度污染的时候------------
监测部门领导获取到通知,当前污染级别为:2
预警人员获取到通知,当前污染级别为:2
监测员获取到通知,当前污染级别为:2
分享到:
评论

相关推荐

    观察者模式Observer

    观察者模式(Observer)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式在软件开发中广泛应用于事件处理和实时...

    swift-Swiftµframework实现观察者模式Observerpattern

    Swift µframework 实现观察者模式Observer pattern

    设计模式之观察者模式(Observer Pattern)

    "ObserverPattern(订阅模式)3.zip"中的代码可能进一步阐述了观察者模式,这里的“订阅”一词可能意味着用户可以订阅特定的主题,只有当这些主题的状态改变时,用户才会收到通知。这与传统的观察者模式类似,但更加...

    设计模式C++学习之观察者模式(Observer)

    观察者模式(Observer)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式在C++中广泛应用,特别是在需要...

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

    观察者模式(Observer)是软件设计模式中的一种行为模式,其主要目的是在对象之间建立一种松散耦合的关系,使得当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式广泛应用于事件驱动...

    观察者模式(Observer)

    观察者模式(Observer)是一种行为设计模式,它允许你定义一个订阅机制,可以在对象状态变化时通知多个“观察”该对象的其他对象。这个模式在软件工程中扮演着重要角色,尤其是在事件驱动编程和发布/订阅系统中。...

    观察者(Observer)模式

    观察者模式的核心概念是主体(Subject)和观察者(Observer)。主体是被观察的对象,它维护了一个观察者列表,并提供了添加、删除观察者以及通知所有观察者的接口。观察者关注主体的状态变化,并在主体状态改变时...

    观察者模式(Observer)

    观察者模式(Observer)是一种行为设计模式,它允许你定义一个订阅机制,可以在对象状态变化时通知多个“观察”该对象的其他对象。这个模式在软件工程中广泛应用于事件驱动编程,例如用户界面组件的交互或者系统状态的...

    观察者模式,Observer

    观察者模式(Observer Pattern)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式常用于实现事件驱动的系统或者...

    C++设计模式之观察者模式(Observer)

    观察者模式通常的叫法叫做订阅-发布模式,类似于报刊杂志的订阅,观察者和被观察者就是读者和邮局的关系,读者先要在邮局订阅想要的报刊,当报刊发行时,邮局会将报刊邮寄到读者家里。观察者(Observer)和被观察者...

    [行为模式]head first 设计模式之观察者模式(observer)

    观察者模式(Observer Pattern)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式在软件开发中广泛应用于事件驱动...

    C#面向对象设计模式纵横谈(19):(行为型模式) Observer 观察者模式 (Level 300)

    **C#面向对象设计模式纵横谈(19)**:**观察者模式**(Observer Pattern)是行为型模式的一种,它在软件工程中扮演着至关重要的角色。观察者模式是一种设计模式,它定义了对象之间的一对多依赖关系,当一个对象的状态...

    Observer 观察者模式 示例 源码 ----设计模式

    观察者模式 概述 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。 适用性 1.当一个抽象模型有两个方面,其中一个方面依赖于另一方面。 将这二者封装...

    使用MFC实现观察者模式(Observer)同时兼顾多窗口之间传值

    观察者模式(Observer)是一种设计模式,它定义了对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。在MFC(Microsoft Foundation Classes)框架中,我们可以...

    android Observer(观察者模式)_案例祥解.pdf

    观察者模式详解 观察者模式是23种设计模式中的一种,尤其是在软件设计过程中体现的更是立足无穷。本文将详细讲解观察者模式的概念和实现,通过代码注释来解释各个组件的作用。 一、观察者模式的定义 观察者模式是...

    observer观察者模式

    观察者模式(Observer Pattern)是一种行为设计模式,它允许你定义一个订阅机制,可以在对象状态改变时通知多个“观察”该对象的其他对象。在软件工程中,这常用于实现事件驱动编程,使得系统能够及时响应变化。 在...

    观察者(Observer)模式详解

    观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动编程或者...

    设计模式实现——观察者模式

    观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现发布-订阅...

Global site tag (gtag.js) - Google Analytics