文章目录

EventBus是什么？有什么用
EventBus简单使用
EventBus原理解析
手撸EventBus框架
EventBus 优化

1.EventBus是什么？有什么用

EventBus 是在 android 平台上基于订阅/发布模式（观察者模式）的事件处理机制，方便用于 android 组件内和组件之间的事件传递

简单的说法就是：一个事件或者通知在android的activity之间的传递方式（虽然片面，但是适合理解）

这就是EventBus？既然是组件之间的通信方式，android 本身就存在很多实现方式，比如 Intent，Broadcast，Handler ，那我为毛要使用EventBus？因为传统方式存在一些痛点，而EventBus刚好解决了它，因此它被广泛应用

传统方式缺点：

Intent 传递大数据时导致TransactionTooLargeException，Broadcast 接受事件之后无法指定运行线程，以及这些实现方式的繁琐，耦合

EventBus优点：

使用简单，可以指定接收事件的函数运行的线程，解耦，传递大量数据的Event时不会崩溃

这么神奇？赶紧看看 EventBus 的使用方式

2.EventBus简单使用

EventBus 使用方式很简单，在哪个对象中准备接受事件，就在那里注册一下，然后写几个接收事件的方法，在页面销毁的时候解绑注册。准备工作做好之后，想在那里发送事件，直接post就行了。简单的一B

EventBus 是允许在任何对象中注册使用，也可以发送任何的事件。假设现在在Activity中点击按钮的时候发送一个事件，在当前的activity中接收事件，并且更新UI

备注：EventBus 事件传递允许在组件内和组件之间，本例子演示在组件内

2.1 准备接收事件的地方，注册一下

现在准备在Activity中接收事件，我们就在Activity的onCreate中注册EventBus

public class XActivity extends Activity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //注册
        EventBus.getDefault().register(this);
    }
}

注册方式很简单，通过 getDefault() 获取 EventBus 的单例，然后调用 register(Object obj) 完成注册

2.2 写一个接收事件的方法

在Activity中接收事件，编写一个接收事件的方法，指定运行线程为主线程

public class XActivity extends Activity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //注册
        EventBus.getDefault().register(this);
    }
	

    /**
     * 接收事件，通过注解的方式实现，指定运行线程为主线程
     *
     * @param event 事件对象
     */
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void updateUI(String event) {
        //更新UI
        button.setText(event);
    }
}

接收事件的函数使用了注解，接收一个参数Object类型的对象。看看 @Subscribe 注解支持那些属性

@Documented
@Retention(RetentionPolicy.RUNTIME)//运行时注解
@Target({ElementType.METHOD})//作用于方法
public @interface Subscribe {
	//运行线程
    ThreadMode threadMode() default ThreadMode.POSTING;

	//是否粘性事件	
    boolean sticky() default false;

	//优先级
    int priority() default 0;
}

通过代码可以了解到，@Subscribe 是作用于方法的的运行时注解，存在3个基础属性：

threadMode() = 函数运行的线程

public enum ThreadMode {
	/**
     * 与发送事件同一个线程
     * 注意：如果post在主线程，避免耗时操作
     */	
    POSTING,

	/**
     * 主线程
     * 如果post在主线程，直接在主线程中运行，会阻塞发布线程
     * 如果post在子线程，则事件排队等待传递，使用handler回调到主线程中 
     */	
    MAIN,
   
	/**
     * 主线程-排队
     * 不同于MAIN，此模式事件总是排队等待传递，不会阻塞发布线程
     */	
    MAIN_ORDERED,

	/**
     * 后台线程
     * 如果post在子线程，则在post所在的线程执行
     * 如果post是主线程，则使用单个后台线程按顺序执行
     */	
    BACKGROUND,

	/**
     * 异步线程
     * 总是使用异步线程执行，通过线程池管理异步线程，不会阻塞发布线程和主线程
     */
    ASYNC
}

sticky() = 是否粘性事件（EventBus默认事件是非粘性的，可以通过这个属性指定，一般来说 EventBus 需要先注册然后才能接收事件，但是粘性事件特殊，可以先发送事件后注册，常用于 XActivity 跳转 YActivity 并且传递数据的场景）
priority() = 事件优先级

2.3 发送事件

前面两个步骤已经完成了准备工作，现在可以在业务需要的地方发送事件，这里模拟点击按钮时发送事件

public class XActivity extends Activity {

    private Button button;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //注册
        EventBus.getDefault().register(this);
        setContentView(R.layout.activity_x);
        button = (Button) findViewById(R.id.btn_post);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //发送事件-->普通
                EventBus.getDefault().post("normal-event");
                //发送事件-->粘性
                //EventBus.getDefault().postSticky("sticky-event");
            }
        });
    }

    /**
     * 接收事件，通过注解的方式实现，指定运行线程为主线程
     *
     * @param event 事件对象
     */
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void updateUI(String event) {
        //更新UI
        button.setText(event);
    }

}

我们看到发送事件也是非常简单，一样获取 EventBus 实例，调用 post(Object event) 发送 Object 类型事件。如果需要发送粘性事件则调用 postSticky(Object event)

2.4 解绑注册

在页面销毁，或者使用完成之后记得解绑注册，释放资源

public class XActivity extends Activity {

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //解绑注册，释放资源
        EventBus.getDefault().unregister(this);
    }
}

Just so so 使用就这么简单。但是作为一名高级程序员我们怎么能仅仅满足于知道如何使用？我们想知道它的原理，想知道为什么EventBus传递大数据时不会崩溃，为什么可以如此方便的指定线程。

3.EventBus原理解析

到这里突然想帮大厂洗白一下，人都说大厂面试造航母，入职拧螺丝，在面试的时候总是喜欢问底层原理，框架结构等等。其实还是很有必要的，这都是在考察一个候选人的基础知识，就好比这即将要分析的EventBus原理，看官此刻能想到什么？你觉得它会是怎么实现的？

