对象间的联动----观察者模式

1. 观察者模式概述

   在软件系统中,有些对象之间存在类似交通信号灯和汽车之间的关系,一个对象的状态或行为的变化将导致其他对象的状态或行为也发生改变,它们之间将产生联动,为了更好的描述对象之间存在的这种一对多或一对一的联动,就产生了观察者模式

观察者模式,用于建立一种对象与对象之间的依赖关系,一个对象发生改变时将会自动通知其他对象,其他对象作出相应的反应,在观察者模式中,发生改变的对象称为观察目标,而被通知的对象称为观察者,一个观察者目标可以对应多个观察者,

2. 观察者模式结构图

3. 观察者模式结构图的角色

    1) Subject(目标): 它是被观察的对象,在目标中定义了一个观察者集合,一个观察目标可以接收任务数量的观察者来观察,提供一系列方法来增加和删除观察者对象,同时定义了通知方法,目标类可以是抽象类或具体类

    2) ConcreteSubject(具体目标): 具体目标包含有经常发生改变的数据,当它的状态发生改变时,向各个观察者发出通知;

    3)  Observer(观察者): 观察者将对观察目标的改变做出反应,一般定义为接口

    4) ConcreteObserver(具体观察者): 维护了一个指向目标对象的引用,它存储具体观察者的有关状态,这些状态需要和具体目标的状态一致,可调用具体目标类的attach()方法和detach()方法将自己从目标类的集合中添加或删除

4. 案例

    1) 完整解决方案

     

    2) 代码实现

package com.zach.pattern.observer;
/**
 * 抽象观察者类
 * @author Zach
 *
 */
public interface ObServer {
	
	String getName();
	void setName(String name);
	void help();
	void beAttacked(AllyControlCenter acc);
}

package com.zach.pattern.observer;

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

/**
 * 战队控制中心类:目标类
 * @author Zach
 *
 */
public abstract class AllyControlCenter {
	protected String allyName;  //战队名称
	protected List<ObServer> players = new ArrayList<ObServer>();
	
	public void setAllyName(String allyName){
		this.allyName = allyName;
	}

	public String getAllyName() {
		return allyName;
	}
	
	public void join(ObServer obs) {
		System.out.println(obs.getName()+"加入"+this.allyName+"战队!");
		players.add(obs);
	}
	
	public void quit(ObServer obs){
		System.out.println(obs.getName()+"退出"+this.allyName+"战队");
		players.remove(obs);
	}
	
	public abstract void notifyObServer(String name);
}

package com.zach.pattern.observer;
/**
 * 具体目标类
 * @author Zach
 *
 */
public class ConcreteAllyControlCenter extends AllyControlCenter {
	
	public ConcreteAllyControlCenter(String allyName) {
		this.allyName = allyName;
	}
	
	/**
	 * 实现通知方法
	 */
	@Override
	public void notifyObServer(String name) {
		
		System.out.println(this.allyName+"战队紧急通知,盟友"+name+"遭受敌人攻击!");
		for (ObServer obServer : players) {
			if(!obServer.getName().equals(name))
				obServer.help();
		}
	}

}

package com.zach.pattern.observer;
/**
 * 具体观察者类
 * @author Zach
 *
 */
public class Player implements ObServer {
	
	private String name;
	
	 
	public Player(String name) {
		this.name = name;
	}
	
	

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return this.name;
	}
	
	@Override
	public void setName(String name) {
		this.name = name;

	}

	@Override
	public void help() {
		System.out.println("坚持住,"+this.name+"来救你!");
	}
	
	//通知盟友
	@Override
	public void beAttacked(AllyControlCenter acc) {
		System.out.println(this.name +"被攻击");
		acc.notifyObServer(name);

	}

}

package com.zach.pattern.observer;

/**
 * 客户端
 * @author Zach
 *
 */
public class Client {
	public static void main(String[] args) {
		AllyControlCenter acc = new ConcreteAllyControlCenter("金庸群侠!");
		
		//定义4个观察者
		ObServer player1 = new Player("杨过");
		acc.join(player1);
		ObServer player2 = new Player("令狐冲");
		acc.join(player2);
		ObServer player3 = new Player("张无忌");
		acc.join(player3);
		ObServer player4 = new Player("段誉");
		acc.join(player4);
		//某成员遭受攻击
		player1.beAttacked(acc);
	}
}

运行结果:

杨过加入金庸群侠!战队!
令狐冲加入金庸群侠!战队!
张无忌加入金庸群侠!战队!
段誉加入金庸群侠!战队!
杨过被攻击
金庸群侠!战队紧急通知,盟友杨过遭受敌人攻击!
坚持住,令狐冲来救你!
坚持住,张无忌来救你!
坚持住,段誉来救你!

 

5. 观察者模式总结

    观察者模式为实现对象之间的联动提供了一套完整的解决方案,凡是涉及一对一或一对多的对象交互的场景都可以使用观察者模式,观察者模式广泛应用于各种GUI处理的实现,基于事件的XML解析技术(如SAX2)以及WEB事件处理

   1)  主要优点

     1. 实现表现层和数据逻辑层的分离,定义了稳定消息的更新传递机制,并抽象了更新接口

     2. 观察者模式支持广播通信,观察目标会向所有的已注册的观察者对象发送通知,简化一对多系统的设计难题

     3. 符合开闭原则

    2)  主要缺点

    1. 若一个观察目标对象有很多直接或间接的观察者,将所有的观察者都通知到会花很多时间

     2. 若在观察者和观察目标之间存在循环依赖,观察目标会触发它们之间的循环调用,可能导致系统崩溃

     3.  观察者模式没有相应的机制让观察者知道所观察的目标对象怎么会发生变化的,而仅仅只是知道观察目标发生了变化

     3) 使用场景

       1. 一个对象的改变将会导致一个或多个其他对象也放生改变,而并不知道到具体有多少对象将发生改变,也不知道这些对象是谁

        2.  需要在系统中创建一个触发链,A对象的行为将影响B, B对象的行为将会影响C对象;