教你一步步搭建自己的EventBus

EventBus相信很多人都用过，主要使用发布/订阅模式来达到事件通知的效果，这里我们简单的实现一下EventBus，作为对EventBus核心思想的练习。

实现猜想

1.EventBus.getDefault()

EventBus.getDefault()，典型的单例模式，这里我们创建一个EventBus类，写一个单例实现，这里我们使用双重检验方式来实现单例。

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

2.register 注册方法

首先我们调用EventBus.getDefault().register(object)进行注册的时候是以什么为桥梁来进行对事件的订阅的，没错，就是通过我们的注解方法，通过Subscribe注解后，通过反射来查找类中的订阅方法，EventBus还提供了线程模型ThreadMode来指定订阅方法执行的线程。

创建枚举类ThreadMode

这里我们只枚举三种线程模型
POSTING：订阅方法执行在发布的线程中。
MAIN：订阅方法发布在UI线程中。
BACKGROUND：如果发布线程不是UI线程，则订阅方法执行运行在此线程，如果发布线程是UI线程，则订阅方法运行在新的子线程。

public enum ThreadMode {
    /**
     * 回调在发布线程中
     */
    POSTING,

    /**
     * 回调在主线程
     */
    MAIN,

    /**
     * 回调在异步线程
     */
    BACKGROUND

}

创建Subscribe注解

//运行时注解
@Retention(RetentionPolicy.RUNTIME)
//注解用在方法上
@Target({ElementType.METHOD})
public @interface Subscribe {
	//这里我们用到了线程模型，默认的是POSTING
    ThreadMode threadMode() default ThreadMode.POSTING;
}

上面我们创建了Subscribe注解类，用来标记我们的订阅方法，同时Subscribe注解类声明了ThreadMode，用来标识我们的线程模型。
现在我们可以在我订阅类中使用 Subscribe注解了。

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void main(TestEvent event) {
    	//dosomething
    }

做完上面的前序工作之后，我们需要在register方法里，找到被Subscribe注解的方法，保存起来，这样才能在发布相应的事件类型的时候，找到我们订阅了此类型的类和方法。
那怎么找到被Subscribe注解的方法呢? 很多同学应该早有眉目，没错，通过反射来查找注解方法。
这里我们先创建一个SubscribeInfo类

/**
 * 订阅信息体
 */
public class SubscribeInfo {
	//订阅的类
    private Object subscriber;
    //订阅方法
    private Method method;
    //订阅方法的事件类型
    private Class<?> eventType;
    //订阅模型
    private ThreadMode threadMode;
    
	......
   }

然后我们在register的时候通过反射机制，来找到我们订阅类中的订阅方法，然后将这些信息包装成SubscribeInfo ，缓存起来。

  /**
     * 获取注册类中的订阅方法
     *
     * @param subscriber
     * @return
     */
    private List<SubscribeInfo> getSubscribeInfo(Object subscriber) {
        List<SubscribeInfo> subscribeInfoList = new ArrayList<>();
        Class<?> subscriberClass = subscriber.getClass();
        //反射得到类中的方法
        Method[] methods = subscriberClass.getDeclaredMethods();
        for (Method method : methods) {
            Subscribe annotation = method.getAnnotation(Subscribe.class);
            //如果是订阅方法
            if (annotation != null) {
                //如果方法不是publish的抛出异常
                if (method.getModifiers() != Modifier.PUBLIC)
                    throw new RuntimeException("subscribe method must be public");
                //获取参数列表
                Class<?>[] parameterTypes = method.getParameterTypes();
                //获取线程模型
                ThreadMode threadMode = annotation.threadMode();
                //我们的event只支持一个参数
                if (parameterTypes.length == 1) {
                	//生成我们的包装类
                    SubscribeInfo subscribeInfo = new SubscribeInfo(subscriber, method, parameterTypes[0], threadMode);
                    subscribeInfoList.add(subscribeInfo);
                } else {
                    throw new RuntimeException(subscriberClass.getName() + " subscribe method supports only one parameter");
                }
            }
        }
        return subscribeInfoList;
    }

通过上面的方法，我们可以找到订阅类中的所有订阅方法，然后将其缓存起来，在发布事件的时候，可以通过订阅的类型eventType来找到需要订阅此类型的SubscribeInfo ，通过反射来执行订阅方法。

