1、概述

最近大家面试说经常被问到EventBus，github上果断down了一份，地址：https://github.com/greenrobot/EventBus，的确是个不错的框架，主要用于事件的发布和订阅。

EventBus定义：是一个发布 / 订阅的事件总线。

这么说应该包含4个成分：发布者，订阅者，事件，总线。

那么这四者的关系是什么呢？

很明显：订阅者订阅事件到总线，发送者发布事件。

大体应该是这样的关系：

订阅者可以订阅多个事件，发送者可以发布任何事件，发布者同时也可以是订阅者。

好了，大体了解基本的关系以后，我们通过案例驱动来教大家如何使用；

2、代码是最好的老师

相信大家对Fragment都有所了解，现在我们的需求是这样的，两个Fragment组成主界面，左边的Fragment是个目录、即列表，右边的Fragment是详细信息面板；

a、目录的列表是从网络获取的。

b、当点击目录上的条目时，动态更新详细信息面板；

效果图：

看了这个需求，我们传统的做法是：

a、目录Fragment在onCreate中去开启线程去访问网络获取数据，获取完成以后，通过handler去更新界面。

b、在目录的Fragment中提供一个接口，然后详细信息面板去注册这个接口，当发生点击时，去回调这个接口，让详细信息面板发生改变。

其实这种做法也还是不错的，但是有了EventBus之后，我们交互会发生什么样的变化呢？拭目以待吧。

首先提一下：

EventBus.getDefault().register(this);//订阅事件

EventBus.getDefault().post(object);//发布事件

EventBus.getDefault().unregister(this);//取消订阅

1、MainActivity及其布局

[java]view plaincopy

package com.angeldevil.eventbusdemo;  
  
import android.os.Bundle;  
import android.support.v4.app.FragmentActivity;  
  
public class MainActivity extends FragmentActivity  
{  
    @Override  
    protected void onCreate(Bundle savedInstanceState)  
    {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
    }  
  
}  

[html]view plaincopy

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:baselineAligned="false"  
    android:divider="?android:attr/dividerHorizontal"  
    android:orientation="horizontal"  
    android:showDividers="middle" >  
  
    <fragment  
        android:id="@+id/item_list"  
        android:name="com.angeldevil.eventbusdemo.ItemListFragment"  
        android:layout_width="0dip"  
        android:layout_height="match_parent"  
        android:layout_weight="1" />  
  
    <fragment  
        android:id="@+id/item_detail_container"  
        android:name="com.angeldevil.eventbusdemo.ItemDetailFragment"  
        android:layout_width="0dip"  
        android:layout_height="match_parent"  
        android:layout_weight="2" />  
  
</LinearLayout>  

可以看到，我们MainActvity可以说没有一行代码，布局文件即两个Fragment组成；

2、ItemListFragment

首先看个实体类：

[java]view plaincopy

package com.angeldevil.eventbusdemo;  
  
import java.util.ArrayList;  
import java.util.List;  
  
public class Item  
{  
    public String id;  
    public String content;  
  
    public static List<Item> ITEMS = new ArrayList<Item>();  
    static  
    {  
        // Add 6 sample items.  
        addItem(new Item("1", "Item 1"));  
        addItem(new Item("2", "Item 2"));  
        addItem(new Item("3", "Item 3"));  
        addItem(new Item("4", "Item 4"));  
        addItem(new Item("5", "Item 5"));  
        addItem(new Item("6", "Item 6"));  
    }  
  
    private static void addItem(Item item)  
    {  
        ITEMS.add(item);  
    }  
  
    public Item(String id, String content)  
    {  
        this.id = id;  
        this.content = content;  
    }  
  
    @Override  
    public String toString()  
    {  
        return content;  
    }  
}  

[java]view plaincopy

package com.angeldevil.eventbusdemo;  
  
import android.os.Bundle;  
import android.support.v4.app.ListFragment;  
import android.view.View;  
import android.widget.ArrayAdapter;  
import android.widget.ListView;  
  
import com.angeldevil.eventbusdemo.Event.ItemListEvent;  
  
import de.greenrobot.event.EventBus;  
  
public class ItemListFragment extends ListFragment  
{  
  
    @Override  
    public void onCreate(Bundle savedInstanceState)  
    {  
        super.onCreate(savedInstanceState);  
        // Register  
        EventBus.getDefault().register(this);  
    }  
  
