通过EventBus框架GET大牛的框架思维

EventBus的作用

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

<pre class="juejin-editor-highlight" style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; font-size: 0.8em; position: relative; padding: 0.5em 1em; background: rgb(248, 248, 248); overflow: auto; border-radius: 2px; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">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:

<pre class="juejin-editor-highlight" style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; font-size: 0.8em; position: relative; padding: 0.5em 1em; background: rgb(248, 248, 248); overflow: auto; border-radius: 2px; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">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能够体现出更好的解耦能力

背景知识

主要涉及三方面的知识:

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

实现过程

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.subscribe

                    && 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消息队列的Handle

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

            }

        }

    }

    ...

}

局限性

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

性能问题

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

可用性问题

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

原文地址:https://blog.51cto.com/14332859/2412719

时间: 2024-10-10 19:59:04

通过EventBus框架GET大牛的框架思维的相关文章

Linux驱动框架之framebuffer驱动框架

1.什么是framebuffer? (1)framebuffer帧缓冲(一屏幕数据)(简称fb)是linux内核中虚拟出的一个设备,framebuffer向应用层提供一个统一标准接口的显示设备.帧缓冲(framebuffer) 是Linux为显示设备提供的一个接口,把显存抽象后的一种设备,他允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作.这种操作是抽象的,统一的.用 户不必关心物理显存的位置.换页机制等等具体细节.这些都是由Framebuffer设备驱动来完成的. (2)从驱动来看,f

面向接口可扩展框架之“Mvc扩展框架及DI”

面向接口可扩展框架之“Mvc扩展框架及DI” 标题“Mvc扩展框架及DI”有点绕口,我也想不出好的命名,因为这个内容很杂,涉及多个模块,但在日常开发又密不可分 首先说Mvc扩展框架,该Mvc扩展就是把以前的那个Mvc分区扩展框架迁移过来,并优化整合了一下 一.Mvc扩展框架主要功能: 1.Mvc的依赖注入(DI)功能(类MvcDependency) 依赖IContainerFactory接口,不再依赖具体容器 2.Mvc全局过滤器(GlobalFilterProvider) 配置在Mvc的依赖注

WisDom.Net 框架设计(七) 验证框架

WisDom.Net-验证框架 1.分类 这里我们将数据验证分为以下几种 数据类型校验      主要用于确保数据类型输入的正确  比如年龄一项输入 A岁 ,显然不合法 域检查               主要用于验证输入的数据的是否在取值范围  比如在年龄一项 输入 400 ,显然这里不合法 格式检查            主要用于检查数据格式是否正确, 比如Email 输入Ca 显然这里也是不合法 自定义检查,       自定义校验数据. 比如 校验数据格式是否合法等 2.简介      

“Zhuang.Data”轻型数据库访问框架(二)框架的入口DbAccessor对象

目录: “Zhuang.Data”轻型数据库访问框架(一)开篇介绍 “Zhuang.Data”轻型数据库访问框架(二)框架的入口DbAccessor对象 先来看一段代码 DbAccessor dba = DbAccessor.Create(); var dt = dba.QueryDataTable("select * from sys_product where productid=#Id#",new {Id=1}); Console.WriteLine(DataTableUtil.

960网格布局框架(前端css框架)的使用方法

960框架总宽960px CSS框架已经出现很长时间了,关于这些框架的用处也被我们讨论了很多遍了.有人说,CSS框架不够先进,还有人说这些框架大大的节省了他们的开发时间.在此,我们将不再讨论这个问题. 前段时间,我了解到了CSS框架.经过对Malo.BluePrint和960做了实验对比后,我得出一个结论:我最喜欢960CSS框架. 本教程将解释这个框架的基本原理,这样你就可以用960来快速进入开发. 基本原理 你必须知道一些基本原理来“学习这个框架是如何工作的”.你可以通过实验(或者是用fir

接口自动化测试框架 (一) :APIAutoTest框架

前言 随着测试技术的发展,接口自动化测试逐渐成为各大公司投入产出比最高的测试技术.介入时间早,执行效率高,稳定性高的优点,让越来越多的公司引入接口自动化测试. 框架简介 APIAutoTest是处理API接口的轻量级自动化测试框架,Java语言实现,基于TestNG测试框架,支持持续集成,自动构建与测试. 框架介绍 1.    数据驱动设计,使用TestNG中的@DataProvider读取Excel中存储的自动化测试用例. 2.    基于TestNG测试框架 3.    使用HttpClie

**【ci框架】精通CodeIgniter框架

http://blog.csdn.net/yanhui_wei/article/details/25803945 一.大纲 [php] view plaincopy 1.codeigniter框架的授课内容安排 2.codeigniter框架的简介 |-----关于框架的概念 |-----使用CI框架的好处 |-----为什么选择CI框架 3.codeigniter框架的具体安装步骤 |-----官网下载:http://www.codeigniter.com/ |-----httpd.conf配

[转]Android中Xposed框架篇—利用Xposed框架实现拦截系统方法

一.前言 关于Xposed框架相信大家应该不陌生了,他是Android中Hook技术的一个著名的框架,还有一个框架是CydiaSubstrate,但是这个框架是收费的,而且个人觉得不怎么好用,而Xposed框架是免费的而且还是开源的,网上也有很多文章介绍了Xposed框架的原理实现,不了解的同学可以自行查阅即可,本文主要介绍如何通过这个框架来进行系统方法的拦截功能,比如我们开发过程中,对于一些测试环境很难模拟,特别是测试同学有时候像随机改变设备的imei,mcc等信息用来模拟不同测试场景,这时候

Apache MINA框架整合到Spring框架中

毕业设计用到了Apache公司的MINA框架作为服务端与安卓客户端的通信框架. 问题:服务端分为两个部分,一个是基于javaEE平台的后台管理系统,另一个是基于MINA框架的服务,整个项目中需求是当tomcat服务器启动的时候,将MINA服务也一起启动起来,相当于服务端程序运行起来后,开启两个服务. 分析:服务端的后台管理系统是采用Spring+Hibernate框架整合搭建的,而当tomcat服务器启动后,会加载spring的配置文件,而spring配置文件中可以自定义监听器,将启动MINA服