Android之路-EventBus学习

官方定义
EventBus is an open-source library for Android using the publisher/subscriber pattern for loose coupling.
简而言之，EventBus是一个通过发布/订阅者模式来实现解耦合的Android lib。

image
那么什么是发布/订阅者模式呢？

Publisher/Subscriber pattern:
Android事件发布订阅模式，通过解耦发布者和订阅者简化 Android事件传递，这里的事件可以理解为消息。事件传递既可用于 Android 四大组件间通讯，也可以用户异步线程和主线程间通讯等等。
传统的事件传递方式包括：Handler、BroadCastReceiver、Interface 回调，相比之下 EventBus 的优点是代码简洁，使用简单，并将事件发布和订阅充分解耦。

Why？我们为什么要使用EventBus？
无利不起早，我们先来看看官方列举的使用EventBus的一些好处：

1. Simplifies the communication between components便捷的组件间通信
2. Decouples event senders and receivers事件发送和接收者解耦
3. Performs well with Activities, Fragments, and background threads能和Activity、Fragment以及后台线程友好协作
4. Avoids complex and error-prone dependencies and life cycle issues避免了复杂的依赖以及生命周期的问题
5. Is fast; specifically optimized for high performance速度快、性能好
6. Is tiny (<50k jar)体积小
7. Is proven in practice by apps with 100,000,000+ installs是经过了大量使用证明可靠的
8. Has advanced features like delivery threads, subscriber priorities, etc.有一些高级的特性可供扩展

吹了好多，大家看看即可，我们下面直接来和EventBus做个深入接触。

先说说EventBus的基本组成

1. 发布者（Publisher）：发布某个事件的对象，通过post接口发布事件。
2. 订阅者（Subscriber）：订阅某种事件的对象。当有发布者发布一类事件后，EventBus会执行订阅者的onEvent函数（事件响应函数）。订阅者通过register接口订阅某个事件类型，unregister接口退订。订阅者存在优先级，优先级高的订阅者可以取消事件继续向优先级低的订阅者分发，默认所有订阅者优先级为0。
3. 事件（Event）：就是一个对象，事件类型指事件所属对象的class。事件分为一般事件和Sticky事件，相对于一般事件，Sticky事件不同之处在于，当事件发布后，再有订阅者开始订阅该类型事件时，依然能收到该类型事件最近的一个Sticky事件。
4. 总线：是一个通道，发布者发布事件到总线，订阅者从总线获取订阅的事件。

再看看十分重要的ThreadMode
字面上来理解，TreadMode就是线程模式，我们直接理解为EventBus在做操作时所在的线程即可。EventBus通过不同的ThreadMode来帮助我们实现在不同线程之间的消息发送和接收，官方将其分为4类：

1. POSTING：默认的 ThreadMode，表示在执行 POST 操作的线程直接调用订阅者的事件响应方法，不论该线程是否为主线程（UI 线程）。当该线程为主线程时，响应方法中不能有耗时操作。适用场景：对于是否在主线程执行无要求，但若 POST 线程为主线程，不能有耗时操作；
2. MAIN：在主线程中执行响应方法。如果发布线程就是主线程，则直接调用订阅者的事件响应方法，否则通过主线程的 Handler 发送消息到主线程中处理——调用订阅者的事件响应函数。显然，Main类的方法也不能有耗时操作。适用场景：必须在主线程执行的操作；
3. BACKROUND：在后台线程中执行响应方法。如果发布线程不是主线程，则直接调用订阅者的事件响应函数，否则启动唯一的后台线程去处理。由于后台线程是唯一的，当事件超过一个的时候，它们会被放在队列中依次执行，因此该类响应方法虽然没有POSTING类和MAIN类方法对性能敏感，但最好不要有重度耗时的操作或太频繁的轻度耗时操作，以造成其他操作等待。适用场景：操作轻微耗时且不会过于频繁，即一般的耗时操作都可以放在这里；
4. ASYNC：不论发布线程是否为主线程，都使用一个空闲线程来处理。和BACKGROUND不同的是，Async类的所有线程是相互独立的，因此不会出现卡线程的问题。适用场景：长耗时操作，例如网络访问。

好了，以上就是关于EventBus我要说的一些废(Li)话(Lun)了，接下来我们来看一下，EventBus到底怎么用。

============================我是华丽的分隔符=================================
假设有这样一个需求：两个Fragment组成主界面，左边的Fragment是目录，右边的Fragment是详细信息面板。要求目录从网络获取，且当点击目录上的条目时，动态更新详细信息面板。

