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

最新推荐文章于 2022-10-23 12:00:55 发布
最新推荐文章于 2022-10-23 12:00:55 发布
阅读量1k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cpongo4/article/details/86613803
版权

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

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

}

效果如下：


1200845-8b3fb87f4558d757.gif
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等可供参考。

参考

EventBus--手把手教你写个自己的EventBus
玩火猴子
11-15 752
此文章适用于使用过EventBus，不了解原理。大牛勿喷。。。(本文章写的MyEventBus只是做为理解EventBus的原理，不适合用在项目中) 没有用过请先移步至Github，官方已经对流程和使用已经做了详细的描述 EventBus核心是反射 1、注册的时候通过反射拿到类的方法(带Subscribe注解的)存起来 2、发送(post)的时候遍历储存的，对类型一样的通过反射执行
自写一个EventBus
Enaium的博客
02-23 329
首发于Enaium的个人博客 EventBus，什么是EventBus。 EventBus是事件发布-订阅总线，简单来说监听一个事件，一个方法订阅这个事件，如果事件调用，那么订阅了这个事件的方法也会跟着调用，这就是EventBus。 创建一个注解，用于订阅事件，名字可以随便起，当然也可以叫Subscribe，我这里叫Event。 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface Event {
自己动手写简单的eventbus
u010523832的专栏
06-19 754
其实之前看过几种事件的分发，包括greenrobot的EventBus，还有rxjava写的事件订阅。前者是写法局限，事件使用太多容易混乱，后者是准备弃用rxjava，仅仅对于使用事件订阅来说太重，于是想着自己写个，满足不是太多的事件订阅。封装不是太多，只是提供一些思路，其实不是太复杂。简单的模仿了rxjava的事件订阅，因为习惯了。 先贴源码package com.wj.eventbus.wj
教你自己实现一个事件总线EventBus
热门推荐
crazychen的专栏
08-11 1万+
EventBus是一个Github上著名的开源事件总线框架，想必很多人都使用过它。它实现了事件订阅者和事件发布者的解耦，让我们更加容易在actvity等组件间传递信息。 我们虽然不喜欢重复造轮子，但是不代表我们不需要了解轮子是怎么造的。 这篇文章通过这个简单的实例，给大家说明EventBus实现的原理，一起来打造一个简单的事件总线框架。如果你明白了这个框架的设计原理，那么EventBus也就相
动手实现一个EventBus
hefrankeleyn的博客
10-23 546
根据Google Guava中的EventBus，动手实现一个简单的EventBus，深入理解其原理。
前端面试题：JS 如何实现事件总线 Event Bus
lwebapp.com
03-10 2132
原文：https://lwebapp.com/zh/post/event-bus 介绍 Event Bus 事件总线，通常作为多个模块间的通信机制，相当于一个事件管理中心，一个模块发送消息，其它模块接受消息，就达到了通信的作用。 比如，Vue 组件间的数据传递可以使用一个 Event Bus 来通信，也可以用作微内核插件系统中的插件和核心通信。 原理 Event Bus 本质上是采用了发布-订阅的设计模式，比如多个模块 A、B、C 订阅了一个事件 EventX，然后某一个模块 X 在事件总线发布了这个事件，
如何在 JavaScript 中实现事件总线 （Event Bus）
zsevgymko的博客
03-12 557
原文：https://dushusir.com/js-event-bus/ 介绍 Event Bus 事件总线，通常作为多个模块间的通信机制，相当于一个事件管理中心，一个模块发送消息，其它模块接受消息，就达到了通信的作用。 比如，Vue 组件间的数据传递可以使用一个 Event Bus 来通信，也可以用作微内核插件系统中的插件和核心通信。 原理 Event Bus 本质上是采用了发布-订阅的设计模式，比如多个模块 A、B、C 订阅了一个事件 EventX，然后某一个模块 X 在事件总线发布了这个事件，那么事
EventBusDemo
08-17
EventBus 是一个在 Android 开发中广泛使用的发布/订阅事件总线库，它简化了组件间的通信，使得组件之间的耦合度大大降低。本 Demo 主要展示了 EventBus3.0 的基本使用方法，通过简单的代码示例帮助开发者快速入门。...
事件总线（Event Bus）知多少
dotNET跨平台
06-11 1456
1. 引言 事件总线这个概念对你来说可能很陌生，但提到观察者（发布-订阅）模式，你也许就很熟悉。事件总线是对发布-订阅模式的一种实现。它是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。 我们来看看事件总线的处理流程： 了解了事件总线的基本概念和处理流程，下面我们就来分析下如何去实现事件总线。 2.回归本质 在动手实现事件总线之前，我们还
event-bus:一个简单的python事件总线
05-14
活动巴士 一个简单的Python 3.5+事件总线。 目的 一种触发多个后续功能的方法。 安装 pip3 install event-bus 用法 EventBus是在整个应用程序中使用的单例。 from event_bus import EventBus bus = EventBus () @ bus . on ( 'hello' ) def subscribed_event (): print ( 'World!' ) def some_func (): print ( 'Hello' ) bus . emit ( 'hello' ) >> > some_func () "Hello" "World!" 表现。 构建库之后，我开始考虑性能并针对多种情况创建了测试。 通过查看tests/目录中的performance_testing.py文件，您可以确切地
message_bus:小消息总线示例
04-30
消息总线 这是一个非常基本的实验，以查看我是否可以实现消息传递总线以通过消息传递总线将消息发送到其他模块。 建造 mkdir build cmake make 执照 该代码是zlib / png下的许可。 随意使用此功能。 尚·塞巴斯蒂安·福特克斯（Jean-SébastienFauteux）
[转]事件总线，解决各种和addEventListener有关的麻烦
03-24
NULL 博文链接：https://as3.iteye.com/blog/1098757
vue的事件总线（EventBus）
丢失的Litte_志伟的博客
12-02 313
vue的事件总线 EventBus 又称为事件总线。在Vue中可以使用 EventBus 来作为沟通桥梁的概念，就像是所有组件共用相同的事件中心，可以向该中心注册发送事件或接收事件，所以组件都可以上下平行地通知其他组件，但也就是太方便所以若使用不慎，就会造成难以维护的灾难，因此才需要更完善的Vuex作为状态管理中心，将通知的概念上升到共享状态层次。 创建EventBus Vue实例（两种方式） 一：在main.js里面创建 因为，我们是通过emit这个方法来触发EventBus的，而emit这个方法来触发E
c++事件总线模型
Fireplusplus的博客
06-29 1707
一种简单的事件总线模型。
c++事件总线简单实现
百冰千岚的博客
03-16 3039
文章目录1. 事件总线2. 任意类型参数3. 注册机制4. 线程处理5. BOOST库链接时提示找不到“libxxx”6. multimap用法7.事件总线简单实现 1. 事件总线 用于多线程操作，降低库与库之间的耦合，提高执行效率。 2. 任意类型参数 当你需要一个可变的类型时，有三种可能的解决方案： 无限制的类型，如 void*. 这种方法不可能是类型安全的，应该象逃避灾难一样避免它。 可变...
Qt 之 事件总线模型
wjjontheway的专栏
01-20 1954
文章目录Qt 之 开源事件总线模块libgitlevtbus模型模块EventEventBusModuleModuleDelegateTestCase Qt 之 开源事件总线模块 libgitlevtbus 用到了libgitlevtbus (libgitlevtbus)[https://github.com/lheric/libgitlevtbus] 介绍 libgitlevtbus 是一个基于Qt的开源的事件总线（消息总线 ） ， BSD lisence. 特征 1. Easy to use (c
vue slot scope使用_Vue组件通信方式居然有这么多？你了解几种
weixin_39781599的博客
11-22 312
作者：梨香链接：https://juejin.im/post/6887709516616433677vue组件通信的方式，这是在面试中一个非常高频的问题，我刚开始找实习便经常遇到这个问题，当时只知道回到props和$emit，后来随着学习的深入，才发现vue组件的通信方式竟然有这么多！今天对vue组件通信方式进行一下总结，如写的有疏漏之处还请大家不吝赐教。1.props/$emit简介p...
c++ 手动加载 netcore_.NET Core搭建微服务框架 + 源码
weixin_34571272的博客
12-25 758
(给DotNet加星标，提升.Net技能)转自：往事随灬锋cnblogs.com/lifeng618/p/14120044.html前言工作快4年了，有时很迷茫，有时很有干劲，学习了一些技术，也忘记了一些技术，即使对一些技术，了解的深度不够，至少自己学习过使用过，那么在面对问题时，不会显得那么无力，解决问题后，也能有更大的收获。1、.NET Core基础知识，EF CORE Code F...
EventBus 3.0：Android事件总线详解与实战应用
本文将详细介绍Android事件总线EventBus3.0的使用方法，这对于开发者理解和实践Android应用程序中的异步通信和组件间的解耦至关重要。EventBus是一个强大的工具，它简化了在Android应用中发布和订阅事件的过程。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值