EventBus学习总结

Posted 2021-06-29 AC_Jobim

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了EventBus学习总结相关的知识，希望对你有一定的参考价值。

EventBus学习总结

一、概述
二、EventBus的基本使用
三、Subscribe 注解介绍
- 3.1 线程模式
- 3.2 粘性事件
四、源码分析（待补）
五、手写简单的EventBus

一、概述

EventBus是一款针对android优化的发布/订阅事件总线。主要功能是替代Intent,Handler,BroadCast在Fragment，Activity，Service，线程之间传递消息.优点是开销小，代码更优雅。以及将发送者和接收者解耦。

GitHub地址：https://github.com/greenrobot/EventBus
官网教程：https://greenrobot.org/eventbus/
EventBus库中最重要的三个点，分别是subscriber（订阅者），事件（消息），publisher（发布者）。

subscriber ——> EventBus 的register方法，传入的object对象
事件（Event）——> EventBus 的post方法，传入的类型。
publisher（发布者）——> EventBus的post方法。

添加依赖

implementation 'org.greenrobot:eventbus:3.2.0'

二、EventBus的基本使用

在需要订阅事件的模块中，进行eventbus的注册和解注册

@Override
protected void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}

@Override
protected void onStop() {
    super.onStop();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    EventBus.getDefault().unregister(this);
}

注意：

注册完了，在不用的时候一定要unregister。
register与unregister的时间根据实际需求来把控，官方的例子是在onStart（）回调方法进行注册，onStop()回调方法进行unregister（）

构造发送消息类

public class EventMessage {

    private int type;
    private String message;

    public EventMessage(int type, String message) {
        this.type = type;
        this.message = message;
    }

    @Override
    public String toString() {
        return "type="+type+"--message= "+message;
    }
}

在需要接受事件的类中进行好register之后，需要在该类中创建一个方法来接收事件消息。
```
@Subscribe(threadMode = ThreadMode.MAIN)
public void onReceiveMsg(EventMessage message) {
    Log.e(TAG, "onReceiveMsg: " + message.toString());
}
```
注意：
1. 该方法有且只有一个参数。
2. 该方法必须是public修饰符修饰，不能用static关键字修饰，不能是抽象的（abstract）
3. 该方法需要用@Subscribe注解进行修饰。

在需要发送事件的地方，调用EventBus的post（Object event），postSticky（Object event）来通知订阅者。

SecondActivity.java

private View.OnClickListener mSendListener = new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.e(TAG, "onClick: " );
        EventMessage msg = new EventMessage(1,"Hello MainActivity");
        EventBus.getDefault().post(msg);//该方法相当于调用上面的onReceiveMsg(EventMessage)方法
    }
};

当点击发布事件的按钮时，SecondActivity将发布一个EventMessage事件。而MainActivity订阅了EventMessage事件。当接收到EventMessage事件时，MainActivity将执行订阅该事件的方法。

三、Subscribe 注解介绍

@Subscribe是EventBus自定义的一种注解，他可接收三个参数。ThreadMode、boolean sticky、int priority。

threadMode 是用来决定onReceiveMsg将在哪种线程环境下被调用
sticky是一个boolean型的参数，默认值是false，表示不启用sticky特性。那么sticky特性是什么呢？我们之前说的EventBus事件传递的例子的时候，我们都是先对订阅者（Subscriber）进行先注册的，然后再post事件的。那sticky的作用是在先post事件，后对订阅者注册这种开发场景的支持的。
priority该参数是int型，默认值是0，表示优先级。值越高，越先接收到事件。注意：优先级只有在相同的线程模式下才有效。

@Subscribe(threadMode = ThreadMode.MAIN,sticky = true,priority = 1)
public void onReceiveMsg(EventMessage message) {
    Log.e(TAG, "onReceiveMsg: " + message.toString());
}

3.1 线程模式

