[TOC]
-
特性
- 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 - 测试完成
