編輯：關於android開發
EventBus3.0 做出了 挺大的改變，拋棄了可讀性極差的 OnEvent 開頭的方法，改用注解的形式來。
@Subscribe(sticky = true, threadMode = ThreadMode.MAIN,priority = 100)
public void test(String string) {
Log.e("cat", "str:" + string);
}
大概像這樣。既然使用了注解，那麼是使用反射來尋找接收事件的方法嗎？答案是 No。EventBus 提供了一個 EventBusAnnotationProcessor，允許通過注解在編譯時生成文件的形式，這種跟 Dagger2 以及 Butterknife 是極為相似的。既擁有省去編寫模板代碼的能力，也不會因為使用反射而帶來的性能損失。當然，編譯注解是可選項，如果不使用這個，還是會使用反射，這個從後面的源碼可以看出來。
在講源碼之前，先把幾個比較重要的類說下，以免造成混亂。
//其實就是把接收事件方法上面的注解封裝成一個 SubscribeMethod
public class SubscriberMethod {
final Method method;
final ThreadMode threadMode;
final Class eventType;
final int priority;
final boolean sticky;
/** Used for efficient comparison */
String methodString;
}
// 將訂閱者以及訂閱的方法封裝成一個 Subscritpion
final class Subscription {
final Object subscriber;
final SubscriberMethod subscriberMethod;
/**
* Becomes false as soon as {@link EventBus#unregister(Object)} is called, which is checked by queued event delivery
* {@link EventBus#invokeSubscriber(PendingPost)} to prevent race conditions.
*/
volatile boolean active;
Subscription(Object subscriber, SubscriberMethod subscriberMethod) {
this.subscriber = subscriber;
this.subscriberMethod = subscriberMethod;
active = true;
}
// 存儲線程信息、訂閱者以及事件。post 事件的時候會用到
/** For ThreadLocal, much faster to set (and get multiple values). */
final static class PostingThreadState {
final List
// 將事件以及訂閱者封裝成一個 PendingPost，這個主要是切換線程的時候會用到，後面會說到。
final class PendingPost {
private final static List pendingPostPool = new ArrayList();
Object event;
Subscription subscription;
PendingPost next;
// 將事件發送到主線程執行的 handler。
final class HandlerPoster extends Handler {
private final PendingPostQueue queue;
private final int maxMillisInsideHandleMessage;
private final EventBus eventBus;
private boolean handlerActive;
}
// EventBus 內部有維護一個Executors.newCachedThreadPool 的線程池，當調用 BackGroudPost.enqueue 的時候，會將事件弄到線程池中執行。
// BackGroundPost是一個 Runnable， 內部維護一個隊列，在 run 方法中會不斷的從隊列中取出 PendingPost，當隊列沒東東時，至多等待1s，然後跳出 run 方法。
final class BackgroundPoster implements Runnable {
private final PendingPostQueue queue;
private final EventBus eventBus;
private volatile boolean executorRunning;
}
// AsyncPoster 的實現跟 BackgroundPoster 的實現極為類似，區別就是是否有在 run 方法中循環取出 PendingPost。
// 雖然相似，但是主要的不同點就是，asyncPost 會確保每一個任務都會在不同的線程中執行，而 BackgroundPoster 則如果發送的速度比較快且接收事件都是在 background 中，則會在同一線程中執行。
class AsyncPoster implements Runnable {
private final PendingPostQueue queue;
private final EventBus eventBus;
好了，幾個重要的類都介紹完了，接下來開始主要流程的分析。
EventBus 同樣允許使用 Builder 的形式來進行構建，不過在實際使用當中，一般用的都是默認實現。同時，EventBus 也是一個單例。單例實現的代碼我就不貼了，太簡單。
public EventBus() {
this(DEFAULT_BUILDER);
}
EventBus(EventBusBuilder builder) {
subscriptionsByEventType = new HashMap<>();//以事件類型為 key，subscription list 為 value 的 map。
typesBySubscriber = new HashMap<>();// 以訂閱者為 key，訂閱的事件的 list 為 value map
stickyEvents = new ConcurrentHashMap<>();// 以事件的類型為 key，事件對象為 value 的 map。
mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
backgroundPoster = new BackgroundPoster(this);
asyncPoster = new AsyncPoster(this);
indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;//這個是有使用編譯時注解才有的， 後面說。
subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,//主要用來查找訂閱者方法的
builder.strictMethodVerification, builder.ignoreGeneratedIndex);
logSubscriberExceptions = builder.logSubscriberExceptions;
logNoSubscriberMessages = builder.logNoSubscriberMessages;
sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
throwSubscriberException = builder.throwSubscriberException;
eventInheritance = builder.eventInheritance; // 是否使用事件類型的繼承，如果為 true，例如參數為 string 類型的方法，參數為 object 類型的方法同樣也能接收到事件。
executorService = builder.executorService;//線程池，實現類為 Executors.newCachedThreadPool()
}
上面的屬性看起來挺多的，現在看不懂不要緊，看個大概就好，沒注釋的可能前面說過了，或者後面講的源碼沒有提及。
public void register(Object subscriber) {
Class subscriberClass = subscriber.getClass();
// 查找該訂閱者需要接收事件的方法
List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
// 主要是將 事件、事件類型、訂閱者等進行存儲，同時，接收 stick 事件，詳細看後面源碼。
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
List findSubscriberMethods(Class subscriberClass) {
// Eventbus 每次訂閱時，會將訂閱者為 key，訂閱者接收事件的方法 list 為 value存儲進 METHOD_CACHE 緩存中，如果有緩存，直接返回。
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;
}
}
注意上面忽略編譯時注解那部分，由於如果使用編譯時注解的文件，那麼就沒有繼續分析下去的意義了，所以，這裡不分析使用編譯時注解的情況。那麼，直接點進 findUsingReflection(subscriberClass)
private List findUsingReflection(Class subscriberClass) {
// FindState 是用來存儲找到的方法、訂閱者類等的對象。
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
// 下面就是真正搜索的方法，包括訂閱者父類的接收消息的方法，也一並會被找出來，當然，這個是可配置的。
while (findState.clazz != null) {
// 搜索接收消息的方法
findUsingReflectionInSingleClass(findState);
// 跳轉到父類，繼續搜索，直到父類為空為止。
findState.moveToSuperclass();
}
// 返回搜索到的方法並清空 findState 的變量。
return getMethodsAndRelease(findState);
}
接下來就來看看真正執行反射的方法。
private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
// findState。clazz 就是訂閱者或者訂閱者的父類
// 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();
//method 必須為 public
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];
// 檢驗是否可以添加，有兩級校驗，第一級是根據 eventType 為 key進行校驗，第二級根據 method 以及 eventType 生成 key，再次進行校驗，詳細實現自行查看。
if (findState.checkAdd(method, eventType)) {
// 封裝 SubscribeMethod，添加到 subscriberMethods 裡面。
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");
}
}
}
上面的實現非常簡單，相信沒看源碼之前你也能意淫出大概是長這樣。主要就是找到接收消息的方法就進行校驗，然後存儲到 findState 裡面的 subscriberMethods 裡面。
這樣，整個搜尋就完成了，再次回到 register 方法。
public void register(Object subscriber) {
Class subscriberClass = subscriber.getClass();
// 查找該訂閱者需要接收事件的方法
List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
// 主要是將 事件、事件類型、訂閱者等進行存儲，同時，接收 stick 事件，詳細看後面源碼。
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
點進 subscribe 方法
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class eventType = subscriberMethod.eventType;
// 將訂閱者以及接收事件的方法封裝成一個 subscription，為什麼需要一個方法以及訂閱者封裝成的 subscription 對象呢？
// 原因就是 EventBus 支持僅僅解綁訂閱者中的某一個方法。
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
// 根據事件類型取出所有的 subscription。subscrpiption。後面的判空以及賦值的不說了，太簡單。
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);
}
}
// 這個循環主要是將優先級(priority) 高的放在 list 的前面。
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);
// 這裡就是處理 stick 事件的了，這裡的 stickEvents 是在 postStick 的時候進行賦值的。
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);
}
}
}
整個訂閱流程就看完了，訂閱完之後要干嘛？發送事件啊。
這裡直接看 postSticky，因為其內部也會調用 post 方法。
public void postSticky(Object event) {
synchronized (stickyEvents) {
// 看到沒，就是這裡，把事件的類型為key，事件對象為 value 存儲到map 裡面。
// 從這裡也看出，如果 postStick 了兩個相同類型的 event，則前一個會覆蓋掉。
stickyEvents.put(event.getClass(), event);
}
// Should be posted after it is putted, in case the subscriber wants to remove immediately
post(event);
}
/** Posts the given event to the event bus. */
public void post(Object event) {
//PostingThreadState 會使用 ThradLocal 根據線程拿到當前線程的PostingThreadState，了解過 handler 機制的同志應該知道。
PostingThreadState postingState = currentPostingThreadState.get();
List
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class eventClass = event.getClass();
boolean subscriptionFound = false;
if (eventInheritance) {
// 根據事件類型，取出自身以及父類、接口所有的類型。
List> 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));
}
}
}
上面的方法會根據 eventInheritance 是否為 true 來決定需要發送給哪些訂閱者。如果為true，則接收包括 event 自身，event 的父類以及接口類型的事件的訂閱者，都會收到事件。
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class eventClass) {
CopyOnWriteArrayList subscriptions;
synchronized (this) {
subscriptions = subscriptionsByEventType.get(eventClass);
}
if (subscriptions != null && !subscriptions.isEmpty()) {
// 取出訂閱者並未 postingState 賦值。
for (Subscription subscription : subscriptions) {
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;
try {
//根據subscription 接收事件的線程以及當前線程來發送事件。
postToSubscription(subscription, event, postingState.isMainThread);
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) {
// 方法指定的接收事件的線程，直接放結論：上篇博客其實也有提到
// 1.如果為 posting，則接收事件以及發送事件會在同一線程執行。
// 2.如果為 mainThread，如果當前線程不是主線程，則會交給 mainThreadPoster 去執行，mainThreadPoster 是一個 handler，內部持有主線程的消息隊列，前面有提到。
// 3.如果為 background，如果當前是主線程，則交給 backgroundPoster 執行，進而交給 eventBus 的線程池執行，否則，將在同一線程執行。
// 4.如果為 Async，則不管當前是啥線程，都交給 asyncPoster 執行，確保每一個任務都在不同的線程中。
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);
}
}
上面，也就是關於對官方文檔中線程分發的一個解釋吧，有興趣看實現的也可以去看，並不復雜。
流程大概就是這樣，分析完了 register 以及 post，其他的都不難分析了。上面一些存儲事件以及訂閱者的 map 或者是 list，雖然在我分析的源碼中沒什麼卵用，但是你去看看解除注冊的那些代碼，就知道他的作用了。
其實 EventBus 的源碼相對來說比較簡單，我沒看源碼前也大概猜出這個流程，不過裡面對並發的控制還是不錯的，還是有值得我們學習的地方的。
Android簡單介紹SharedPreference,內部文件,sdcard數據存儲，
Android簡單介紹SharedPreference,內部文件,sdcard數據存儲，SharedPreference 以xml的結構儲存簡單的數據，儲存在data
Android登錄客戶端，驗證碼的獲取，網頁數據抓取與解析，HttpWatch基本使用
Android登錄客戶端，驗證碼的獲取，網頁數據抓取與解析，HttpWatch基本使用 大家好，我是M1ko。在互聯網時代的今天，如果一個App不接入互聯網，那麼這個
深入理解 Android 之 View 的繪制流程，androidview
深入理解 Android 之 View 的繪制流程，androidview概述 本篇文章會從源碼（基於Android 6.0）角度分析Android中View的繪制流程，
自定義控件之創建可以復用的組合控件（三）
自定義控件之創建可以復用的組合控件（三） 前面已學習了兩種自定義控件的實現，分別是自定義控件之對現有控件拓展（一）和 自定義控件之直接繼承View創建全新視圖（二）,
