java的观察者模式

Java里面的观察者模式，是一个非常经典的模式，经常在开发中被用到，掌握了这个思想，我相信对于一些开发，受益是匪浅的；鄙人也是觉得比较不错，所以发表一点自己的总结，如果对还处于迷茫的你有稍微的帮助的话，鄙人很高兴；下面就让我们共同的理解一下：

一、需求：

  在开发的过程中我们会遇到比较实际额问题就是比如一个事物某种状态发生了改变，想让其他关心它的事物知道，而不是，其他的事物一直看着它，那么就可以抽出一个基本的思想，就是让关心的事物订阅被关心的事物，然后被关心的事物一旦有了改变就去通知关心的事物，如下图：

我们可以清楚的看出被观察者要做的事情，就是添加观察者、删除观察者以及状态更新之后要通知观察者做相应的操作，而观察者，就是得到数据；到此的话，似乎有点眉目了；

二、设计：

知道了思路了，就是需要把思路设计出来；接下来，我们就自己化抽象为具体，化腐朽为神奇：

1. 被观察者（成为目标对象）：Subject

2. 观察者：（监督者）:Observer

Subject类的实现：

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

/**
 *创建人：UncleMin
 *时间：2017/3/11 0011-下午 6:58
 *描述：Subject:目标对象；注册与通知观察者
 *链接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public class Subject{
    private List<Observer> observers = new ArrayList<>();
    public void addObserver(Observer observer){
    //添加观察者的方法：
        observers.add(observer);
    }
    public void removeObserver(Observer observer){
    //删除观察者
        observers.remove(observer);
    }
    protected void notifyObserves(){
    //通知观察者
        for (Observer observer:observers) {
            observer.updata(this);
        }
    }
}

Observer类的实现：

/**
 *创建人：UncleMin
 *时间：2017/3/11 0011-下午 6:15
 *描述：观察者的接口对象：Observer
 *链接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public interface Observer {
   //更新方法
    public void updata(Subject subject);
}

上面Observable被观察者的基类，为了给具体被观察者继承的，而Observer是接口，里面的方法是刷新数据的；

三、下面就是具体的调用和实现：

import java.util.Observable;

/**
 *创建人：UncleMin
 *时间：2017/3/11 0011-下午 6:59
 *描述：ConcreteSubject:具体的目标对象，负责数据完成之后通知观察者ds
 *链接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public class ConcreteSubject extends Subject {
    private String mContent;
    public String getmContent() {
        return mContent;
    }
    public void setmContent(String mContent) {
        this.mContent = mContent;
        notifyObserves();
    }
}
**
 *创建人：UncleMin
 *时间：2017/3/11 0011-下午 6:57
 *描述：ConcreteObserver：具体的实现观察者对象
 *链接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public class ConcreteObserver implements Observer {
    @Override
    public void updata(Subject subject) {
        String s = ((ConcreteSubject) subject).getmContent();
        Log.e("ob", "updata: "+s);
    }
}

测试调用：

import android.app.Activity;
import android.os.Bundle;
import android.view.View;

/**
 * 创建人：UncleMin
 * 时间：2017/3/11 0011-下午 6:28
 * 描述：
 * 链接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public class ObserverActivity extends Activity {
    private ConcreteSubject subject;
    private ConcreteObserver observer;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_observe);
        subject = new ConcreteSubject();
        observer = new ConcreteObserver();
        subject.addObserver(observer);
    }

    public void onClick(View view) {
        int id = view.getId();
        switch (id){
            case R.id.btn_send:
                subject.setmContent("我是天气晴朗哦，嘻嘻！");
                break;
            case R.id.btn_remove:
                subject.removeObserver(observer);
                break;
        }

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

    }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <Button
        android:id="@+id/btn_send"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="onClick"
        android:onClick="onClick"
        />

    <Button
        android:id="@+id/btn_remove"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="remove"
        android:onClick="onClick"
        />


</LinearLayout>

上面就是观察者模式的通用的思路与代码，到这里其实回过头来，明白了思想，其实也是很简单的，当然，这么经典的东西，Java的编写人肯定不会遗漏的，其实java里面的Util包已经给我们写好了两个基类，我们用的时候可以直接的调用就ok了；

四、下面就是Java包下的引用：

被观察者：

package com.example.wz.mystudydemo;

import java.util.Observable;

    /**
     *创建人：UncleMin
     *时间：2017/3/11 0011-下午 6:59
     *描述：ConcreteSubject:具体的目标对象，负责数据完成之后通知观察者ds
     *链接：http://blog.csdn.net/wz1993_0719/article/details/60783657
     */
    public class ConcreteSubject extends Observable {
        private String mContent;
        public String getmContent() {
            return mContent;
        }
        public void setmContent(String mContent) {
            this.mContent = mContent;
            setChanged();
            notifyObservers();
        }
    }

观察者：

import android.util.Log;

import java.util.*;

/**
 *创建人：UncleMin
 *时间：2017/3/11 0011-下午 6:57
 *描述：ConcreteObserver：具体的实现观察者对象
 *链接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public class ConcreteObserver implements java.util.Observer {
    @Override
    public void update(Observable observable, Object data) {
        String s = ((ConcreteSubject) observable).getmContent();
        Log.e("ob", "updata: "+s);
    }
    /*@Override
    public void updata(Subject subject) {
        String s = ((ConcreteSubject) subject).getmContent();
        Log.e("ob", "updata: "+s);
    }*/
}

再观察者模式里面有两种实现方式：推模模型和拉模型；若是感兴趣的童鞋们可以自己去研究一下，毕竟纸上得来终觉浅，绝知此事要躬行

总结：

1.观察者模式的优点：(1)实现了观察者与目标时间的抽象解耦；(2)实现了动态联动；(3)支持广播通信
2.缺点：引起无所谓的操作；例如一些没必要的通知、