EventBus

EventBus

用法:

1. 在接受消息的类注册EventBus,
2. 并添加接受消息的注解方法,
3. 然后在发送消息的类发送消息

public class MainActivity extends AppCompatActivity {
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        EventBus.getDefault().register(this);//注册EventBus
    }

    //添加接收消息的方法
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void receive(Friend friend){
        Toast.makeText(this, friend.toString(), Toast.LENGTH_SHORT).show();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        EventBus.getDefault().unregister(this);//取消EventBus的注册
    }

    public void jump(View view) {
        startActivity(new Intent(this,SeconedActivity.class));
    }
}

public class SeconedActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_seconed);
    }
    
    //发送消息
    public void send(View view) {
        EventBus.getDefault().post(new Friend("alan",18));
    }
}

原理:

1. 注册时将接收消息的类即注册类,和其父类中添加了@Subscrib方法的集合放进一个Map中缓存,
   Map> cacheMap

2. 发送消息时首先获取发送的事件类型,就是post(Object obj)方法中的参数的数据类型,
   然后调用cacheMap.keySet(),拿到cacheMap的key,即注册类的集合,
   然后根据key,调用cacheMap.get(key)拿到注册类中的接收消息的方法的集合,即拿List list
   然后遍历list拿到SubscribleMethod中的参数,
   如果发送消息的事件类型跟SubscribleMethod中的参数的类型相同,就根据@Subscrib注解中指定的线程,在相应的线程中,通过反射调用注册类中接收消息的方法(此时我们已知注册类的类名,方法名,方法的参数类型).
   这样就实现了:在B类发送消息后,接收方A类及时接收到消息,然后进行了处理

   
   
   

   eventbus.jpg

源码

getDefault()
就是一个懒汉单例

    public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }

register()

    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();//1.拿到register传过来的MainActivity,即注册类的类名
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//2.拿到MainActivity中所有添加了@Subscribe注解的方法
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);//将类和方法添加到Map集合中
            }
        }
    }

List findSubscriberMethods(Class subscriberClass) {
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);//先从缓存中拿
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        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 {
            METHOD_CACHE.put(subscriberClass, subscriberMethods);//拿到后存入缓存
            return subscriberMethods;
        }
    }

// Must be called in synchronized block
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;//获取事件类型,就是发送事件的类型
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        CopyOnWriteArrayList 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> 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).
                Set, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry, 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);
            }
        }
    }

post()

/** Posts the given event to the event bus. */
    public void post(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get();
        List