    @Override  
    public void onDestroy()  
    {  
        super.onDestroy();  
        // Unregister  
        EventBus.getDefault().unregister(this);  
    }  
  
    @Override  
    public void onViewCreated(View view, Bundle savedInstanceState)  
    {  
        super.onViewCreated(view, savedInstanceState);  
        // 开启线程加载列表  
        new Thread()  
        {  
            public void run()  
            {  
                try  
                {  
                    Thread.sleep(2000); // 模拟延时  
                    // 发布事件，在后台线程发的事件  
                    EventBus.getDefault().post(new ItemListEvent(Item.ITEMS));  
                } catch (InterruptedException e)  
                {  
                    e.printStackTrace();  
                }  
            };  
        }.start();  
    }  
  
    public void onEventMainThread(ItemListEvent event)  
    {  
        setListAdapter(new ArrayAdapter<Item>(getActivity(),  
                android.R.layout.simple_list_item_activated_1,  
                android.R.id.text1, event.getItems()));  
    }  
  
    @Override  
    public void onListItemClick(ListView listView, View view, int position,  
            long id)  
    {  
        super.onListItemClick(listView, view, position, id);  
        EventBus.getDefault().post(getListView().getItemAtPosition(position));  
    }  
  
}  

ItemListFragment里面在onCreate里面进行了事件的订阅，onDestroy里面进行了事件的取消；onViewCreated中我们模拟了一个子线程去网络加载数据，获取成功后我们调用

了EventBus.getDefault().post(new ItemListEvent(Item.ITEMS));发布了一个事件；

onListItemClick则是ListView的点击事件，我们调用了EventBus.getDefault().post(getListView().getItemAtPosition(position));去发布一个事件，

getListView().getItemAtPosition(position)的类型为Item类型；

细心的你一定发现了一些诡异的事，直接new Thread()获取到数据以后，竟然没有使用handler；我们界面竟然发生了变化，那么List是何时绑定的数据？

仔细看下代码，发现这个方法：

public void onEventMainThread(ItemListEvent event)
{
setListAdapter(new ArrayAdapter<Item>(getActivity(),
android.R.layout.simple_list_item_activated_1,
android.R.id.text1, event.getItems()));
}

应该是这个方法为List绑定的数据。那么这个方法是怎么被调用的呢？

现在就可以细谈订阅事件与发布事件了：

如果方法名以onEvent开头，则代表要订阅一个事件，MainThread意思，这个方法最终要在UI线程执行；当事件发布的时候，这个方法就会被执行。

那么这个事件什么时候发布呢？

我们的onEventMainThread触发时机应该在new Thread()执行完成之后，可以看到子线程执行完成之后，执行了EventBus.getDefault().post(new ItemListEvent(Item.ITEMS));

意味着发布了一个事件，当这个事件发布，我们的onEventMainThread就执行了，那么二者的关联关系是什么呢？

其实和参数的类型，我们onEventMainThread需要接收一个ItemListEvent ，我们也发布了一个ItemListEvent的实例。

现在我们完整的理一下：

在onCreate里面执行 EventBus.getDefault().register(this);意思是让EventBus扫描当前类，把所有onEvent开头的方法记录下来，如何记录呢？使用Map，Key为方法的参数类型，Value中包含我们的方法。

这样在onCreate执行完成以后，我们的onEventMainThread就已经以键值对的方式被存储到EventBus中了。

然后当子线程执行完毕，调用EventBus.getDefault().post(new ItemListEvent(Item.ITEMS))时，EventBus会根据post中实参的类型，去Map中查找对于的方法，于是找到了我们的onEventMainThread，最终调用反射去执行我们的方法。

现在应该明白了，整个运行的流程了；那么没有接口却能发生回调应该也能解释了。

现在我们在看看代码，当Item点击的时候EventBus.getDefault().post(getListView().getItemAtPosition(position));我们同样发布了一个事件，参数为Item；这个事件是为了让详细信息的Fragment去更新数据，不用说，按照上面的推测，详细信息的Fragment里面一个有个这样的方法：public void onEventMainThread(Item item) ；是不是呢？我们去看看。

3、ItemDetailFragment

[java]view plaincopy

package com.angeldevil.eventbusdemo;  
  
import android.os.Bundle;  
import android.support.v4.app.Fragment;  
import android.view.LayoutInflater;  
import android.view.View;  
import android.view.ViewGroup;  
import android.widget.TextView;  
import de.greenrobot.event.EventBus;  
  
public class ItemDetailFragment extends Fragment  
{  
  