有些同学可能一脸懵逼，感觉很吊的一个框架，应该很难，什么头绪都没有；

有些同学可能就想到了一些基础，根据介绍中说EventBus基于观察者模式实现，又通过注解的方式实现接收事件的方法。

那么我们猜测：首先肯定跟注解相关，这个注解的知识你得了解吧！进而到注解的使用，注解怎么用？一般就是搭配反射呀，这反射你得会吧！进阶的还有apt，这apt你会吗？看看这就是为什么大厂要问你框架原理了，都是考察你的基础知识呀，这都不懂你怎么看框架源码？你怎么去BAT拿高薪？

OK，废话少说，现在我们一起看看 EventBus 的源码，了解一下这个框架的实现原理

首先我们通过使用步骤一步步看源码分析一下：

3.1 EventBus.getDefault().register(Object subscriber);

   /**
     * 注册对象
     */			
  public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();//获取当前对象的class
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//获取当前类中使用@Subscribe注解的方法列表  ->> 分析点1
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);//遍历注解方法，订阅到当前对象  ->> 分析点2
            }
        }
    }

分析点1：通过反射获取 @Subscribe 注解的方法列表

 private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();//当前对象（如：XActivity）中使用@Subscribe注解的方法列表 缓存Map，key=当前对象，value=注解方法列表
 List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
		//查看缓存中是否存在当前对象的注解方法列表，如果存在直接返回
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        if (ignoreGeneratedIndex) {
            subscriberMethods = findUsingReflection(subscriberClass);//忽略无关紧要信息最终调用findUsingReflectionInSingleClass()
        } else {
            subscriberMethods = findUsingInfo(subscriberClass);//忽略无关紧要信息最终调用findUsingReflectionInSingleClass()
        }
        if (subscriberMethods.isEmpty()) {//如果没有找到注解方法，抛异常，这就是为什么在没有使用@Subscribe方法的类中尝试register会报错的原因
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            METHOD_CACHE.put(subscriberClass, subscriberMethods);//缓存Map，key=当前对象，value=注解方法列表
            return subscriberMethods;
        }
    }

	//忽略无关紧要信息最终调用findUsingReflectionInSingleClass()
    private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
		//忽略代码
        findUsingReflectionInSingleClass(findState);
    }

	//忽略无关紧要信息最终调用findUsingReflectionInSingleClass()
 	private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
		//忽略代码
        findUsingReflectionInSingleClass(findState);
    }

