游戏技术文章

Android开发事件总线之EventBus运用和框架原理深入理解

时间:2017-4-20 13:26:51  作者:棋牌资源网  来源:棋牌资源网  查看:6881  评论:0
内容摘要:[Android]事件总线之EventBus的使用背景  在我们的android项目开发过程中,经常会有各个组件如activity,fragment和service之间,各个线程之间的通信需求;项目中用的最多的是Android框架的广播机制,android的广播机制是基于系统的B...
[Android]事件总线之EventBus的使用背景

  在我们的android项目开发过程中,经常会有各个组件如activity,fragment和service之间,各个线程之间的通信需求;项目中用的最多的是Android框架的广播机制,android的广播机制是基于系统的Binder机制实现IPC或者进程内部的通信,而Binder这种IPC机制相比于Linux原有的机制来说具有,性能更好、安全性更高和易用性更好的特点,所以android系统中很多系统事件都是基于广播的方式来发送,如开机广播、电量低的提醒广播等。然而在一个android的进程内部,各个组件、子线程之间通信如果使用广播的话,那就有种杀鸡用牛刀的赶脚。。。

[Android]进程内部通信之EventBus

  EventBus是greenrobot开发的发布/订阅事件总线组件,也是基于观察者模式,不同点在于,EventBus框架解耦了事件的发送和订阅模块,事件对象的分发交由EventBus来处理,下面的框架图可以清晰的看到这一点。

Android开发事件总线之EventBus运用和框架原理深入理解

[Android]EventBus 3.0基本使用方法

一、定义事件类

作为事件的发布者,需要定义所发布的事件的类:

public class MessageEvent {
    private String msg;
    public MessageEvent(String msg) {
    this.msg = msg;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

二、注册/取消注册响应事件

作为事件的订阅者,需要把响应事件的对象注册到EventBus当中:

EventBus.getDefault().register(obj)

当不需要处理某个类型的事件的时候,取消对这个事件的监听:

EventBus.getDefault().unregister(obj)

三、声明和注释订阅方法,选择指定线程模式

  作为事件的订阅者,需要定义事件的响应方法,方法名称可以随意取,方法的形参类型,必须和监听的事件对象类型一致:

@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {
    Toast.makeText(this, event.getMsg (),
    Toast.LENGTH_SHORT).show();
}

3.1 四种线程模式

事件订阅者可以通过注解的方式选择处理事件的方法所在的线程:

PostThread:如果事件处理函数指定了线程模型为PostThread,那么事件的发布和接收处理会在同一个线程当中。

BackgroundThread:如果事件处理函数指定了线程模型为BackgroundThread,那么如果事件是在UI线程中发布出来的,那么该事件处理函数就会在新的子线程中运行,如果事件发布本来就是非UI线程中发布出来 的,那么该事件处理函数直接在发布事件的线程中执行。

MainThread:如果事件处理函数指定了线程模型为MainThread,那么不论事件对象是在哪个线程中发布出来的,该事件处理函数都会在UI线程中执行。

Async:如果事件处理函数指定了线程模型为Async,那么无论事件在哪个线程发布,该事件处理函数都会在新建的子线程中执行。

3.2 黏性事件

通过注解的方式设置sticky为true,那么事件处理函数则可以处理上一次的事件对象:

@Subscribe(sticky = true, threadMode = ThreadMode.MAIN)

四、EventBus 3.0源码详解

4.1 注册流程 

/**
* Registers the given subscriber to receive events.     Subscribers must call {@link #unregister(Object)} once they
* are no longer interested in receiving events.
* <p/>
* Subscribers have event handling methods that must be  annotated by {@link Subscribe}.
* The {@link Subscribe} annotation also allows configuration    like {@link
* ThreadMode} and priority.
*/
public void register(Object subscriber) {
//通过注册的对象得到其类的class对象
Class<?> subscriberClass = subscriber.getClass();
//通过类的class对象得到此对象的订阅方法列表
List<SubscriberMethod> subscriberMethods =  subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod :subscriberMethods) {
            //线程同步,遍历订阅方法列表,注册每一个订阅方法
            subscribe(subscriber, subscriberMethod);
        }
    }
}

