EventBus从入门到装逼,源码分析,手撸框架

Posted Ruffian-痞子

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了EventBus从入门到装逼,源码分析,手撸框架相关的知识,希望对你有一定的参考价值。

文章目录

  1. EventBus是什么?有什么用
  2. EventBus简单使用
  3. EventBus原理解析
  4. 手撸EventBus框架
  5. 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个基础属性:

  1. threadMode() = 函数运行的线程
public enum ThreadMode 
	/**
     * 与发送事件同一个线程
     * 注意:如果post在主线程,避免耗时操作
     */	
    POSTING,

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

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

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

  1. sticky() = 是否粘性事件(EventBus默认事件是非粘性的,可以通过这个属性指定,一般来说 EventBus 需要先注册然后才能接收事件,但是粘性事件特殊,可以先发送事件后注册,常用于 XActivity 跳转 YActivity 并且传递数据的场景 )
  2. 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)
    Java框架型项目从入门到装逼第一节 - Spring框架 IOC的丧心病狂解说

EventBus3.0源码解读

EventBus3.0源码分析

EventBus3.0源码分析

EventBus3.0源码分析

guava中EventBus(事件总线)源码分析与使用