自己动手写事件总线(EventBus)

事件总线核心逻辑的实现。

EventBus的作用

Android中存在各种通信场景，如Activity之间的跳转，Activity与Fragment以及其他组件之间的交互，以及在某个耗时操作（如请求网络）之后的callback回调等，互相之之间往往需要持有对方的引用，每个场景的写法也有差异，导致耦合性较高且不便维护。以Activity和Fragment的通信为例，官方做法是实现一个接口，然后持有对方的引用，再强行转成接口类型，导致耦合度偏高。再以Activity的返回为例，一方需要设置setResult，而另一方需要在onActivityResult做对应处理，如果有多个返回路径，代码就会十分臃肿。而SimpleEventBus（本文最终实现的简化版事件总线）的写法如下：

public class MainActivity extends AppCompatActivity {
    TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = findViewById(R.id.tv_demo);
        mTextView.setText("MainActivity");
        mTextView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, SecondActivity.class);
                startActivity(intent);
            }
        });

        EventBus.getDefault().register(this);
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onReturn(Message message) {
        mTextView.setText(message.mContent);
    }

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

来源Activity：

public class SecondActivity extends AppCompatActivity {
    TextView mTextView;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = findViewById(R.id.tv_demo);
        mTextView.setText("SecondActivity,点击返回");
        mTextView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Message message = new Message();
                message.mContent = "从SecondActivity返回";
                EventBus.getDefault().post(message);
                finish();
            }
        });
    }

}

效果如下：


eventbus-demo.gif

似乎只是换了一种写法，但在场景愈加复杂后，EventBus能够体现出更好的解耦能力。

背景知识

主要涉及三方面的知识：

  1. 观察者模式(or 发布-订阅模式)
  2. Android消息机制
  3. Java并发编程

本文可以认为是greenrobot/EventBus这个开源库的源码阅读指南，笔者在看设计模式相关书籍的时候了解到这个库，觉得有必要实现一下核心功能以加深理解。

实现过程

EventBus的使用分三个步骤：注册监听、发送事件和取消监听，相应本文也将分这三步来实现。

注册监听

定义一个注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Subscribe {
    ThreadMode threadMode() default ThreadMode.POST;
}

greenrobot/EventBus还支持优先级和粘性事件，这里只支持最基本的能力：区分线程，因为如更新UI的操作必须放在主线程。ThreadMode如下：

public enum ThreadMode {
    MAIN, // 主线程
    POST, // 发送消息的线程
    ASYNC // 新开一个线程发送
}

在对象初始化的时候，使用register方法注册，该方法会解析被注册对象的所有方法，并解析声明了注解的方法（即观察者），核心代码如下：

public class EventBus {
    ...

    public void register(Object subscriber) {
        if (subscriber == null) {
            return;
        }
        synchronized (this) {
            subscribe(subscriber);
        }
    }

    ...
    private void subscribe(Object subscriber) {
        if (subscriber == null) {
            return;
        }

        // TODO 巨踏马难看的缩进
        Class<?> clazz = subscriber.getClass();
        while (clazz != null && !isSystemClass(clazz.getName())) {
            final Method[] methods = clazz.getDeclaredMethods();
            for (Method method : methods) {
                Subscribe annotation = method.getAnnotation(Subscribe.class);
                if (annotation != null) {
                    Class<?>[] paramClassArray = method.getParameterTypes();
                    if (paramClassArray != null && paramClassArray.length == 1) {
                        Class<?> paramType = convertType(paramClassArray[0]);
                        EventType eventType = new EventType(paramType);
                        SubscriberMethod subscriberMethod = new SubscriberMethod(method, annotation.threadMode(), paramType);
                        realSubscribe(subscriber, subscriberMethod, eventType);
                    }
                }
            }
            clazz = clazz.getSuperclass();
        }
    }