ThreadMode.POSTING 订阅者方法将在发布事件所在的线程中被调用。这是默认的线程模式。事件的传递是同步的，一旦发布事件，所有该模式的订阅者方法都将被调用。这种线程模式意味着最少的性能开销，因为它避免了线程的切换。因此，对于不要求是主线程并且耗时很短的简单任务推荐使用该模式。使用该模式的订阅者方法应该快速返回，以避免阻塞发布事件的线程，这可能是主线程。
ThreadMode.MAIN 订阅者方法将在主线程（UI线程）中被调用。因此，可以在该模式的订阅者方法中直接更新UI界面。如果发布事件的线程是主线程，那么该模式的订阅者方法将被直接调用。使用该模式的订阅者方法必须快速返回，以避免阻塞主线程。
ThreadMode.MAIN_ORDERED 订阅者方法将在主线程（UI线程）中被调用。因此，可以在该模式的订阅者方法中直接更新UI界面。事件将先进入队列然后才发送给订阅者，所以发布事件的调用将立即返回。这使得事件的处理保持严格的串行顺序。使用该模式的订阅者方法必须快速返回，以避免阻塞主线程。
ThreadMode.BACKGROUND 订阅者方法将在后台线程中被调用。如果发布事件的线程不是主线程，那么订阅者方法将直接在该线程中被调用。如果发布事件的线程是主线程，那么将使用一个单独的后台线程，该线程将按顺序发送所有的事件。使用该模式的订阅者方法应该快速返回，以避免阻塞后台线程。
ThreadMode.ASYNC 订阅者方法将在一个单独的线程中被调用。因此，发布事件的调用将立即返回。如果订阅者方法的执行需要一些时间，例如网络访问，那么就应该使用该模式。避免触发大量的长时间运行的订阅者方法，以限制并发线程的数量。EventBus使用了一个线程池来有效地重用已经完成调用订阅者方法的线程。

订阅事件的代码如下所示：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initContentView();
        // 注册订阅者
        EventBus.getDefault().register(this);
    }

    private void initContentView() {
        findViewById(R.id.btn_main_start_activity).setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        if (v.getId() == R.id.btn_main_start_activity) {
            SecondActivity.start(this);
        }
    }

    @Subscribe(threadMode = ThreadMode.POSTING)
    public void onMessageEventPosting(MessageEvent event) {
        Log.i(TAG, "onMessageEventPosting(), current thread is " + Thread.currentThread().getName());
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEventMain(MessageEvent event) {
        Log.i(TAG, "onMessageEventMain(), current thread is " + Thread.currentThread().getName());
    }

    @Subscribe(threadMode = ThreadMode.MAIN_ORDERED)
    public void onMessageEventMainOrdered(MessageEvent event) {
        Log.i(TAG, "onMessageEventMainOrdered(), current thread is " + Thread.currentThread().getName());
    }

    @Subscribe(threadMode = ThreadMode.BACKGROUND)
    public void onMessageEventBackground(MessageEvent event) {
        Log.i(TAG, "onMessageEventBackground(), current thread is " + Thread.currentThread().getName());
    }

    @Subscribe(threadMode = ThreadMode.ASYNC)
    public void onMessageEventAsync(MessageEvent event) {
        Log.i(TAG, "onMessageEventAsync(), current thread is " + Thread.currentThread().getName());
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 注销订阅者
        EventBus.getDefault().unregister(this);
    }
}

在这里插入图片描述

3.2 粘性事件

果先发布了事件，然后有订阅者订阅了该事件，那么除非再次发布该事件，否则订阅者将永远接收不到该事件。此时，可以使用粘性事件。发布一个粘性事件之后，EventBus将在内存中缓存该粘性事件。当有订阅者订阅了该粘性事件，订阅者将接收到该事件。

订阅和发布一个粘性事件：

// 订阅粘性事件
@Subscribe(sticky = true)
public void onMessageEvent(MessageEvent event) {
    ...
}

// 发布粘性事件
EventBus.getDefault().postSticky(new MessageEvent("Hello EventBus!"));

移除粘性事件

// 移除指定的粘性事件
removeStickyEvent(Object event);

// 移除指定类型的粘性事件
removeStickyEvent(Class<T> eventType);

// 移除所有的粘性事件
removeAllStickyEvents();

代码示例：

在MainActivity中发布粘性事件：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

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

    private void initContentView() {
        findViewById(R.id.btn_main_post_event).setOnClickListener(this);
        findViewById(R.id.btn_main_start_activity).setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_main_post_event:
                // 发布粘性事件
                EventBus.getDefault().postSticky(new MessageEvent("Hello EventBus!"));
                break;

            case R.id.btn_main_start_activity:
                SecondActivity.start(this);
                break;

            default:
                break;
        }
    }
}

SecondActivity中订阅粘性事件：

public class SecondActivity extends AppCompatActivity {
    private static final String TAG = "SecondActivity";

