手撕EventBus框架源碼，再徒手擼一個
文章目錄java
- EventBus是什麼？有什麼用
- EventBus簡單使用
- EventBus原理解析
- 手擼EventBus框架
- EventBus 優化
1.EventBus是什麼？有什麼用
EventBus 是在 android 平臺上基於訂閱/發佈模式（觀察者模式）的事件處理機制，方便用於 android 組件內和組件之間的事件傳遞android
簡單的說法就是：一個事件或者通知在android的activity之間的傳遞方式（雖然片面，可是適合理解）程序員
這就是EventBus？既然是組件之間的通訊方式，android 自己就存在不少實現方式，好比 Intent，Broadcast，Handler ，那我爲毛要使用EventBus？由於傳統方式存在一些痛點，而EventBus恰好解決了它，所以它被普遍應用面試
傳統方式缺點：設計模式
Intent 傳遞大數據時致使TransactionTooLargeException，Broadcast 接受事件以後沒法指定運行線程，以及這些實現方式的繁瑣，耦合數組
EventBus優勢：緩存
使用簡單，能夠指定接收事件的函數運行的線程，解耦，傳遞大量數據的Event時不會崩潰框架
這麼神奇？趕忙看看 EventBus 的使用方式異步
2.EventBus簡單使用
EventBus 使用方式很簡單，在哪一個對象中準備接受事件，就在那裏註冊 一下，而後寫幾個接收事件的方法，在頁面銷燬的時候解綁註冊。準備工做作好以後，想在那裏發送事件，直接post就好了。簡單的一Basync
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個基礎屬性：
- threadMode() = 函數運行的線程
public enum ThreadMode {
/** * 與發送事件同一個線程 * 注意：若是post在主線程，避免耗時操做 */
POSTING,
/** * 主線程 * 若是post在主線程，直接在主線程中運行，會阻塞發佈線程 * 若是post在子線程，則事件排隊等待傳遞，使用handler回調到主線程中 */
MAIN,
/** * 主線程-排隊 * 不一樣於MAIN，此模式事件老是排隊等待傳遞，不會阻塞發佈線程 */
MAIN_ORDERED,
/** * 後臺線程 * 若是post在子線程，則在post所在的線程執行 * 若是post是主線程，則使用單個後臺線程按順序執行 */
BACKGROUND,
/** * 異步線程 * 老是使用異步線程執行，經過線程池管理異步線程，不會阻塞發佈線程和主線程 */
ASYNC
}
複製代碼
- sticky() = 是否粘性事件（EventBus默認事件是非粘性的，能夠經過這個屬性指定，通常來講 EventBus 須要先註冊而後才能接收事件，可是粘性事件特殊，能夠先發送事件後註冊，經常使用於 XActivity 跳轉 YActivity 而且傳遞數據的場景 ）
- 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)
public void updateUI(String event) {
}
@Subscribe(threadMode = ThreadMode.ASYNC)
public void updateUI2(int event) {
}
}
class Activity2{
@Subscribe(threadMode = ThreadMode.MAIN)
public void updateUI(String event) {
}
@Subscribe(threadMode = ThreadMode.ASYNC)
public void updateUI2(int event) {
}
}
map.put("Stirng.class", List(Subscription(Activity1&updateUI),Subscription(Activity2&updateUI)));
map.put("Int.class", List(Subscription(Activity1&updateUI2),Subscription(Activity2&updateUI2)));
複製代碼
如上述僞代碼，Activity1 和 Activity2 中都使用 @Subscribe 註解接收事件的方法，事件的類型爲String，int 那麼根據事件對象類型做爲 key 保存 map 能夠獲得：map.put("Stirng.class", List(Subscription(Activity1&updateUI),Subscription(Activity2&updateUI))); 表示多個Activity綁定了事件對象類型爲 String 的事件。 構建這個map有何做用？ 由於後續 post（事件）時要根據事件類型發送給全部已經註冊該事件類型的對象（Activity）中的註解方法 (updateUI(String event))
2.2 根據註冊對象（Activity）保存當前對象中存在的事件類型，構建map
class Activity1{
@Subscribe(threadMode = ThreadMode.MAIN)
public void updateUI(String event) {
}
@Subscribe(threadMode = ThreadMode.ASYNC)
public void updateUI2(int event) {
}
}
map.put("Activity1", List(String.class,Int.class..));
複製代碼
如上述僞代碼，在註冊對象（這裏假設是Activity）中將全部接收事件的事件類型保存起來，能夠獲得：map.put("Activity1", List(String.class,Int.class..)); 表示 Acticity1 對象中存在多種類型的事件。有何做用？1.用於查詢是否已經註冊了當前對象 2.爲解綁註冊，釋放資源作支撐（解綁註冊後面詳細分析）
2.3 若是當前註解方法接收的事件是粘性事件，則根據當前方法的參數類型（也就是事件類型）從粘性事件map緩存中（postSticky時保存）獲取粘性事件信息，若是存在則執行當前註解方法（實現延遲響應事件的原理）
能夠看到 register() 算是一個重頭戲，主要是保存一些數據，爲後續post發送事件作一些鋪墊做用。那接下來就看看 post 方法的源碼
3.2 EventBus.getDefault().post(Object event);
發送事件，能夠是任意類型的事件
//發送事件
public void post(Object event) {
PostingThreadState postingState = currentPostingThreadState.get();//根據不一樣Thread區分保存對象
List<Object> eventQueue = postingState.eventQueue;//事件列表
eventQueue.add(event);
if (!postingState.isPosting) {
postingState.isMainThread = isMainThread();
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;
}
}
}
//發送單一事件
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();//事件對象class
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) {
logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));//未找到訂閱對象，發送NoSubscriberEvent
}
}
}
//根據事件類型發送找到註冊對象，而後逐個發送事件
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
subscriptions = subscriptionsByEventType.get(eventClass);//獲取註冊時添加的註冊對象，也就是尋找綁定eventClass的activity集合，能夠看到這裏依賴於註冊方法準備的數據
}
if (subscriptions != null && !subscriptions.isEmpty()) {//循環全部註冊對象（例如：activity1,activity2..）
for (Subscription subscription : subscriptions) {
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;
try {
postToSubscription(subscription, event, postingState.isMainThread);//發送事件到已註冊的對象（某個activity）
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) {
switch (subscription.subscriberMethod.threadMode) {
case POSTING://與發送事件同一個線程,若是post在主線程，避免耗時操做
invokeSubscriber(subscription, event);//直接反射調用方法
break;
case MAIN://主線程
if (isMainThread) {//若是post在主線程，直接在主線程中運行，會阻塞發佈線程
invokeSubscriber(subscription, event);
} else {//若是post在子線程，則事件排隊等待傳遞，使用handler回調到主線程中
mainThreadPoster.enqueue(subscription, event);
}
break;
case MAIN_ORDERED://主線程-排隊
/** * 這裏就有點尷尬了，前面根據 ThreadMode 類的解釋是：不一樣於MAIN，此模式事件老是排隊等待傳遞，不會阻塞發佈線程 * 但這裏的實現並非必定方式隊列中。不過源碼中官方本身備註了技術上實現不正確，未按照 ThreadMode 定義的思想來實現，因此咱們就無論它了 */
if (mainThreadPoster != null) {
mainThreadPoster.enqueue(subscription, event);//事件排隊等待傳遞，不會阻塞發佈線程
} else {
// temporary: technically not correct as poster not decoupled from subscriber
// 臨時：技術上不正確，未與post線程分離
invokeSubscriber(subscription, event);
}
break;
case BACKGROUND://後臺線程
if (isMainThread) {//若是post是主線程，則使用單個後臺線程按順序執行
backgroundPoster.enqueue(subscription, event);
} else {//若是post在子線程，則在post所在的線程執行
invokeSubscriber(subscription, event);
}
break;
case ASYNC://異步線程,老是使用異步線程執行，經過線程池管理異步線程，不會阻塞發佈線程和主線程
asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}
//最終執行方法，經過反射調用 method.invoke(方法所在對象,方法參數)
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);
}
}
複製代碼
post 方法代碼很簡單，跟着註釋走主要路線就行，首先經過事件類型，找到已經註冊的列表，（註冊列表在每次註冊的時候添加），找到註冊列表以後挨個發送當前事件，怎麼發送當前事件？找到註冊對象的目標method，根據method指定的運行線程，按須要作一些線程切換的操做，而後經過反射調用 method.invoke(方法所在對象,方法參數)，就這麼簡單。
再看看發送粘性事件是怎麼處理的
//發送粘性事件
public void postSticky(Object event) {
synchronized (stickyEvents) {
stickyEvents.put(event.getClass(), event);//將粘性事件保存到緩存map中
}
// 調用post方法
post(event);
}
複製代碼
so easy. 粘性事件和普通事件相比，就多了一步將粘性事件保存到緩存 map 中，原來粘性事件的原理這麼簡單，發送的時候保存到緩存map中，延時（須要時）再取，實現了能夠先發送事件，後註冊的效果。
3.3 EventBus.getDefault().unregister(Object subscriber);
//解綁註冊，釋放資源等
public synchronized void unregister(Object subscriber) {
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);//根據當前對象找到事件類型列表
if (subscribedTypes != null) {
for (Class<?> eventType : subscribedTypes) {
unsubscribeByEventType(subscriber, eventType);//遍歷各個事件類型解綁已經註冊的對象
}
typesBySubscriber.remove(subscriber);
} else {
logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}
//根據事件類型解綁已註冊對象
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--;
}
}
}
}
複製代碼
解綁註冊也是比較簡單的，首先經過當前對象找到本類中全部的事件類型，再根據某個事件類型找到已經註冊該事件的對象列表（如：activity1，activity2..），而後根據比較當前對象是否存在列表中，若是存在，從列表中移除，釋放資源
以上即是EventBus的源碼解析，結合註釋，相信可以看懂它的原理思想，因爲分析的時候須要抓住主線不向外擴散，忽略了一些代碼，看客最好根據文章打開源碼對照着看看，加深印象。文章基於 EventBus 3.1.1
看完源碼來討論幾個問題： 1.爲何EventBus傳遞大數據時不會崩潰？ 分析： Intent 方式實際上底層parcel對象在不一樣activity直接傳遞過程當中保存在一個叫作「 Binder transaction buffe 」的緩衝區，而且這個緩衝區大小有限制，不能超過1M。 EventBus 不存在將數據放在什麼緩衝區中，普通事件直接拿到事件對象，找到須要調用的方法直接調用便可，簡單的方法參數傳遞； 而粘性事件，將數據緩存在內存中，保存在map，除非是內存爆炸，否則是沒有大小限制的說法。所以說EventBus能夠傳遞大數據
2.EventBus如何指定接收事件方法運行的線程？ 分析： EventBus 經過註解的方式指定接收事件的運行線程，在註冊的時候將註解信息保存起來，當post事件的時候拿到註冊時保存的註解信息（運行線程），經過不一樣的 ThreadMode 作不一樣的處理，如開啓工做線程執行接收事件的方法，或者經過handler方式將事件運行在主線程中，以此達到指定線程運行方法的目的
嗯，感受良好，熟練使用了，源碼分析也會了，常見面試問題也知道怎麼回答了，若是這時候面試官忽然問你：能本身手寫一個EventBus框架嗎？
What the X ? 好不容易分析完了源碼，你還想給你手擼一個框架出來？沒錯，就是手擼一個EventBus框架！不要虛，源碼分析出來了，思路已經知道了，手擼框架也不過如此，來，跟着痞子哥幹它！
4.手擼EventBus框架
固然，EventBus框架仍是相對比較完善的，這裏說的手擼框架，是實現簡易版本的，實現主要的功能，經過本身動手實現，深刻理解框架思想，加深理解。
咱們暫且按照EventBus提供的各個幾個接口來實現主要核心邏輯 首先就是 REventBus
/** * 簡易版本EventBus */
public class REventBus {
static volatile REventBus mInstance;
private REventBus() {
}
/** * 單例實現，雙重校驗 * * @return */
public static REventBus getDefault() {
if (mInstance == null) {
synchronized (REventBus.class) {
if (mInstance == null) {
mInstance = new REventBus();
}
}
}
return mInstance;
}
/** * 註冊對象 * * @param subscriber 訂閱對象 */
public void register(Object subscriber) {
}
/** * 解綁註冊，釋放資源 * * @param subscriber 訂閱對象 */
public void unregister(Object subscriber) {
}
/** * 發送事件 * * @param event 事件 */
public void post(Object event) {
}
/** * 發送粘性事件 * * @param event 事件 */
public void postSticky(Object event) {
}
/** * 某對象是否已經訂閱 * * @param subscriber 訂閱對象 * @return */
public boolean isRegistered(Object subscriber) {
return false;
}
}
複製代碼
自定義註解 (這裏暫時欠一篇關於註解的文章，後續寫完補充)
@Retention(RetentionPolicy.RUNTIME)//運行註解
@Target({ElementType.METHOD})//做用於方法
public @interface Subscribe {
/** * 事件運行線程 */
ThreadMode threadMode() default ThreadMode.POSTING;
/** * 是否粘性事件 */
boolean sticky() default false;
}
複製代碼
ThreadMode
public enum ThreadMode {
/** * 調用線程 */
POSTING,
/** * 主線程 */
MAIN
}
複製代碼
以上就是EventBus基礎的類，在REventBus中已經定好了基礎的API，那麼如今咱們來一步步完善它
4.1 手擼EventBus框架-->register(Object subscriber)
回憶 EventBus ->> register() 原理
- 獲取訂閱對象中訂閱方法（註解方法）的信息，而且封裝成對象
SubscriberMethod
//訂閱方法封裝的對象
class SubscriberMethod {
Object subscriber;//訂閱者
Method method;//訂閱方法
ThreadMode threadMode;//訂閱方法運行線程
Class<?> eventType;//事件類型class
boolean sticky;//是否粘性
public SubscriberMethod(Object subscriber, Method method, Class<?> eventType, ThreadMode threadMode, boolean sticky) {
this.subscriber = subscriber;
this.method = method;
this.eventType = eventType;
this.threadMode = threadMode;
this.sticky = sticky;
}
}
複製代碼
獲取訂閱對象中的註解方法（訂閱方法），返回的是一個列表（可能一個類中有多個註解方法嘛）
/** * 獲取當前對象中註解方法信息(列表) * * @param subscriber * @return */
private List<SubscriberMethod> getSubscriberMethod(Object subscriber) {
List<SubscriberMethod> list = new ArrayList<>();
Class<?> subscriberClass = subscriber.getClass();//註冊對象的class
Method[] methods = subscriberClass.getDeclaredMethods();//獲取全部修飾類型的方法
for (Method method : methods) {
Subscribe subscribe = method.getAnnotation(Subscribe.class);//獲取方法註解信息
if (subscribe == null) {//若是爲空，表示此方法不是註解方法
continue;
}
Class<?>[] types = method.getParameterTypes();//獲取方法參數列表class，注意是class，好比int->Int.class
if (types.length != 1) {//這裏只接受一個參數的方法（參照EventBus）
throw new RuntimeException("REventBus 只接受一個參數!");
}
ThreadMode threadMode = subscribe.threadMode();//獲取註解信息 -> ThreadMode (第一次接觸註解的同窗是否是恍然大悟，真TM簡單)
boolean sticky = subscribe.sticky();//獲取註解信息 -> sticky
//構建 SubscriberMethod 封裝註解信息，方法參數，方法對象
SubscriberMethod subscriberMethod = new SubscriberMethod(subscriber, method, types[0], threadMode, sticky);
list.add(subscriberMethod);//添加到列表
}
return list;
}
複製代碼
- 將訂閱方法綁定到訂閱對象。當訂閱方式是粘性時特殊處理，從粘性事件集合中獲得事件，執行對應方法
//某事件對象的 訂閱者列表 集合
private Map<Class<?>, List<SubscriberMethod>> subscriberMethodMap;
//某訂閱者的 事件列表 集合
private Map<Object, List<Class<?>>> subscriberEventMap;
//粘性事件集合 key = 事件.class
private Map<Class<?>, Object> stickyEventMap;
/** * 將 訂閱方法 與 訂閱對象 綁定 * * @param subscriber 訂閱對象 * @param subscriberMethod 訂閱方法 */
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
List<SubscriberMethod> subscriberMethods = subscriberMethodMap.get(eventType);//獲取 某事件對象的 訂閱者列表 集合
if (subscriberMethods == null) {
subscriberMethods = new ArrayList<>();
subscriberMethodMap.put(eventType, subscriberMethods);
}
subscriberMethods.add(subscriberMethod);
List<Class<?>> subscribedEvents = subscriberEventMap.get(subscriber);//獲取 某訂閱者的 事件列表 集合
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
subscriberEventMap.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
if (subscriberMethod.sticky) {//粘性事件方法
Object eventSticky = stickyEventMap.get(eventType);//粘性事件對象
if (eventSticky != null) {//存在粘性事件，調用當前方法
postEvent(subscriberMethod, eventSticky);
}
}
}
複製代碼
綜述，register方法爲：
/** * 註冊對象 * * @param subscriber 訂閱對象 */
public void register(Object subscriber) {
List<SubscriberMethod> subscriberMethodList = getSubscriberMethod(subscriber);//獲取訂閱者中的註解方法
if (subscriberMethodList == null || subscriberMethodList.isEmpty()) return;//容錯
for (SubscriberMethod subscriberMethod : subscriberMethodList) {
subscribe(subscriber, subscriberMethod);//綁定訂閱對象和訂閱方法
}
}
複製代碼
4.2 手擼EventBus框架-->post(Object event)
回憶post原理：
獲取全部事件爲 event 的訂閱方法，而後逐個發送事件，發送事件的原理是經過反射實現方法的調用，同時根據指定的線程模式作線程切換
/** * 發送事件 * * @param event 事件 */
public void post(Object event) {
List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(event.getClass());//獲取某事件的全部訂閱者
if (subscriberMethodList == null && subscriberMethodList.isEmpty()) return;//容錯
for (SubscriberMethod subscriberMethod : subscriberMethodList) {
postEvent(subscriberMethod, event);//發送事件
}
}
/** * 發送事件 * * @param subscriberMethod 訂閱方法封裝的對象 * @param event 事件（方法參數） */
private void postEvent(SubscriberMethod subscriberMethod, Object event) {
Object subscriber = subscriberMethod.subscriber;//訂閱者
ThreadMode threadMode = subscriberMethod.threadMode;//訂閱方法的執行線程
Method method = subscriberMethod.method;//訂閱方法
switch (threadMode) {
case POSTING://post線程
invokeMethod(subscriber, method, event);
break;
case MAIN://主線程
//經過handler實現主線程調用方法
Object[] objects = new Object[]{subscriber, method, event};
mainHandler.sendMessage(mainHandler.obtainMessage(1, objects));
break;
}
}
/** * 經過反射執行方法 * * @param subscriber 方法所在對象 * @param method 方法對象 * @param event 方法參數 */
private void invokeMethod(Object subscriber, Method method, Object event) {
try {
method.invoke(subscriber, event);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
/** * Handler */
class MainHandler extends Handler {
public MainHandler() {
super(Looper.getMainLooper());
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Object[] obj = (Object[]) msg.obj;
Object subscriber = obj[0];//類對象
Method method = (Method) obj[1];//方法
Object event = obj[2];//方法參數
//反射執行方法
invokeMethod(subscriber, method, event);
}
}
複製代碼
4.3 手擼EventBus框架-->unregister(Object subscriber)
回憶解綁註冊原理：
經過當前對象獲取 該訂閱者的 事件列表，在訂閱者列表中找到當前訂閱對象，移除它。而後再清空當前訂閱者的 事件列表
/** * 解綁註冊，釋放資源 * * @param subscriber 訂閱對象 */
public void unregister(Object subscriber) {
List<Class<?>> eventClass = subscriberEventMap.get(subscriber);//獲取 某訂閱者的 事件列表 集合
if (eventClass == null || eventClass.isEmpty()) return;//容錯
for (Class<?> clazz : eventClass) {
List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(clazz);//獲取 某事件對象的 訂閱者列表 集合
for (int i = 0; i < subscriberMethodList.size(); i++) {
if (subscriberMethodList.get(i).subscriber == subscriber) {//在訂閱者列表中找到當前訂閱對象
subscriberMethodList.remove(i);//移除它
}
}
}
subscriberEventMap.remove(subscriber);//移除當前訂閱者的 事件列表
}
複製代碼
REventBus一覽
/** * 簡易版本EventBus */
public class REventBus {
static volatile REventBus mInstance;
//主線程Handler
private MainHandler mainHandler;
//某事件對象的 訂閱者列表 集合
private Map<Class<?>, List<SubscriberMethod>> subscriberMethodMap;
//某訂閱者的 事件列表 集合
private Map<Object, List<Class<?>>> subscriberEventMap;
//粘性事件集合 key = 事件.class
private Map<Class<?>, Object> stickyEventMap;
private REventBus() {
subscriberMethodMap = new HashMap<>();
subscriberEventMap = new HashMap<>();
stickyEventMap = new HashMap<>();
mainHandler = new MainHandler();
}
/** * 單例實現，雙重校驗 * * @return */
public static REventBus getDefault() {
if (mInstance == null) {
synchronized (REventBus.class) {
if (mInstance == null) {
mInstance = new REventBus();
}
}
}
return mInstance;
}
/** * 註冊對象 * * @param subscriber 訂閱對象 */
public void register(Object subscriber) {
List<SubscriberMethod> subscriberMethodList = getSubscriberMethod(subscriber);//獲取訂閱者中的註解方法
if (subscriberMethodList == null || subscriberMethodList.isEmpty()) return;//容錯
for (SubscriberMethod subscriberMethod : subscriberMethodList) {
subscribe(subscriber, subscriberMethod);//綁定訂閱對象和訂閱方法
}
}
/** * 獲取當前對象中註解方法信息(列表) * * @param subscriber * @return */
private List<SubscriberMethod> getSubscriberMethod(Object subscriber) {
List<SubscriberMethod> list = new ArrayList<>();
Class<?> subscriberClass = subscriber.getClass();//註冊對象的class
Method[] methods = subscriberClass.getDeclaredMethods();//獲取全部修飾類型的方法
for (Method method : methods) {
Subscribe subscribe = method.getAnnotation(Subscribe.class);//獲取方法註解信息
if (subscribe == null) {//若是爲空，表示此方法不是註解方法
continue;
}
Class<?>[] types = method.getParameterTypes();//獲取方法參數列表class，注意是class，好比int->Int.class
if (types.length != 1) {//這裏只接受一個參數的方法（參照EventBus）
throw new RuntimeException("REventBus 只接受一個參數!");
}
ThreadMode threadMode = subscribe.threadMode();//獲取註解信息 -> ThreadMode (第一次接觸註解的同窗是否是恍然大悟，真TM簡單)
boolean sticky = subscribe.sticky();//獲取註解信息 -> sticky
//構建 SubscriberMethod 封裝註解信息，方法參數，方法對象
SubscriberMethod subscriberMethod = new SubscriberMethod(subscriber, method, types[0], threadMode, sticky);
list.add(subscriberMethod);//添加到列表
}
return list;
}
/** * 將 訂閱方法 與 訂閱對象 綁定 * * @param subscriber 訂閱對象 * @param subscriberMethod 訂閱方法 */
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
List<SubscriberMethod> subscriberMethods = subscriberMethodMap.get(eventType);//獲取 某事件對象的 訂閱者列表 集合
if (subscriberMethods == null) {
subscriberMethods = new ArrayList<>();
subscriberMethodMap.put(eventType, subscriberMethods);
}
subscriberMethods.add(subscriberMethod);
List<Class<?>> subscribedEvents = subscriberEventMap.get(subscriber);//獲取 某訂閱者的 事件列表 集合
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
subscriberEventMap.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
if (subscriberMethod.sticky) {//粘性事件方法
Object eventSticky = stickyEventMap.get(eventType);//粘性事件對象
if (eventSticky != null) {//存在粘性事件，調用當前方法
postEvent(subscriberMethod, eventSticky);
}
}
}
/** * 解綁註冊，釋放資源 * * @param subscriber 訂閱對象 */
public void unregister(Object subscriber) {
List<Class<?>> eventClass = subscriberEventMap.get(subscriber);//獲取 某訂閱者的 事件列表 集合
if (eventClass == null || eventClass.isEmpty()) return;//容錯
for (Class<?> clazz : eventClass) {
List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(clazz);//獲取 某事件對象的 訂閱者列表 集合
for (int i = 0; i < subscriberMethodList.size(); i++) {
if (subscriberMethodList.get(i).subscriber == subscriber) {//在訂閱者列表中找到當前訂閱對象
subscriberMethodList.remove(i);//移除它
}
}
}
subscriberEventMap.remove(subscriber);//移除當前訂閱者的 事件列表
}
/** * 發送事件 * * @param event 事件 */
public void post(Object event) {
List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(event.getClass());//獲取某事件的全部訂閱者
if (subscriberMethodList == null && subscriberMethodList.isEmpty()) return;//容錯
for (SubscriberMethod subscriberMethod : subscriberMethodList) {
postEvent(subscriberMethod, event);//發送事件
}
}
/** * 發送粘性事件 * * @param event 事件 */
public void postSticky(Object event) {
//保存粘性事件
stickyEventMap.put(event.getClass(), event);
//調用post
post(event);
}
/** * 發送事件 * * @param subscriberMethod 訂閱方法封裝的對象 * @param event 事件（方法參數） */
private void postEvent(SubscriberMethod subscriberMethod, Object event) {
Object subscriber = subscriberMethod.subscriber;//訂閱者
ThreadMode threadMode = subscriberMethod.threadMode;//訂閱方法的執行線程
Method method = subscriberMethod.method;//訂閱方法
switch (threadMode) {
case POSTING://post線程
invokeMethod(subscriber, method, event);
break;
case MAIN://主線程
//經過handler實現主線程調用方法
Object[] objects = new Object[]{subscriber, method, event};
mainHandler.sendMessage(mainHandler.obtainMessage(1, objects));
break;
}
}
/** * 經過反射執行方法 * * @param subscriber 方法所在對象 * @param method 方法對象 * @param event 方法參數 */
private void invokeMethod(Object subscriber, Method method, Object event) {
try {
method.invoke(subscriber, event);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
/** * 某對象是否已經訂閱 * * @param subscriber 訂閱對象 * @return */
public boolean isRegistered(Object subscriber) {
return subscriberEventMap.containsKey(subscriber);
}
/** * 封裝訂閱方法 */
class SubscriberMethod {
Object subscriber;//訂閱者
Method method;//訂閱方法
ThreadMode threadMode;//訂閱方法運行線程
Class<?> eventType;//事件類型class
boolean sticky;//是否粘性
public SubscriberMethod(Object subscriber, Method method, Class<?> eventType, ThreadMode threadMode, boolean sticky) {
this.subscriber = subscriber;
this.method = method;
this.eventType = eventType;
this.threadMode = threadMode;
this.sticky = sticky;
}
}
/** * Handler */
class MainHandler extends Handler {
public MainHandler() {
super(Looper.getMainLooper());
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Object[] obj = (Object[]) msg.obj;
Object subscriber = obj[0];//類對象
Method method = (Method) obj[1];//方法
Object event = obj[2];//方法參數
//反射執行方法
invokeMethod(subscriber, method, event);
}
}
}
複製代碼
這裏明確說明，這個類只是用於分析和加深理解EventBus的框架原理，雖然功能是能夠跑通的，可是不要直接應用到項目中，畢竟是簡易版本，還有不少地方須要完善和容錯
5.EventBus 優化
當咱們自信滿滿的擼完EventBus框架以後，面試官又問了一個問題：EventBus 是否存在性能問題？它使用反射實現，是否還能夠再優化一下？
啊~西八！這offer我不要了，這不是逼死人嘛！ 不要offer了？怎麼可能，我不但要了這offer，我還想提個價格
首先，反射調用和直接調用到底性能差多少？不少人一聽到反射就說性能很差，一棒子打死了，可是究竟差多少呢？有什麼數字指標拿出來講話呢？在這裏再欠一篇文章，後續找時間分析一下寫篇文章。
反射是確定存在性能問題，差多少暫時不討論，若是不要使用反射是否是就能夠提高一下呢？若是咱們能經過直接調用方法的方式，來避免反射調用方法帶來的性能問題，是否是就能夠提高性能了呀。
若是咱們知道即將調用的方法長什麼樣，給他提早寫好，而不是運行時反射調用，就能夠解決這個問題，而提早寫好方法的實現方式也是有的，那就是apt！在編譯時就建立」方法副本「提供代碼調用。
因爲篇幅緣由，這裏又欠了一篇關於apt的使用文章！
一篇文章讀下來，就算沒有徹底掌握，起碼知道有幾個知識點須要去學習一下：
- Java基礎-反射
- 註解
- 設計模式->單例
- apt技術
- 源碼中忽略掉的ThreadLocal
反射相關的用法直接寫了一篇博客，剩下的幾個內容暫時欠着，後續各自寫一篇文章補上！
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
