Android 常用开源框架源码解析 系列 (八)Eventbus 事件发布订阅框架

EventBus
 
一、前言
(一)、作用 
1、Android 事件发布 / 订阅框架
2、事件传递既可以用于Android 四大组件间的通信
3、用户异步线程和主线程间通信的时候进行联系的工具
 
(二)、意义
通过框架解耦事件的 发布者 和订阅者 ,进而简化Android 事件传递
 
(三)、优点
代码简洁,使用简单,并将事件发布和订阅充分解耦
 
(四)、传统的事件传递方法
        a、handler
        b、BroadcastReceiver
        c、接口回调
传统事件传递的缺陷:
    代码量臃肿、繁琐、复杂
 
传统事件传递之handler
 
handler 机制工作原理 
Android 常用开源框架源码解析 系列  (八)Eventbus 事件发布订阅框架
 
ps:Android 中的主线程 :ActivityThread 类——Ui线程
通过这个类创建的Looper 和 Handler 就可以进行消息的传递了
 
思考1:子线程是否可以创建handler对象?
答: 子线程直接创建handler对象会报 缺少Looper对象的错误。进行三个步骤创建handler :
   1、调用Looper的prepare()方法创建当前线程的Looper
    2、之后创建当前线程的Handler()
    3、在创建完Handler()后要通过Looper.loop()开启Looper消息队列的循环
 
解析:在Android异步消息处理机制中,handler就是用来处理消息的,并进行消息的发送,和处理在handleMessage。
发出、经过处理的消息最后都会回到handler这个方法中来执行。
Looper 每个线程中MessageQueue的管家,负责消息队列的运作。Looper内部死循环不断的从MessageQueue中获取消息,
有消息就取出并返回给handleMessage去进行处理。所以也就是说单单仅有一个handler是无法进行消息的处理工作的,因为没有Looper 无法获取MessageQueue 中的消息。
    也就是说需要handler发送消息后通过Looper接收消息,放到MessageQueue中进行轮询操作。最后looper会将Message 返回给handler,调用handleMessage 方法进行异步消息的处理操作。
 
思考2:handler 在Activity中进行消息的传递有几种形式?
 
实例代码一 形式:
/**
* 利用handler,在Ui 主线程中发送消息,在work子线程执行耗时操作
*/
public class HandlerSendMessageActivity extends Activity {
    public Button btn1;
    Handler handler;//主线程handler
    public TextView textview;
 
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState, @Nullable PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);
        setContentView(R.layout.butterknife_layout);
        textview = findViewById(R.id.textview_1);
        btn1 = findViewById(R.id.button_1);
        btn1.setText("Ui->Work");
        btn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //主线程发送消息给子线程去处理需要耗时的操作
                Message msg = handler.obtainMessage();
                msg.arg1 = 1;
                msg.obj = "obj 消息";
                handler.sendMessage(msg);
                System.out.println(Thread.currentThread().getName());
            }
        });
        new MyThread().start();
    }
    class MyThread extends Thread {
        @Override
        public void run() {
            //子线程创建handler之前一定要首先创建looper 通过Looper.prepare();
            Looper.prepare();
            handler = new Handler() {
                @Override
                public void handleMessage(Message msg) {
                    System.out.println(Thread.currentThread().getName());
                    super.handleMessage(msg);
                }
            };
            Looper.loop();
            super.run();
        }
    }
}
实例代码二 形式:
/**
* 利用handler,在子线程发送消息,然后在主线程中获取并执行
*/
public class HandlerGetMessageActivity extends Activity {
    Button btn1;
    //1、主线程定义handler 并重现handleMessage()
   Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            System.out.println(Thread.currentThread().getName());
            System.out.println("消息-->" + msg.arg1 + "-" + msg.obj);
            super.handleMessage(msg);
        }
    };
 
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState, @Nullable PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);
        setContentView(R.layout.butterknife_layout);
        btn1 = findViewById(R.id.button_1);
        btn1.setText("Work-->Ui");
        btn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //2、开启一个子线程在run()方法中发送消息给主线程处理
                Thread thread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Message msg = handler.obtainMessage();
                        msg.arg1 = 1;
                        msg.obj = "obj 消息";
                        handler.sendMessage(msg);
                        System.out.println(Thread.currentThread().getName());
                    }
                });
                thread.start();
            }
        });
    }
}
 