    private TextView tvDetail;  
  
    @Override  
    public void onCreate(Bundle savedInstanceState)  
    {  
        super.onCreate(savedInstanceState);  
        // register  
        EventBus.getDefault().register(this);  
    }  
  
    @Override  
    public void onDestroy()  
    {  
        super.onDestroy();  
        // Unregister  
        EventBus.getDefault().unregister(this);  
    }  
  
    /** List点击时会发送些事件，接收到事件后更新详情 */  
    public void onEventMainThread(Item item)  
    {  
        if (item != null)  
            tvDetail.setText(item.content);  
    }  
  
    @Override  
    public View onCreateView(LayoutInflater inflater, ViewGroup container,  
            Bundle savedInstanceState)  
    {  
        View rootView = inflater.inflate(R.layout.fragment_item_detail,  
                container, false);  
        tvDetail = (TextView) rootView.findViewById(R.id.item_detail);  
        return rootView;  
    }  
}  

果然不出我们的所料，真的存在onEventMainThread(Item item)的方法。当然了，必须在onCreate里面首先书写EventBus.getDefault().register(this);让EventBus扫描再说。

那么这个Fragment的流程就是：onCreate时，EventBus扫描当前类，将onEventMainThread以键值对的形式进行存储，键为Item.class ，值为包含该方法的对象。

然后当ItemListFragment中Item被点击时，发布了一个事件：EventBus.getDefault().post(getListView().getItemAtPosition(position));实参的类型恰好是Item，于是触发我们的

onEventMainThread方法，并把Item实参传递进来，我们更新控件。

4、Event

这里还有个事件类：

[java]view plaincopy

package com.angeldevil.eventbusdemo;  
  
import java.util.List;  
  
public class Event  
{  
    /** 列表加载事件 */  
    public static class ItemListEvent  
    {  
        private List<Item> items;  
  
        public ItemListEvent(List<Item> items)  
        {  
            this.items = items;  
        }  
  
        public List<Item> getItems()  
        {  
            return items;  
        }  
    }  
  
}  

ItemListEvent我们在ItemListFragment中使用的，作为的是onEventMainThread中的参数。为什么封装这么个类呢？会在之后的EventBus源码解析中说明。

到此我们的EventBus的初步用法就介绍完毕了。纵观整个代码，木有handler、木有AsynTask，木有接口回调；but，我们像魔术般的实现了我们的需求；来告诉我，什么是耦合，没见到~~~

3、EventBus的ThreadMode

EventBus包含4个ThreadMode：PostThread，MainThread，BackgroundThread，Async

MainThread我们已经不陌生了；我们已经使用过。

具体的用法，极其简单，方法名为：onEventPostThread， onEventMainThread，onEventBackgroundThread，onEventAsync即可

具体什么区别呢？

onEventMainThread代表这个方法会在UI线程执行

onEventPostThread代表这个方法会在当前发布事件的线程执行

BackgroundThread这个方法，如果在非UI线程发布的事件，则直接执行，和发布在同一个线程中。如果在UI线程发布的事件，则加入到一个后台的单线程队列中去。

Async 代表这个方法直接在独立的线程中执行。

4、题外话

大家可以利用EventBus尝试做以下操作：

当接收到某个广播，例如短信，在界面上显示。

开启一个Service，在服务器里面启动一个定时线程，不断更新ActivityUI。

等等...之后，你会发现EventBus的魅力！

补充：

EventBus使用详解(一)——初步使用EventBus

前言：EventBus是上周项目中用到的，网上的文章大都一样，或者过时，有用的没几篇，经过琢磨，请教他人，也终于弄清楚点眉目，记录下来分享给大家。

一、概述

EventBus是一款针对Android优化的发布/订阅事件总线。主要功能是替代Intent,Handler,BroadCast在Fragment，Activity，Service，线程之间传递消息.优点是开销小，代码更优雅。以及将发送者和接收者解耦。
1、下载EventBus的类库
源码：https://github.com/greenrobot/EventBus

2、基本使用

（1）自定义一个类，可以是空类，比如：

[java]view plaincopy

public class AnyEventType {  
     public AnyEventType(){}  
 }  

（2）在要接收消息的页面注册：

[java]view plaincopy

eventBus.register(this);  

（3）发送消息

[java]view plaincopy

eventBus.post(new AnyEventType event);  

（4）接受消息的页面实现(共有四个函数，各功能不同，这是其中之一，可以选择性的实现，这里先实现一个)：

