被说了很多遍的设计模式---观察者模式

最新推荐文章于 2021-11-02 20:15:23 发布
最新推荐文章于 2021-11-02 20:15:23 发布
阅读量756 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 观察者模式 设计模式 教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ABCD898989/article/details/52948576
版权

[把你的理性思维慢慢变成条件反射]

本文，我们讲介绍观察者模式，文章主题结构与上文一致。惯例，先来看看我们示例工程的环境：

操作系统：win7 x64

其他软件：eclipse mars，jdk7

-------------------------------------------------------------------------------------------------------------------------------------

经典问题：

EventListener，publisher/subscriber，MQ，Spring MVC等等。

思路分析：

要点一：拥有消息发布方，消息接收方两个角色。

要点二：其中一方功能严重依赖于另一方功能。

示例工程：


错误写法：

创建Publisher.java文件，具体内容如下： 

package com.csdn.ingo.gof_Observer;

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

public class Publisher {
	private List<Subsriber> observers = new ArrayList<Subsriber>();
	
	private String action;
	
	public void attach(Subsriber observer){
		observers.add(observer);
	}
	public String getAction() {
		return action;
	}
	public void setAction(String action) {
		this.action = action;
	}
	public void notifya(){
		for(Subsriber so:observers){
			so.update();
		}
	}
}
创建Subscriber.java文件，具体内容如下： 
package com.csdn.ingo.gof_Observer;

public class Subsriber {
	private String name;
	private Publisher se;
	
	public Subsriber(String name, Publisher se) {
		super();
		this.name = name;
		this.se = se;
	}

	public void update() {
		System.out.println("name:"+name+",action:"+se.getAction());
	}
}
创建Window.java文件，具体内容如下： 

package com.csdn.ingo.gof_Observer;

public class Window {
	public static void main(String[] args) {
		Publisher pub = new Publisher();
		Subsriber sub1 = new Subsriber("sub1",pub);
		Subsriber sub2 = new Subsriber("sub2",pub);
		pub.attach(sub1);
		pub.attach(sub2);
		pub.setAction("start");
		pub.notifya();
	}
}

错误原因：

Publisher与Subscriber代码耦合度非常高。并且，新增Subscriber时，需要同时修改双方的内容。违反了“开闭原则”，“依赖倒转原则”，“迪米特法则”等。

错误写法（2）：

创建Observer.java文件，具体内容如下：

package com.csdn.ingo.gof_Observer.one;

public abstract class Observer {
	protected String name;
	protected Publisher sc;
	public Observer(String name, Publisher sc) {
		this.name = name;
		this.sc = sc;
	}
	public abstract void update();
}
创建Publisher.java文件，具体内容如下： 
package com.csdn.ingo.gof_Observer.one;

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

public class Publisher {
	private List<Observer> observers = new ArrayList<Observer>();
	
	private String action;
	
	public void attach(Observer observer){
		observers.add(observer);
	}
	public void detach(Observer observer){
		observers.remove(observer);
	}
	public String getAction() {
		return action;
	}
	public void setAction(String action) {
		this.action = action;
	}
	public void notifya(){
		for(Observer so:observers){
			so.update();
		}
	}
}
创建SubObserverA.java，SubObserverB.java文件，具体内容如下： 

package com.csdn.ingo.gof_Observer.one;

public class SubObserverA extends Observer {
	public SubObserverA(String name, Publisher sc) {
		super(name,sc);
	}

	public void update() {
		System.out.println("name:"+name+",action:"+sc.getAction()+",JOB-A");
	}
}
创建Window.java文件，具体内容如下： 
package com.csdn.ingo.gof_Observer.one;

public class Window {
	public static void main(String[] args) {
		Publisher pub = new Publisher();
		SubObserverB subob1 = new SubObserverB("subob1",pub);
		SubObserverA subob2 = new SubObserverA("subob2",pub);
		pub.attach(subob1);
		pub.attach(subob2);
		pub.setAction("start");
		pub.notifya();
	}
}<span style="font-family:Microsoft YaHei;font-size:14px;">
</span>