二、EventBus框架基本用法
 
   (一)eventbus 流程图
 
                    event                               ———event————Subscriber
Publisher ——————>Event Bus — | 
  (发布器)      post()                              ———event————Subscriber
 
流程:发布器 通过post()方法 把event 发布到 event bus 总线当中 ,eventbus总线中根据 event 事件类型 匹配给相应的订阅者 
 ps:注意只有注册了事件才能收到event 发送的请求;同时反注册可以清理需要的eventbus请求
 
(二)eventbus 使用方法
1、导入:
   implementation ‘org.greenrobot:eventbus:3.0.0‘
 
2、定义自定义事件event类型
public class MyBusEvent{
    public final String message;
    public MyBusEvent(String message) {
        this.message = message;
    }
 
}
3、创建订阅者-通过注解
    //订阅者一定要带上@Subscribe注解,eventbus之后的订阅者方法名可以随意
@Subscribe(定义这个方法完成的线程级别),不用考虑线程问题抛出的异常
@Subscribe(threadMode = ThreadMode.MAIN) //表示onMessageEvent()在主线程中完成
    public void onMessageEvent(MyBusEvent event) {
        System.out.println();
    }
}
4、注册与反注册事件
@Override
protected void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}
@Override
protected void onStop() {
    super.onStop();
    EventBus.getDefault().unregister(this);
}
ps:注册与反注册 如果在Activity 或是fragment 这类组件,尽量与它的生命周期绑定在一起
 
5、发送事件 -无位置限制-主/子线程均可以发送事件
btn1.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        //主线程发送消息给子线程去处理需要耗时的操作
        Message msg = handler.obtainMessage();
        msg.arg1 = 1;
        msg.obj = "obj 消息";
        handler.sendMessage(msg);
    //将自定义的事件类型,作为参数传递给post()函数
        EventBus.getDefault().post(new MyBusEvent("test fot eventbus"));
    }
});
ps:所有注册、订阅这个事件的订阅者都能够匹配接收的这个事件xxx
 
 
三、EventBus框架的对象构建 和线程调度
 EventBus 的实例化均带有EventBus.getDefault() 方法,所以以此为入口:
 
简单来说:EventBus就是一个单例模式创建并用构建者模式Build内部类构建的对象
 
EventBus.getDefault():双检查机制的单例模式
public static EventBus getDefault() {
    if (defaultInstance == null) {
        synchronized (EventBus.class) {
            if (defaultInstance == null) {
                defaultInstance = new EventBus();
            }
        }
    }
    return defaultInstance;
}
 
思考:单例模式构造函数一般都是private修饰的,但是eventBus的构造模式是public 修饰的,这个原因是?
publicEventBus() {
    this(DEFAULT_BUILDER);
}
private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
 
解析:EventBus在代码中并不是只有一条 总线,还有其他的总线。订阅者可以注册到不同的EventBus上,通过不同的EventBus发送数据。不同的EventBus发送的数据是相互隔离开的,订阅者只会收到注册在该线程上的数据。通过上面DEFAULT_BUILDER 对象的初始化可以发现EventBus构建对象是通过构建者模式 Builde内部类 进行构建的。
 