[java]view plaincopy

public void onEvent(AnyEventType event) {}  

（5）解除注册

[java]view plaincopy

eventBus.unregister(this);  

顺序就是这么个顺序，可真正让自己写，估计还是云里雾里的，下面举个例子来说明下。

首先，在EventBus中，获取实例的方法一般是采用EventBus.getInstance()来获取默认的EventBus实例，当然你也可以new一个又一个，个人感觉还是用默认的比较好，以防出错。

二、实战

先给大家看个例子：

当击btn_try按钮的时候，跳到第二个Activity，当点击第二个activity上面的First Event按钮的时候向第一个Activity发送消息，当第一个Activity收到消息后，一方面将消息Toast显示，一方面放入textView中显示。

按照下面的步骤，下面来建这个工程：

1、基本框架搭建

想必大家从一个Activity跳转到第二个Activity的程序应该都会写，这里先稍稍把两个Activity跳转的代码建起来。后面再添加EventBus相关的玩意。

MainActivity布局（activity_main.xml）

[html]view plaincopy

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:orientation="vertical">  
      
    <Button   
        android:id="@+id/btn_try"  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:text="btn_bty"/>  
    <TextView   
        android:id="@+id/tv"  
        android:layout_width="wrap_content"  
        android:layout_height="match_parent"/>  
  
</LinearLayout>  

新建一个Activity，SecondActivity布局（activity_second.xml）

[html]view plaincopy

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:orientation="vertical"  
    tools:context="com.harvic.try_eventbus_1.SecondActivity" >  
  
    <Button   
        android:id="@+id/btn_first_event"  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:text="First Event"/>  
  
</LinearLayout>  

MainActivity.java （点击btn跳转到第二个Activity）

[java]view plaincopy

public class MainActivity extends Activity {  
  
    Button btn;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        btn = (Button) findViewById(R.id.btn_try);  
  
        btn.setOnClickListener(new View.OnClickListener() {  
  
            @Override  
            public void onClick(View v) {  
                // TODO Auto-generated method stub  
                Intent intent = new Intent(getApplicationContext(),  
                        SecondActivity.class);  
                startActivity(intent);  
            }  
        });  
    }  
  
}  

到这，基本框架就搭完了，下面开始按步骤使用EventBus了。

2、新建一个类FirstEvent

[java]view plaincopy

package com.harvic.other;  
  
public class FirstEvent {  
  
    private String mMsg;  
    public FirstEvent(String msg) {  
        // TODO Auto-generated constructor stub  
        mMsg = msg;  
    }  
    public String getMsg(){  
        return mMsg;  
    }  
}  

这个类很简单，构造时传进去一个字符串，然后可以通过getMsg()获取出来。

3、在要接收消息的页面注册EventBus：

在上面的GIF图片的演示中，大家也可以看到，我们是要在MainActivity中接收发过来的消息的，所以我们在MainActivity中注册消息。

通过我们会在OnCreate()函数中注册EventBus，在OnDestroy（）函数中反注册。所以整体的注册与反注册的代码如下：

[java]view plaincopy

package com.example.tryeventbus_simple;  
  
import com.harvic.other.FirstEvent;  
  
import de.greenrobot.event.EventBus;  
import android.app.Activity;  
import android.content.Intent;  
import android.os.Bundle;  
import android.util.Log;  
import android.view.View;  
import android.widget.Button;  
import android.widget.TextView;  
import android.widget.Toast;  
  
public class MainActivity extends Activity {  
  
    Button btn;  
    TextView tv;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
                //注册EventBus  
        EventBus.getDefault().register(this);  
  
        btn = (Button) findViewById(R.id.btn_try);  
        tv = (TextView)findViewById(R.id.tv);  
  
        btn.setOnClickListener(new View.OnClickListener() {  
  
            @Override  
            public void onClick(View v) {  
                // TODO Auto-generated method stub  
                Intent intent = new Intent(getApplicationContext(),  
                        SecondActivity.class);  
                startActivity(intent);  
            }  
        });  
    }  
    @Override  
    protected void onDestroy(){  
        super.onDestroy();  
        EventBus.getDefault().unregister(this);//反注册EventBus  
    }  
}  

4、发送消息

发送消息是使用EventBus中的Post方法来实现发送的，发送过去的是我们新建的类的实例！

[java]view plaincopy

EventBus.getDefault().post(new FirstEvent("FirstEvent btn clicked"));  