    private TextView mTvMessage;

    public static void start(Context context) {
        Intent intent = new Intent(context, SecondActivity.class);
        context.startActivity(intent);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        initContentView();
        // 注册订阅者
        EventBus.getDefault().register(this);
    }

    private void initContentView() {
        mTvMessage = findViewById(R.id.tv_second_message);
    }

    @Subscribe(threadMode = ThreadMode.MAIN, sticky = true)
    public void onMessageEvent(MessageEvent event) {
        Log.i(TAG, "message is " + event.getMessage());
        // 更新界面
        mTvMessage.setText(event.getMessage());
        // 移除粘性事件
        EventBus.getDefault().removeStickyEvent(event);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 注销订阅者
        EventBus.getDefault().unregister(this);
    }
}

SecondActivity订阅了MessageEvent粘性事件。当接收到MessageEvent粘性事件时，订阅者方法将打印日志消息，并更新界面上的TextView，最后移除该粘性事件。

四、源码分析（待补）

五、手写简单的EventBus

EventBus

public class EventBus {

    private static volatile EventBus instance;
    private Handler mHandler;

    private Map<Object, List<SubscribleMethod>> cacheMap;

    private EventBus(){
        cacheMap = new HashMap<>();
        mHandler = new Handler();
    }

    public static EventBus getDefault(){
        if (instance == null) {
            synchronized (EventBus.class) {
                if (instance == null) {
                    instance = new EventBus();
                }
            }
        }
        return instance;
    }

    public void register(Object obj) {
        //循环obj中所有的方法，将带有subscrible注解的方法全部存到cacheMap中
        List<SubscribleMethod> list = cacheMap.get(obj);
        if(list == null){
            list = findSubsrcibleMethods(obj);
            cacheMap.put(obj,list);
        }
    }

    //查找该订阅者的订阅者方法
    private List<SubscribleMethod> findSubsrcibleMethods(Object obj) {
        List<SubscribleMethod> list = new ArrayList<>();
        Class<?> clazz = obj.getClass();

        while(clazz != null){
            //凡是系统级别的父类，直接省略
            String name = clazz.getName();
            if (name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("android.")){
                break;
            }

            Method[] declaredMethods = clazz.getDeclaredMethods();
            for (Method method : declaredMethods) {
                Subscrible subscrible = method.getAnnotation(Subscrible.class);

                if(subscrible != null){

                    //判断subscriblieMethod的参数是否唯一
                    Class<?>[] types = method.getParameterTypes();
                    if(types.length != 1){
                        Log.e("EventBus","EventBus only accept one parameter");
                    }
                    ThreadMode threadMode = subscrible.threadMode();
                    SubscribleMethod subscribleMethod = new SubscribleMethod(method, threadMode, types[0]);
                    list.add(subscribleMethod);
                }
            }
            clazz = clazz.getSuperclass();
        }
        return list;
    }


    public void post(Object type) {

        Set<Object> set = cacheMap.keySet();
        Iterator<Object> iterator = set.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            List<SubscribleMethod> list = cacheMap.get(obj);
            for (SubscribleMethod subscribleMethod : list) {
               if (subscribleMethod.getType().isAssignableFrom(type.getClass())) {
                   switch (subscribleMethod.getThreadMode()) {
                       case MAIN:
                           if (Looper.myLooper() == Looper.getMainLooper()){
                               //主-主
                               invoke(subscribleMethod,obj,type);
                           } else {
                               //子-主
                               mHandler.post(new Runnable() {
                                   @Override
                                   public void run() {
                                       invoke(subscribleMethod,obj,type);
                                   }
                               });
                           }
                           break;
                       case BACKGROUNP:
                           if (Looper.myLooper() == Looper.getMainLooper()){
                               //主-子
//                               ExecutorService
                           }else{
                               //子-子
                               invoke(subscribleMethod,obj,type);
                           }
                           break;
                       default:
                           break;
                   }
               }
            }

        }


    }

    private void invoke(SubscribleMethod subscribleM以上是关于EventBus学习总结的主要内容，如果未能解决你的问题，请参考以下文章 
 EventBus3.0 组件通信框架源码学习总结
 EventBus3.0 组件通信框架源码学习总结
 EventBus 知识点总结
 EventBus事件通信框架 ( 总结 | 手写事件通信框架完整代码示例 | 测试上述框架 )
 Python学习总结
 EventBus源码分析