观察者模式（行为型）

资源下载链接：点击下载代码<=>点击下载文档

1.观察者

1.1定义

观察者模式：定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象都得到通知并被自动更新。

观察者模式的定义说明：

• 别名

• 发布-订阅(Publish/Subscribe)模式

• 模型-视图(Model/View)模式

• 源-监听器(Source/Listener)模式

• 从属者(Dependents)模式

1.2角色

观察者模式包含以下4个角色：

• Subject（目标）
• ConcreteSubject（具体目标）
• Observer（观察者）
• ConcreteObserver（具体观察者）

1.3优点

• 可以实现表示层和数据逻辑层的分离
• 在观察目标和观察者之间建立一个抽象的耦合
• 支持广播通信，简化了一对多系统设计的难度
• 符合开闭原则，增加新的具体观察者无须修改原有系统代码，在具体观察者与观察目标之间不存在关联关系的情况下，增加新的观察目标也很方便

1.4缺点

• 将所有的观察者都通知到会花费很多时间
• 如果存在循环依赖时可能导致系统崩溃
• 没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而只是知道观察目标发生了变化

1.5适用环境

• 一个抽象模型有两个方面，其中一个方面依赖于另一个方面，将这两个方面封装在独立的对象中使它们可以各自独立地改变和复用
• 一个对象的改变将导致一个或多个其他对象发生改变，且并不知道具体有多少对象将发生改变，也不知道这些对象是谁
• 需要在系统中创建一个触发链

1.6教学例子

（1）分析

软件系统：一个对象的状态或行为的变化将导致其他对象的状态或行为也发生改变，它们之间将产生联动

通过例子了解观察者模式：

• 定义了对象之间一种一对多的依赖关系，让一个对象的改变能够影响其他对象

• 发生改变的对象称为观察目标，被通知的对象称为观察者

• 一个观察目标可以对应多个观察者

（2）类图

（3）代码

Subject（目标）

public abstract class TrafficSign {
	//观察者列表
	private List<TrafficJoiner> joiners = new ArrayList<TrafficJoiner>();
	

	//增加观察者
	public void Attach(TrafficJoiner joiner){
		this.joiners.add(joiner);
	}
	
	//删除观察者
	public void Dettach(TrafficJoiner joiner){
		this.joiners.remove(joiner);
	}
	
	//通知观察者
	public void notify(int flag){
		//红灯时候
		if(flag == 0){
			this.joiners.forEach(j->{
				j.stop();
			});
		}
		//绿灯时候
		if(flag == 1){
			this.joiners.forEach(j->{
				j.start();
			});
		}
	}
	
	//放行的抽象方法
	public abstract void pass();
	
	//禁行的抽象方法
	public abstract void noEntry();

}

ConcreteSubject（具体目标）

public class TrafficLight extends TrafficSign {

	@Override
	public void pass() {
		System.out.println("绿灯亮了。。。。。");
		notify(1);
	}
	
	@Override
	public void noEntry() {
		System.out.println("红灯亮了。。。。。");
		notify(0);
		
	}

}

Observer（观察者）

public interface TrafficJoiner {
	public void start();
	public void stop();
}

ConcreteObserver（具体观察者）

public class Bus implements TrafficJoiner {
	private String LineNo;
	

	public Bus(String lineNo){
		this.LineNo = lineNo;
	}
	
	@Override
	public void start() {
		System.out.println(this.LineNo+"公交车启动。");
	
	}
	
	@Override
	public void stop() {
		System.out.println(this.LineNo+"公交车刹车。");
	
	}

}

Client（客户端）

public class Client {

	public static void main(String[] args) {
		TrafficSign light = new TrafficLight();
		
		TrafficJoiner bus327 = new Bus("327");
		TrafficJoiner bus332 = new Bus("332");
		TrafficJoiner bus108 = new Bus("108");
		TrafficJoiner bus117 = new Bus("117");
		
		light.Attach(bus327);
		light.Attach(bus108);
		
		light.pass();
	
		light.Dettach(bus327);
		light.noEntry();
	}

}

1.7复杂观察者模式

（1）问题：

在某多人联机对战游戏中，多个玩家可以加入同一战队组成联盟，当战队中的某一成员受到敌人攻击时将给所有其他盟友发送通知，盟友收到通知后将做出响应。

现使用观察者模式设计并实现该过程，以实现战队成员之间的联动。

（2）分析及类图：

（3）代码

ConcreteSubject（具体目标）

public class AllyControlCenter {
	protected String teamName;
	protected List<Member> members = new ArrayList<Member>();
	
	public AllyControlCenter(String teamName){
		this.teamName = teamName;
	}
	
	public void addMember(Member m){
		this.members.add(m);
		m.setAllyControlCenter(this);
	}
	
	public void detachMember(Member m){
		this.members.remove(m);
	}
	
	public void receiveAlarm(Member m){
		System.out.println("联盟中心接到"+m.name+"发出的警报。");
		NotifyMember(m);
	}
	