最终获取 @Subscribe 注解的方法列表

  //在单个类中使用反射查找	
  private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            methods = findState.clazz.getDeclaredMethods();//反射获取所有方法（public,private,protected,默认类型 ）
        } catch (Throwable th) {
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
		//遍历这个类中的所有方法，接下来无非就获取我们想要的方法（通过@Subscribe注解的方法），解析这个方法相关的信息（方法名称，方法修饰符，参数，以及注解相关的信息）
        for (Method method : methods) {
            int modifiers = method.getModifiers();//方法修饰符
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {//方法修饰类型必须是public=共有的 && 同时（不能抽象的，不能静态的，不能桥接的，不能合成的） （ MODIFIERS_IGNORE == Modifier.ABSTRACT | Modifier.STATIC | BRIDGE | SYNTHETIC）
                Class<?>[] parameterTypes = method.getParameterTypes();//方法参数类型数组（形参类型）
                if (parameterTypes.length == 1) {//只有一个形参的方法
					//获取注解@Subscribe相关信息
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {//注解不为空，说明此方法是@Subscribe注解的方法，也就是我们寻找的目标方法
                        Class<?> eventType = parameterTypes[0];//获取第一个形参的类型（如：Event.class,String.class）
                        if (findState.checkAdd(method, eventType)) {//校验是否参数是否满足条件，这个我们可以忽略吧
                            ThreadMode threadMode = subscribeAnnotation.threadMode();//获取注解上的信息线程模式（@Subscribe(threadMode = ThreadMode.MAIN)）
							//获取其他注解信息（priority=优先级，sticky=是否粘性事件）然后构建SubscriberMethod对象保存到列表
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {//如果开启了严格验证，但是@Subscribe的方法参数超过1个，则抛异常（就是说如果开启了严格验证，@Subscribe注解的方法参数超过1个就会抛异常）
                    String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                    throw new EventBusException("@Subscribe method " + methodName +
                            "must have exactly 1 parameter but has " + parameterTypes.length);
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {//如果开启了严格校验，但是@Subscribe使用非public，或者static，或者abstract等修饰符，会报错
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException(methodName +
                        " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
            }
        }
    }

我们可以看到这一步就是通过反射和注解相关的知识，获取注册对象中使用 @Subscribe 注解的方法，然后将注解信息(运行线程，是否粘性，事件优先级)，方法(Method)，事件类型封装成 SubscriberMethod 保存到 List<SubscriberMethod> subscriberMethods 列表中，到这一步我们得到什么呢？

public class XActivity extends Activity {

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void updateUI(String event) {
    }

    @Subscribe(threadMode = ThreadMode.ASYNC)
    public void updateUI2(int event) {
    }

    @Subscribe(threadMode = ThreadMode.POSTING)
    public void updateUI3(Object event) {
    }
}

简单说，就是将注册对象（XActivity）中所有 @Subscribe 注解的方法信息都获取到了，并且封装在了一个list列表中，接下来就遍历这些方法信息，绑定到注册对象XActivity

分析点2

	for (SubscriberMethod subscriberMethod : subscriberMethods) {
		subscribe(subscriber, subscriberMethod);//遍历注解方法，订阅到当前对象 
	}

   //绑定 SubscriberMethod 到 当前对象 
   private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {

		/**
	     * 1.根据注解方法中的参数类型（event）作为key，保存所有参数是 event 的注解方法 的封装对象（包含注解方法所在的类）
	     * 例如：Activity1中存在注解方法 method1(String msg),method2(String msg) 那么Activity1和method1会打包成一个对象保存，Activity1和method2又会打包一个对象保存
	     * 
	     * map.put("String.class", List(Subscription（Activity1&m1）,Subscription（Activity1&m2）,Subscription（Activity2&m1）) );
	     * map.put("Int.class", List(Subscription（Activity1&m1）,Subscription（Activity1&m2）,Subscription（Activity2&m1）) );
	     * 备注：这里的注册对象其实是注解方法和
	     */	
		/**
	     * 重点对象
	     * 缓存集合 key = 事件对象类型（event.class），value = 所有参数是 event 的注解方法 的封装对象（包含注解方法所在的类）
	     * 可以理解为对于 String.class 类型的事件，有多个 Activity1，Activity2... 中存在接收的方法 （可以结合广播理解，一个 action，可以有多个广播接收器能够接收）
	     */	
		private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;

        Class<?> eventType = subscriberMethod.eventType;//获取事件对象类型，也就是注解方法的参数类型
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);//构建新的注册对象（理解为封装后的activity&Method对象）
        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);//根据事件对象类型为Key，获取缓存中的注册对象列表
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);//如果为空，添加到map
        } else {
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }

        int size = subscriptions.size();
        for (int i = 0; i <= size; i++) {
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
                subscriptions.add(i, newSubscription);//根据事件优先级，将当前注册对象插入到合适位置
                break;
            }
        }

		/**
		 *   步骤1总结
	     * 
	     *   @Subscribe(threadMode = ThreadMode.MAIN)
		 *   public void updateUI(String event) {
		 *   }
		 *   
		 *   到这一步为止，会根据 String.class 作为key 保存所有方法参数为String的封装对象（理解为 List(Subscription（Activity1&m1）,Subscription（Activity1&m2）,Subscription（Activity2&m1）)）
		 *   有什么作用呢？等下 post(String event) 的时候就可以根据这个 String.class 作为key找到 所有的已经注册的对象，然后挨个调用这些对象中的  @Subscribe 方法
	     */	


		/**
	     * 2.根据当前注册对象（Activity）作为key，保存所有事件类型。形成一个map
	     * map.put("Activity1",List(String.class,Int.class..));
	     * map.put("Activity2",List(String.class,Int.class..));
	     */	
		/**
	     * 重点对象
	     * 缓存集合 key = 当前注册对象，value = 事件对象类型列表 
	     * 可以理解为在 Activity1 中存在多个注解方法，他们的事件类型为 String.class ，Int.class   
	     */	
 		private final Map<Object, List<Class<?>>> typesBySubscriber;

        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);//添加事件类型


		/**
		 *   步骤2总结
	     * 
		 *   到这一步为止，会根据当前注册对象 Activity 作为key 保存本类中所有注解方法的事件类型（也是方法参数类型）
		 *   
		 *   有什么作用呢？
		 *   1.用于查询是否已经注册了当前对象 isRegistered(Object subscriber){ return typesBySubscriber.containsKey(subscriber); } 
		 *   2.解绑注册 unregister(Object subscriber) 的时候可以找到所有的事件类型，（结合 subscriptionsByEventType ）然后再根据事件找到 已经注册对象的列表，移除当前注册的对象
	     */	



		/**
	     * 3.判断当前注册对象中的注解方法是否为粘性事件，如果粘性事件，从粘性事件缓存中取出粘性事件相关的信息
	     */	
		/**
	     * 重点对象
	     * 缓存集合 key = 事件对象类型，value = Object（事件） 
	     * 粘性事件单独存在一个Map集合中，这也是为什么可以先发送粘性事件，然后在注册接收，因为它存放在缓存map中，只要不清除，它就一直在
	     * map.put("String.class", Object 粘性事件1 );
	     * map.put("String.class", Object 粘性事件2 );
	     * map.put("Int.class",    Object 粘性事件1 );
	     * map.put("Int.class",    Object 粘性事件2 );
	     */	
 		private final Map<Class<?>, Object> stickyEvents;

        if (subscriberMethod.sticky) {
            if (eventInheritance) {
                Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry<Class<?>, Object> entry : entries) {
                    Class<?> candidateEventType = entry.getKey();
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        Object stickyEvent = entry.getValue();
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);//根据事件类型在粘性map中查找粘性事件
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);//调用post事件，调用对应的注解方法，使得注解方法能够接收之前发送的粘性事件
            }
        }
    }

通过分析点2，我们可以知道，注册过程中，就是将获取到的注解方法列表挨个遍历，然后构造了2个重要的map，将数据保存在map中，需要使用的时候再去取出来。

分析点1和分析点2 构成了 register(Object subscriber) 方法，此方法主要内容 1.获取注册对象中通过 @Subscribe 注解的方法，保存在list列表 2.遍历注解方法列表，逐个绑定到当前对象 2.1 根据注解方法事件对象类型，构建map

class Activity1{
	@Subscribe(threadMode = ThreadMode.MAIN)
    public void updateUI(String event) {
    }

    @Subscribe(threadMode = ThreadMode.ASYNC)
    public void updateUI2(int event) {
    }
}

class Activity2{
	@Subscribe(threadMode = ThreadMode.MAIN)
    public void updateUI(String event) {
    }

    @Subscribe(threadMode = ThreadMode.ASYNC)
    public void updateUI2(int event) {
    }
}

map.put("Stirng.class", List(Subscription(Activity1&updateUI),Subscription(Activity2&updateUI)));
map.put("Int.class",	List(Subscription(Activity1&updateUI2),Subscription(Activity2&updateUI2)));

