观察者模式（为了Rxjava，Retrofit....）

以下都是本人收集和总结的内容:

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 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 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.观察者模式原理

首先我们看一下观察者模式的通用类图

观察者模式的通用类图.png

在这里对上面类图中的角色进行一下详细介绍
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 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等也借鉴了这些模式，所有在使用它们带来方便的同时也需要了解其内部原理。