学习总结与分享-设计模式之观察者模式

在完成日常业务中，观察者模式也是十分常见的一种模式，当我们需要改变某一个对象的属性时，其依赖的所有对象都需要做相同的相应的变动的时候，这时使用观察者模式就可以使代码更加的独立健壮。
观察者模式
观察者模式是一种对象行为模式。它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在观察者模式中，主题是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知。观察者模式不仅被广泛应用于软件界面元素之间的交互，在业务对象之间的交互、权限管理等方面也有广泛的应用。（–摘自百度百科）
由此可以看出，观察者模式的主要优点就是解耦，让观察者与被观察者之间的依赖性更小。
观察者模式的特点
每个设计模式都有他独有的一些特点，就是因为有了这些特点才能完成对代码的优化，不论业务逻辑如何变更，想要使用该设计模式，就一定是实现了它的特点，而观察者模式的特点主要有：
1）被观察者需要持有一个或者多个观察者对象。
2）系统中一个模块的变化，某些模块也会跟随着变化。
3）观察者模式都拥有几个角色：

1. 抽象被观察者角色：也就是一个抽象主题，它把所有对观察者对象的引用保存在一个集合中，每个主题都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。
2. 抽象观察者角色：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
3. 具体被观察者角色：也就是一个具体的主题，在集体主题的内部状态改变时，所有登记过的观察者发出通知。
4. 具体观察者角色：实现抽象观察者角色所需要的更新接口，一边使本身的状态与制图的状态相协调。

自定义观察者模式
抽象被观察者角色并创建增、删、通知观察者的方法，创建保存具体观察者角色的集合：

public class Subject {
    //保存注册的观察者对象
    private List<Observer> mObervers = new ArrayList<>();

    //注册观察者对象
    public void attach(Observer observer) {
        mObervers.add(observer);
        Log.e("SZH", "attach an observer");
    }

    //注销观察者对象
    public void detach(Observer observer) {
        mObervers.remove(observer);
        Log.e("SZH", "detach an observer");
    }

    //通知所有注册的观察者对象
    public void notifyEveryOne(String newState) {
        for (Observer observer : mObervers) {
            observer.update(newState);
        }
    }
}

具体的观察者类，实现相应的方法：

public class ConcreteSubject extends Subject {
    private String state;

    public String getState() {
        return state;
    }

    public void change(String newState) {
        state = newState;
        Log.e("SZH", "concreteSubject state:" + newState);

        //状态发生改变，通知观察者
        notifyEveryOne(newState);
    }
}

抽象观察者接口，创建接收通知的方法：

public interface Observer {
    void update(String newState);
}

具体观察者对象，实现接收通知的方法：

public class ObserverA implements Observer {

    //观察者状态
    private String observerState;

    @Override
    public void update(String newState) {
        //更新观察者状态，让它与目标状态一致
        observerState = newState;
        Log.e("SZH", "接收到消息：" + newState + "；我是A模块，快来抢吧！！");
    }
	}

	public class ObserverB implements Observer {
	    //观察者状态
	    private String observerState;
	
	    @Override
	    public void update(String newState) {
        //更新观察者状态，让它与目标状态一致
        observerState = newState;
        Log.e("SZH", "接收到消息：" + newState + "；我是B模块，快来抢吧！！");
    }
	}
	
	public class ObserverC implements Observer {
	    //观察者状态
	    private String observerState;

    @Override
    public void update(String newState) {
        //更新观察者状态，让它与目标状态一致
        observerState = newState;
        Log.e("SZH", "接收到消息：" + newState + "；我是C模块，快来抢吧！！");
    }
}

代码到此，每当具体的被观察者对象发生改变之后，被观察者对象中保存的所有观察者对象都会收到相应的通知并处理，这就是观察者模式。
观察者模式的优缺点
优点：
1）观察者和被观察者之间抽象耦合。观察者模式容易扩展，被观察者只持有观察者集合，并不需要知道具体观察者内部的实现。
2）对象之间的保持高度的协作。当被观察者发生变化时，所有被观察者都会通知到，然后做出相应的动作。
缺点：
1）如果观察者太多，被观察者通知观察者消耗的时间很多，影响系统的性能。
2）当观察者集合中的某一观察者错误时就会导致系统卡壳，因此一般会采用异步方式。
我们应结合实际情况来使用观察者模式，避免系统性能的过分消耗。
java JDK中的观察者模式
在java中jdk也帮我们封装了观察者模式的代码，我们只需要让被观察者继承Observable方法，观察者实现Observer接口，重写各自的方法即可。
需注意：setChanged()、chearChanged()和hasChanged()这3个方法：
参见上面Observable类的notifyObservers(Object arg)方法，hasChanged()为true才会通知观察者数据有变化，并且在通知完成之后调用clearChanged()修改hasChanged()为false，所以当主题数据改变时，需要先调用setChanged()方法使hasChanged为true。

而jdk的观察者模式实现起来虽然简单，但是也会有一些缺点，使用jdk自带的观察者模式的缺点：

1. Observable是一个类，而不是一个接口，导致Observable类的扩展性不高，不如自己实现的观察者模式灵活
2. Observable将某些方法保护了起来(setChanged()和clearChanged()为protected)，这意味着除非继承自Observable，否则将有关键的方法不能调用。导致无法通过组合的方式使其它类获得Observable类的功能。