完整的SecondActivity.java的代码如下：

[java]view plaincopy

package com.example.tryeventbus_simple;  
  
import com.harvic.other.FirstEvent;  
  
import de.greenrobot.event.EventBus;  
import android.app.Activity;  
import android.os.Bundle;  
import android.view.View;  
import android.widget.Button;  
  
public class SecondActivity extends Activity {  
    private Button btn_FirstEvent;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_second);  
        btn_FirstEvent = (Button) findViewById(R.id.btn_first_event);  
  
        btn_FirstEvent.setOnClickListener(new View.OnClickListener() {  
  
            @Override  
            public void onClick(View v) {  
                // TODO Auto-generated method stub  
                EventBus.getDefault().post(  
                        new FirstEvent("FirstEvent btn clicked"));  
            }  
        });  
    }  
}  

5、接收消息

接收消息时，我们使用EventBus中最常用的onEventMainThread（）函数来接收消息，具体为什么用这个，我们下篇再讲，这里先给大家一个初步认识，要先能把EventBus用起来先。

在MainActivity中重写onEventMainThread（FirstEvent event），参数就是我们自己定义的类：

在收到Event实例后，我们将其中携带的消息取出，一方面Toast出去，一方面传到TextView中；

[java]view plaincopy

public void onEventMainThread(FirstEvent event) {  
  
    String msg = "onEventMainThread收到了消息：" + event.getMsg();  
    Log.d("harvic", msg);  
    tv.setText(msg);  
    Toast.makeText(this, msg, Toast.LENGTH_LONG).show();  
}  

完整的MainActiviy代码如下：

[java]view plaincopy

package com.example.tryeventbus_simple;  
  
import com.harvic.other.FirstEvent;  
  
import de.greenrobot.event.EventBus;  
import android.app.Activity;  
import android.content.Intent;  
import android.os.Bundle;  
import android.util.Log;  
import android.view.View;  
import android.widget.Button;  
import android.widget.TextView;  
import android.widget.Toast;  
  
public class MainActivity extends Activity {  
  
    Button btn;  
    TextView tv;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        EventBus.getDefault().register(this);  
  
        btn = (Button) findViewById(R.id.btn_try);  
        tv = (TextView)findViewById(R.id.tv);  
  
        btn.setOnClickListener(new View.OnClickListener() {  
  
            @Override  
            public void onClick(View v) {  
                // TODO Auto-generated method stub  
                Intent intent = new Intent(getApplicationContext(),  
                        SecondActivity.class);  
                startActivity(intent);  
            }  
        });  
    }  
  
    public void onEventMainThread(FirstEvent event) {  
  
        String msg = "onEventMainThread收到了消息：" + event.getMsg();  
        Log.d("harvic", msg);  
        tv.setText(msg);  
        Toast.makeText(this, msg, Toast.LENGTH_LONG).show();  
    }  
  
    @Override  
    protected void onDestroy(){  
        super.onDestroy();  
        EventBus.getDefault().unregister(this);  
    }  
}  

好了，到这，基本上算初步把EventBus用起来了，下篇再讲讲EventBus的几个函数，及各个函数间是如何识别当前如何调用哪个函数的。

源码地址：http://download.csdn.net/detail/harvic880925/8111357

请大家尊重原创者版权，转载请标明出处：http://blog.csdn.net/harvic880925/article/details/40660137 谢谢！

EventBus使用详解(二)——EventBus使用进阶

前言：这段时间感觉自己也有点懒了，真是内心有点自责呢，除了工作，也没做点什么，EventBus也是一周前总结出来的，只能以写博客为名来弥补内心的罪恶感了，集合同事们做的项目，虽然上周开动了，但总感觉大家积极性不高，如何才能做一个合格的管理者，还真是一个考验。follow your heart!! just do it!

一、概述

前一篇给大家装简单演示了EventBus的onEventMainThread（）函数的接收，其实EventBus还有另外有个不同的函数，他们分别是：

1、onEvent
2、onEventMainThread
3、onEventBackgroundThread
4、onEventAsync

这四种订阅函数都是使用onEvent开头的，它们的功能稍有不同,在介绍不同之前先介绍两个概念：
告知观察者事件发生时通过EventBus.post函数实现，这个过程叫做事件的发布，观察者被告知事件发生叫做事件的接收，是通过下面的订阅函数实现的。