代码subscriberMethodFinder.findSubscriberMethods(subscriberClass)获取订阅方法列表具体如下:

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    //在缓存中查找此class对象对应的订阅方法列表
    List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
    if (subscriberMethods != null) {
      return subscriberMethods;
    }
  //是否忽略注解器生成的MyEventBusIndex类
  if (ignoreGeneratedIndex) {
        //通过反射机制得到订阅者类class对象对应的订阅事件方法列表
        subscriberMethods = findUsingReflection(subscriberClass);
  } else {
        //从注解器生成的MyEventBusIndex类中获得订阅类的订阅方法列表
        subscriberMethods = findUsingInfo(subscriberClass);
    }
  if (subscriberMethods.isEmpty()) {
      throw new EventBusException("Subscriber " + subscriberClass
              + " and its super classes have no public methods with the @Subscribe annotation");
  } else {
      //缓存此class对象的订阅方法列表
      METHOD_CACHE.put(subscriberClass, subscriberMethods);
      return subscriberMethods;
  }
}

通过反射机制获取订阅方法列表:

private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
  FindState findState = prepareFindState();
  findState.initForSubscriber(subscriberClass);
  while (findState.clazz != null) {
      //遍历当前class对象和其父类中的订阅方法
      findUsingReflectionInSingleClass(findState);
      findState.moveToSuperclass();
  }
  return getMethodsAndRelease(findState);
}

findUsingReflectionInSingleClass方法:

private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    try {
        // This is faster than getMethods, especially when subscribers are fat classes like Activities
    methods = findState.clazz.getDeclaredMethods();
    } catch (Throwable th) {
    // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
    methods = findState.clazz.getMethods();
    findState.skipSuperClasses = true;
    }
    //遍历此类的方法
    for (Method method : methods) {
        int modifiers = method.getModifiers();
        if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
            Class<?>[] parameterTypes = method.getParameterTypes();
            //形参只有一个的函数
            if (parameterTypes.length == 1) { 
                //得到此函数的注解信息对象
                Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                if (subscribeAnnotation != null) {
                Class<?> eventType = parameterTypes[0];
                if (findState.checkAdd(method, eventType)) {
                    ThreadMode threadMode = subscribeAnnotation.threadMode();
                    findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                            subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                }
            }
         } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
            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)) {
        String methodName = method.getDeclaringClass().getName() + "." + method.getName();
        throw new EventBusException(methodName +
                " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
        }
    }
}

至此,我们得到了所有的订阅函数列表,下一步,会对每一个订阅函数进行注册:

// Must be called in synchronized block
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    Class<?> eventType = subscriberMethod.eventType;
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    //通过监听的事件对象得到其对应的监听者对象列表
    CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
    if (subscriptions == null) {
        subscriptions = new CopyOnWriteArrayList<>();
        subscriptionsByEventType.put(eventType, subscriptions);
    } 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;
        }
    }
    //通过订阅者对象得到其对应的监听事件类型列表
    List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    //添加事件类型对象到此监听对象对应的事件对象列表当中
    subscribedEvents.add(eventType);
    //在这里处理黏性事件
    if (subscriberMethod.sticky) {
        if (eventInheritance) {
        // Existing sticky events of all subclasses of eventType have to be considered.
        // Note: Iterating over all events may be inefficient with lots of sticky events,
        // thus data structure should be changed to allow a more efficient lookup
        // (e.g. an additional map storing sub classes of super classes: Class -> List<Class>).
        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);
        //将黏性事件发送到指定的订阅方法当中处理 
        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
    }
}

事件的注册流程实际是从监听者对象和消息事件两个维度,将对方分别添加到自己对应的列表当中,具体可以通过以下流程图总结:

Android开发事件总线之EventBus运用和框架原理深入理解

4.2发布流程

