手动实现事件总线框架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
  • 测试完成
发布了12 篇原创文章 · 获赞 10 · 访问量 2万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览