手动实现事件总线框架EventBus
Posted csdn用户R
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了手动实现事件总线框架EventBus相关的知识，希望对你有一定的参考价值。
文章目录
- 特性
- 1.事件传递
- 2.线程调度
- 3.粘性事件，可以有多个，但需要自己移除
- 4.顺序事件
- 使用了静态方法和代理类，代码结构和demo有所不同
1.基础使用方式
注册注销
@Override
protected void onCreate(Bundle savedInstanceState)
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
EventBus.register(this);
@Override
protected void onDestroy()
super.onDestroy();
EventBus.unRegister(this);
发送、接收
EventBus.post(new Btn3EventBean("msg:按钮3的消息"));
@Subscribe
public void btn3Event1(Btn3EventBean bean)
show(bean.msg);
实现分析
- 定注解Subscribe，标记回调方法
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Subscribe
- 定义保存注解方法的对象MethodInfo,保存注解方法和所在类对象，invoke用
public class MethodInfo
//消息Bean类型
public Class<?> type;
//注解方法
public Method method;
public MethodInfo(Class<?> type, Method method)
this.type = type;
this.method = method;
- 定义EventBus类，这是管理类,需要有:
- 注册注销，参数是类对象
- 读取类中带注解的方法并保存,参数是类对象
- 发送消息,参数是消息对象
- 执行注解方法
//保存带注解的方法
private Map<Object, List<MethodInfo>> cacheMap;
public void register(Object getter)
List<MethodInfo> list = cacheMap.get(getter);
if (list == null)
list = findAnnotationMethod(getter);
cacheMap.put(getter, list);
public void unRegister(Object getter)
if (cacheMap.containsKey(getter))
cacheMap.remove(getter);
private List<MethodInfo> findAnnotationMethod(Object getter)
Log.e(TAG, "寻找带注解方法: " + getter.getClass().getName());
List<MethodInfo> list = new ArrayList<>();
return list;
public void post(Object setter)
Log.e(TAG, "发送消息: " + setter.getClass().getName());
private void invoke()
具体实现
- 启动一个activity时，调用注册register，寻找保存带注解方法（destroy时注销，删除映射）,传入类对象，反射获取所有方法，找出带定义好的注解的方法，最好做下规范性验证，没有返回值&没有参数只有1个消息对象，保存类和带注解方法集合的映射
private List<MethodInfo> findAnnotationMethod(Object getter)
Log.e(TAG, "寻找带注解方法: " + getter.getClass().getName());
List<MethodInfo> list = new ArrayList<>();
Class<?> clazz = getter.getClass();
Method[] methods = clazz.getMethods();
for (Method method : methods)
Subscribe subscribe = method.getAnnotation(Subscribe.class);
if (subscribe == null)
continue;
//方法必须是返回void
if (!"void".equals(method.getGenericReturnType().toString()))
throw new RuntimeException("method must return void");
//方法参数校验
Class<?>[] paramsTypes = method.getParameterTypes();
if (paramsTypes.length != 1)
throw new RuntimeException("method must has only one params");
//方法符合规则，加入缓存
MethodInfo methodInfo = new MethodInfo(paramsTypes[0], method);
list.add(methodInfo);
return list;
- post发送一个消息，参数是消息对象,遍历map保存的所有MethodInfo，如果MethodInfo的消息类型（Class）和要发送的消息类型一致，就调用这个方法,完成消息传递
public void post(final Object setter)
Log.e(TAG, "发送消息: " + setter.getClass().getName());
Set<Object> set = cacheMap.keySet();
for (final Object getter : set)
List<MethodInfo> list = cacheMap.get(getter);
if (list != null)
for (final MethodInfo info : list)
//判断是否这个类的对象
if (info.type.isAssignableFrom(setter.getClass()))
execute(info, getter, setter);
private void execute(MethodInfo info, Object getter, Object setter)
try
Log.e(TAG, "执行注解方法: " + info.method.getName());
info.method.invoke(getter, setter);
catch (IllegalAccessException e)
e.printStackTrace();
catch (InvocationTargetException e)
e.printStackTrace();
这里用到反射，getter是方法所在的类对象，setter是消息对象，即注解方法的参数
线程调度实现
- 参考EventBus和实际场景，定义MethodMode
- POSTING：发送者所在的线程
- BACKGROUND：如果发送者在主线程，那么使用新线程执行注解方法，否则同POSTING
- ASYNC：总是使用新线程执行注解方法
public enum ThreadMode
POSTING,
MAIN,
BACKGROUND,
ASYNC
- 注解增加线程模式属性
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Subscribe
ThreadMode threadMode() default ThreadMode.POSTING;
- 注解方法对象中保存线程信息
public class MethodInfo
//消息类型
public Class<?> type;
//回调线程
public ThreadMode threadMode;
//回调方法
public Method method;
public MethodInfo(Class<?> type, ThreadMode threadMode, Method method)
this.type = type;
this.threadMode = threadMode;
this.method = method;
private List<MethodInfo> findAnnotationMethod(Object getter)
...
//方法符合规则，加入缓存
MethodInfo methodInfo = new MethodInfo(paramsTypes[0], subscribe.threadMode(), method);
list.add(methodInfo);
return list;
- 执行注解方法时，增加线程调度逻辑,使用了线程池
private Handler handler;
private ExecutorService executorService;
private EventBus()
cacheMap = new HashMap<>();
handler = new Handler(Looper.getMainLooper());
executorService = Executors.newCachedThreadPool();
public void post(final Object setter)
Log.e(TAG, "发送消息: " + setter.getClass().getName());
Set<Object> set = cacheMap.keySet();
for (final Object getter : set)
List<MethodInfo> list = cacheMap.get(getter);
if (list != null)
for (final MethodInfo info : list)
//判断是否这个类的对象
if (info.type.isAssignableFrom(setter.getClass()))
switch (info.threadMode)
case MAIN:
if (Looper.getMainLooper() == Looper.myLooper())
invoke(info, getter, setter);
else
handler.post(new Runnable()
@Override
public void run()
invoke(info, getter, setter);
);
break;
case POSTING:
invoke(info, getter, setter);
break;
case BACKGROUND:
if (Looper.getMainLooper() == Looper.myLooper())
executorService.execute(new Runnable()
@Override
public void run()
invoke(info, getter, setter);
);
else
invoke(info, getter, setter);
break;
case ASYNC:
executorService.execute(new Runnable()
@Override
public void run()
invoke(info, getter, setter);
);
break;
线程调度测试完成，连续发送几百次正常运行
粘性事件实现
EventBus中代码有点多了，将寻找注解方法、发送消息等具体操作放入到代理类EventHelper中去，删除getInstance()改用静态方法对外提供api,所有外部调用的api都在EventBus中
实现分析
- 需要一个列表保存粘性消息
- 需要发送粘性消息的方法，参数为消息对象
- 需要移除粘性消息的方法，参数为消息对象
- 发送粘性消息时，先匹配找到的注解方法，然后再每次有新类注册进来时，匹配新类中的注解方法
- 方法可以拒绝粘性消息
具体实现
/**
* 保存粘性事件
*/
private List<Object> cacheStickList = new ArrayList<>();
/**
* 发送粘性消息
* @param setter
*/
public static void postStick(Object setter)
helper.post(instance.cacheMap, setter);
if (!instance.cacheStickList.contains(setter))
instance.cacheStickList.add(setter);
/**
* 移除粘性消息
* @param setter
*/
public static void removeStick(Object setter)
if (instance.cacheStickList.contains(setter))
instance.cacheStickList.remove(setter);
在register方法中，增加匹配粘性消息的过程
/**
* 注册类时，与粘性消息匹配，然后在存入映射map
* @param getter 类对象
*/
public static void register(Object getter)
List<MethodInfo> list = instance.cacheMap.get(getter);
if (list == null)
list = helper.findAnnotationMethod(getter);
//注册查找完一个类的注解方法后，匹配粘性消息
Map<Object, List<MethodInfo>> map = new HashMap<>();
map.put(getter, list);
for (Object setter : instance.cacheStickList)
helper.post(map, setter);
//将查找到的带注解方法放入map
instance.cacheMap.putAll(map);
Subscribe注解中增加属性refuseStick，是否拒绝接受粘性消息，默认接受,MethodInfo中也增加refuseStick属性
/**
* 执行注解方法
* @param info 方法封装对象
* @param setter 消息对象的封装
*/
private void invoke(MethodInfo info, Object setter)
try
if (EventBus.isStick(setter) && info.refuseStick)
//是粘性消息，方法拒绝粘性消息，则不执行
return;
Log.e("------invoke"," priority = " + info.priority);
info.method.setAccessible(true);
info.method.invoke(info.getter, setter);
catch (IllegalAccessException e)
e.printStackTrace();
catch (InvocationTargetException e)
e.printStackTrace();
测试已完成
顺序事件实现
实现分析
- 注解中增加优先级属性priority
- 方法封装MethodInfo中增加priority属性
- 发送时先全部找到，排序再发送
- 增加打断方法
具体实现
/**
* 取消事件在不同优先级方法中的传递
* @param setter 事件对象
*/
public static void cancelLowerPriority(Object setter)
helper.cancelLowerPriority(setter);
- 拆分代理类中的post方法，分为：
- 查找匹配方法
- 根据优先级排序，执行
- 线程调度
- 反射执行
/**
* 发送消息
* @param setter 消息对象
*/
public void post(Map<Object, List<MethodInfo>> cacheMap, final Object setter)
List<MethodInfo> matchedMethods = new ArrayList<>();
Set<Object> set = cacheMap.keySet();
for (final Object getter : set)
List<MethodInfo> list = cacheMap.get(getter);
if (list != null)
for (final MethodInfo info : list)
//判断是否这个类的对象
if (info.type.isAssignableFrom(setter.getClass()))
matchedMethods.add(info);
execute(matchedMethods,setter);
/**
* 找到所有匹配的注解方法，执行
* 如果是顺序事件，判断是否被取消传递
* @param matchedMethods
* @param setter
*/
private void execute(List<MethodInfo> matchedMethods,Object setter)
sortByPriority(matchedMethods);
for (int i = 0; i < matchedMethods.size(); i++)
if(cacheCancelList.contains(setter))
break;
execute(matchedMethods.get(i),setter);
cacheCancelList.remove(setter);
/**
* 线程调度
*/
private void execute(final MethodInfo info,final Object setter)
switch (info.threadMode)
...
/**
* 执行注解方法
* @param info 方法封装对象
* @param setter 消息对象的封装
*/
private void invoke(MethodInfo info, Object setter)
try
if (EventBus.isStick(setter) && info.refuseStick)
//是粘性消息，方法拒绝粘性消息，则不执行
return;
Log.e("------invoke"," priority = " + info.priority);
info.method.setAccessible(true);
info.method.invoke(info.getter, setter);
catch (IllegalAccessException e)
e.printStackTrace();
catch (InvocationTargetException e)
e.printStackTrace();
测试完成
顺序传递事件，不能使用线程调度，否则执行顺序不符合预期
补充
- 边想边敲，记录前部分可能会和实际有不同,
可以参考demo - 测试完成
以上是关于手动实现事件总线框架EventBus的主要内容，如果未能解决你的问题，请参考以下文章
EventBusEventBus 事件总线框架简介 ( EventBus 使用流程 )