设计模式学习笔记——观察者模式

观察者模式

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

结构图

代码实现

抽象观察者Observer：根据被观察者动作，做出相应动作。

/**
 * 抽象观察者类
 * @author xukai
 * 2016年3月16日 下午11:33:10
 */
public abstract class Observer {

	/**
	 * 做出相应
	 */
	public abstract void update();
	
}

抽象被观察者Subject：被观察，可以选择通过某个观察者，也可以不通知

/**
 * 抽象被观察者
 * @author xukai
 * 2016年3月16日 下午11:43:21
 */
public abstract class Subject {

	private Vector<Observer> observers = new Vector<>();
	

	public void attach(Observer observer){
		observers.add(observer);
	}
	
	public void detach(Observer observer){
		observers.remove(observer);
	}
	
	public void notifyObserver(){
		for(Observer o : observers){
			o.update();
		}
	}
	
}

具体被观察者ConcreteSubject：

/**
 * 具体被观察者
 * @author xukai
 * 2016年3月16日 下午11:46:37
 */
public class ConcreteSubject extends Subject {

	private String subjectState;

	public String getSubjectState() {
		return subjectState;
	}

	public void setSubjectState(String subjectState) {
		this.subjectState = subjectState;
	}

}

具体观察者ConcreteObserver：

/**
 * 具体观察者
 * 
 * @author xukai 2016年3月16日 下午11:37:20
 */
public class ConcreteObserver extends Observer {

	private String name;

	private String observerState;

	private ConcreteSubject subject;

	public ConcreteSubject getSubject() {
		return subject;
	}

	public void setSubject(ConcreteSubject subject) {
		this.subject = subject;
	}

	public ConcreteObserver(ConcreteSubject subject, String name) {
		this.subject = subject;
		this.name = name;
	}

	@Override
	public void update() {
		observerState = subject.getSubjectState();
		System.out.println("观察者"+ name +"的状态：" + observerState);
	}

}

客户端：

public class Client {

	public static void main(String[] args) {
		ConcreteSubject s = new ConcreteSubject();
		s.attach(new ConcreteObserver(s, "A"));
		s.attach(new ConcreteObserver(s, "B"));
		
		s.setSubjectState("ABC");
		s.notifyObserver();
	}
	
}

控制台：

观察者A的状态：ABC
观察者B的状态：ABC

可以看到根据被观察者的通知，可以修改观察者相应的信息。

demo

问题：公司中，老板有事外出，员工有的炒股，有的看NBA比赛，员工请求前台小妹通知老板回来。

结构图

代码实现

抽象通知者类Subject：

import java.util.Vector;

/**
 * 抽象通知者，即被观察者
 * 
 * @author xukai 2016年3月17日 上午9:40:26
 */
public abstract class Subject {

	protected String name;
	protected String state;

	public Subject(String name, String state) {
		this.name = name;
		this.state = state;
	}

	Vector<Observer> observers = new Vector<>();

	public void attacth(Observer observer) {
		observers.add(observer);
	}

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

	public void notifyObserver() {
		System.out.println(name + "说：" + state);
		for (Observer o : observers) {
			o.update();
		}
	}

}

抽象观察者类Observer：

/**
 * 抽象观察者，对通知者做出响应
 * 
 * @author xukai 2016年3月17日 上午9:39:03
 */
public abstract class Observer {

	private String name;

	protected Subject subject;

	protected String doing;

	public Observer(String name, Subject subject) {
		this.name = name;
		this.subject = subject;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public abstract void update();

	@Override
	public String toString() {
		return name + doing;
	}

}

具体通知者类Boss：

/**
 * 老板类，继承通知者
 * 
 * @author xukai 2016年3月17日 上午9:45:03
 */
public class Boss extends Subject {

	public Boss(String name, String state) {
		super(name, state);
	}

}

具体通知者类：

/**
 * 前台通知者
 * @author xukai
 * 2016年3月17日 上午10:25:47
 */
public class ReceptionGirl extends Subject {

	public ReceptionGirl(String name, String state) {
		super(name, state);
	}

}

看NBA的观察者：

/**
 * 具体观察者，喜爱看NBA
 * @author xukai
 * 2016年3月17日 上午9:57:21
 */
public class EmployeeNBAObserver extends Observer {

	public EmployeeNBAObserver(String name, Subject subject) {
		super(name, subject);
	}

	@Override
	public void update() {
		if(super.subject.state == "出去了"){
			super.doing = "，看NBA比赛...";
		}else if(super.subject.state == "回来了"){
			super.doing = "，停止看比赛，开始工作...";
		}
		System.out.println(super.getName() + super.doing);
	}

}

炒股的观察者：

/**
 * 具体观察者，喜爱看股票
 * @author xukai
 * 2016年3月17日 上午10:00:23
 */
public class EmployeeStockObserver extends Observer {

	public EmployeeStockObserver(String name, Subject subject) {
		super(name, subject);
	}

	@Override
	public void update() {
		if(super.subject.state == "出去了"){
			super.doing = "，看股票市场...";
		}else if(super.subject.state == "回来了"){
			super.doing = "，停止看股票，开始工作...";
		}
		System.out.println(super.getName() + super.doing);
	}

}

客户端：

public class TestObserver {

	public static void main(String[] args) {
		System.out.println("===========老板自己的行为通知==========");
		// 创建一个通知者
		Subject subject = new Boss("老板", "出去了");
		// 多个观察者
		Observer ob1 = new EmployeeNBAObserver("我爱看NBA", subject);
		Observer ob2 = new EmployeeStockObserver("我爱炒股", subject);
		
		// 通知者，添加观察者
		subject.attacth(ob1);
		subject.attacth(ob2);
		
		// 发出通知
		subject.notifyObserver();
		
		// 不通知炒股的人
		subject.detach(ob2);
		subject.state = "回来了";
		subject.notifyObserver();
		// 炒股的人还在炒股，被老板发现
		System.out.println(ob2 + "被老板发现在炒股");
		
		System.out.println("===========前台小妹通知老板回来==========");
		// 创建小妹
		subject = new ReceptionGirl("前台小妹", "出去了");
		// 多个观察者
		Observer ob3 = new EmployeeNBAObserver("我爱看NBA", subject);
		Observer ob4 = new EmployeeStockObserver("我爱炒股", subject);
		
		// 通知者，添加观察者
		subject.attacth(ob3);
		subject.attacth(ob4);
		
		// 发出通知
		subject.notifyObserver();
		
		subject.state = "回来了";
		subject.notifyObserver();
	}
	
}

控制台输出：

分析：

1.老板和前台小妹都是通知者

2.观察者需要知道老板的状态

3.通知者中使用Vector容器不使用List，是因为多线程操作时，Vector是安全地，而List是不安全的。

观察者模式优点

观察者与被观察者之间属于轻度的关联关系，并且是抽象耦合的，对于两者比较容易扩展。

观察者模式是一种常用的触发机制，形成一条触发链，依次对各个观察者的方法进行处理。但是由于链式触发，当观察者比较多的时候，性能问题很难解决。并且链式结构容易出现循环引用错误，造成系统假死。

使用场景

当一个对象的改变需要同时改变其他对象，而且它不知道具体有多少对象有待给边，应该考虑使用观察者模式。

观察者模式所做的工作就是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖具体。从而使得各自的变化都不会影响另一边的变化。

另外，Java语言中，有接口Observer和它的实现类Observable，对观察者角色进行了实现。