【框架】EventBus简单实现

最新推荐文章于 2021-05-06 15:55:25 发布
最新推荐文章于 2021-05-06 15:55:25 发布
阅读量221 收藏
点赞数
分类专栏： anddroid相关 设计框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/soybeen/article/details/88806567
版权
本文介绍了EventBus的使用，包括SubScribe注解的详细说明，SubScribeMethod的封装以及线程模式的应用。同时，通过EvenBus的单例模式实现注册、注销和发布事件的方法，并通过MainActivity接收消息和SecondActivity发送消息的实际案例进行阐述。
摘要由CSDN通过智能技术生成

1.SubScribe注解

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

2.SubScribeMethod封装

public class SubScribeMethod {

    /**
     * 方法
     */
    private Method method;

    /**
     * 线程模式
     */
    private ThreadMode threadMode;

    /**
     * 参数
     */
    private Class<?> type;

    public SubScribeMethod() {
    }

    public SubScribeMethod(Method method, ThreadMode threadMode, Class<?> type) {
        this.method = method;
        this.threadMode = threadMode;
        this.type = type;
    }

    public Method getMethod() {
        return method;
    }

    public void setMethod(Method method) {
        this.method = method;
    }

    public ThreadMode getThreadMode() {
        return threadMode;
    }

    public void setThreadMode(ThreadMode threadMode) {
        this.threadMode = threadMode;
    }

    public Class<?> getType() {
        return type;
    }

    public void setType(Class<?> type) {
        this.type = type;
    }
}

线程模式


public enum  ThreadMode {
    MAIN,
    BACKGROUND
}

EvenBus单例实现：regiseter unRegister,post

public class EventBus {

    private ConcurrentHashMap<Object, List<SubScribeMethod>> mCache;

    private static EventBus instance;

    private Handler mHandler;

    private ThreadPoolExecutor mThreadPoolExecutor;

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

    public EventBus() {
        this.mCache = new ConcurrentHashMap<>(16);
        mHandler = new Handler(Looper.getMainLooper());
        mThreadPoolExecutor = new ThreadPoolExecutor(3, 5, 3, TimeUnit.SECONDS, new PriorityBlockingQueue<Runnable>());
    }

    /**
     * 注册
     * @param object
     */
    public void register(Object object) {
        if (object == null) {
            return;
        }
        // 从缓存中拿
        List<SubScribeMethod> list = mCache.get(object);
        if (list == null) {
            list = findSubScribeInfos(object);
            mCache.put(object, list);
        }

    }

    private List<SubScribeMethod> findSubScribeInfos(Object object) {
        List<SubScribeMethod> subScribeMethods = new ArrayList<>();
        Class<?> clazz = object.getClass();
        while (clazz != null) {
            if (clazz.getName().startsWith("java.") || clazz.getName().startsWith("javax.")
                || clazz.getName().startsWith("android.")) {
                break;
            }
            // 获取当前所有的方法
            Method[] methods = clazz.getMethods();
            if (methods != null) {
                for (int i = 0; i < methods.length; i++) {
                    Method method = methods[i];
                    Class<?>[] types = method.getParameterTypes();
                    if (types.length == 1) {
                        Subscrible subscribe = method.getAnnotation(Subscrible.class);
                        // 当前注解
                        if (subscribe != null) {
                            // 当前线程模式
                            ThreadMode threadMode = subscribe.threadMode();
                            SubScribeMethod subScribeMethod = new SubScribeMethod();
                            subScribeMethod.setType(types[0]);
                            subScribeMethod.setThreadMode(threadMode);
                            subScribeMethod.setMethod(method);
                            subScribeMethods.add(subScribeMethod);
                        }
                    }

                }
            }

            clazz = clazz.getSuperclass();

        }
        return subScribeMethods;
    }

    /**
     * 取消注册
     * @param object
     */
    public void unRegister(Object object) {
        // 去除当前的注册缓存
        mCache.remove(object);

    }

    /**
     * post方法
     * @param object
     */
    public void post(final Object object) {
        // 循环遍历map
        Set<Object> set = mCache.keySet();
        Iterator<Object> iterable = set.iterator();
        while (iterable.hasNext()) {
            final Object key = iterable.next();
            List<SubScribeMethod> methodLis = mCache.get(key);
            Class<?> clazz = object.getClass();
            if (methodLis != null && !methodLis.isEmpty()) {
                for (final SubScribeMethod subScribeMethod : methodLis) {
                    // 参数的type一样
                    if (subScribeMethod.getType().isAssignableFrom(clazz)) {
                        // 区分线程进行
                        if (subScribeMethod.getThreadMode() == ThreadMode.MAIN) {
                            if (isMainUI()) {
                                involke(subScribeMethod, key, object);
                            } else {
                                mHandler.post(new Runnable() {
                                    @Override
                                    public void run() {
                                        involke(subScribeMethod, key, object);
                                    }
                                });
                            }

                        } else if (subScribeMethod.getThreadMode() == ThreadMode.BACKGROUND) {
                            if (isMainUI()) {
                                mThreadPoolExecutor.execute(new Runnable() {
                                    @Override
                                    public void run() {
                                        involke(subScribeMethod, key, object);
                                    }
                                });
                            } else {
                                involke(subScribeMethod, key, object);

                            }

                        }
                    }
                }
            }
        }

    }