EventBus 的对象构建 
    
 
private final ThreadLocal<PostingThreadState> currentPostingThreadState= new ThreadLocal<PostingThreadState>() {
    @Override
    protected PostingThreadState initialValue() {
        return new PostingThreadState();
    }
};
ps:ThreadLocal是 线程内部的数据存储类 ,通过它可以在指定的线程中存储数据,也只有在指定的线程中可以获取到数据。其他线程无法获取到
 
 
EventBus(EventBusBuilder builder) {
    subscriptionsByEventType = new HashMap<>(); 
    //以event 为key,以subscribe为value值
    ps:可以通过subscriptionsByEventType这个HashMap找到对应的订阅者
 
    typesBySubscriber = new HashMap<>(); 
    //以subscribe为key,以event为value
    ps:当进行注册和反注册事件的时候都会在这个typesBySubscriber HashMap中操作
 
    stickyEvents = new ConcurrentHashMap<>();
    //粘性事件,当event发送出去后再注册粘性事件的话,这个粘性事件也能收到之前发送的event事件
   ps:ConcurrentHashMap是一个并发的HashMap
 
思考 :什么是post? 答: 负责线程间调度 
    三个比较重要的成员变量的初始化 mainThreadPoster、backgroundPoster、asyncPoster
    mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
    backgroundPoster = new BackgroundPoster(this);
    asyncPoster = new AsyncPoster(this);
 
    indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0; //eventbus生成的索引
 
    //对已经设定好注解的@Subscribe的Method方法的找寻器    
    //通过这个方法找寻设定好注解的方法
subscriberMethodFinder= new SubscriberMethodFinder(builder.subscriberInfoIndexes,
            builder.strictMethodVerification, builder.ignoreGeneratedIndex);
 
 
    logSubscriberExceptions = builder.logSubscriberExceptions; //发生异常是否进行异常信息的打印
    logNoSubscriberMessages = builder.logNoSubscriberMessages;//没有订阅者订阅该事件的时候是否打印日志
    sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;//当调用事件处理函数时若发生异常是否需要发送这个事件
    sendNoSubscriberEvent = builder.sendNoSubscriberEvent;//当没有事件处理的时候是否对事件处理发送sendNoSubscriberEvent
    throwSubscriberException = builder.throwSubscriberException;//是否需要抛出异常
    eventInheritance = builder.eventInheritance; //与event有继承关系的是否都需要发送
    executorService = builder.executorService;
}
 
下面看一下eventBus 最核心的三个线程间调度的方法:
 
    (1) 、mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
final class HandlerPoster extends Handler所以可知其实际上就是个handler 具柄
//存放即将执行的post的队列
private final PendingPostQueue queue; 
 
//post这个事件最大的所能在handler当中handleMessage()所存在的最大时间值 max值
private final int maxMillisInsideHandleMessage;
 
//标着者handler是否运行起来
private boolean handlerActive;
 
在handleMessage()方法的任务,首先开启while一个循环,从队列中不停的获取数据后,调用invokeSubscriber()方法进行事件的分发
eventBus.invokeSubscriber(pendingPost);
//然后,每分发完一次事件都会对比下时间,判断这个method的时间timeInMethod 是否大于等于maxMillisInsideHandleMessage这个最大值时间,若小于就跳出循环,来继续下面的操作
long timeInMethod = SystemClock.uptimeMillis() - started;
if (timeInMethod >= maxMillisInsideHandleMessage) 
 
handleMessage() 循环的源码:
while (true) {
    //从前面定义好的queue队列中通过poll方法拉取需要的PendingPost对象
    pendingPost实际上就是一个维护着可以复用的对象的复用池 
    PendingPost pendingPost = queue.poll();
 
ps:PendingPost是一个arrayList,内部有两个核心方法:获取pendingPost:obtainPendingPost() 和 
回收pendingPost:releasePendingPost()
 
    if (pendingPost == null) {
        synchronized (this) {
            // Check again, this time in synchronized
            pendingPost = queue.poll();
            if (pendingPost == null) {
                handlerActive = false;//设置标志位为false,说明handler还没有运行
                return;
            }
        }
    }
    eventBus.invokeSubscriber(pendingPost);
    long timeInMethod = SystemClock.uptimeMillis() - started;
    
    if (timeInMethod >= maxMillisInsideHandleMessage) {
        if (!sendMessage(obtainMessage())) {
            throw new EventBusException("Could not send handler message");
        }
        rescheduled = true;
        return;
    }
}
 