onEvent:如果使用onEvent作为订阅函数，那么该事件在哪个线程发布出来的，onEvent就会在这个线程中运行，也就是说发布事件和接收事件线程在同一个线程。使用这个方法时，在onEvent方法中不能执行耗时操作，如果执行耗时操作容易导致事件分发延迟。
onEventMainThread:如果使用onEventMainThread作为订阅函数，那么不论事件是在哪个线程中发布出来的，onEventMainThread都会在UI线程中执行，接收事件就会在UI线程中运行，这个在Android中是非常有用的，因为在Android中只能在UI线程中跟新UI，所以在onEvnetMainThread方法中是不能执行耗时操作的。
onEventBackground:如果使用onEventBackgrond作为订阅函数，那么如果事件是在UI线程中发布出来的，那么onEventBackground就会在子线程中运行，如果事件本来就是子线程中发布出来的，那么onEventBackground函数直接在该子线程中执行。
onEventAsync：使用这个函数作为订阅函数，那么无论事件在哪个线程发布，都会创建新的子线程在执行onEventAsync.

二、实战

1、解析

上面列出的这四个函数，关键问题在于，我们怎么指定调用哪个函数呢？

我们先研究一下，上一篇中是怎么调用的onEventMainThread函数，除了在接收端注册与反注册以后，关键问题在于新建的一个类：

新建一个类：

[java]view plaincopy

package com.harvic.other;  
  
public class FirstEvent {  
  
    private String mMsg;  
    public FirstEvent(String msg) {  
        // TODO Auto-generated constructor stub  
        mMsg = msg;  
    }  
    public String getMsg(){  
        return mMsg;  
    }  
}  

发送时：

[java]view plaincopy

EventBus.getDefault().post(new FirstEvent("FirstEvent btn clicked"));    

接收时：

[java]view plaincopy

public void onEventMainThread(FirstEvent event) {    
  
    ……  
}    

发现什么问题了没？

没错，发送时发送的是这个类的实例，接收时参数就是这个类实例。

所以！！！！！！当发过来一个消息的时候，EventBus怎么知道要调哪个函数呢，就看哪个函数传进去的参数是这个类的实例，哪个是就调哪个。那如果有两个是呢，那两个都会被调用！！！！

为了证明这个问题，下面写个例子，先看下效果

2、实例

先看看我们要实现的效果：

这次我们在上一篇的基础上，新建三个类：FirstEvent、SecondEvent、ThirdEvent,在第二个Activity中发送请求，在MainActivity中接收这三个类的实例，接收时的代码为：

[java]view plaincopy

public void onEventMainThread(FirstEvent event) {  
  
    Log.d("harvic", "onEventMainThread收到了消息：" + event.getMsg());  
}  
  
public void onEventMainThread(SecondEvent event) {  
  
    Log.d("harvic", "onEventMainThread收到了消息：" + event.getMsg());  
}  
  
public void onEvent(ThirdEvent event) {  
    Log.d("harvic", "OnEvent收到了消息：" + event.getMsg());  
}  

使用两个onEventMainThread分别接收FirstEvent实例的消息和SecondEvent实例的消息，使用onEvent接收ThirdEvent实例的消息。界面操作及结果如下：

Log输出结果：

可以看到，在发送FirstEvent时，在MainActiviy中虽然有三个函数，但只有第一个onEventMainThread函数的接收参数是FirstEvent，所以会传到它这来接收。所以这里识别调用EventBus中四个函数中哪个函数，是通过参数中的实例来决定的。

因为我们是在上一篇例子的基础上完成的，所以这里的代码就不详细写了，只写改动的部分。

1、三个类

[java]view plaincopy

package com.harvic.other;  
  
public class FirstEvent {  
  
    private String mMsg;  
    public FirstEvent(String msg) {  
        // TODO Auto-generated constructor stub  
        mMsg = msg;  
    }  
    public String getMsg(){  
        return mMsg;  
    }  
}  

[java]view plaincopy

package com.harvic.other;  
  
public class SecondEvent{  
  
    private String mMsg;  
    public SecondEvent(String msg) {  
        // TODO Auto-generated constructor stub  
        mMsg = "MainEvent:"+msg;  
    }  
    public String getMsg(){  
        return mMsg;  
    }  
}  

[java]view plaincopy

package com.harvic.other;  
  
public class ThirdEvent {  
  
    private String mMsg;  
    public ThirdEvent(String msg) {  
        // TODO Auto-generated constructor stub  
        mMsg = msg;  
    }  
    public String getMsg(){  
        return mMsg;  
    }  
}  

