Android EventBus源码分析

一、先看看EventBus的简单使用

1. 导入eventbus

compile 'org.greenrobot:eventbus:3.0.0'

2. MainActivity

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //首先要在你要接受EventBus的界面注册，这一步很重要
        EventBus.getDefault().register(this);
        Button btnCommon = (Button) findViewById(R.id.btn_common);
        btnCommon.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {          
            case R.id.btn_common:
                //点击按钮进入CommonActivity
                CommonActivity.start(this);
                break;
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //在界面销毁的地方要解绑
        EventBus.getDefault().unregister(this);
    }

    //任意写一个方法，给这个方法一个@Subscribe注解，参数类型可以自定义，但是一定要与你发出的类型相同
    @Subscribe
    public void getEventBus(Integer num) {
        if (num != null) {
            //这里拿到事件之后吐司一下
            Toast.makeText(this, "num" + num, Toast.LENGTH_SHORT).show();
        }
    }
}

3. CommonActivity

public class CommonActivity extends AppCompatActivity implements View.OnClickListener {

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

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_common);
        Button button = (Button) findViewById(R.id.btn_send);
        button.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_send:
                //点击按钮，发送一个int类型的事件
                EventBus.getDefault().post(666);
                finish();
                break;
        }
    }
}

4. 指定线程执行

//CommonActivity 里面发送消息放到子线程
new Thread(new Runnable() {
                    @Override
                    public void run() {
                        EventBus.getDefault().post(666);
                        finish();
                    }
    }).start();
                
                
//MainActivity里面接收事件，只需要指定线程模式即可，即threadMode = ThreadMode.MAIN-->
@Subscribe(threadMode = ThreadMode.MAIN)
public void getEventBus(Integer num) {
        if (num != null) {
            Toast.makeText(this, "num" + num, Toast.LENGTH_SHORT).show();
        }
}

5. Stick Event（黏性事件）

  简单讲，就是在发送事件之后再订阅该事件也能收到该事件，跟黏性广播类似。
  1. 先发布事件

//点击按钮，跳转到StickActivity并携带参数，参数类型为String
EventBus.getDefault().postSticky("我是黏性事件");
//开启新的activity
StickActivity.start(this);

  2. 在订阅事件

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_stick);
        //前面也说了，在任何你要接收事件的地方都要先注册
        EventBus.getDefault().register(this);
}
    
//同样的，自定义一个方法，加上 @Subscribe，不同的是在后面再加上一句sticky = true告诉EventBus这是一个粘性事件
@Subscribe(sticky = true)
public void getEventBus(String str) {
        Toast.makeText(this, str, Toast.LENGTH_SHORT).show();
}

二、源码分析（EventBus.java）

1. 看看定义的变量

    // 一看就是单例
    static volatile EventBus defaultInstance;
    // 建造者模式
    private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
    // 类型缓存的集合
    private static final Map, List>> eventTypesCache = new HashMap<>();

    // key 是 Event 参数的类 例如String
    // value 存放的是 Subscription 的集合列表
    // Subscription 包含两个属性，一个是 subscriber 订阅者（反射执行对象），一个是 SubscriberMethod 注解方法的所有属性参数值
    //  发送消息会遍历此集合
    private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
    // key 是所有的订阅者
    // value 是所有订阅者里面方法的参数的class 例如String
    //  主要用于移除订阅者
    private final Map>> typesBySubscriber;
    //  发送粘性事件会遍历此集合
    private final Map, Object> stickyEvents;

    // 空间换时间 每个线程都有自己的副本
    private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
        @Override
        protected PostingThreadState initialValue() {
            return new PostingThreadState();
        }
    };

2. 看看注册方法

    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        // 拿到类的所以的方法（通过反射方法，然后拿到方法上的注解）
        // findSubscriberMethods()去解析注册者对象的所有方法，并且找出带有注解 Subscribe注解的的方法，然后通过Annotation解析所有细节参数（threadMode，priority，sticky，eventType，method），把这些参数封装成一个 SubscriberMethod，添加到集合返回。
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                // 将activity 和注解的方法一一绑定
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

3. 看看反射方法的实现

    private void findUsingReflectionInSingleClass(FindState findState) {
       
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class[] parameterTypes = method.getParameterTypes();
                if (parameterTypes.length == 1) {
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];
                        if (findState.checkAdd(method, eventType)) {
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            // 讲方法上的注解 封装成一个对象 ,存放到集合里面List
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                }
    }

4. 在看看怎么绑定的

// subscriptionsByEventType
// 第一步 讲acitivty 和方法封装成一个对象
// 第二步 讲方法类型 作为key 不同的activity和方法做一个对象放到一个集合里面
// 第三步 按照当前方法的优先级进行集合的存放

// typesBySubscriber
// 将Actvitity作为key eventType存放到一个集合，然后存放到typesBySubscriber

    // Must be called in synchronized block
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }

        int size = subscriptions.size();
        for (int i = 0; i <= size; i++) {
        // 存放activity +type  按照优先级排序
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
                subscriptions.add(i, newSubscription);
                break;
            }
        }

        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

       
    }

5. 简单的例子（subscriptionsByEventType）

  将Event的参数类型作为Key,Subscription的集合列表作为Value。然后在post发送内容的时候依据参数的类型去寻找对应的注册者 ，执行对象的方法。结构如下(伪代码)。

    // String类型的subscriber
    List