(2) 、backgroundPoster = new BackgroundPoster(this);
final class BackgroundPoster implements Runnable
@Override
public void run() {
    try {
        try {
           //在while循环中不断的从队列中获取消息,同样通过类似的eventBus.invokeSubscriber 进行事件的分发
        ps:注意这里是有一个限定条件,直到取完池中所以的为止
            while (true) {
                PendingPost pendingPost =queue.poll(1000);
                if (pendingPost == null) {
                    synchronized (this) {
                        // Check again, this time in synchronized
                        pendingPost = queue.poll();
                        if (pendingPost == null) {
                            executorRunning = false;
                            return;
                        }
                    }
                }
               eventBus.invokeSubscriber(pendingPost);
            }
        } catch (InterruptedException e) {
            Log.w("Event", Thread.currentThread().getName() + " was interruppted", e);
        }
    } finally {
        executorRunning = false;
    }
}
(3) 、asyncPoster = new AsyncPoster(this);
AsyncPoster implements Runnable ,区别与BackgroundPoster:
    只获取队列中一个PendingPost,然后进行invokeSubscriber()事件的分发
@Override
public void run() {
    PendingPost pendingPost = queue.poll();
    if(pendingPost == null) {
        throw new IllegalStateException("No pending post available");
    }
    eventBus.invokeSubscriber(pendingPost);
}
 
 
四、EventBus框架的subscribe注解 
@Documented  //指定为是一个JavaDocument 文档
@Retention(RetentionPolicy.RUNTIME)  //指定可以在运行时有效
@Target({ElementType.METHOD}) //指定用来描述方法
public @interface Subscribe{ 
        //线程模式
         ThreadModethreadMode() default ThreadMode.POSTING;
    boolean sticky() default false; //判断是否为粘性事件
    int priority() default 0;
}
ThreadMode 枚举类:
    POSTING 
    / 默认的线程模式;在执行post操作的时候线程会直接调用订阅者的事件方法
     MAIN  
    / 在主线程中执行;当发布线程是在主线程可以直接调用该订阅者的方法;否则需要通过handlePost发送消息
    BACKGROUND--backgroundPost进行调度(所有队列)
    / 后台线程;表示在后台线程中执行相应的方法,如果发布线程不是在主线程中,不可以直接调用订阅者函数,必须启动唯一的后台线程进行处理,后台线程是唯一的,当事件发送post超过一个的时候会被放置在这里依次处理
    ASYNC —asyncPoster 每次只会从队列里获取一个所以不存在卡顿
   / 不论方法线程是在哪个线程都会使用一个空线程进行处理;Async所有的线程都相互独立,不会出现线程卡顿现象
 
粘性事件
    事件消费者在事件发布之后才注册的也能接收到该事件的特殊类型
 
Sticky Broadcast 粘性广播-传统
粘性广播存在的意义:
        在正常情况下,如果发送者发送了某个广播,而接受者在这个广播发送广播之后才注册广播接收者的话,那么广播接收者是无法接受到刚才的广播的。
 
引入之后:
    当接收者注册完之后,还可以接收到刚才发出的广播
在广播发射结束后保存刚刚发送的广播
 
区别于传统:
Android 的 EventBus会存储所有的Sticky事件,也就是说某个事件不需要的时候就进行手动的移除操作
 
五、EventBus框架的register订阅者
每新建一个eventbus总线,它的发布和订阅事件都是相互隔离的
 
举例:创建一个eventbus对象,在这个对象中通过他发布事件;然后又创建一个eventBus对象,在这个eventbus对象中,订阅者是不会收到前一个eventbus所发生的事件的
 
