android组件间的通讯方式

1.Activity之间的回调：

利用intent传递数据的StartActivity或者startActivityForResult实现activity之间的通讯

 

2.广播通讯方式：

广播通讯是我们常用的方式，也是android里面标准的方法，可以进行跨应用使用，可以算观察者模式的一种实现方式。

缺点：无法传递复杂的数据，必须通过bundle来传递

1,广播接收者BroadcastReceive通过Binder机制向AMS（Activity ManagerService）进行注册

2，广播发送者通过Binder机制向AMS发送广播

3，AMS查找符合相应条件（IntentFilter/Permission等）的BroadcastReceiver,将广播发送到BroadcastReceiver的相应的消息循环队列中

4，消息循环执行拿到此广播，回调BroadcastReceiver中的onReceive()方法。

3.基于观察者模式的通讯方式：

观察者：

（Observer）将自己注册到被观察对象（Subject）中，被观察对象将观察者存放在一个容器（Container）里。

被观察者：

（Observeable）被观察者对象发生了某种变化，从容器中得到所有注册过的观察者，将变化通知观察者。

简单例子：

1，定义抽象的观察者接口：

public interface ObserverInterface {
    /**
     * 根据事件进行数据或者UI的更新
     * @param message
     */
    public void dispatchChange(String message);
}

2,定义观察者，实现观察者接口：

public abstract class  Observer implements ObserverInterface{
    private Handler mHandler;

    public Observer(){
        mHandler=new Handler(Looper.getMainLooper());
    }


    public abstract void onChange(String message);

    @Override
    public void dispatchChange(String message){
        mHandler.post(new NotificationRunnable(message));
    }

    private final class NotificationRunnable implements Runnable{
        private String message;
        public NotificationRunnable(String message){
            this.message=message;
        }
        @Override
        public void run() {
            Observer.this.onChange(message);
        }
    }
}

3,定义抽象的被观察者接口：

public interface ObserveableInteraface {
    /**
     * 注册观察者
     * @param observer
     */
    public void registerObserver(Observer observer);

    /**
     * 反注册观察者
     * @param observer
     */
    public void removeObserver(Observer observer);

    /**
     * 通知注册的观察者进行数据或者UI的更新
     */
    public void notifyObserver(String message);
}

4，定义被观察者，实现被观察者接口：

public class Observeable implements ObserveableInteraface {
    private List<Observer> mEventObservers=new ArrayList<Observer>();
    private static volatile Observeable mEventObserveablet;
    private Subject(){

    }

    public synchronized static Observeable getInstance(){
        if(mEventObserveable ==null){
            mEventObserveable =new Observeable();
        }
        return mEventObserveable;
    }

    @Override
    public void registerObserver(Observer observer) {
        synchronized (mEventObservers){
            if(observer!=null){
                if(mEventObservers.contains(observer)){
                    return;
                }
                mEventObservers.add(observer);
            }
        }
    }

    @Override
    public void removeObserver(Observer observer) {
        synchronized (mEventObservers){
            int index = mEventObservers.indexOf(observer);
            if (index >= 0) {
                mEventObservers.remove(observer);
            }
        }
    }

    @Override
    public void notifyObserver(String message) {
        if(mEventObservers!=null && mEventObservers.size()>0 && message!=null){
            for(Observer observer:mEventObservers){
                observer.dispatchChange(message);
            }
        }

    }
}

就这样我们定义好了观察者（Observer）和被观察者（Observeable）

具体使用：

一般为了减少不必要的代码复用，我们会封装一个基类Activity，所以我们把观察者的使用在BaseActivity中进一步封装，方便我们快速调用

(observer)观察者封装使用：

public abstract  class BaseActivity extends ActionBarActivity {
    private ActivityObserver mActivityObserver;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mActivityObserver=new ActivityObserver(this);
        registerObserver(mActivityObserver);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        removeObserver(mActivityObserver);
    }


    /**
     * 注册为观察者
     * @param observer
     */
    public void registerObserver(Observer observer) {
            final Observeable eventObserveable t=Observeable.getInstance();
            Observeable.registerObserver(observer);
    }

    /**
     * 反注册观察者
     * @param observer
     */
    public void removeObserver(Observer observer) {
            final Observeable eventObserveable = Observeable.getInstance();
            eventObserveable.removeObserver(observer);
    }

    /**
     * 该方法会在具体的观察者对象中调用，可以根据事件的类型来更新对应的UI，这个方法在UI线程中被调用，
     * 所以在该方法中不能进行耗时操作，可以另外开线程
     * @param message 事件类型
     */
    protected abstract void onChange(String message);


    private static class ActivityObserver extends Observer {
        //添加弱引用，防止对象不能被回收
        private final WeakReference<BaseActivity> mActivity;
        public ActivityObserver(BaseActivity activity){
            super();
            mActivity=new WeakReference<BaseActivity>(activity);
        }

        @Override
        public void onChange(String message) {
            BaseActivity activity=mActivity.get();
            if(activity!=null){
                activity.onChange(message);
            }
        }
    }
}

(Observeable)被观察者使用实例：

public class FirstActivity extends ActionBarActivity {

    private Button notifyButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);

        notifyButton=(Button) findViewById(R.id.NotifyButton);
        notifyButton.setOnClickListener(
                new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                //通知所有观察者，给所有观察者发出消息
                Observeable ob = Observeable.getInstance();
                 ob.notifyObserver("are you ok ?");
            }
        });
    }
}

（observer）观察者使用实例：

public class SecondActivity extends BaseActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
    }

    @Override
    protected void onChange(String message) {
        //接收到被observeable 被观察者发来的消息

        System.out.println("I'm fine thank you ");
    }
}

4.基于发布/订阅者 模式的通讯方式：

发布/订阅简称(Pub/Sub)模式，这种模式是观察者observer的一种变体。发布者主要是负责向外发送消息，S订阅者主要是订阅接收消息。主要用于“只负责传递消息，并不关心其他订阅者已经收到这个消息”.和广播通信非常相似。我们常用的发布订阅模式是EventBus框架. 
优点：代码简洁优雅，大大降低了耦合性。简化了应用程序内各组件间、组件与后台线程间的通信。 
缺点：无法进程间通信，如果一个应用内有多个进程的话就没办法了，无法跨应用传递事件。在组件之间通信非常频繁复杂繁琐的时候，会需要很多不同通信的消息Event实体 ， EventBus的缺点也就暴露出来了，此时代码维护也很变得不容易了，显得混乱。

1、初始化时注册EventBus.getDefault().register(this);
2、用完之后注销EventBus.getDefault().unregister(this);
3、中间过程主要就是消息推送和接收,通过EventBus.getDefault().post(param)推送,通过onEventMainThread(param),onEventPostThread(param),onEventBackgroundThread(param),onEventAsync(param)接收并处理。