	public void NotifyMember(Member m){
		System.out.println(this.teamName+"全体成员注意："+m.name+"在"+m.address+"处受到攻击，请前去帮助。");
		this.members.forEach(mem->{
			if(mem != m){
				mem.Help(m);
			}
		});
	}

}

Observer（观察者）

public abstract class Member {
	protected String name;
	protected String address;
	protected AllyControlCenter allyControlCenter;
	
	public void setAllyControlCenter(AllyControlCenter allyControlCenter) {
		this.allyControlCenter = allyControlCenter;
	}
	
	public void setAddress(String address) {
		this.address = address;
	}
	
	public Member(String name,String address){
		this.name = name;
		this.address = address;
	}
	
	public abstract void Help(Member m);
	
	public abstract void BeAttacked();

}

ConcreteObserver（具体观察者）

public class Player extends Member{

	public Player(String name, String address) {
		super(name, address);		
	}
	
	@Override
	public void Help(Member m) {
		System.out.println(this.name+"从"+this.address+"出发赶往"+m.address+"帮助"+m.name);
	}
	
	@Override
	public void BeAttacked() {
		this.allyControlCenter.receiveAlarm(this);
	}

}

Client（客户端）

public class Client {

	public static void main(String[] args) {
		AllyControlCenter java1 = new AllyControlCenter("Java1班");
		
		Member solder1 = new Player("石小龙", "6教4楼");
		Member solder2 = new Player("乐红", "3教6楼");
		Member solder3 = new Player("赵本山", "食堂");
		
		java1.addMember(solder1);
		java1.addMember(solder2);
		java1.addMember(solder3);
		
		//solder2.BeAttacked();
		
		solder2.setAddress("前校门");
		
		solder1.BeAttacked();
	}

}

1.8实操案例

（1）问题

某公司要开发一套机房监控系统，里面包含很多的传感设备。如：机房达到某一指定温度，传感器将做出反应，将信号传递给响应设备，如警示灯闪烁、报警器将发出警报，安全逃生门将自动开启、隔热门将自动关闭等，每一种响应设备的行为由它自己的程序来控制。系统设计时需要考虑将来引入新类型的传感设备和相应设备等。选用合适的设计模式来设计该系统，并画出类图后模拟实现。

（2）类图
（3）代码

Observer（观察者）

public interface Equipment {
	public  void quiet();
	public  void move();
}

ConcreteObserver（具体观察者）

public class WarningLight implements Equipment {
	
	@Override
	public void quiet() {
		// TODO Auto-generated method stub
		System.out.println("警示灯关闭");
	}
	
	@Override
	public void move() {
		// TODO Auto-generated method stub
		System.out.println("警示灯闪烁");
	}

}

public class WarningDevice implements Equipment {
	
	@Override
	public void quiet() {
		// TODO Auto-generated method stub
		System.out.println("报警器关闭");
	}
	
	@Override
	public void move() {
		// TODO Auto-generated method stub
		System.out.println("报警器发出警报");
	}

}

public class InsulatedDoor implements Equipment {

	@Override
	public void quiet() {
		// TODO Auto-generated method stub
		System.out.println("隔热门打开");
	}
	
	@Override
	public void move() {
		// TODO Auto-generated method stub
		System.out.println("隔热门将自动关闭");
	}

}

public class EscapeDoor implements Equipment {

	@Override
	public void quiet() {
		// TODO Auto-generated method stub
		System.out.println("逃生门关闭");
	}
	
	@Override
	public void move() {
		// TODO Auto-generated method stub
		System.out.println("逃生门将自动打开");
	}

}

Subject（目标）

public abstract class Sensor {
	List<Equipment> lists = new ArrayList<Equipment>();
	public void addEquipment(Equipment e){
		this.lists.add(e);
	}
	public void removeEquipment(Equipment e){
		this.lists.remove(e);
	}
	public void condition(boolean bool){
		if(bool){
			this.lists.forEach(i->{
				i.move();
			});
		}else{
			this.lists.forEach(i->{
				i.quiet();
			});
		}
	}
	public abstract void show(float tp);
	
}

ConcreteSubject（具体目标）

public class Temperature extends Sensor {

	@Override
	public void show(float tp) {
		// TODO Auto-generated method stub
		if(tp>40){
			System.out.println("温度异常-->");
			condition(true);
		}else{
			System.out.println("温度正常-->");
			condition(false);
		}
	}

}

Client（客户端）

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Sensor sensor = new Temperature();
		Equipment equipment1 = new EscapeDoor();
		Equipment equipment2 = new InsulatedDoor();
		Equipment equipment3 = new WarningDevice();
		Equipment equipment4 = new WarningLight();
		sensor.addEquipment(equipment1);
		sensor.addEquipment(equipment2);
		sensor.addEquipment(equipment3);
		sensor.addEquipment(equipment4);
		
		sensor.show(5);
		System.out.println("-------------------------");
		sensor.removeEquipment(equipment3);
		sensor.show(90);
		
	}

}