public void register(Object subscriber) {
   //通过反射机制 获取到订阅者的class对象
    Class<?> subscriberClass = subscriber.getClass();
    //register的核心方法——findSubscriberMethods
通过subscriberMethodFinder找寻器的findSubscriberMethods订阅对象class找到订阅方法的集合,返回一个订阅方法的集合
    List<SubscriberMethod> subscriberMethods = 
   //完成注册订阅的第一步:
subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    //遍历订阅好的方法集合 ,进行每个方法的订阅操作
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}
 
findSubscriberMethods():
//SubscriberMethod 类型的 List
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
SubscriberMethod:EventBus 总的包装类
 
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    //1、从方法缓存池中查找是否已经有了这个方法,如果有的话就把这个集合返回
    List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
    if (subscriberMethods != null) {
        return subscriberMethods;
    }
    //索引的判断(默认是false) ,所以会进入findUsingInfo()方法
    if (ignoreGeneratedIndex) {
        subscriberMethods = findUsingReflection(subscriberClass);
    } else {
    //获取到订阅方法的集合
        subscriberMethods = findUsingInfo(subscriberClass);
    }
    if (subscriberMethods.isEmpty()) {
        throw new EventBusException("Subscriber " + subscriberClass
                + " and its super classes have no public methods with the @Subscribe annotation");
    } else {
        //将subscriberMethods 存储到METHOD_CAHCE当中
        METHOD_CACHE.put(subscriberClass, subscriberMethods);
        return subscriberMethods;
    }
}
 
findUsingInfo():
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
    //1、获取到FindState对象 ,找到订阅过的方法和其状态,如果没有就new 新建一个FindState对象
    FindState findState = prepareFindState();
          ...
  ps:FindState(){
    定义:
    //保存所有订阅方法的ArrayList
            final List<SubscriberMethod> subscriberMethods = new ArrayList<>();
    //保存事件类型为key ,订阅类型为value的HashMap
            final Map<Class, Object> anyMethodByEventType = new HashMap<>();
    // 订阅方法为Methodkey,订阅者的class对象为value
            final Map<String, Class> subscriberClassByMethodKey = new HashMap<>();
     }   
 
//找到FindState对象的state状态
private FindState prepareFindState() {
    //从Find state对象池中查找
    synchronized (FIND_STATE_POOL) {
            //遍历对象池查找需要的 state对象
        for (int i = 0; i < POOL_SIZE; i++) {
            FindState state = FIND_STATE_POOL[i];
            if (state != null) {
               //已经找到了可用的复用的State,这时候将该位置清空,为了以后可以继续复用它,并返回这个状态给FindState()函数
                FIND_STATE_POOL[i] = null;
                return state;
            }
        }
    }
//当遍历完整个对象池还没有找到需要的state的时候调用new FindState()创建一个新的state
    return new FindState();
}
   ...
    ...
    findState.initForSubscriber(subscriberClass);
    ...