/** Posts the given event to the event bus. */
public void post(Object event) {
    //通过ThreadLocal机制得到当前线程的postingState对象
    PostingThreadState postingState = currentPostingThreadState.get();
    List<Object> eventQueue = postingState.eventQueue;
    //在此线程的eventQueue中添加此事件对象
    eventQueue.add(event);
    if (!postingState.isPosting) {
        //判断当前线程是否UI线程
        postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
        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;
        }
    }
}

ThreadLocal机制可以存储各个线程的局部数据;
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);
   }
    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));
        }
    }
}

事件消息对象具体的分发函数:postToSubscription

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
    //根据注解方式设置的线程模式,在不同的线程中执行订阅函数
    switch (subscription.subscriberMethod.threadMode) {
        case POSTING:
            invokeSubscriber(subscription, event);
            break;
        case MAIN:
            if (isMainThread) {
                invokeSubscriber(subscription, event);
            } else {
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
        case BACKGROUND:
            if (isMainThread) {
                backgroundPoster.enqueue(subscription, event);
            } else {
                invokeSubscriber(subscription, event);
            }
            break;
        case ASYNC:
            asyncPoster.enqueue(subscription, event);
            break;
        default:
            throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
    }
}

至此,我们完成了事件消息对象的分发流程,以下流程图来总结post的过程:

Android开发事件总线之EventBus运用和框架原理深入理解

4.3 取消注册流程

/** Unregisters the given subscriber from all event classes. */
public synchronized void unregister(Object subscriber) {
    //根据订阅者对象得到其对应的事件类型列表
    List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
    if (subscribedTypes != null) {
        for (Class<?> eventType : subscribedTypes) {
            //遍历事件类型列表,得到每个事件类型对应的订阅者对象列表,遍历这个列表,如果是此观察者对象,则从列表中删除
            unsubscribeByEventType(subscriber, eventType);
        }
        //typesBySubscriber中删除此订阅者对象
        typesBySubscriber.remove(subscriber);
    } else {
        Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
    }
}

unsubscribeByEventType函数:

/** Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber. */
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--;
            }
        }
    }
}

取消注册的流程总结如下:

1.通过观察者类对象通过MAP表得到其对应的事件类class对象列表.

2.遍历list列表,通过事件类class对象得到其在MAP表中对应的观察者类对象列表。

3.遍历此观察者对象列表,判断如果列表中存在需要取消的注册观察者对象,则从对象列表中删除此观察者对象。

4.从第1步中得到的MAP对象中删除以取消注册的观察者对象为key的映射项目。

5.完成unregister过程。

五、相似功能框架的比较

和EventBus具有相似功能的组件有Square推出的Otto,Android系统的LocalBroadCast,共同点是这三个框架都是进程内通信,方便进程内各个组件和子线程间的通信。

Ottootto采用了注解的方式完成注册,Otto更多使用场景应该就是在主线程中,因为其不像EventBus可以选择不同的线程模式。

LocalBroadCast是Android在Android Support Library中提供的,用于进程内部通信框架,其主要目的是保证广播在进程内部传递,确保通讯的安全行,其内部通过handler的方式实现。

标签:Android开发事件总线之EventBus运用和框架原理深入理解 

欢迎加入VIP,【VIP售价:只要288元永久VIP会员】畅享商业棋牌游戏程序下载,点击开通!

下载说明


☉本站所有源码和资源均由站长亲自测试-绝对保证都可以架设,运营!
☉如源码和资源有损坏或所有链接均不能下载,请告知管理员,

☉本站软件和源码大部分为站长独资,资源购买和收集,放心下载!

☉唯一站长QQ:1004003180  [人格担保-本站注重诚信!]

☉购买建议E-mail:1004003180@qq.com   源码收购 E-mail:1004003180@qq.com    

☉本站文件解压密码  【文章内都自带解压密码,每个密码不同!】


本站提供的所有源码,均来源站长提供,仅学习交流 浙ICP备09009969号

由此产生不良后果和法律责任与本站无关,如果侵犯了您的版权,请来信告知 1004003180@qq.com 将及时更正和删除! 

Copyright © 2008-2021 棋牌资源网,你身边的棋牌资源下载站    All Rights Reserved