十四、观察者模式

观察者模式又叫做：发布--订阅（Publish/Subscirbe)模式；
观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化的时候，会通知所有观察者对象，使它们能够更新自己；

观察者模式UML图.png

---

一、Subject类，可以为主题或者抽象通知者，一般用一个抽象类或者一个接口实现。他把所有的观察者对象的引用保存在一个集合里；每个主题可以有任意数量的观察者对象，可以增加或删除观察者对象；

/**
 * Created by serenitynanian on 2018/6/7.
 * 主题或抽象通知者，被观察者   一般是一个抽象类或者是一个接口实现
 * 缺点：通知者SubjectClass-----依赖-----观察者ObserverClass
 */

public abstract class SubjectClass {

    //针对抽象编程，减少与具体类的耦合
    private List<ObserverClass> list = new ArrayList<ObserverClass>();

    //被观察者的状态
    private String actionStatus ;


    public String getActionStatus() {
        return actionStatus;
    }

    public void setActionStatus(String actionStatus) {
        this.actionStatus = actionStatus;
    }

    abstract void attach(ObserverClass observerClass);
    abstract void detach(ObserverClass observerClass);
    abstract void notifyAllObserver();


}

二、Observer类，抽象观察者，为所有具体的观察者定义一个接口，在得到主题通知时更新自己；这个接口叫做更新接口。抽象观察者通常是一个抽象类或者一个接口实现；更新接口通产有个更新的方法；

/**
 * Created by serenitynanian on 2018/6/7.
 * 观察者
 */

public abstract class ObserverClass {

    protected String name;
    protected SubjectClass subjectClass ;

    /**
     *
     * @param name
     * @param subjectClass 为抽象通知者，减少与具体类的耦合
     */
    public ObserverClass(String name, SubjectClass subjectClass) {
        this.name = name;
        this.subjectClass = subjectClass;
    }

    public abstract void update();

}

三、具体Subject

import java.util.ArrayList;
import java.util.List;

/**
 * Created by serenitynanian on 2018/6/7.
 */

public class ConcreteSubject extends SubjectClass {

    //针对抽象编程，减少与具体类的耦合
    private List<ObserverClass> list = new ArrayList<ObserverClass>();



    /**
     * 添加观察者
     * @param observerClass  //针对抽象编程，减少与具体类的耦合
     */
    @Override
    public void attach(ObserverClass observerClass) {
        if (null != list) {
            list.add(observerClass);
        }
    }

    /**
     * 移除观察者
     * @param observerClass //针对抽象编程，减少与具体类的耦合
     */
    @Override
    public void detach(ObserverClass observerClass) {
        if (null != list) {
            list.remove(observerClass);
        }
    }

    /**
     * 通知所有观察者
     */
    @Override
    public void notifyAllObserver() {

        for (int i = 0; i < list.size(); i++) {
            ObserverClass observerClass = list.get(i);
            observerClass.update();
        }

    }
}

四、具体观察者

/**
 * Created by serenitynanian on 2018/6/7.
 */

public class ConcreteObserver1 extends ObserverClass {

    public static final String TAG = ConcreteObserver1.class.getSimpleName();
    /**
     * @param name
     * @param subjectClass 为抽象通知者，减少与具体类的耦合
     */
    public ConcreteObserver1(String name, SubjectClass subjectClass) {
        super(name, subjectClass);
    }

    @Override
    public void update() {
        System.out.println(name+"------已经被告知---->"+subjectClass.getActionStatus());
    }
}



/**
 * Created by serenitynanian on 2018/6/7.
 */

public class ConcreteObserver2 extends ObserverClass {

    public static final String TAG = ConcreteObserver2.class.getSimpleName();
    /**
     * @param name
     * @param subjectClass 为抽象通知者，减少与具体类的耦合
     */
    public ConcreteObserver2(String name, SubjectClass subjectClass) {
        super(name, subjectClass);
    }

    @Override
    public void update() {
        System.out.println(name+"------已经被告知---->"+subjectClass.getActionStatus());
    }
}

五、具体调用

/**
 * Created by serenitynanian on 2018/6/7.
 */

public class ClientTest {


    public static void main(String[] args) {
        ConcreteSubject subjectClass = new ConcreteSubject();
        ObserverClass observerClass1 = new ConcreteObserver1("1号观察者",subjectClass);
        ObserverClass observerClass2 = new ConcreteObserver2("2号观察者", subjectClass);


        subjectClass.attach(observerClass1);
        subjectClass.attach(observerClass2);

        subjectClass.setActionStatus("这是一条新通知");
        subjectClass.notifyAllObserver();
    }
}

六、总结

• 1.将一个系统分割成由许多相互协作的类有一个很不好的副作用，就是需要维护相关对象间的一致性。我们希望不希望为了维护相关对象的一致性，而使各类紧密耦合，这样会给维护、扩展和重用都带来不便；
• 2.观察者模式就是解除耦合，让耦合双方都依赖于抽象，而不是依赖于具体；从而使各自一边的变化都不会影响到另一边；
• 3.一个抽象模型有两个方面，当一个方面依赖另一个方面，这时就可以使用观察者模式将两者封装在独立的对象中，从而使它们独立的复用或改变而不影响到另一方；

七、缺点

• 1.抽象通知者----依赖----抽象观察者，万一没有了抽象观察者这样的接口，通知功能就不能进行；
• 2.通知者下发通知，每个观察者都进行同一个方法的回调，不能按照各自的逻辑，回调各自不同的方法；

八、解决缺点---事件委托

如果通知者和观察者之间，它们根本不相互知道，由客户端决定来通知谁，那么问题就都解决了；