//在while 循环结尾 每一次循环之后都会通过moveToSuperclass()进行下一次的循环
    while (findState.clazz != null) {
        //getSubscriberInfo()函数获取到FindState订阅者的信息
        findState.subscriberInfo = getSubscriberInfo(findState);
 
        if (findState.subscriberInfo != null) {
       //首先获得 findState对象当中的订阅方法的集合
            SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
           //通过for循环进行 订阅方法的遍历
        for (SubscriberMethod subscriberMethod : array) {
                //订阅方法过滤操作—> 返回true ,订阅好的方法,以及订阅方法的事件类型都是符合它的准则的
                if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                //将订阅的方法添加到findState的arrayList中,也就是subscriberMethods
                    findState.subscriberMethods.add(subscriberMethod);
                }
            }
        } else {
                //如果getSubscriberMethods() 返回为null 空,则进入下面 
ps:getSubscriberMethods()默认情况下一般都是null 
            findUsingReflectionInSingleClass(findState);
        }
        findState.moveToSuperclass();
    }
    return getMethodsAndRelease(findState);
}
 
 
findState.checkAdd():
boolean checkAdd(Method method, Class<?> eventType) {
    //以eventType事件类型为key,以method为value
   //1、anyMethodByEventType.put()会返回之前的方法
    Object existing = anyMethodByEventType.put(eventType, method);
    if (existing == null) {
        return true;
    } else {
   ps:在eventbus中 有一种特点:
    一个订阅者包括订阅者的所有的父类和子类,不会有多个方法,相同的全部去接收同一个事件;
   
        if (existing instanceof Method) {
            if (!checkAddWithMethodSignature((Method) existing, eventType)) {
                throw new IllegalStateException();
            }
            anyMethodByEventType.put(eventType, this);
        }
    但有可能子类有可能会订阅该事件,同时它的父类也会订阅该事件的时候,会调用checkAddWithMethodSignature()来根据方法的签名来检查
        return checkAddWithMethodSignature(method, eventType);
    }
}
checkAddWithMethodSignature():根据方法的签名来检查过滤
private boolean checkAddWithMethodSignature(Method method, Class<?> eventType) {
    methodKeyBuilder.setLength(0);
    methodKeyBuilder.append(method.getName());
    methodKeyBuilder.append(‘>‘).append(eventType.getName());
    String methodKey = methodKeyBuilder.toString();
    Class<?> methodClass = method.getDeclaringClass();
    //以方法为key,以订阅好的类的class对象为value;
    //调用put方法()也会和之前一样会返回之前的订阅的class对象,然后根据class对象进行下一步操作
    Class<?> methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
  //如果这个class对象不存在 ,或者是这个值是method 对象的父类的话就会返回true
    if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
        return true;
    } else {
      //如果不是的话 ,或是class对象是空,就会把methodKey作为key 添加到subscriberClassByMethodKey 这个HashMap中
        ps:这个时候并没有put内容进缓存;因为put的值是methodClassOld是以前的class
    put()方法目的是revery:不要出现一个订阅者有多个相同方法,订阅同一个事件,如果有的话就把以前的这个class放到hashMap中去覆盖
        subscriberClassByMethodKey.put(methodKey, methodClassOld);
        return false;
    }
}
 
