[大白裝逼]YEventBus事件總線的實現

Y事件總線:基於java的Observe和Observable實現的事件總線
github地址:https://github.com/lewis-v/YEventBus

使用方式

導入依賴

Add it in your root build.gradle at the end of repositories:

    allprojects {
        repositories {
            ...
            maven { url 'https://jitpack.io' }
        }
    }

Add the dependency

    dependencies {
            compile 'com.github.lewis-v:YEventBus:1.0.0'
    }

使用方式

定義事件類TestEvent2繼承於IEvent,並註冊事件

YEventBus.getInstance().subscriber(TestEvent2.class, new YObserver<TestEvent2>() {//訂閱事件,處理的所在的線程與分發的線程一致
            @Override
            public void onSuccess(TestEvent2 event) {
                Log.i(TAG,event.toString());
            }

            @Override
            public void onFail(Exception e) {
                Log.e(TAG,e.getMessage());
            }
        });

YEventBus.getInstance().subscriber(TestEvent.class, new YMainThreadObserver<TestEvent>() {//訂閱事件,會在主線程中處理
            @Override
            public void onSuccess(TestEvent event) {
                Log.i(TAG,event.toString());
            }

            @Override
            public void onFail(Exception e) {
                Log.e(TAG,e.getMessage());
            }
        });

發佈事件

 YEventBus.getInstance().postMainEvent(TestEvent.class,new TestEvent(TAG));//發佈在主線程分發的事件

 YEventBus.getInstance().postEvent(TestEvent.class,new TestEvent(TAG));//發佈在子線程分發的事件

取消訂閱

YEventBus.getInstance().unSubscriber(TestEvent.class,observer);//取消某事件下的某個訂閱者的訂閱
YEventBus.getInstance().unSubscriberEvent(TestEvent.class);//取消TestEvent整個系列事件的訂閱
YEventBus.getInstance().unSubscriberAll();//取消所有事件的訂閱

具體實現

Observable與Observer

首先是使用java的Observable,在發佈事件時需要先setChanged()在進行發佈,否者是發佈不了的

public class YObservable extends Observable {

    public <T extends IEvent> void postEvent(T data){
        setChanged();
        notifyObservers(data);
    }
}

然後是java的Observer,這裏實現了OnGetEvent接口,主要是要在本來的Observer接口上加上成功與失敗的調用方法,其中Observer接口需要實現updata方法,此方法是在事件分發時調用的方法

interface OnGetEvent<E extends IEvent> extends Observer{
    void onSuccess(E event);
    void onFail(Exception e);
}

YObserver控制了事件的實際處理及異常的獲取

public abstract class YObserver<E extends IEvent> implements OnGetEvent<E> {

    @Override
    public void update(Observable o, Object arg) {
        try {
            onSuccess((E) arg);
        }catch (Exception e){
            onFail(e);
        }
    }
}

這裏除了提供YObserver,還提供了YMainThreadObserver,此Observer的事件處理會在主線程中進行,添加此類的意義是,可以再發布時指定在主線程,也可以在訂閱的時候指定在主線程,當然在訂閱的時候指定的優先級比發佈的時候指定優先級高.

public abstract class YMainThreadObserver<E extends IEvent> implements OnGetEvent<E>{
    @Override
    public void update(final Observable o, final Object arg) {
        ThreadSchedule.getMainHandle().post(new Runnable() {
            @Override
            public void run() {
                try {
                    onSuccess((E) arg);
                }catch (Exception e){
                    onFail(e);
                }
            }
        });
    }
}

Observable管理類

YObservableManager用於管理Observable,內部定義了ConcurrentHashMap來存儲Observable,其鍵值爲對應事件的Class,在訂閱和取消訂閱會對map進行插入或遍歷

public class YObservableManager {
    private ConcurrentHashMap<Class,YObservable> mObservableMap;
    private IEventHandle handle;


    public YObservableManager() {
        mObservableMap = new ConcurrentHashMap<>();
        init();
    }

    public YObservableManager(ConcurrentHashMap<Class, YObservable> mObservableMap) {
        this.mObservableMap = mObservableMap;
        init();
    }

    public void init(){
        handle = new YEventHandle();
    }

    /**
     * 設置自定義的事件分發處理
     * @param handle
     */
    public void setHandle(IEventHandle handle) {
        this.handle = handle;
    }