    private void involke(SubScribeMethod subScribeMethod, Object object, Object type) {
        Method method = subScribeMethod.getMethod();
        if (method != null) {
            try {
                method.invoke(object, type);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

    private boolean isMainUI() {
        return Looper.getMainLooper() == Looper.myLooper();
    }
}

例子：MainActivity 接收消息

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        EventBus.getDefault().register(this);
        findViewById(R.id.b).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent();
                intent.setClass(MainActivity.this,SecondActivity.class);
                startActivity(intent);
            }
        });
    }

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

    @Subscrible(threadMode = ThreadMode.MAIN)
    public void getMainMessage(EventBean eventBean){
        Log.d("zpb","Main from="+ eventBean.getFrom()+":: to="+eventBean.getTo()+" thread="+Thread.currentThread().getName());

    }

    @Subscrible(threadMode = ThreadMode.BACKGROUND)
    public void getThreadMessage(EventBean eventBean){
        Log.d("zpb"," thread from="+ eventBean.getFrom()+":: to="+eventBean.getTo()+" thread="+Thread.currentThread().getName());


    }

    @Subscrible
    public void getStringMessage(String message){
        Log.d("zpb","string value ="+message);
    }


}

SecondActivity发送消息

public class SecondActivity extends Activity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.secord_activity);
        findViewById(R.id.b1).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                EventBean eventBean = new EventBean();
                eventBean.setFrom("b1 main thread");
                eventBean.setTo("main actityv");
                EventBus.getDefault().post(eventBean);
            }
        });

        findViewById(R.id.b2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        EventBean eventBean = new EventBean();
                        eventBean.setFrom("b2 subThread");
                        eventBean.setTo("mainactivity");
                        EventBus.getDefault().post(eventBean);

                    }
                }).start();

            }
        });

        findViewById(R.id.b3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                EventBus.getDefault().post("发送子付出啊");

            }
        });

    }

}
动手实现一个EventBus
hefrankeleyn的博客
10-23 549
根据Google Guava中的EventBus，动手实现一个简单的EventBus，深入理解其原理。
Android中使用开源框架EventBus3.0实现Fragment之间的通信交互
潘侯爷的博客
02-20 3941
在之前的博文中简单介绍过如何实现fragment之间的信息交互：《Android中Fragment与Activity之间的交互（两种实现方式）》，今天继续给大家介绍一种可以实现此效果的另外一种方式EventBus。 EventBus是Android下高效的发布/订阅事件的消息总线。作用是可以代替传统的Intent,Handler,Broadcast或接口函数在Fragment、Activity、
EventBus的简单实现
LI_YUANQI的博客
11-30 268
创建一个bean类 public class User { private String name; public User(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } } Acti...
基于EventBus核心原理的简单实现
工匠的博客
03-18 881
通过对EventBus源码分析，剥离出核心api的实现： 1、EventBus.getDefault()：EventBus的单例实现，保证全局只有一个EventBus类实例； 2、register()：事件订阅者的注册 3、post()：消息的发送 4、unregister()：事件订阅者的注销 注：不考虑不同线程之间的消息发送，不考虑发送消息的优先级以及其他防止内存泄漏的优化处理等。 ...
轻量级的EventBus简单实现
FFZZHH的专栏
06-18 310
EventBus 简介 EventBus是一种用于Android的事件发布-订阅总线，由GreenRobot开发，Gihub地址是：EventBus。它简化了应用程序内各个组件之间进行通信的复杂度，尤其是碎片之间进行通信的问题，可以避免由于使用广播通信而带来的诸多不便。 1.1 三个角色 Event：事件，它可以是任意类型，EventBus会根据事件类型进行全局的通知。 Subscriber：事件订阅者，在EventBus 3.0之前我们必须定义以onEvent开头的那几个方法，分别是onEvent
Android中使用开源框架eventbus3.0实现fragment之间的通信交互
01-05
在之前的博文中简单介绍过如何实现fragment之间的信息交互：《Android中Fragment与Activity之间的交互（两种实现方式）》，今天继续给大家介绍一种可以实现此效果的另外一种方式EventBus。（相比于handler，接口回调...
Android 自己实现组件间通信框架EventBus
11-14
【Android 自己实现组件间通信框架EventBus】 EventBus 是一个流行且轻量级的 Android 组件间通信库，它简化了应用程序中的事件发布/订阅机制。传统的 Android 通信方式，如 Intent、BroadcastReceiver 或者回调...
Android框架EventBus实例
05-26
创建一个简单的Java类，标记为`@Parcelize`（如果使用Kotlin）或实现Parcelable接口（如果使用Java），表示事件对象。例如： ```kotlin @Parcelize data class MyEvent(val message: String) : Parcelable ```...
简单实现EventBus
qq_32021429的博客
05-06 247
简单实现EventBus 我们知道，基于DOM2级绑定事件是基于事件池的机制，可以给同一个元素的同一个行为绑定多个不同的方法，当该行为触发时，绑定的这些方法会被依次执行。但是，DOM2级事件绑定只能对元素的默认行为进行方法绑定，例如：click、keydown、scroll等原生默认行为。 // 基于事件池机制实现事件绑定，可以绑定任意自定义事件 (function(){ function Sub(){ this.listeners = {} } Sub.protot
EventBus五种ThreadMode
12-06
ThreadMode 提供了5种mode, 我觉得在只用其中的MAIN和BACKGROUD就可以了 1. ThreadMode: POSTING 事件处理和post在同一个线程中,如果是UI线程注意耗时操作。 2. ThreadMode: MAIN 事件处理将在Android的主线程(UI线程)中被调用。 3. ThreadMode: BACKGROUND 事件处理将在后台线程中被调用, 如果事件发布在子线程,则直接当前子线程处理事件;如果处理事件是耗时操作会影响后续事件的处理。 4. ThreadMode: ASYNC 事件处理将在一个单独的,且不是UI线程的线程中被调用。 5. ThreadMode: MAIN_ORDERED 在主线程中处理事件, 事件总是放入队列中通过handle处理, 并且总是发布时间按着先后顺序执行事件的处理
EventBus手写简单实现
Android小船的专栏
05-05 302
package com.demo.administrator.eventbus.eventbus; import java.lang.reflect.Method; import java.lang.reflect.Type; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import j...
开源框架 EventBus 简单使用
繁星点点~
07-07 532
EventBus 项目地址：https://github.com/greenrobot/EventBus#comparison-with-squares-otto 简介       EventBus 是基于推送/订阅模式的事件总线开源项目，使用它可以代替传统的Handler，Intent，广播等实现不同组件之间数据传递。例如Activity之间传递数据，Activity与Fragment之间传
EventBus简单的使用
湖言的博客
06-04 389
1，导包EventBus compile 'de.greenrobot:eventbus:3.0.0-beta1' 2，接收消息的类 在oncreat里初始化 if (!EventBus.getDefault().isRegistered(this)) { EventBus.getDefault().register(this); } //接收和销毁方法 @Subscrib...
自己动手实现EventBus框架功能
z979451341的博客
01-25 2558
github项目代码地址，欢迎starthttps://github.com/979451341/EventLine我篇博文主要是为了模仿EventBus框架实现事件总线的功能：Activity、Service和Fragment之间建立订阅者关系，并且指定订阅者接收数据的线程1.Activity之间的通信我做的事件总线传递信息是通过实体类，为了好用，这个实体类必须用户来定义，所以泛型就用上场了，然...
EventBus 的简单使用
怪咖先森的博客
02-08 273
1. 简介EventBus是一个Android端优化的publish/subscribe消息总线，简化了应用程序内各组件间、组件与后台线程间的通信。比如请求网络，等网络返回时通过Handler或Broadcast通知UI，两个Fragment之间需要通过Listener通信，这些需求都可以通过EventBus实现。2. 下载地址https://github.com/greenrobot/EventB
eventBus的简单使用
yukaihuaboke的博客
12-27 217
依赖： compile 'org.greenrobot:eventbus:3.1.1' 实现功能： 当击btn_try按钮的时候，跳到第二个Activity， 当点击第二个activity上面的First Event按钮的时候向第一个Activity发送消息 ，当第一个Activity收到消息后 ，在textview中显示 1. //ThreadMode.MAIN表示这个方法在主线
Android开发EventBus最简单的使用
聪哥的专栏
01-13 1266
EventBus的出现我再也不用广播通知了。别问我为什么，它太好了。 下面说下最简单的应用。原理什么的，我也不是很懂。我只是会用。 接收方： 1.必须先做的操作 @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); EventBus.
EventBus框架的使用
mn的博客
03-20 626
1、注意我们传递参数的类一定要写成javaBean的形式，也就是必须要有get set方法。 2、一个注册了EventBus事件的类必须要有一个订阅函数，否则报的错误会让你怀疑人生。（我就因为写错了一个单词将onMainEventThread写成onMianEventThread,找了整整一个小时哭） 3、同样的订阅函数可以有多个，只要参数不同即可，比如onMainEventThread你爱写多少个就可以写多少个只要Event不同微笑。 4、注册之后一定要记得反注册，否则怎么死的都知道大哭 5、一定不要注册
深入理解JavaScript事件总线eventBus的实现原理
在实际开发中，eventBus的实现不仅可以是一个简单的对象，还可以是一个框架的一部分，或者是一个专门的库。例如，Vue.js框架内置了eventBus的概念，称为事件总线（Event Bus），在Vue实例中通过$emit和$on来实现事件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值