错误原因：

在上一个版本的基础之上，我们将Observer角色进行抽象，在一定程度上满足了Observer角色的变化不会影响Publisher。但是，对于Publisher本身而言，缺少抽象。即，Observer本身也不需要关注具体的消息发布者是谁？在MQ异步消息模型中，经常需要使用的就是这种模型。可能存在多个消息发布者，而无论哪一个消息发布者发出的消息，接受方都需要进行接受并处理。因此，我们还需要进一步优化模型结构。

推荐写法：


创建Observer.java文件，具体内容如下：

package com.csdn.ingo.gof_Observer.two;

public abstract class Observer {
	protected String name;
	protected Publisher sub;
	public Observer(String name, Publisher sub) {
		this.name = name;
		this.sub = sub;
	}
	public abstract void update();
}
创建Publisher.java文件，具体内容如下： 
public interface Publisher {
	void attach(Observer observer);
	void detach(Observer observer);
	void notifya();
	void setObserverState(String ObserverState);
	String getObserverState();
}
创建ConcretePublisherA.java文件，具体内容如下： 
package com.csdn.ingo.gof_Observer.two;

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

public class ConcretePublisherA implements Publisher{
	private List<Observer> observers = new ArrayList<Observer>();
	private String action;
	
	public void attach(Observer observer) {
		observers.add(observer);
	}

	public void detach(Observer observer) {
		observers.remove(observer);
	}

	public void notifya() {
		for(Observer so:observers){
			so.update();
		}
	}

	public void setObserverState(String oc) {
		this.action = oc;
	}

	public String getObserverState() {
		// TODO Auto-generated method stub
		return action;
	}
}
创建SubObserverA.java文件，具体内容如下： 
package com.csdn.ingo.gof_Observer.two;

public class SubObserverA extends Observer {
	public SubObserverA(String name, Publisher sub) {
		super(name,sub);
	}

	public void update() {
		System.out.println("name:"+name+",action:"+sub.getObserverState()+",JOB-A");
	}
}
创建Window.java文件，具体内容如下： 
public class Window {
	public static void main(String[] args) {
		Publisher wlw = new ConcretePublisherA();
		SubObserverB subob1 = new SubObserverB("s1", wlw);
		SubObserverA subob2 = new SubObserverA("n1", wlw);
		
		wlw.attach(subob2);
		wlw.attach(subob1);
		
		wlw.setObserverState("stop");
		wlw.notifya();
	}
}

推荐原因：

这里仅作为功能原始，在实际使用时，会存在共享变量帮助实现消息发布方的抽象。另外，修改之后的代码为面向接口编程，符合“单一职责原则”等。

模式总结：

标准观察者模式UML结构图：


概念总结：

观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同事监听某一个对象。这个主题对象在状态发生变化是，会通知所有观察者对象，使他们能够自动更新自己。

组成部分：Subject(抽象观察者合集)，ConcreteSubject(具体实现类)，Observer（抽象观察者），ConcreteObserver(具体观察者)四部分组成。

模板功能扩展：事件委托处理机制

委托，就是一种引用方法的类型。一旦委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以向其他任何方法一样，具有参数和返回值。委托可以看做是对函数的抽象，是函数的“类”，委托的实例将代表一个具体的函数。一个委托可以搭载多个方法，所有方法被一次唤起。并且，可以是委托对象所搭载的方法并不需要属于同一个类。特别的，委托对象所搭载的所有方法必须具有相同的原型和形式，也就是拥有相同的参数列表和返回值类型。


创建Event.java文件，具体内容如下：

package com.csdn.ingo.gof_Observer.three;

import java.lang.reflect.Method;

public class Event {
	// 要执行方法的对象
	private Object object;
	// 要执行的方法名称
	private String methodName;
	// 要执行方法的参数
	private Object[] params;
	// 要执行方法的参数类型
	private Class[] paramTypes;

	public Event() {

	}