findUsingReflectionInSingleClass():通过这个方法找到哪些是订阅者订阅好的方法 或是 事件
private void findUsingReflectionInSingleClass(FindState findState) {
    …
  //1、通过反射的getDeclaredMethods() 获取到订阅者所有的方法
  methods = findState.clazz.getDeclaredMethods();
    …
  //2、对前面获取到的方法进行依次的遍历
  for (Method method : methods) {
     //3、获取到方法的修饰符 ,然后用这个修饰符进行判断
     int modifiers = method.getModifiers();
     //4、判断这个方法是否是public 以及该方法的修饰符是否可以忽略
      if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0){
        //5、getParameterTypes()获取方法的参数
       Class<?>[] parameterTypes = method.getParameterTypes();
           //6、进行方法参数的判断是否等于1
            ps:eventbus中只允许订阅方法后面的订阅事件是1个,所以通过方法参数长度的判断过滤出参数只有1哥的方法
            if (parameterTypes.length == 1) {
               //7、调用getAnnotation()方法获取Subscribe对象,用来过滤出只被@Subscribe修饰过的方法
                Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    …
                //8、被subscribeAnnotation过滤好的方法的threadMode()方法获取到相应的线程模式
                    ThreadMode threadMode = subscribeAnnotation.threadMode();
                //9、根据不同的线程模式 进行不同的线程调度操作
                 SubscriberMethod封装的eventbus使用时候所需要的对象添加到FindState 存储方法的集合当中
                    findState.subscriberMethods.add(
                                        new SubscriberMethod(method, eventType, threadMode,
                            subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                    …
    }
 
getMethodsAndRelease():进行返回和释放资源的操作
private List<SubscriberMethod> getMethodsAndRelease(FindState findState) {
    List<SubscriberMethod> subscriberMethods = new ArrayList<>(findState.subscriberMethods);
       //进行资源回收
    findState.recycle();
       ...
}
 
六、EventBus框架的subscribe 观察者
目标:根据获取到方法的集合单个方法的获取工作
public void register(Object subscriber) {
    Class<?> subscriberClass = subscriber.getClass();
    List<SubscriberMethod> subscriberMethods = 
  //完成注册订阅的第一步:
subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    //下面的目标是:遍历订阅好的方法集合 ,进行每个方法的订阅操作
 
    //建立同步代码块
    synchronized (this) { 
            //遍历获取到的方法集合——
ps:在上一版本中 是通过 获取subscriberMethods的迭代器 ,然后while循环不断的遍历这个迭代器(迭代器.hasNext())
    
    //增强for循环 不断遍历获取到每一个订阅方法
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
           //完成订阅的第二步:调用该方法完成订阅 
ps:
           parameter:订阅者-subscriber
           parameter:订阅方法-subscriberMethod
            subscribe(subscriber, subscriberMethod);
        }
    }
}
        
subscribe():
主体流程:
  •     1、首先判断是否有注册过该事件;有注册过抛出异常
  •     2、按照优先级顺序加入到 subscriptionsByEventType的 value的List中;通过这个HashMap 找到该事件的订阅者、
  • 订阅的方法和参数 等等
  •     3、再添加到typesBySubscriber的value的List中;通过这个HashMap可以使订阅者找到该订阅者订阅的所有事件
  •     4、判断是否是粘性事件、是否有继承关系
  •     5、调用checkPostStickyEventToSubscription进行事件的的分发
 
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
   //首先获取订阅方法的 事件类型 eventType属性
    Class<?> eventType = subscriberMethod.eventType;
 
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
   ps:Subscription内部封装了 subscriber订阅者 和 subscriberMethod 订阅方法;
而subscriberMethod又封装了订阅的方法,线程模式,事件类型,优先级,是否是粘性事件等属性。
所以在这里可以看出Subscription 是一个更大的封装类而已
 
//subscriptionsByEventType这个HashMap的key就是eventType,而value就是subscriptions
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
ps:CopyOnWriteArrayList 是一个可以并发读写的arrayList
 
//如果subscriptions 为空null,表明这个事件还没有被注册过
if (subscriptions == null) {
       //新创建一个arrayList 并把这个arraylist放入到 subscriptionsByEventType 这个HashMap当中
    subscriptions = new CopyOnWriteArrayList<>();
    subscriptionsByEventType.put(eventType, subscriptions);//为了后期复用
//如果这个 subscriptions当中包含了新创建好的newSubscription的话就会抛出异常 ;
异常信息是 该订阅者 已经注册过了该事件 +该事件的类型
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) {
     //根据优先级添加到arrayList当中的制定位置
         subscriptions.add(i, newSubscription);
        break;
    }
}
//以订阅者subscriber为key,以eventType为value,来获取到eventType 的arrayList
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
   //新创建一个并填入typesBySubscriber这个HashMap当中
    subscribedEvents = new ArrayList<>();
    typesBySubscriber.put(subscriber, subscribedEvents);
}
   //将这个事件类型放入到eventType的arrayList当中
subscribedEvents.add(eventType);
 
    //判断订阅方法是否为粘性事件,进一步判断是否支持继承关系
if (subscriberMethod.sticky) {
    if (eventInheritance) {
   //根据entrySet() 函数获取所有粘性事件的Set集合
Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
   //依次遍历 并通过eventType.isAssignableFrom()再次判断是否有继承关系
for (Map.Entry<Class<?>, Object> entry : entries) {
    Class<?> candidateEventType = entry.getKey();
    if (eventType.isAssignableFrom(candidateEventType)) {
        Object stickyEvent = entry.getValue();
    //如果有继承关系的话,进行事件的分发操作
        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
    }
}
 
checkPostStickyEventToSubscription():
private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
    if (stickyEvent != null) {
        postToSubscription(newSubscription, stickyEvent,
                Looper.getMainLooper() == Looper.myLooper() );//通过该标志位判断是否在主线程当中
    }
}
 
postToSubscription(): 核心方法使用的是 线程调度的 三个 post 方法
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
    switch (subscription.subscriberMethod.threadMode) {
        case POSTING: 
        //如果处于POSTING 默认模式 就直接完成线程调用
            invokeSubscriber(subscription, event);
            break;
        case MAIN: 
       //如果处于Ui主线程中,就直接调用invokeSubscriber
            if (isMainThread) {
                invokeSubscriber(subscription, event);
            } else {
       //如果不是在主线程,通过handlerPost中的enqueue方法 把需要的 ()入到队列当中
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
        case BACKGROUND:
            if (isMainThread) {
       //如果在Ui线程 ,就需要通过background 入队列
                backgroundPoster.enqueue(subscription, event);
            } else {
        //如果不在UI线程,区别于MAIN ,可以直接调用
                invokeSubscriber(subscription, event);
            }
            break;
        case ASYNC:
        //不管在哪个线程都会添加到队列当中
            asyncPoster.enqueue(subscription, event);
            break;
        default:
            throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
    }
}
 
invokeSubscriber(): //通过反射完成方法的调用
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);
    }
}
 