    /**
     * 發佈消息
     * @param event
     * @param <T>
     */
    public <T extends IEvent> void postEvent(Class<T> event,T data){
        YObservable observables = mObservableMap.get(event);
        if (handle == null){
            init();
        }
        handle.postEvent(observables,data);
    }

    /**
     * 發佈主線程消息
     * @param event
     * @param <T>
     */
    public <T extends IEvent> void postMainEvent(Class<T> event,T data){
        YObservable observables = mObservableMap.get(event);
        if (handle == null){
            init();
        }
        handle.postMainEvent(observables,data);
    }

    /**
     * 訂閱事件
     * @param event
     * @param observer
     * @param <T>
     */
    public <T extends IEvent> void subscriber(Class<T> event,OnGetEvent<T> observer){
        if (mObservableMap.containsKey(event)){
            mObservableMap.get(event).addObserver(observer);
        }else {
            YObservable observable = new YObservable();
            observable.addObserver(observer);
            mObservableMap.put(event, observable);
        }
    }

    /**
     * 解除訂閱
     * @param event
     * @param observer
     * @param <T>
     */
    public <T extends IEvent> void unSubscriber(Class<T> event,YObserver<T> observer){
        if (mObservableMap.containsKey(event)){
            mObservableMap.get(event).deleteObserver(observer);
        }
    }

    /**
     * 解除一個事件系列的訂閱
     * @param event
     */
    public void unSubscriberEvent(Class<? extends IEvent> event){
        if (mObservableMap.containsKey(event)) {
            mObservableMap.get(event).deleteObservers();
            mObservableMap.remove(event);
        }
    }

    /**
     * 解除所有事件訂閱
     */
    public void unSubscriberAll(){
        for (Map.Entry<Class,YObservable> entry : mObservableMap.entrySet()){
            YObservable value = entry.getValue();
            if (value != null){
                value.deleteObservers();
            }
        }
        mObservableMap.clear();
    }

    /**
     * 釋放資源
     */
    public void destroy(){
        handle.destroy();
        handle = null;
        unSubscriberAll();
    }
}

事件的發佈

上述代碼中,在發佈消息的時候會調用IEventHandle的postEvent,其實際的實現爲

public class YEventHandle implements IEventHandle{
    private ExecutorService executorServiceHandle;//處理線程池

    public YEventHandle() {
        init();
    }
    private void init(){
        executorServiceHandle = Executors.newFixedThreadPool(2*Runtime.getRuntime().availableProcessors());
    }

    /**
     * 發佈消息
     * @param observable
     * @param data
     * @param <T>
     * @throws InterruptedException
     */
    @Override
    public <T extends IEvent> void postEvent(YObservable observable, T data) {
        handle(observable,data);
    }

    /**
     * 發佈主線程處理消息
     * @param observable
     * @param data
     * @param <T>
     */
    @Override
    public <T extends IEvent> void postMainEvent(YObservable observable, T data) {
        handleInMain(observable,data);
    }

    /**
     * 處理
     * @param observable
     * @param data
     * @param <T>
     */
    private <T extends IEvent>  void handle(final YObservable observable, final T data){
        executorServiceHandle.execute(new Runnable() {
            @Override
            public void run() {
                if (observable != null) {
                    observable.postEvent(data);
                }
            }
        });
    }

    /**
     * 在主線程處理
     * @param observable
     * @param data
     * @param <T>
     */
    private <T extends IEvent>  void handleInMain(final YObservable observable, final T data){
        executorServiceHandle.execute(new Runnable() {
            @Override
            public void run() {
                if (observable != null) {
                    ThreadSchedule.getMainHandle().post(new Runnable() {
                        @Override
                        public void run() {
                            observable.postEvent(data);
                        }
                    });

                }
            }
        });
    }

    /**
     * 釋放資源
     */
    @Override
    public void destroy() {
        executorServiceHandle.shutdownNow();
        executorServiceHandle = null;
    }


}

事件的分發處理,會在一個線程池裏進行,線程池的大小爲Cpu核心數的2倍,當事件過多時會在線程池的隊列中等待,需要注意的是對事件的處理儘量不要做太耗時的任務,不然把線程池中的所有線程都阻塞了會導致整個事件總線阻塞,後面的時間將無法繼續發佈.

小結結

Y事件總線的實現只要是使用了java的Observable和Observer,其內部也是使用一個Vector類保存Observer,在發佈的時候,遍歷這裏列表進行發佈,這也是設計模式中的觀察與被觀察者的模式.