    ...
    private void realSubscribe(Object subscriber, SubscriberMethod method, EventType eventType) {
        CopyOnWriteArrayList<Subscription> subscriptions = mSubscriptionsByEventtype.get(subscriber);
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
        }
        Subscription subscription = new Subscription(subscriber, method);
        if (subscriptions.contains(subscription)) {
            return;
        }
        subscriptions.add(subscription);
        mSubscriptionsByEventtype.put(eventType, subscriptions);
    }

    ...
}

执行过这些逻辑后，该对象所有的观察者方法都会被存在一个Map中，其Key是EventType，即观察事件的类型，Value是订阅了该类型事件的所有方法（即观察者）的一个列表，每个方法和对象一起封装成了一个Subscription类：

public class Subscription {
    public final Reference<Object> subscriber;
    public final SubscriberMethod subscriberMethod;

    public Subscription(Object subscriber, 
                        SubscriberMethod subscriberMethod) {
        this.subscriber = new WeakReference<>(subscriber);// EventBus3 没用弱引用?
        this.subscriberMethod = subscriberMethod;
    }

    @Override
    public int hashCode() {
        return subscriber.hashCode() + subscriberMethod.methodString.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Subscription) {
            Subscription other = (Subscription) obj;
            return subscriber == other.subscriber
                    && subscriberMethod.equals(other.subscriberMethod);
        } else {
            return false;
        }
    }
}

如此，便是注册监听方法的核心逻辑了。

消息发送

消息的发送代码很简单：

public class EventBus {
    ...
    private EventDispatcher mEventDispatcher = new EventDispatcher();
    private ThreadLocal<Queue<EventType>> mThreadLocalEvents = new ThreadLocal<Queue<EventType>>() {
        @Override
        protected Queue<EventType> initialValue() {
            return new ConcurrentLinkedQueue<>();
        }
    };
    ...
    public void post(Object message) {
        if (message == null) {
            return;
        }

        mThreadLocalEvents.get().offer(new EventType(message.getClass()));
        mEventDispatcher.dispatchEvents(message);
    }

    ...
}

比较复杂一点的是需要根据注解声明的线程模式在对应的线程进行发布：

public class EventBus {

    ...
    private class EventDispatcher {
        private IEventHandler mMainEventHandler = new MainEventHandler();
        private IEventHandler mPostEventHandler = new DefaultEventHandler();
        private IEventHandler mAsyncEventHandler = new AsyncEventHandler();

        void dispatchEvents(Object message) {
            Queue<EventType> eventQueue = mThreadLocalEvents.get();
            while (eventQueue.size() > 0) {
                handleEvent(eventQueue.poll(), message);
            }
        }

        private void handleEvent(EventType eventType, Object message) {
            List<Subscription> subscriptions = mSubscriptionsByEventtype.get(eventType);
            if (subscriptions == null) {
                return;
            }
            for (Subscription subscription : subscriptions) {
                IEventHandler eventHandler =  getEventHandler(subscription.subscriberMethod.threadMode);
                eventHandler.handleEvent(subscription, message);
            }
        }

        private IEventHandler getEventHandler(ThreadMode mode) {
            if (mode == ThreadMode.ASYNC) {
                return mAsyncEventHandler;
            }
            if (mode == ThreadMode.POST) {
                return mPostEventHandler;
            }
            return mMainEventHandler;
        }
    }// end of the class

    ...
}

三种线程模式分别如下，DefaultEventHandler（在发布线程执行观察者放方法）：