2、发送

然后在SecondActivity中新建三个按钮，分别发送不同的类的实例，代码如下：

[java]view plaincopy

package com.harvic.tryeventbus2;  
  
import com.harvic.other.FirstEvent;  
import com.harvic.other.SecondEvent;  
import com.harvic.other.ThirdEvent;  
  
import de.greenrobot.event.EventBus;  
import android.app.Activity;  
import android.os.Bundle;  
import android.view.View;  
import android.widget.Button;  
  
public class SecondActivity extends Activity {  
    private Button btn_FirstEvent, btn_SecondEvent, btn_ThirdEvent;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_second);  
        btn_FirstEvent = (Button) findViewById(R.id.btn_first_event);  
        btn_SecondEvent = (Button) findViewById(R.id.btn_second_event);  
        btn_ThirdEvent = (Button) findViewById(R.id.btn_third_event);  
  
        btn_FirstEvent.setOnClickListener(new View.OnClickListener() {  
  
            @Override  
            public void onClick(View v) {  
                // TODO Auto-generated method stub  
                EventBus.getDefault().post(  
                        new FirstEvent("FirstEvent btn clicked"));  
            }  
        });  
          
        btn_SecondEvent.setOnClickListener(new View.OnClickListener() {  
  
            @Override  
            public void onClick(View v) {  
                // TODO Auto-generated method stub  
                EventBus.getDefault().post(  
                        new SecondEvent("SecondEvent btn clicked"));  
            }  
        });  
  
        btn_ThirdEvent.setOnClickListener(new View.OnClickListener() {  
  
            @Override  
            public void onClick(View v) {  
                // TODO Auto-generated method stub  
                EventBus.getDefault().post(  
                        new ThirdEvent("ThirdEvent btn clicked"));  
  
            }  
        });  
  
    }  
  
}  

3、接收

在MainActivity中，除了注册与注册，我们利用onEventMainThread(FirstEvent event)来接收来自FirstEvent的消息，使用onEventMainThread(SecondEvent event)接收来自SecondEvent 实例的消息，使用onEvent(ThirdEvent event) 来接收ThirdEvent 实例的消息。

[java]view plaincopy

package com.harvic.tryeventbus2;  
  
import com.harvic.other.FirstEvent;  
import com.harvic.other.SecondEvent;  
import com.harvic.other.ThirdEvent;  
  
import de.greenrobot.event.EventBus;  
import android.app.Activity;  
import android.content.Intent;  
import android.os.Bundle;  
import android.util.Log;  
import android.view.Menu;  
import android.view.MenuItem;  
import android.view.View;  
import android.widget.Button;  
import android.widget.TextView;  
  
public class MainActivity extends Activity {  
  
    Button btn;  
    TextView tv;  
    EventBus eventBus;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        EventBus.getDefault().register(this);  
  
        btn = (Button) findViewById(R.id.btn_try);  
  
        btn.setOnClickListener(new View.OnClickListener() {  
  
            @Override  
            public void onClick(View v) {  
                // TODO Auto-generated method stub  
                Intent intent = new Intent(getApplicationContext(),  
                        SecondActivity.class);  
                startActivity(intent);  
            }  
        });  
    }  
  
    public void onEventMainThread(FirstEvent event) {  
  
        Log.d("harvic", "onEventMainThread收到了消息：" + event.getMsg());  
    }  
  
    public void onEventMainThread(SecondEvent event) {  
  
        Log.d("harvic", "onEventMainThread收到了消息：" + event.getMsg());  
    }  
  
    public void onEvent(ThirdEvent event) {  
        Log.d("harvic", "OnEvent收到了消息：" + event.getMsg());  
    }  
  
    @Override  
    protected void onDestroy() {  
        // TODO Auto-generated method stub  
        super.onDestroy();  
        EventBus.getDefault().unregister(this);  
    }  
}  

到这里，代码就结束了，从上面的代码，我们可以看到，EventBus是怎么接收消息的，是根据参数中类的实例的类型的判定的，所以当如果我们在接收时，同一个类的实例参数有两个函数来接收会怎样？答案是，这两个函数都会执行，下面实验一下：

在MainActivity中接收时，我们在接收SecondEvent时，在上面onEventMainThread基础上另加一个onEventBackgroundThread和onEventAsync，即下面的代码：

[java]view plaincopy