如上述伪代码，Activity1 和 Activity2 中都使用 @Subscribe 注解接收事件的方法，事件的类型为String，int 那么根据事件对象类型作为 key 保存 map 可以得到：map.put("Stirng.class", List(Subscription(Activity1&updateUI),Subscription(Activity2&updateUI))); 表示多个Activity绑定了事件对象类型为 String 的事件。构建这个map有何作用？因为后续 post（事件）时要根据事件类型发送给所有已经注册该事件类型的对象（Activity）中的注解方法 (updateUI(String event))

2.2 根据注册对象（Activity）保存当前对象中存在的事件类型，构建map

class Activity1{
	@Subscribe(threadMode = ThreadMode.MAIN)
    public void updateUI(String event) {
    }

    @Subscribe(threadMode = ThreadMode.ASYNC)
    public void updateUI2(int event) {
    }
}

map.put("Activity1", List(String.class,Int.class..));

如上述伪代码，在注册对象（这里假设是Activity）中将所有接收事件的事件类型保存起来，可以得到：map.put("Activity1", List(String.class,Int.class..)); 表示 Acticity1 对象中存在多种类型的事件。有何作用？1.用于查询是否已经注册了当前对象 2.为解绑注册，释放资源做支撑（解绑注册后面详细分析）

2.3 如果当前注解方法接收的事件是粘性事件，则根据当前方法的参数类型（也就是事件类型）从粘性事件map缓存中（postSticky时保存）获取粘性事件信息，如果存在则执行当前注解方法（实现延迟响应事件的原理）

可以看到 register() 算是一个重头戏，主要是保存一些数据，为后续post发送事件做一些铺垫作用。那接下来就看看 post 方法的源码

3.2 EventBus.getDefault().post(Object event);

发送事件，可以是任意类型的事件

	//发送事件
    public void post(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get();//根据不同Thread区分保存对象
        List<Object> eventQueue = postingState.eventQueue;//事件列表
        eventQueue.add(event);

        if (!postingState.isPosting) {
            postingState.isMainThread = isMainThread();
            postingState.isPosting = true;
            if (postingState.canceled) {
                throw new EventBusException("Internal error. Abort state was not reset");
            }
            try {
                while (!eventQueue.isEmpty()) {
                    postSingleEvent(eventQueue.remove(0), postingState);//循环，发送单一事件
                }
            } finally {
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }

	//发送单一事件
    private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class<?> eventClass = event.getClass();//事件对象class
        boolean subscriptionFound = false;//是否找到订阅对象
        if (eventInheritance) {
            List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
            int countTypes = eventTypes.size();
            for (int h = 0; h < countTypes; h++) {
                Class<?> clazz = eventTypes.get(h);
                subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);//发送事件
            }
        } else {
            subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);//发送事件
        }
        if (!subscriptionFound) {//未找到订阅对象
            if (logNoSubscriberMessages) {
                logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
            }
            if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                    eventClass != SubscriberExceptionEvent.class) {
                post(new NoSubscriberEvent(this, event));//未找到订阅对象，发送NoSubscriberEvent
            }
        }
    }

   //根据事件类型发送找到注册对象，然后逐个发送事件
   private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
        CopyOnWriteArrayList<Subscription> subscriptions;
        synchronized (this) {
            subscriptions = subscriptionsByEventType.get(eventClass);//获取注册时添加的注册对象，也就是寻找绑定eventClass的activity集合，可以看到这里依赖于注册方法准备的数据
        }
        if (subscriptions != null && !subscriptions.isEmpty()) {//循环所有注册对象（例如：activity1,activity2..）
            for (Subscription subscription : subscriptions) {
                postingState.event = event;
                postingState.subscription = subscription;
                boolean aborted = false;
                try {
                    postToSubscription(subscription, event, postingState.isMainThread);//发送事件到已注册的对象（某个activity）
                    aborted = postingState.canceled;
                } finally {
                    postingState.event = null;
                    postingState.subscription = null;
                    postingState.canceled = false;
                }
                if (aborted) {
                    break;
                }
            }
            return true;
        }
        return false;
    }

	//发送事件线程处理，队列处理		
   private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {
            case POSTING://与发送事件同一个线程,如果post在主线程，避免耗时操作
                invokeSubscriber(subscription, event);//直接反射调用方法
                break;
            case MAIN://主线程
                if (isMainThread) {//如果post在主线程，直接在主线程中运行，会阻塞发布线程
                    invokeSubscriber(subscription, event);
                } else {//如果post在子线程，则事件排队等待传递，使用handler回调到主线程中 
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;
            case MAIN_ORDERED://主线程-排队
				/**
			     * 这里就有点尴尬了，前面根据 ThreadMode 类的解释是：不同于MAIN，此模式事件总是排队等待传递，不会阻塞发布线程
			     * 但这里的实现并不是一定方式队列中。不过源码中官方自己备注了技术上实现不正确，未按照 ThreadMode 定义的思想来实现，所以我们就不管它了
			     */	
                if (mainThreadPoster != null) {
                    mainThreadPoster.enqueue(subscription, event);//事件排队等待传递，不会阻塞发布线程
                } else {
 					// temporary: technically not correct as poster not decoupled from subscriber
					// 临时：技术上不正确，未与post线程分离
                    invokeSubscriber(subscription, event);
                }
                break;
            case BACKGROUND://后台线程
                if (isMainThread) {//如果post是主线程，则使用单个后台线程按顺序执行
                    backgroundPoster.enqueue(subscription, event);
                } else {//如果post在子线程，则在post所在的线程执行
                    invokeSubscriber(subscription, event);
                }
                break;
            case ASYNC://异步线程,总是使用异步线程执行，通过线程池管理异步线程，不会阻塞发布线程和主线程
                asyncPoster.enqueue(subscription, event);
                break;
            default:
                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
        }
    }

	//最终执行方法，通过反射调用 method.invoke(方法所在对象,方法参数)
   void invokeSubscriber(Subscription subscription, Object event) {
        try {
            subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
        } catch (InvocationTargetException e) {
            handleSubscriberException(subscription, event, e.getCause());
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("Unexpected exception", e);
        }
    }

