前言#

之前我们聊了观察者模式，那肯定要说说EventBus，我这几天也在看EventBus的源码，整体的流程都已经看过了，也发现了EventBus的优点，但是还有一些小细节还没缕清楚，现在处于一种不知道怎么用语言表达的阶段，所以关于EventBus的源码解析就稍微推迟一下，非常的sorry。

所以就先简单的写一个demo，最后在这个demo的基础上，先简单的说一下EventBus对于几点功能的性能优化。

正文#

首先我们来思考一个问题：是用Java的Obserable和Obsever，还是我们自己来定义观察者和被观察者呢?

我是这么认为的：

1、Obserable和Obsever在语义上，我觉得稍微差了点，并且和一些开源库，例如RxJava，在类的命名上有重复，容易弄混。

2、如果使用Obserable，每一次定义被观察者都得实现一些内部的小细节，也就是要新定义类，而我们往往都是通过String或者int来区分更加方便管理。

所以我觉得还是自己实现整个流程比较方便，那就不废话了，代码走起：

先定义回调函数，观察者来实现此接口。

/**
 * Created by li.zhipeng on 2017/8/4.
 *
 *      EventBus的通知回调函数
 */

public interface EventListener {

    void onEvent(int eventCode, Object object);
}

再定义观察者：

/**
 * Created by li.zhipeng on 2017/8/4.
 * <p>
 * EventBus主体类，实现被观察者分发的主要逻辑
 */

public class EventBus {

    /**
     * 使用单例模式
     */
    private static EventBus instance;

    private EventBus() {
    }

    public synchronized static EventBus getInstance() {
        if (instance == null) {
            instance = new EventBus();
        }
        return instance;
    }


    /**
     * 保存所有的观察者，按照被观察者分类
     * <p>
     * 这里我们使用int类型，作为被观察者的标识,主要是为了使用高效的SparseArray
     * <p>
     * 每一个中被观察者，对应的是HashSet，里面保存了对应的所有观察者
     */
    private SparseArray<HashSet<EventListener>> observables = new SparseArray<>();


    /**
     * 注册观察者方法
     * <p>
     * 添加同步锁，防止注册，通知，移除等操作同时进行引起的异常
     */
    public synchronized void registerEvent(int eventCode, EventListener listener) {
        // 首先在所有的被观察者中找到对一个的集合
        HashSet<EventListener> observers = observables.get(eventCode);
        // 如果没有这个集合，新建集合，并放到里面去
        if (observers == null) {
            observers = new HashSet<>();
            observables.put(eventCode, observers);
        }
        // 添加观察者
        observers.add(listener);
    }

    /**
     * 解绑观察者
     * <p>
     * 添加同步锁，防止注册，通知，移除等操作同时进行引起的异常
     */
    public synchronized void unregisterEvent(int eventCode, EventListener listener) {
        // 首先在所有的被观察者中找到对一个的集合
        HashSet<EventListener> observers = observables.get(eventCode);
        // 从集合中移除这个观察者
        if (observers != null) {
            observers.remove(listener);
        }
    }

    /**
     * 通知对应的观察者，被观察者发生变化的事件
     * <p>
     * 这里我们模仿Observable的做法
     */
    public void sendEvent(int eventCode, Object object) {
        // 先定义一个临时Set集合
        EventListener[] arrLocal;
        // 这里添加同步锁，避免多线程或者是，多操作同时引起的问题
        synchronized (this) {
            arrLocal = toArray(observables.get(eventCode));
        }
        // 开发分发事件
        for (int i = arrLocal.length - 1; i >= 0; i--) {
            arrLocal[i].onEvent(eventCode, object);
        }
    }

    /**
     * HashSet转数组
     * */
    private EventListener[] toArray(HashSet<EventListener> set){
        EventListener[] r = new EventListener[set.size()];
        Iterator<EventListener> it = set.iterator();
        for (int i = 0; i < r.length; i++) {
            r[i] = it.next();
        }
        return r;
    }

    /**
     * 清除所有的观察者
     * */
    public void clear(){
        observables.clear();
    }

}

我们把所有的被观察者和对应的观察者，作为键值对保存在Map中，这样就方便获取和保存，然后注册和解绑去添加或移除观察者，通知实际上就是一个遍历对应的观察者的操作。

使用起来也和之前没有什么太大的区别:

public class MainActivity extends AppCompatActivity implements EventListener{

    private TextView textView;

    private int count;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = (TextView) findViewById(R.id.textView)；
    // 点击发送一个通知变化的事件
        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                EventBus.getInstance().sendEvent(1, "test" + count++);
            }
        });
         // 注册
        EventBus.getInstance().registerEvent(1, this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 解绑
        EventBus.getInstance().unregisterEvent(1, this);
    }
    
    // 实现的回调函数
    @Override
    public void onEvent(int eventCode, Object object) {
        textView.setText((String) object);
    }
}

<h2>EventBus的优化</h2>

实现的中心思想是没有差别的，但是在性能上，肯定还是很粗糙的，例如所有所有的操作都是主线程中，所以并发和耗时都有潜在的问题，那么EventBus是如何优化这些问题的呢？

1、增加队列管理，增加异步通知方式，减轻了主线程的压力。
2、在队列管理的基础上，增加了任务取消的机制，防止重复任务的执行。
3、增加了缓存机制，防止每次通知时创建无意义的对象，减小内存的开销。
4、增加回调函数的执行，是在主线程还是子线程，可以通过注解使用。

总结#

EventBus还有一些非常好的特点，可能我还没发现和说到，但是从他使用的受到众多开发者的欢迎程度，首先说明他稳定可靠，效率也不错，等我再好好的研究他的源码，再仔细的介绍一下。