public class DefaultEventHandler implements IEventHandler {
    @Override
    public void handleEvent(Subscription subscription, Object message) {
        if (subscription == null || subscription.subscriber.get() == null) {
            return;
        }
        try {
            subscription.subscriberMethod.method.invoke(subscription.subscriber.get(), message);
        } catch (IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

MainEventHandler（在主线程执行）：

public class MainEventHandler implements IEventHandler {
    private Handler mMainHandler = new Handler(Looper.getMainLooper());
    DefaultEventHandler hanlder = new DefaultEventHandler();

    @Override
    public void handleEvent(final Subscription subscription, final Object message) {
        mMainHandler.post(new Runnable() {
            @Override
            public void run() {
                hanlder.handleEvent(subscription, message);
            }
        });

    }
}

AsyncEventHandler（新开一个线程执行）：

public class AsyncEventHandler implements IEventHandler {
    private DispatcherThread mDispatcherThread;
    private IEventHandler mEventHandler = new DefaultEventHandler();

    public AsyncEventHandler() {
        mDispatcherThread = new DispatcherThread(AsyncEventHandler.class.getSimpleName());
        mDispatcherThread.start();
    }

    @Override
    public void handleEvent(final Subscription subscription, final Object message) {
        mDispatcherThread.post(new Runnable() {
            @Override
            public void run() {
                mEventHandler.handleEvent(subscription, message);
            }
        });

    }

    private class DispatcherThread extends HandlerThread {

        // 关联了AsyncExecutor消息队列的Handler
        Handler mAsyncHandler;

        DispatcherThread(String name) {
            super(name);
        }

        public void post(Runnable runnable) {
            if (mAsyncHandler == null) {
                throw new NullPointerException("mAsyncHandler == null, please call start() first.");
            }
            mAsyncHandler.post(runnable);
        }

        @Override
        public synchronized void start() {
            super.start();
            mAsyncHandler = new Handler(this.getLooper());
        }

    }

}

以上便是发布消息的代码。

注销监听

最后一个对象被销毁还要注销监听，否则容易导致内存泄露，目前SimpleEventBus用的是WeakReference，能够通过GC自动回收，但不知道greenrobot/EventBus为什么没这样实现，待研究。注销监听其实就是遍历Map，拿掉该对象的订阅即可：

public class EventBus {

    ...
    public void unregister(Object subscriber) {
        if (subscriber == null) {
            return;
        }
        Iterator<CopyOnWriteArrayList<Subscription>> iterator = mSubscriptionsByEventtype.values().iterator();
        while (iterator.hasNext()) {
            CopyOnWriteArrayList<Subscription> subscriptions = iterator.next();
            if (subscriptions != null) {
                List<Subscription> foundSubscriptions = new LinkedList<>();
                for (Subscription subscription : subscriptions) {
                    Object cacheObject = subscription.subscriber.get();
                    if (cacheObject == null || cacheObject.equals(subscriber)) {
                        foundSubscriptions.add(subscription);
                    }
                }
                subscriptions.removeAll(foundSubscriptions);
            }
            // 如果针对某个Event的订阅者数量为空了,那么需要从map中清除
            if (subscriptions == null || subscriptions.size() == 0) {
                iterator.remove();
            }
        }
    }
    ...
}

以上便是事件总线最核心部分的代码实现，完整代码见vimerzhao/SimpleEventBus，后面发现问题更新或者进行升级也只会改动仓库的代码。

局限性

由于时间关系，目前只研究了EventBus的核心部分，还有几个值得深入研究的点，在此记录一下，也欢迎路过的大牛指点一二。

性能问题

实际使用时，注解和反射会导致性能问题，但EventBus3已经通过Subscriber Index基本解决了这一问题，实现也非常有意思，是通过注解处理器（Annotation Processor）把耗时的逻辑从运行期提前到了编译期，通过编译期生成的索引来给运行期提速，这也是这个名字的由来。

可用性问题

如果订阅者很多会不会影响体验，毕竟原始的方法是点对点的消息传递，不会有这种问题，如果部分订阅者尚未初始化怎么办。等等。目前EventBus3提供了优先级和粘性事件的属性来进一步满足开发需求。但是否彻底解决问题了还有待验证。

跨进程问题

EventBus是进程内的消息管理机制，并且从开源社区的反馈来看这个项目是非常成功的，但稍微有点体量的APP都做了进程拆分，所以是否有必要支持多进程，能否在保证性能的情况下提供同等的代码解耦能力，也值得继续挖掘。目前有lsxiao/Apollo和Xiaofei-it/HermesEventBus等可供参考。

参考

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,185评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,445评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,684评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,564评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,681评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,874评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,025评论 3赞 408
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,761评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,217评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,545评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,694评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,351评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,988评论 3赞 315
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,778评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,007评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,427评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,580评论 2赞 349