//SecondEvent接收函数一  
public void onEventMainThread(SecondEvent event) {  
  
    Log.d("harvic", "onEventMainThread收到了消息：" + event.getMsg());  
}  
//SecondEvent接收函数二  
public void onEventBackgroundThread(SecondEvent event){  
    Log.d("harvic", "onEventBackground收到了消息：" + event.getMsg());  
}  
//SecondEvent接收函数三  
public void onEventAsync(SecondEvent event){  
    Log.d("harvic", "onEventAsync收到了消息：" + event.getMsg());  
}  

完整的代码在这里：

[java]view plaincopy

package com.harvic.tryeventbus2;  
  
import com.harvic.other.FirstEvent;  
import com.harvic.other.SecondEvent;  
import com.harvic.other.ThirdEvent;  
  
import de.greenrobot.event.EventBus;  
import android.app.Activity;  
import android.content.Intent;  
import android.os.Bundle;  
import android.util.Log;  
import android.view.Menu;  
import android.view.MenuItem;  
import android.view.View;  
import android.widget.Button;  
import android.widget.TextView;  
  
public class MainActivity extends Activity {  
  
    Button btn;  
    TextView tv;  
    EventBus eventBus;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        EventBus.getDefault().register(this);  
  
        btn = (Button) findViewById(R.id.btn_try);  
  
        btn.setOnClickListener(new View.OnClickListener() {  
  
            @Override  
            public void onClick(View v) {  
                // TODO Auto-generated method stub  
                Intent intent = new Intent(getApplicationContext(),  
                        SecondActivity.class);  
                startActivity(intent);  
            }  
        });  
    }  
  
    public void onEventMainThread(FirstEvent event) {  
  
        Log.d("harvic", "onEventMainThread收到了消息：" + event.getMsg());  
    }  
  
    //SecondEvent接收函数一  
    public void onEventMainThread(SecondEvent event) {  
  
        Log.d("harvic", "onEventMainThread收到了消息：" + event.getMsg());  
    }  
    //SecondEvent接收函数二  
    public void onEventBackgroundThread(SecondEvent event){  
        Log.d("harvic", "onEventBackground收到了消息：" + event.getMsg());  
    }  
    //SecondEvent接收函数三  
    public void onEventAsync(SecondEvent event){  
        Log.d("harvic", "onEventAsync收到了消息：" + event.getMsg());  
    }  
  
    public void onEvent(ThirdEvent event) {  
        Log.d("harvic", "OnEvent收到了消息：" + event.getMsg());  
    }  
  
    @Override  
    protected void onDestroy() {  
        // TODO Auto-generated method stub  
        super.onDestroy();  
        EventBus.getDefault().unregister(this);  
    }  
}  

经过上面的分析，当发送SecondEvent实例的消息过来的时候，这三个函数会同时接收到并各自执行，所以当点击Second Event这个button的时候，会出现下面的结果：

好啦，这篇就到了，讲来讲去就是说一个问题：消息的接收是根据参数中的类名来决定执行哪一个的；

参考文章：

《Android解耦库EventBus的使用和源码分析》：http://blog.csdn.net/yuanzeyao/article/details/38174537

《EventBus的使用初试》：http://blog.csdn.net/pp_hdsny/article/details/14523561

《EventBusExplained 》：https://code.google.com/p/guava-libraries/wiki/EventBusExplained

《Google Guava EventBus实例与分析》

如果我的文章有帮到你，记得关注哦！

源码下载地址：http://download.csdn.net/detail/harvic880925/8128633

请大家尊重原创者版权，转载请标明出处：http://blog.csdn.net/harvic880925/article/details/40787203 谢谢！

Kirsong Blog

2015年4月30日星期四

监听控件位置发生变化

ExpandableListView 的用法总结

2015年4月20日星期一

property nonatomic与atomic(无原子与原子)

Xcode快捷键使用

方法参数的命名方式

使用cube 实现异步下载图片

2015年4月17日星期五

webview的WebViewClient 网址重组重新加载的问题

2015年4月16日星期四

EventBus的使用(GITHUB 事件分发机制)

1、概述

2、代码是最好的老师

1、MainActivity及其布局

2、ItemListFragment

3、ItemDetailFragment

4、Event

3、EventBus的ThreadMode

4、题外话

一、概述

二、实战

1、基本框架搭建

2、新建一个类FirstEvent

3、在要接收消息的页面注册EventBus：

4、发送消息

5、接收消息

一、概述

二、实战

1、解析

2、实例

1、三个类

2、发送

3、接收