post 方法代码很简单，跟着注释走主要路线就行，首先通过事件类型，找到已经注册的列表，（注册列表在每次注册的时候添加），找到注册列表之后挨个发送当前事件，怎么发送当前事件？找到注册对象的目标method，根据method指定的运行线程，按需要做一些线程切换的操作，然后通过反射调用 method.invoke(方法所在对象,方法参数)，就这么简单。

再看看发送粘性事件是怎么处理的

  //发送粘性事件
  public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);//将粘性事件保存到缓存map中
        }
        // 调用post方法
        post(event);
    }

so easy. 粘性事件和普通事件相比，就多了一步将粘性事件保存到缓存 map 中，原来粘性事件的原理这么简单，发送的时候保存到缓存map中，延时（需要时）再取，实现了可以先发送事件，后注册的效果。

3.3 EventBus.getDefault().unregister(Object subscriber);

    //解绑注册，释放资源等
    public synchronized void unregister(Object subscriber) {
        List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);//根据当前对象找到事件类型列表
        if (subscribedTypes != null) {
            for (Class<?> eventType : subscribedTypes) {
                unsubscribeByEventType(subscriber, eventType);//遍历各个事件类型解绑已经注册的对象
            }
            typesBySubscriber.remove(subscriber);
        } else {
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

	//根据事件类型解绑已注册对象
 	private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
        List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);//根据事件类型获取已注册的对象列表
        if (subscriptions != null) {
            int size = subscriptions.size();
            for (int i = 0; i < size; i++) {//遍历已注册列表
                Subscription subscription = subscriptions.get(i);
                if (subscription.subscriber == subscriber) {//已注册列表等于当前对象时
                    subscription.active = false;
                    subscriptions.remove(i);//移除列表中的当前对象
                    i--;
                    size--;
                }
            }
        }
    }

解绑注册也是比较简单的，首先通过当前对象找到本类中所有的事件类型，再根据某个事件类型找到已经注册该事件的对象列表（如：activity1，activity2..），然后根据比较当前对象是否存在列表中，如果存在，从列表中移除，释放资源

以上便是EventBus的源码解析，结合注释，相信能够看懂它的原理思想，由于分析的时候需要抓住主线不向外扩散，忽略了一些代码，看客最好根据文章打开源码对照着看看，加深印象。文章基于 EventBus 3.1.1

看完源码来讨论几个问题： 1.为什么EventBus传递大数据时不会崩溃？分析： Intent 方式实际上底层parcel对象在不同activity直接传递过程中保存在一个叫做“ Binder transaction buffe ”的缓冲区，并且这个缓冲区大小有限制，不能超过1M。 EventBus 不存在将数据放在什么缓冲区中，普通事件直接拿到事件对象，找到需要调用的方法直接调用即可，简单的方法参数传递；而粘性事件，将数据缓存在内存中，保存在map，除非是内存爆炸，不然是没有大小限制的说法。因此说EventBus可以传递大数据

2.EventBus如何指定接收事件方法运行的线程？分析： EventBus 通过注解的方式指定接收事件的运行线程，在注册的时候将注解信息保存起来，当post事件的时候拿到注册时保存的注解信息（运行线程），通过不同的 ThreadMode 做不同的处理，如开启工作线程执行接收事件的方法，或者通过handler方式将事件运行在主线程中，以此达到指定线程运行方法的目的

嗯，感觉良好，熟练使用了，源码分析也会了，常见面试问题也知道怎么回答了，如果这时候面试官突然问你：能自己手写一个EventBus框架吗？

What the X ? 好不容易分析完了源码，你还想给你手撸一个框架出来？没错，就是手撸一个EventBus框架！不要虚，源码分析出来了，思路已经知道了，手撸框架也不过如此，来，跟着痞子哥干它！

4.手撸EventBus框架

当然，EventBus框架还是相对比较完善的，这里说的手撸框架，是实现简易版本的，实现主要的功能，通过自己动手实现，深入理解框架思想，加深理解。

我们暂且按照EventBus提供的各个几个接口来实现主要核心逻辑首先就是 REventBus

/**
 * 简易版本EventBus
 */
public class REventBus {

    static volatile REventBus mInstance;
   
    private REventBus() {
    }

    /**
     * 单例实现，双重校验
     *
     * @return
     */
    public static REventBus getDefault() {
        if (mInstance == null) {
            synchronized (REventBus.class) {
                if (mInstance == null) {
                    mInstance = new REventBus();
                }
            }
        }
        return mInstance;
    }

    /**
     * 注册对象
     *
     * @param subscriber 订阅对象
     */
    public void register(Object subscriber) {
    }
  
    /**
     * 解绑注册，释放资源
     *
     * @param subscriber 订阅对象
     */
    public void unregister(Object subscriber) {
    }

    /**
     * 发送事件
     *
     * @param event 事件
     */
    public void post(Object event) {
    }

    /**
     * 发送粘性事件
     *
     * @param event 事件
     */
    public void postSticky(Object event) {
    }

    /**
     * 某对象是否已经订阅
     *
     * @param subscriber 订阅对象
     * @return
     */
    public boolean isRegistered(Object subscriber) {
        return false;
    }
  
}

自定义注解 (这里暂时欠一篇关于注解的文章，后续写完补充)

