以下都是本人收集和总结的内容:
1.什么是观察者模式
观察者模式（Observer Pattern）也叫做发布-订阅(Publish/Subscribe)模式。这个模式最重要的作用就是解耦。也就是将被观察者和观察者进行解耦，使得他们之间的依赖性更小，甚至做到毫无依赖。观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
2.如何实现观察者模式
我们假定一个场景，有一家报社中，现在有这么一个需求，部分读者希望在报社有新的报纸的时候能够收到通知。于是这些读者就订阅该功能。而当报社添加新的报纸的时候，报社将会把报纸发送给订阅的读者。
上面这个场景就是典型的观察者模式。对于读者我们可以称为观察者，而报社则可以作为被观察者。在报社（被观察者）中去添加注册需要接收通知的读者（观察者）。这时候在报社中添加新的报纸后，系统便会通知在系统注册该功能的读者。下面看一下代码实现。既然是观察者模式，首先我们需要创建一个观察者接口。
package com.wuxiao.example.observer;
public interface Observer {
public void update(Object object);
}
接下来我们创建一个被观察者，对于被观察者中，里面的功能必然有添加一个观察者，删除观察者，通知更新观察者这三个公共方法，于是我们可以写一个抽象类。
package com.wuxiao.example.observer;
import java.util.Vector;
public abstract class Observable {
//定义一个观察这数组
private Vector<Observer> obVector = new Vector<>();
//添加一个观察者
public void addObserver(Observer observer) {
this.obVector.add(observer);
}
//删除一个观察者
public void delObserver(Observer observer) {
this.obVector.remove(observer);
}
//通知所有观察者
public void notifyObservers(Newspaper newspaper) {
for (Observer observer : obVector) {
observer.update(newspaper);
}
}
}
下面我们就来实现上述场景。既然是报社，我们首先需要创建一个Newspaper类。
package com.wuxiao.example.observer;
public class Newspaper{
public String NewspaperContent;
public Newspaper(String NewspaperContent) {
this.NewspaperContent= NewspaperContent;
}
@Override
public String toString() {
return "Newspaper[NewspaperContent=" + NewspaperContent+ "]";
}
}
下面创建一个Library类，由于这个Library作为被观察者，我们使其继承自抽象类Observable。
package com.wuxiao.example.observer;
import java.util.ArrayList;
import java.util.List;
public class Library extends Observable{
//使用list用于存放报纸
private List<Newspaper> newspaperList;
public Library() {
this.newspaperList= new ArrayList<>();
}
public void addNewspaper (Newspaper newspaper) {
this.newspaperList.add(newspaper);
super.notifyObservers(newspaper);
}
public void delNewspaper (Newspaper newspaper) {
this.newspaperList.remove(newspaper);
}
}
下面再创建两个读者类ReaderA，ReaderB。它们作为观察者，就叫他们实现Observer接口。
ReaderA
package com.wuxiao.example.observer;
public class ReaderA implements Observer{
public ReaderA() {
}
@Override
public void update(Object object) {
System.out.println("读者A收到报纸:" + object.toString());
}
}
ReaderB
package com.wuxiao.example.observer;
public class ReaderB implements Observer{
public ReaderB() {
}
@Override
public void update(Object object) {
System.out.println("读者B收到报纸:"+object.toString());
}
}
接下里我们就来测试一下结果。
package com.wuxiao.example.observer;
public class Test {
public static void main(String[] args) {
Library library = new Library();
Observer readerAObserver = new ReaderA();
Observer readerBObserver = new ReaderB();
//添加读者A
library.addObserver(readerAObserver);
//添加读者B
library.addObserver(readerBObserver);
//添加一本新书
Newspaper newspaper = new Newspaper("青年日报");
library.addNewspaper (newspaper );
}
}
运行结果如下
log ---> 读者A收到报纸::[青年日报]
log ---> 读者B收到报纸::[青年日报]
3.观察者模式原理
首先我们看一下观察者模式的通用类图
在这里对上面类图中的角色进行一下详细介绍
Subject:抽象主题，也就是上面的被观察者(Observable)角色。Subject把所有观察者对象的引用保存在一个集合里，并且能够动态的增加、取消观察者。
Observer:抽象观察者，他是观察者的抽象类，在这里定义个一个更新的接口，目的就是为了在接收到被观察者的更改通知是更新自己。
ConcreteSubject:具体主题，也就是具体的被观察者，在上面对应于Library类。在ConcreteSubject里面定义一些被观察者自己的业务逻辑，当ConcreteSubject内部状态发生改变时，给所有注册过的观察者发送通知。
ConcreteObserver:具体观察者，ConcreteObserver实现了抽象观察者所定义的更新接口，再被观察者通知改变是更新自身状态。
下面我们看下观察者模式的通用代码。
Sunject（被观察者类）
package com.wuxiao.designpatterns.observer;
import java.util.Vector;
public abstract class Subject {
//定义一个观察这数组
private Vector<Observer> obVector = new Vector<>();
//添加一个观察者
public void addObserver(Observer observer) {
this.obVector.add(observer);
}
//删除一个观察者
public void delObserver(Observer observer) {
this.obVector.remove(observer);
}
//通知所有观察者
public void notifyObservers() {
for (Observer observer : obVector) {
observer.update();
}
}
}
ConcreteSubject（具体被观察者）
package com.wuxiao.designpatterns.observer;
public class ConcreteSubject extends Subject{
// 具体业务逻辑
public void doSomething() {
super.notifyObservers();
}
}
Observer（观察者类）
package com.wuxiao.designpatterns.observer;
public interface Observer {
public void update();
}
Observer（具体观察者）
package com.wuxiao.designpatterns.observer;
public class ConcreteObserver implements Observer{
public ConcreteObserver() {
}
//实现更新方法
@Override
public void update() {
System.out.println("收到消息");
}
}
Test（测试类）
public class Test{
public static void main(String[] args) {
ConcreteSubject subject = new ConcreteSubject();
Observer observer = new ConcreteObserver();
subject.addObserver(observer);
subject.doSomething();
}
}
总结：
观察者模式在Java中使用很广泛，那么我们android中有很多优秀三方架构，如Eventbus，RxJava等也借鉴了这些模式，所有在使用它们带来方便的同时也需要了解其内部原理。
