观察者模式的定义
观察者模式（Observer Pattern）也叫发布订阅模式（Publish/subscribe）,在项目中经常用到。定义如下Define a one-to-many dependency between objects so that when one object changes state , all its dependents are notified and updated automatically.
(定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象会得到通知并自动更新)
▶Subject被观察者
定义
被观察者必须实现的职责，它必须能够动态的增加、取消观察者。它一般是抽象类或者实现类，仅仅完成作为被观察者必须实现的职责：管理观察者并通知观察者▶Observer观察者
观察者接收到消息后，即进行update操作，对接收到的信息进行处理▶ConcreteSubject具体被观察者
定义
被观察者自己的业务逻辑，同时定义对哪些事件进行通知▶ConcreteObserver被观察者
每个观察在接收到消息后的处理反应是不同的，各个观察者有自己的处理逻辑
被观察者
被观察者的职责很简单，就是定义谁能够观察，谁不能观察，程序中使用 ArrayList 和 Vector没有太大区别，ArrayList 是线程异步，不安全；Vector是线程同步，安全。
public abstract class Subject {
//定义一个观察者数组
private Vector<Observer> obsVector = new Vector<>();
//增加一个观察者
public void addObserver(Observer o){
this.obsVector.add(o);
}
//删除一个观察者
public void delObserver(Observer o) {
this.obsVector.remove(o);
}
//通知所观察者
public void notifyObsevers(){
for (Observer o : this.obsVector) {
o.update();
}
}
}
具体被观察者
这里只是一个纯净的被观察者，在具体项目中会有很多变种
public class ConcreteSubject extends Subject {
//具体业务
public void doSomething(){
/**
* do something
*/
super.notifyObsevers();
}
}
观察者
观察者一般是一个接口，每一个实现该接口的实现类都是具体的观察者
public interface Observer {
//更新方法
public void update();
}
具体观察者
public class ConcreteObserver implements Observer {
//实现更新方法
@Override
public void update() {
System.out.println("收到信息，进行处理！");
}
}
场景
public class Client {
public static void main(String[] args) {
//创建一个被观察者
ConcreteSubject subject = new ConcreteSubject();
//定义一个观察者
Observer obs = new ConcreteObserver();
//观察者 观察 被观察者
subject.addObserver(obs);
//观察者开始活动
subject.doSomething();
}
}
观察者模式的定用
观察者模式的优点
▶观察者和被观察者之间是抽象耦合
容易扩展
▶建立一套触发机制
根据单一职责原则，每个类的职责是单一的，观察者模式可以实现一条完美的触发链
观察者模式的缺点
观察者模式需要多考虑一下开发的效率问题，一个观察者，多个观察者，开发和试调就会比较复杂，而且在Java中消息的通知默认是顺序执行，一个观察者卡住，会影响整体的执行效率。这种情况下一般考虑采用异步的方式。
多级触发的效率问题
观察者模式的使用场景
- 关联行为场景。关联（聚合）的行为是可以拆分的，而不是组合。
- 事件多级触发场景
- 跨系统的消息交换场景，如消息队列的处理机制
观察者模式的注意事项
▶广播链问题
一个观察者可以有双重身份，即是观察者，也是被观察者，但是一旦链建立，逻辑可能会比较复杂，可维护性非常差。
注意：
它和职责链模式的最大区别就是观察者广播链在传播的过程中消息是随时更改的，它是由相邻的两个节点协商的消息结构；而职责链模式在消息传递的过程中基本是保持消息不可变，如果要改变，也只是在原有的消息上进行修正。
▶异步处理问题
观察者较多，处理时间较长，就用异步，异步处理要考虑线程安全和队列安全的问题。MQ
观察者模式的扩展
Java中的观察者模式
Java从一开始诞生就提供了一个可扩展的父类，即 java.util.Observable，这个类就是为那些“暴漏”自己的类准备的，他们总是喜欢把自己的状态变更让别人去欣赏，去触发。
JDK中提供了：java.util.Observable实现类和java.util.Observer接口。
被观察者接口
public interface IHanFeiZi {
public void haveBreakfast();
public void haveFun();
}
优化后的被观察者
import java.util.Observable;
public class HanFeiZi extends Observable implements IHanFeiZi{
@Override
public void haveBreakfast() {
System.out.println("韩非子——开始吃饭...");
//通知所有的观察者
super.setChanged();
super.notifyObservers("韩非子在吃饭");
}
@Override
public void haveFun() {
System.out.println("韩非子——开始玩...");
//通知所有的观察者
super.setChanged();
super.notifyObservers("韩非子在玩");
}
}
优化后的观察者
import java.util.Observable;
import java.util.Observer;
//观察者
public class LiSi implements Observer{
//李斯是观察者，一旦韩非子有活动，他就知道，就要向上级报道
@Override
public void update(Observable o, Object obj) {
System.out.println("李斯——观察到韩非子活动，向上级报道...");
//通知所有的观察者
this.reportTo(obj.toString());
System.out.println("李斯——汇报完毕");
}
//汇报上级
private void reportTo(String reportContext) {
System.out.println("李斯——报告！韩非子有活动-->"+reportContext);
}
}
场景
import java.util.Observer;
public class Client {
public static void main(String[] args) {
//定义被观察者
HanFeiZi hanFeiZi = new HanFeiZi();
//创建观察者 有多个
Observer liSi = new LiSi();
//进行观察
hanFeiZi.addObserver(liSi);
//看看被观察者在干什么
hanFeiZi.haveBreakfast();
hanFeiZi.haveFun();
}
}
输出：
韩非子——开始吃饭...
李斯——观察到韩非子活动，向上级报道...
李斯——报告！韩非子有活动-->韩非子在吃饭
李斯——汇报完毕
韩非子——开始玩...
李斯——观察到韩非子活动，向上级报道...
李斯——报告！韩非子有活动-->韩非子在玩
李斯——汇报完毕
未完待续。。。
