手动实现事件总线框架EventBus

[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
• 测试完成