	public Event(Object object, String methodName, Object... args) {
		this.object = object;
		this.methodName = methodName;
		this.params = args;
		contractParamTypes(this.params);
	}

	// 根据参数数组生成参数类型数组
	private void contractParamTypes(Object[] params) {
		this.paramTypes = new Class[params.length];
		for (int i = 0; i < params.length; i++) {
			this.paramTypes[i] = params[i].getClass();
		}
	}

	public void setParamTypes(Class[] paramTypes) {
		this.paramTypes = paramTypes;
	}

	// 执行该 对象的该方法
	public void invoke() throws Exception {
		Method method = object.getClass().getMethod(this.getMethodName(), this.getParamTypes());
		if (null == method) {
			return;
		}
		method.invoke(this.getObject(), this.getParams());
	}

	public String getMethodName() {
		return methodName;
	}

	public void setMethodName(String methodName) {
		this.methodName = methodName;
	}

	public Object[] getParams() {
		return params;
	}

	public void setParams(Object[] params) {
		this.params = params;
	}

	public Class[] getParamTypes() {
		return paramTypes;
	}

	public void setObject(Object object) {
		this.object = object;
	}
	public Object getObject() {
		return object;
	}
}
创建EventHandler.java文件，具体内容如下; 

package com.csdn.ingo.gof_Observer.three;

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

public class EventHandler {
	 //是用一个List   
    private List<Event> objects;   
       
    public EventHandler(){   
        objects=new ArrayList<Event>();   
    }   
    //添加某个对象要执行的事件，及需要的参数   
    public void addEvent(Object object,String methodName,Object...args){   
        objects.add(new Event(object,methodName,args));   
    } 
  //添加某个对象要执行的事件，及需要的参数   
    public void reEvent(Object object,String methodName,Object...args){   
        objects.add(new Event(object,methodName,args));   
    } 
    //通知所有的对象执行指定的事件   
    public void notifyX() throws Exception{   
        for(Event e : objects){   
            e.invoke();   
        }   
    }   
}
创建ListenerA.java，ListenerB.java文件，具体内容如下： 

package com.csdn.ingo.gof_Observer.three;

import java.util.Date;

public class ListenerA {
	public ListenerA(){
		System.out.println("ListenerA start listenering");
	}
	public void stop(Date date){
		System.out.println("ListenerA stop");
	}
}
创建Notifier.java文件，具体内容如下： 

package com.csdn.ingo.gof_Observer.three;

public abstract class Notifier {
	private EventHandler eventHandler = new EventHandler();

	public EventHandler getEventHandler() {
		return eventHandler;
	}

	public void setEventHandler(EventHandler eventHandler) {
		this.eventHandler = eventHandler;
	}

	public abstract void attach(Object obj, String methodName, Object... args);

	public abstract void detach(Object obj, String methodName, Object... args);

	public abstract void notifya();
}
创建NotifierA.java，NotifierB.java文件，具体内容如下： 

package com.csdn.ingo.gof_Observer.three;

public class NotifierA extends Notifier {
	
	@Override
	public void attach(Object object, String methodName, Object... args) {
		// TODO Auto-generated method stub
		System.out.println("add someone");
		this.getEventHandler().addEvent(object, methodName, args);
	}

	@Override
	public void detach(Object object, String methodName, Object... args) {
		System.out.println("re someone");
		this.getEventHandler().reEvent(object, methodName, args);
	}