传统做法
1.目录Fragment中开启线程访问网络获取数据，完成数据获取之后使用handler更新UI；
2.目录Fragment中提供一个接口，详细信息面板Fragment中注册这个接口，发生点击事件时，回调改接口，随之更新详细信息面板。
在我们使用了EventBus之后~~~代码是这样的：

布局activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"                 
    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.example.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.example.eventbusdemo.ItemDetailFragment"        
        android:layout_width="0dip"        
        android:layout_height="match_parent"        
        android:layout_weight="2" />

</LinearLayout>    

MainActivity.java

public class MainActivity extends FragmentActivity {    
    
@Override    
protected void onCreate(Bundle savedInstanceState) {        

    super.onCreate(savedInstanceState);       
    setContentView(R.layout.activity_main);    
    }
}

ItemListFragment.java---列表Fragment

public class ItemListFragment extends ListFragment {    
      private static final String TAG = "ItemListFragment";    

    @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(3000); // 模拟延时                    
                    // 发布事件，在后台线程发的事件                    
                    EventBus.getDefault().post(new Event.ItemListEvent(Item.ITEMS));                
                } catch (InterruptedException e) {                    
                    e.printStackTrace();                
                }            
            }        
        }.start();    
    }    

    @Subscribe(threadMode = ThreadMode.MAIN)    
    public void onEventReceived(Event.ItemListEvent event) {        

        setListAdapter(new ArrayAdapter<Item>(getActivity(), 
            android.R.layout.simple_list_item_activated_1, 
            android.R.id.text1, event.getItems()));       
        Log.d(TAG, "ItemListFragment received events.");    
    }    

    @Override    
    public void onListItemClick(ListView listView, View view, int position, long id) {               

        super.onListItemClick(listView, view, position, id);              
        EventBus.getDefault().post(getListView().getItemAtPosition(position));   
    }
}

ItemDetailFragment.java---详情页Fragment

public class ItemDetailFragment extends Fragment {

    private static final String TAG = "ItemDetailFragment";
    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点击时会发送些事件，接收到事件后更新详情
    */
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onEventReceived(Item item) {

        if (item != null)
            tvDetail.setText(item.content);
        Log.d(TAG, "ItemDetailFragment received " + item.toString());
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onEventsReceived(Event.ItemListEvent event) {

        for (Item item : event.getItems()) {
            Log.d(TAG, item.toString());
        }
    }

    @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;
    }
}

Item.java---实体封装类

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;
    }
}

Event.java---Event事件

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;
        }
    }
}

ItemListFragment：在onCreate()和onDestroy()中分别进行EventBus的注册和反注册，然后通过在子线程中通过延时3s模拟网络操作，之后通过EventBus.getDefault().post()方法将相应的Event发送至消息总线，此为发布事件。
ItemDetailFragment：在onCreate()和onDestroy()中分别进行EventBus的注册和反注册，并通过事件响应函数onEventReceived()和onEventsReceived()对EventBus发送的事件做相应处理，此为订阅事件。

这里需要注意的是，EventBus在升级到3.0版本之后支持自定义响应函数名（之前是需要使用固定的函数名字）。我们可能会好奇，EventBus是如何知道在某个事件被Post出去之后应该去调用哪个方法响应这一事件的。其实很简单，在ItemListFragment以及ItemDetailFragment中我们加入EventBus.getDefault().register(this)这一行代码之后，EventBus会自动去扫描对应类中所有以Subscribe注解过的方法，并将方法名以及方法类型以键值对的类型加入Map，Key为方法参数，Value为方法。此后，当一个Event被Post加入到总线之后，EventBus会根据之前的记录匹配对应的方法参数，定位确定的方法之后调用符合的响应函数。

我们应该可以看到，在上面这样一个案例里面，代码中没有出现我们常用的Handler、AsyncTask，也没有接口回调。通过EventBus我们很神奇的将ItemListFragment和ItemDetailFragment解耦了。由此可见，EventBus应用于Android之中确实能够很大程度的帮助我们实现Loose Coupling这一设计理念。

好了，今天就到此为止，EventBus中的一些高级用法（StickyEvent、Priority等）改天再聊。

案例出自：http://blog.csdn.net/lmj623565791/article/details/40794879

声明：此文章中所使用部分内容及案例参考了互联网上部分文章，如对内容版权有异议，请联系我~