3.post方法

  /**
     * 发送事件
     * @param event
     */
    public void post(Object event) {
        Class eventType = event.getClass();
        //这里是我们在register的时候缓存了订阅了此事件类型的所有SubscribeInfo
        List<SubscribeInfo> subscribeInfoList = eventForSubscriber.get(eventType);
        if (subscribeInfoList == null) return;
        for (SubscribeInfo subscribeInfo : subscribeInfoList) {
        	//生成将要执行的信息
            ExecuteInfo executeInfo = new ExecuteInfo(subscribeInfo, event);
            //根据线程模型来进行相应操作
            switch (subscribeInfo.getThreadMode()) {
                case MAIN:
                	//如果是UI线程，则直接执行，否则则通过handler来切换到UI线程执行
                    if (isMain()) {
                        invoke(executeInfo);
                    } else {
                        handler.post(executeInfo);
                    }
                    break;
                case POSTING:
                	//直接执行
                    invoke(executeInfo);
                    break;
                case BACKGROUND:
                	//如果是UI线程，我们在一个新线程里执行
                    if (isMain()) {
                        backgroundPoster.post(executeInfo);
                    } else {
                    	//如果是子线程直接执行
                        invoke(executeInfo);
                    }
                    break;
            }
        }
    }
    
  void invoke(ExecuteInfo executeInfo) {
        SubscribeInfo subscribeInfo = executeInfo.getSubscribeInfo();
        Object event = executeInfo.getEvent();
        try {
            //执行method
            subscribeInfo.getMethod().invoke(subscribeInfo.getSubscriber(), event);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

post方法也比较简单，通过event的类型找到订阅了该类型的所有订阅者，然后通过线程模型来执行不同的操作。
其中我们的handler使用了Looper.getMainLooper(),所以执行在UI线程。
backgroundPoster是一个发射管理类，里面包含一个线程池，用来执行线程操作。

class ExecuteHandler extends Handler {
    private EventBus eventBus;

    public ExecuteHandler(Looper looper, EventBus eventBus) {
        super(looper);
        this.eventBus = eventBus;
    }

    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        //获取要执行的信息
        ExecuteInfo executeInfo = (ExecuteInfo) msg.obj;
        eventBus.invoke(executeInfo);
    }


    public void post(ExecuteInfo executeInfo){
        Message message = Message.obtain();
        message.obj = executeInfo;
        sendMessage(message);
    }
}

/**
 * 子线程发送器，通过线程池发送事件
 */
public class BackgroundPoster {
    private EventBus eventBus;
    private ExecutorService executor =  Executors.newCachedThreadPool();

    public BackgroundPoster(EventBus eventBus){
        this.eventBus = eventBus;
    }

    public void post(ExecuteInfo executeInfo) {
        executor.execute(new Poster(executeInfo, eventBus));
    }

    private class Poster implements Runnable {
        private ExecuteInfo executeInfo;
        private EventBus eventBus;

        public Poster(ExecuteInfo executeInfo, EventBus eventBus) {
            this.executeInfo = executeInfo;
            this.eventBus = eventBus;
        }

        @Override
        public void run() {
        	//执行eventBus中的invoke
            eventBus.invoke(executeInfo);
        }
    }
}

4.unregister方法

 /**
     * 取消订阅
     *
     * @param subscriber
     */
    public void unregister(Object subscriber) {
        synchronized (this) {
            List<Class<?>> eventTypes = subscribeType.get(subscriber);
            if (eventTypes != null) {
                for (Class<?> eventType : eventTypes) {
                    unsubscribe(subscriber, eventType);
                }
            }
            subscribeType.remove(subscriber);
        }
    }

    /**
     * 取消该类中对该事件的订阅
     */
    private void unsubscribe(Object subscriber, Class eventType) {
        List<SubscribeInfo> subscribeInfoList = eventForSubscriber.get(eventType);
        Iterator iterator = subscribeInfoList.iterator();
        while (iterator.hasNext()) {
            SubscribeInfo subscribeInfo = (SubscribeInfo) iterator.next();
            if (subscribeInfo.getSubscriber() == subscriber) {
                iterator.remove();
            }
        }
    }

取消订阅的逻辑也比较简单，找出订阅了此事件类型的SubscribeInfo，逐一删除，然后将订阅类从我们的缓存中删除。

5.总结

到此我们的EventBus就搭建好了，重复造轮子只是供我们一个复习的机会，知道原理才能百战不殆。
完整的项目地址EventBusDemo