Java设计模式——观察者模式

概述

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察对象，使他们能够自动更新自己。

UML

Subject： 把所有的观察对象的引用都保存在一个集合里面，每一个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加、删除和清空观察者对象。

ConcreteSubject：具体主题，将有关状态存入聚义观察者对象，在具体主题的内容状态改变时，给多有登记过的观察者发出通知。

Observer：抽象观察者类，为所有的具体观察者定义一个接口，在得到主题的时候通知更新自己。

ConcreteObserver：具体的观察者，实现抽象观察者角色要求的更新接口，以便使本身的状态与主题相互协调。

代码举例

下面就举一个项目实例，利用观察者模式监听网络状态变化。在网络变化时，让注册的观察者对象作出自己的应对。

/**
 * 角色：Subject
 */
public abstract class Subject {

    ArrayList<Observer> observerList = new ArrayList<>();

    /**
     * 增加观察者
     *
     * @param observer
     */
    public void addObserver(Observer observer) {
        if (!observerList.contains(observer)) {
            observerList.add(observer);
        }
    }

    /**
     * 移除观察者
     *
     * @param observer
     */
    public void removeObserver(Observer observer) {
        if (observerList.contains(observer)) {
            observerList.remove(observer);
        }
    }

    /**
     * 通知
     */
    public void notifyWhenInternetIsReconnected() {
        if (observerList.size() == 0) {
            return;
        }
        for (Observer observer : observerList) {
            observer.onInternetIsReconnected();
        }
    }

}

/**
 * 角色：ConcreteSubject
 */
public class ConcreteSubject extends Subject {

    private static ConcreteSubject concreteSubject;
    private int connectState;//0网络断开 1网络连接

    private ConcreteSubject() {

    }

    public static ConcreteSubject getInstance() {
        if (concreteSubject == null) {
            concreteSubject = new ConcreteSubject();
        }
        return concreteSubject;
    }

    public int getConnectState() {
        return connectState;
    }

    public void setConnectState(int connectState) {
        this.connectState = connectState;
    }
}

/**
 * 角色：观察者接口
 */

public interface Observer {
    void onInternetIsReconnected();
}

/**
 * 角色：ConcreteObserver
 */
public class TestActivity1 extends Activity implements Observer{
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ConcreteSubject.getInstance().addObserver(this);
    }

    @Override
    public void onInternetIsReconnected() {
        //TODO 具体的操作
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ConcreteSubject.getInstance().removeObserver(this);
    }
}

/**
 * 角色：ConcreteObserver
 */
public class TestActivity2 extends Activity implements Observer {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main1);
        ConcreteSubject.getInstance().addObserver(this);
    }

    @Override
    public void onInternetIsReconnected() {
        //TODO 具体的操作
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ConcreteSubject.getInstance().removeObserver(this);
    }
}

public class AppBaseApplication extends Application {

    private BroadcastReceiver mNetWorkRecevier = new DataUpdateReceiver();

    @Override
    public void onCreate() {
        super.onCreate();
        IntentFilter mFilter = new IntentFilter();
        mFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        registerReceiver(mNetWorkRecevier, mFilter);
    }

    class DataUpdateReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
                if (isNetworkAvailable(context)) {
                    ConcreteSubject.getInstance().notifyWhenInternetIsReconnected();
                }
            }
        }
    }

    public boolean isNetworkAvailable(Context context) {
        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo ni = cm.getActiveNetworkInfo();
        if (ni != null) {
            return ni.getState() == NetworkInfo.State.CONNECTED;
        }
        return false;
    }

}

上面的代码完成了一个观察者模式。基本的流程在application中监听网络情况，如果是网络连接时，就会通知所有实现Observer接口的activity去进行相应的处理。我们可以看到，两个实例activity实现了observer接口，并在onCreate方法中把自己添加到observer的管理类中，在onDestroy方法中将自己删去。

观察者模式是java 设计模式中极为重要的一种设计模式，其应用也是非常广泛。比如EventBus Rxjava等等。掌握这种设计模式对Android项目开发帮助很多。