@Retention(RetentionPolicy.RUNTIME)//运行注解
@Target({ElementType.METHOD})//作用于方法
public @interface Subscribe {
    /**
     * 事件运行线程
     */
    ThreadMode threadMode() default ThreadMode.POSTING;

    /**
     * 是否粘性事件
     */
    boolean sticky() default false;
}

ThreadMode

public enum ThreadMode {
    /**
     * 调用线程
     */
    POSTING,

    /**
     * 主线程
     */
    MAIN
}

以上就是EventBus基础的类，在REventBus中已经定好了基础的API，那么现在我们来一步步完善它

4.1 手撸EventBus框架-->register(Object subscriber)

回忆 EventBus ->> register() 原理

获取订阅对象中订阅方法（注解方法）的信息，并且封装成对象 SubscriberMethod

  //订阅方法封装的对象
  class SubscriberMethod {
        Object subscriber;//订阅者
        Method method;//订阅方法
        ThreadMode threadMode;//订阅方法运行线程
        Class<?> eventType;//事件类型class
        boolean sticky;//是否粘性

        public SubscriberMethod(Object subscriber, Method method, Class<?> eventType, ThreadMode threadMode, boolean sticky) {
            this.subscriber = subscriber;
            this.method = method;
            this.eventType = eventType;
            this.threadMode = threadMode;
            this.sticky = sticky;
        }
    }

获取订阅对象中的注解方法（订阅方法），返回的是一个列表（可能一个类中有多个注解方法嘛）

   /**
     * 获取当前对象中注解方法信息(列表)
     *
     * @param subscriber
     * @return
     */
    private List<SubscriberMethod> getSubscriberMethod(Object subscriber) {
        List<SubscriberMethod> list = new ArrayList<>();
        Class<?> subscriberClass = subscriber.getClass();//注册对象的class
        Method[] methods = subscriberClass.getDeclaredMethods();//获取所有修饰类型的方法
        for (Method method : methods) {
            Subscribe subscribe = method.getAnnotation(Subscribe.class);//获取方法注解信息
            if (subscribe == null) {//如果为空，表示此方法不是注解方法
                continue;
            }

            Class<?>[] types = method.getParameterTypes();//获取方法参数列表class，注意是class，比如int->Int.class
            if (types.length != 1) {//这里只接受一个参数的方法（参照EventBus）
                throw new RuntimeException("REventBus 只接受一个参数!");
            }

            ThreadMode threadMode = subscribe.threadMode();//获取注解信息 -> ThreadMode (第一次接触注解的同学是不是恍然大悟，真TM简单)
            boolean sticky = subscribe.sticky();//获取注解信息 -> sticky

            //构建 SubscriberMethod 封装注解信息，方法参数，方法对象
            SubscriberMethod subscriberMethod = new SubscriberMethod(subscriber, method, types[0], threadMode, sticky);
            list.add(subscriberMethod);//添加到列表
        }
        return list;
    }

将订阅方法绑定到订阅对象。当订阅方式是粘性时特殊处理，从粘性事件集合中得到事件，执行对应方法

    //某事件对象的 订阅者列表 集合
    private Map<Class<?>, List<SubscriberMethod>> subscriberMethodMap;
    //某订阅者的 事件列表 集合
    private Map<Object, List<Class<?>>> subscriberEventMap;
    //粘性事件集合 key = 事件.class
    private Map<Class<?>, Object> stickyEventMap;

    /**
     * 将 订阅方法 与 订阅对象 绑定
     *
     * @param subscriber       订阅对象
     * @param subscriberMethod 订阅方法
     */
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class<?> eventType = subscriberMethod.eventType;
        List<SubscriberMethod> subscriberMethods = subscriberMethodMap.get(eventType);//获取 某事件对象的 订阅者列表 集合
        if (subscriberMethods == null) {
            subscriberMethods = new ArrayList<>();
            subscriberMethodMap.put(eventType, subscriberMethods);
        }
        subscriberMethods.add(subscriberMethod);

        List<Class<?>> subscribedEvents = subscriberEventMap.get(subscriber);//获取 某订阅者的 事件列表 集合
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            subscriberEventMap.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

        if (subscriberMethod.sticky) {//粘性事件方法
            Object eventSticky = stickyEventMap.get(eventType);//粘性事件对象
            if (eventSticky != null) {//存在粘性事件，调用当前方法
                postEvent(subscriberMethod, eventSticky);
            }
        }
    }

综述，register方法为：

	/**
     * 注册对象
     *
     * @param subscriber 订阅对象
     */
    public void register(Object subscriber) {
        List<SubscriberMethod> subscriberMethodList = getSubscriberMethod(subscriber);//获取订阅者中的注解方法
        if (subscriberMethodList == null || subscriberMethodList.isEmpty()) return;//容错
        for (SubscriberMethod subscriberMethod : subscriberMethodList) {
            subscribe(subscriber, subscriberMethod);//绑定订阅对象和订阅方法
        }
    }

4.2 手撸EventBus框架-->post(Object event)

回忆post原理：