七、EventBus框架的Post事件发送 -核心的线程调度
EventBus.getDefault().post(new MyBusEvent("test fot eventbus"));
public void post(Object event) {
   //通过ThreadLocal 获取到一个发送状态 postingThreadState
    PostingThreadState postingState = currentPostingThreadState.get();
    ps:PostingThreadState 发送事件的线程类的封装类;
    currentPostingThreadState 就是一个ThreadLocal ,线程独有的,不会让其他线程共享当前线程的数据
 
   //获取到事件队列,并将这个事件添加到队列当中
    List<Object> eventQueue = postingState.eventQueue;
    eventQueue.add(event);
   //判断是否在进行发送状态,如果发送了就取消操作
    if (!postingState.isPosting) {
       //获取到Looper判断是否在主线程,获取到当前线程的Looper 和主线程的Looper然后进行对比,如果对比结果isMainThread为true 就继续下面的操作
        postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
        //将isPosting设为true 表示这个事件正在分发了
        postingState.isPosting = true;
        if (postingState.canceled) {
            throw new EventBusException("Internal error. Abort state was not reset");
        }
        try {
           //直到整个队列都为空,如果队列不为空则用postSingleEvent()发送事件
            while (!eventQueue.isEmpty()) {
                postSingleEvent(eventQueue.remove(0), postingState);
            }
        } finally {
        //将发生状态清零
            postingState.isPosting = false;
            postingState.isMainThread = false;
        }
    }
}
 
postSingleEvent():
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
    Class<?> eventClass = event.getClass();
    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);
    }
//如果没有任何的事件,就会调用post(new NoSubscriberEvent() ),表明没有订阅者订阅该事件
    if (!subscriptionFound) {
        if (logNoSubscriberMessages) {
            Log.d(TAG, "No subscribers registered for event " + eventClass);
        }
        if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                eventClass != SubscriberExceptionEvent.class) {
            post(new NoSubscriberEvent(this, event));
        }
    }
}
 
postSingleEventForEventType()://获取subscriptionFound 标志位
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
    CopyOnWriteArrayList<Subscription> subscriptions;
    synchronized (this) {
       //在同步代码块中,通过sbuscriptionsByEventType的HashMap,获取到一个订阅event事件的集合
        subscriptions = subscriptionsByEventType.get(eventClass);
    }
    …
    //完成订阅-核心的三个post调度方法
    postToSubscription(subscription, event, postingState.isMainThread);
    aborted = postingState.canceled;
    …
}
 

Android 常用开源框架源码解析 系列 (八)Eventbus 事件发布订阅框架

上一篇:最火移动端跨平台方案盘点:React Native、weex、Flutter


下一篇:Android Studio复制项目作为一个新的工程