	@Override
	public void notifya() {
		System.out.println("notify all");
		try {
			this.getEventHandler().notifyX();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}
创建Window.java文件，具体内容如下： 

package com.csdn.ingo.gof_Observer.three;

import java.util.Date;

public class Window {
	public static void main(String[] args) {
		Notifier n = new NotifierA();
		ListenerA la = new ListenerA();
		ListenerB lb = new ListenerB();
		n.attach(la, "stop", new Date());
		n.attach(lb, "stop", new Date());
		n.notifya();
	}
}

反思：

应用场景：

  1. 一个模型中存在两个方面，其中一个方面依赖于另一个方便，并且被依赖方具有独立性。
  2. 被依赖方的数量具有不确定性，即，消息的接受方数量不限。
  3. 模型中的依赖层级具有不缺定性。即，可能存在多级依赖时，建议使用松耦合的方式进行关联。

优点：

  1. 实现表现层与数据逻辑层的分离，定义了稳定的消息发布机制，使得观察者的角色不受类型限制。
  2. Publisher与Subscriber双向解耦，互相不知道其内部细节。
  3. 支持广播通信，简化一对多的模型设计。
  4. 满足“开闭原则”“单一职责原则”“依赖倒转原则”等。

缺点：

  1. 在没有高性能组件的支持下，通过循环通知所有Subscriber，可能会产生一定延迟。
  2. 依赖层级对于上层不可见，因此，如果发生多级依赖，可能造成程序设计，测试的复杂度上升。
  3. 完全的松耦合模型，可能会造成两个开发人员团队理解上的困难。

-------------------------------------------------------------------------------------------------------------------------------------

至此，被说了很多遍的设计模式---观察者模式 结束


参考资料：

图书：《大话设计模式》

其他博文：http://blog.csdn.NET/lovelion/article/details/7563445


y-yg
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
观察者模式(Observer Pattern)（一）：观察者模式介绍
jialinqiang的专栏
05-11 5539
一、意图 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。 二、适用性 《设计模式》中提到在以下任一情况下可以使用观察者模式： 1.当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。 2.当对一个对象的改变需要同时改变
《设计模式》- 观察者模式
oyl822的专栏
01-19 1035
还记得Windows系统右键菜单中的“刷新”吗？通过FPT传输一个文件至某个目录后，还需要手动刷新一下文件窗口才能看到文件，而在Linux系统中确不存在这样的问题。
【设计模式】观察者模式 ( 简介 | 适用场景 | 优缺点 | 代码示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-17 4812
一、观察者模式简介、 二、观察者模式适用场景、 三、观察者模式优缺点、 四、观察者模式代码示例、 1、被观察者、 2、观察者、 3、通知类、 4、测试类、 五、JDK 中的观察者模式支持类、 1、Observable、 2、Observer、
观察者模式(Observer) 简介
热门推荐
nvd11的专栏
12-31 1万+
一, 观察者模式(Observer) 的定义 观察者模式: 定义了一种 1对多 的依赖关系, 让多个观察者对象同时监听1个主题对象. 这个主题对象在状态发生变化时, 会通知所有的观察者对象, 使它们能够同时更新自己. 稍微解释一下 这个1 对多 的依赖关系. 1对多 这个关键词我们常常在DB 表设计里提到, 但是这里的意思是有
通俗易懂设计模式解析——观察者模式
gman344的博客
08-01 230
前言 　　今天我们一起看看这个观察者模式，这个模式简单来说就是一个发布订阅类似的模式。按照名字来理解也就是存在一个观察者和一个被观察者。说几个例子给大家听，大家应该就明白了。例如在我们现在通过银行卡支付之后，会收到银行发过来的提示信息。例如当我们话费余额或者流量不足之时也会收到提示信息。这其中的逻辑帮我们理解观察者模式。当我们观察的一个对象发送变化之时就会触发某一机制。然后做出一系列的措施。 观察者模式介绍 一、来由 　　在软件系统中我们经常会遇到对象之间存在一对多的关系，当一个对象被修改时，将会自动通知.
设计模式与应用：观察者模式
maoyuanming0806的博客
05-16 910
本文介绍观察者模式，和通过jdk的实现来使用。 简介 结构图 角色和职责 实现 使用场景 简介 观察者模式Observer是行为模式的一种 作用是当一个对象的状态发生变化时，能够自动通知其它关联对象，自动刷新对象状态 Observer模式提供给关联对象一种同步通信的手段，使得某个对象与依赖他的其它对象之间保持状态同步 结构图 实际上，j...
JavaScript设计模式之观察者模式（发布者-订阅者模式）
12-01
观察者模式( 又叫发布者-订阅者模式 )应该是最常用的模式之一. 在很多语言里都得到大量应用. 包括我们平时接触的dom事件. 也是js和dom之间实现的一种观察者模式. 代码如下: div.onclick = function click (){ ...
Java设计模式-第22章-观察者模式.ppt
最新发布
05-29
Java设计模式中的观察者模式（Observer Pattern）是一种对象行为型模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。这种模式常用于事件处理和实时...
用C++ 实现设计模式之观察者模式
12-22
观察者模式，又称发布–订阅，mvc模式等. 通俗点讲，比如股票来说，很多人关注一支股票，派一个人去观察股票的情况，一有变化(观察)，通知所有的预定这个消息的人. 　而我们常见的mvc模式，v是指view-视图，m指...
C++设计模式之观察者模式
01-21
前言 之前做了一个性能测试的项目，就是需要对现在的产品进行性能测试，获得测试数据，然后...在GOF的《设计模式:可复用面向对象软件的基础》一书中对观察者模式是这样说的：定义对象间的一种一对多的依赖关系，当一个
JavaScript设计模式之观察者模式与发布订阅模式详解
11-21
学习了一段时间设计模式，当学到观察者模式和发布订阅模式的时候遇到了很大的问题，这两个模式有点类似，有点傻傻分不清楚，博客起因如此，开始对观察者和发布订阅开始了Google之旅。对整个学习过程做一个简单的记录...
观察者模式简介及使用示例
。鲸落
06-10 5944
文章目录观察者模式简介使用示例总结优缺点使用场景扩展联想学习 观察者模式简介 观察者模式又叫发布订阅（Publish/Subscribe）模式 观察者模式（Observer Pattern）定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。 类图： 核心类说明： Subject： 抽象主题，即为被观...
观察者模式详解
qq_39200581的博客
07-04 246
观察者模式 概念：当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。 本文以微信工作号的形式为例进行阐述观察者模式。 了解观察者模式首先需要了解观察者模式的概念，牵扯到4个概念 抽象主题: 抽象主题定义的是服务号接口 **具体主题:**具体主题主要是对抽象实体的实现 **抽象观察者:**抽象观察者定义的是订阅号接口 **具体观察者:**具体观察者是对抽象观察者的具体实现 抽象主题 微信中的服务号需要用
观察者模式
ThinkWon的博客
09-25 5216
当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。 介绍 意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。 何时使用：一个对象（目标对象）...
什么是观察者模式？
m0_45861545的博客
11-02 5462
https://www.runoob.com/design-pattern/observer-pattern.html
设计模式介绍之七：观察者模式（observer）
安晓辉生涯——聚焦程序员的职业规划与成长
02-18 9111
观察者模式（又称发布/订阅模式）定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新
观察者模式----介绍
fengzi
08-21 881
在android开发中,我们有很多地方都会使用到观察者模式,那么观察者模式是什么呢? Observer(Subscriber:RxJava中的另一种体现方式):观察者 ConcreteObserverA:观察者实现类 Observable:被观察者 通过上图我们可以看出,Observable通过subcribe()将Observer订阅到Observable中,当Observable发...
个人对观察者模式的理解
阿杜童鞋的博客
05-17 3121
问题：观察者模式有什么用？通常被用来实现事件处理系统，当一个主题对象发生改变的时候，所有的观察者都会发生改变；假如我们现在需要测量人的身高体重，电子秤显示的数值会随着被测量的人不同而显示不同的数据，这个时候我们就可以把人的身体数据看为主题对象（Subject），把电子秤看为观察者对象（Observer）,电子秤可以有多个，当人的数据变化的时候多个电子秤的数据都会变化，这样就可以看为主题对象和观察者...
06行为型模式1
08-03
观察者模式是一种行为型设计模式，它建立了一种对象与对象之间的依赖关系。当一个对象的状态发生改变时，所有依赖于它的对象都会收到通知并且自动更新。这种模式的动机在于创建一个松散耦合的系统，其中对象之间的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值