获取所有事件为 event 的订阅方法，然后逐个发送事件，发送事件的原理是通过反射实现方法的调用，同时根据指定的线程模式做线程切换

    /**
     * 发送事件
     *
     * @param event 事件
     */
    public void post(Object event) {
        List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(event.getClass());//获取某事件的所有订阅者
        if (subscriberMethodList == null && subscriberMethodList.isEmpty()) return;//容错
        for (SubscriberMethod subscriberMethod : subscriberMethodList) {
            postEvent(subscriberMethod, event);//发送事件
        }
    }

    /**
     * 发送事件
     *
     * @param subscriberMethod 订阅方法封装的对象
     * @param event            事件（方法参数）
     */
    private void postEvent(SubscriberMethod subscriberMethod, Object event) {
        Object subscriber = subscriberMethod.subscriber;//订阅者
        ThreadMode threadMode = subscriberMethod.threadMode;//订阅方法的执行线程
        Method method = subscriberMethod.method;//订阅方法
        switch (threadMode) {
            case POSTING://post线程
                invokeMethod(subscriber, method, event);
                break;
            case MAIN://主线程
                //通过handler实现主线程调用方法
                Object[] objects = new Object[]{subscriber, method, event};
                mainHandler.sendMessage(mainHandler.obtainMessage(1, objects));
                break;
        }
    }

    /**
     * 通过反射执行方法
     *
     * @param subscriber 方法所在对象
     * @param method     方法对象
     * @param event      方法参数
     */
    private void invokeMethod(Object subscriber, Method method, Object event) {
        try {
            method.invoke(subscriber, event);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }


 	/**
     * Handler
     */
    class MainHandler extends Handler {

        public MainHandler() {
            super(Looper.getMainLooper());
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Object[] obj = (Object[]) msg.obj;
            Object subscriber = obj[0];//类对象
            Method method = (Method) obj[1];//方法
            Object event = obj[2];//方法参数
            //反射执行方法
            invokeMethod(subscriber, method, event);
        }
    }

4.3 手撸EventBus框架-->unregister(Object subscriber)

回忆解绑注册原理：

通过当前对象获取该订阅者的事件列表，在订阅者列表中找到当前订阅对象，移除它。然后再清空当前订阅者的事件列表

   /**
     * 解绑注册，释放资源
     *
     * @param subscriber 订阅对象
     */
    public void unregister(Object subscriber) {
        List<Class<?>> eventClass = subscriberEventMap.get(subscriber);//获取 某订阅者的 事件列表 集合
        if (eventClass == null || eventClass.isEmpty()) return;//容错
        for (Class<?> clazz : eventClass) {
            List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(clazz);//获取 某事件对象的 订阅者列表 集合
            for (int i = 0; i < subscriberMethodList.size(); i++) {
                if (subscriberMethodList.get(i).subscriber == subscriber) {//在订阅者列表中找到当前订阅对象
                    subscriberMethodList.remove(i);//移除它
                }
            }
        }
        subscriberEventMap.remove(subscriber);//移除当前订阅者的 事件列表
    }

REventBus一览

/**
 * 简易版本EventBus
 */
public class REventBus {

    static volatile REventBus mInstance;
    //主线程Handler
    private MainHandler mainHandler;
    //某事件对象的 订阅者列表 集合
    private Map<Class<?>, List<SubscriberMethod>> subscriberMethodMap;
    //某订阅者的 事件列表 集合
    private Map<Object, List<Class<?>>> subscriberEventMap;
    //粘性事件集合 key = 事件.class
    private Map<Class<?>, Object> stickyEventMap;

    private REventBus() {
        subscriberMethodMap = new HashMap<>();
        subscriberEventMap = new HashMap<>();
        stickyEventMap = new HashMap<>();
        mainHandler = new MainHandler();
    }

    /**
     * 单例实现，双重校验
     *
     * @return
     */
    public static REventBus getDefault() {
        if (mInstance == null) {
            synchronized (REventBus.class) {
                if (mInstance == null) {
                    mInstance = new REventBus();
                }
            }
        }
        return mInstance;
    }

    /**
     * 注册对象
     *
     * @param subscriber 订阅对象
     */
    public void register(Object subscriber) {
        List<SubscriberMethod> subscriberMethodList = getSubscriberMethod(subscriber);//获取订阅者中的注解方法
        if (subscriberMethodList == null || subscriberMethodList.isEmpty()) return;//容错
        for (SubscriberMethod subscriberMethod : subscriberMethodList) {
            subscribe(subscriber, subscriberMethod);//绑定订阅对象和订阅方法
        }
    }

    /**
     * 获取当前对象中注解方法信息(列表)
     *
     * @param subscriber
     * @return
     */
    private List<SubscriberMethod> getSubscriberMethod(Object subscriber) {
        List<SubscriberMethod> list = new ArrayList<>();
        Class<?> subscriberClass = subscriber.getClass();//注册对象的class
        Method[] methods = subscriberClass.getDeclaredMethods();//获取所有修饰类型的方法
        for (Method method : methods) {
            Subscribe subscribe = method.getAnnotation(Subscribe.class);//获取方法注解信息
            if (subscribe == null) {//如果为空，表示此方法不是注解方法
                continue;
            }

            Class<?>[] types = method.getParameterTypes();//获取方法参数列表class，注意是class，比如int->Int.class
            if (types.length != 1) {//这里只接受一个参数的方法（参照EventBus）
                throw new RuntimeException("REventBus 只接受一个参数!");
            }

            ThreadMode threadMode = subscribe.threadMode();//获取注解信息 -> ThreadMode (第一次接触注解的同学是不是恍然大悟，真TM简单)
            boolean sticky = subscribe.sticky();//获取注解信息 -> sticky

            //构建 SubscriberMethod 封装注解信息，方法参数，方法对象
            SubscriberMethod subscriberMethod = new SubscriberMethod(subscriber, method, types[0], threadMode, sticky);
            list.add(subscriberMethod);//添加到列表
        }
        return list;
    }

    /**
     * 将 订阅方法 与 订阅对象 绑定
     *
     * @param subscriber       订阅对象
     * @param subscriberMethod 订阅方法
     */
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class<?> eventType = subscriberMethod.eventType;
        List<SubscriberMethod> subscriberMethods = subscriberMethodMap.get(eventType);//获取 某事件对象的 订阅者列表 集合
        if (subscriberMethods == null) {
            subscriberMethods = new ArrayList<>();
            subscriberMethodMap.put(eventType, subscriberMethods);
        }
        subscriberMethods.add(subscriberMethod);

        List<Class<?>> subscribedEvents = subscriberEventMap.get(subscriber);//获取 某订阅者的 事件列表 集合
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            subscriberEventMap.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

        if (subscriberMethod.sticky) {//粘性事件方法
            Object eventSticky = stickyEventMap.get(eventType);//粘性事件对象
            if (eventSticky != null) {//存在粘性事件，调用当前方法
                postEvent(subscriberMethod, eventSticky);
            }
        }
    }

    /**
     * 解绑注册，释放资源
     *
     * @param subscriber 订阅对象
     */
    public void unregister(Object subscriber) {
        List<Class<?>> eventClass = subscriberEventMap.get(subscriber);//获取 某订阅者的 事件列表 集合
        if (eventClass == null || eventClass.isEmpty()) return;//容错
        for (Class<?> clazz : eventClass) {
            List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(clazz);//获取 某事件对象的 订阅者列表 集合
            for (int i = 0; i < subscriberMethodList.size(); i++) {
                if (subscriberMethodList.get(i).subscriber == subscriber) {//在订阅者列表中找到当前订阅对象
                    subscriberMethodList.remove(i);//移除它
                }
            }
        }
        subscriberEventMap.remove(subscriber);//移除当前订阅者的 事件列表
    }

    /**
     * 发送事件
     *
     * @param event 事件
     */
    public void post(Object event) {
        List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(event.getClass());//获取某事件的所有订阅者
        if (subscriberMethodList == null && subscriberMethodList.isEmpty()) return;//容错
        for (SubscriberMethod subscriberMethod : subscriberMethodList) {
            postEvent(subscriberMethod, event);//发送事件
        }
    }

    /**
     * 发送粘性事件
     *
     * @param event 事件
     */
    public void postSticky(Object event) {
        //保存粘性事件
        stickyEventMap.put(event.getClass(), event);
        //调用post
        post(event);
    }

    /**
     * 发送事件
     *
     * @param subscriberMethod 订阅方法封装的对象
     * @param event            事件（方法参数）
     */
    private void postEvent(SubscriberMethod subscriberMethod, Object event) {
        Object subscriber = subscriberMethod.subscriber;//订阅者
        ThreadMode threadMode = subscriberMethod.threadMode;//订阅方法的执行线程
        Method method = subscriberMethod.method;//订阅方法
        switch (threadMode) {
            case POSTING://post线程
                invokeMethod(subscriber, method, event);
                break;
            case MAIN://主线程
                //通过handler实现主线程调用方法
                Object[] objects = new Object[]{subscriber, method, event};
                mainHandler.sendMessage(mainHandler.obtainMessage(1, objects));
                break;
        }
    }

    /**
     * 通过反射执行方法
     *
     * @param subscriber 方法所在对象
     * @param method     方法对象
     * @param event      方法参数
     */
    private void invokeMethod(Object subscriber, Method method, Object event) {
        try {
            method.invoke(subscriber, event);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    /**
     * 某对象是否已经订阅
     *
     * @param subscriber 订阅对象
     * @return
     */
    public boolean isRegistered(Object subscriber) {
        return subscriberEventMap.containsKey(subscriber);
    }

    /**
     * 封装订阅方法
     */
    class SubscriberMethod {
        Object subscriber;//订阅者
        Method method;//订阅方法
        ThreadMode threadMode;//订阅方法运行线程
        Class<?> eventType;//事件类型class
        boolean sticky;//是否粘性

        public SubscriberMethod(Object subscriber, Method method, Class<?> eventType, ThreadMode threadMode, boolean sticky) {
            this.subscriber = subscriber;
            this.method = method;
            this.eventType = eventType;
            this.threadMode = threadMode;
            this.sticky = sticky;
        }
    }

    /**
     * Handler
     */
    class MainHandler extends Handler {

        public MainHandler() {
            super(Looper.getMainLooper());
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Object[] obj = (Object[]) msg.obj;
            Object subscriber = obj[0];//类对象
            Method method = (Method) obj[1];//方法
            Object event = obj[2];//方法参数
            //反射执行方法
            invokeMethod(subscriber, method, event);
        }
    }
}

这里明确说明，这个类只是用于分析和加深理解EventBus的框架原理，虽然功能是可以跑通的，但是不要直接应用到项目中，毕竟是简易版本，还有很多地方需要完善和容错

5.EventBus 优化

当我们自信满满的撸完EventBus框架之后，面试官又问了一个问题：EventBus 是否存在性能问题？它使用反射实现，是否还可以再优化一下？

啊~西八！这offer我不要了，这不是逼死人嘛！不要offer了？怎么可能，我不但要了这offer，我还想提个价格

首先，反射调用和直接调用到底性能差多少？很多人一听到反射就说性能不好，一棒子打死了，但是究竟差多少呢？有什么数字指标拿出来说话呢？在这里再欠一篇文章，后续找时间分析一下写篇文章。

反射是肯定存在性能问题，差多少暂时不讨论，如果不要使用反射是不是就可以提升一下呢？如果我们能通过直接调用方法的方式，来避免反射调用方法带来的性能问题，是不是就可以提升性能了呀。

如果我们知道即将调用的方法长什么样，给他提前写好，而不是运行时反射调用，就可以解决这个问题，而提前写好方法的实现方式也是有的，那就是apt！在编译时就创建”方法副本“提供代码调用。

由于篇幅原因，这里又欠了一篇关于apt的使用文章！

一篇文章读下来，就算没有完全掌握，起码知道有几个知识点需要去学习一下：

Java基础-反射
注解
设计模式->单例
apt技术
源码中忽略掉的ThreadLocal

反射相关的用法直接写了一篇博客，剩下的几个内容暂时欠着，后续各自写一篇文章补上！