观察者模式
观察者模式,定义了一种一对多的依赖关系,让多个观察者对象同时监听某个主题对象。这个主题对象在状态发生变化时,会通知所有观察者对象,使他们能够自动更新自己。
结构图
代码实现
抽象观察者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,对观察者角色进行了实现。