组件化代替EventBus的通信

对于组件化的通信，不能再持有对方的引用了。

前面写了一个ui通信工具，从实际工作中进行考虑，改造了下，封装了jdk的原生观察者模式。

直接上代码：

import android.os.Bundle;
import android.os.SystemClock;

import java.util.HashMap;
import java.util.Observable;
import java.util.Observer;

public class EventMng {

    public static void main(String args[]) {
        EventMng.registObserver(new EventObserver("play") {
            @Override
            public void onNotify(Bundle data) {
                System.out.println("通知数据:" + data);
            }
        });


        Bundle bundle = new Bundle();
        bundle.putString("key", "first blood");
        EventMng.notify("play", bundle);
    }


    private EventMng() {
    }


    private static HashMap<String, Event> eventHashMap = new HashMap<>();


    /**
     * 观察者观察某类事件,该类事件统称事件A，对应一个事件源eventA
     *
     * @param o
     */
    public static void registObserver(EventObserver o) {
        String name = o.getmEventName();

        if (eventHashMap.containsKey(name)) {
            eventHashMap.get(name).addObserver(o);
            return;
        }

        Event event = new Event();
        event.addObserver(o);

        eventHashMap.put(name, event);
    }


    public static void unRegitst(String eventName) {

        if (eventHashMap.containsKey(eventName)) {
            eventHashMap.get(eventName).deleteObservers();
        }
    }

    public static void unRegitstAll() {

        for (Event e : eventHashMap.values()) {
            e.deleteObservers();
        }
    }


    public static void notify(String eventName, Bundle data) {
        Event event = eventHashMap.get(eventName);
        if (event == null) {
            return;
        }
        data = data == null ? new Bundle() : data;
        event.onEvent(data);
    }


    private static class Event extends Observable {


        final long[] mHits = new long[2];

        private Bundle data;
        private long time = 16;//ms

        private void onEvent(Bundle data) {

            System.arraycopy(mHits, 1, mHits, 0, mHits.length - 1);
            mHits[mHits.length - 1] = SystemClock.uptimeMillis();
            if (mHits[0] >= SystemClock.uptimeMillis() - time) {
                return;
            }

            this.data = data;
            setChanged();
            notifyObservers();

        }

        Bundle getData() {
            return data;
        }
    }


    public static abstract class EventObserver implements Observer {

        private String mEventName;//绑定的事件名

        String getmEventName() {
            return mEventName;
        }

        public EventObserver(String mEventName) {
            this.mEventName = mEventName;
        }

        public abstract void onNotify(Bundle data);

        @Override
        public void update(Observable o, Object arg) {
            onNotify(((Event) o).getData());
        }
    }
}

非常简洁紧凑，使用也非常方便。

主要思路就是每一个事件源对应一个业务中的某类事件(比如命名为play)，那么就用play来注册代表观察者对象关注这类事件。

在需要触发该业务的地方，以该命名为标记通知该类事件要触发了，该类的关注者会自动的接受到变化信息，并接受到相应数据。