一、概述
Android原生有个HandlerThread,从字面上便可看出,这是一个异步事件分发线程。配合Handler一起使用,便可实现一个简单的EventBus。
代码实现在细节上的考虑
1. 组件的销毁,如果不是贯穿整个进程的生命周期,则不需要时可以销毁它,节省内存。
2. 定义一个事件监听器接口,通过泛型来定义事件类型。
3. 监听器对象存储,通过虚引用来存储监听器对象,防止内存泄漏。
4. 并发问题,利用synchronized来处理并发问题。
二、代码实现
package com.example.utils;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.support.annotation.Nullable;
import android.support.v4.util.ArraySet;
import android.util.Log;
import java.lang.ref.WeakReference;
import java.util.Iterator;
/**
* Created by zqil on 2018/2/5.
*/
public class ZEventBus<T> {
private Handler mHandler = null;
private ArraySet<WeakReference<EventListener<T>>> listeners = new ArraySet<>();
public interface EventListener<T> {
void onEvent(T t);
}
public ZEventBus(String name) {
HandlerThread thread = new HandlerThread(name);
thread.start();
mHandler = new EventHandler<>(thread.getLooper(), this);
}
public synchronized void destroy() {
if (mHandler != null) {
mHandler.getLooper().quit();
mHandler = null;
}
}
public boolean isDestroyed() {
if (mHandler == null) {
Log.d(ZEventBus.class.getSimpleName(), "EventBus is destroyed !");
return true;
}
return false;
}
private static class EventHandler<T> extends Handler {
private WeakReference<ZEventBus<T>> mWeakRef = null;
public EventHandler(Looper looper, ZEventBus<T> eventBus) {
super(looper);
this.mWeakRef = new WeakReference<ZEventBus<T>>(eventBus);
}
private static final int MSG_NOTIFY_EVENT = 1;
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
ZEventBus<T> eventBus = mWeakRef != null ? mWeakRef.get() : null;
if (eventBus == null) {
return;
}
switch (msg.what) {
case MSG_NOTIFY_EVENT:
eventBus.doNotifyEvent((T) msg.obj);
break;
default:
break;
}
}
}
public synchronized void notifyEvent(T t) {
if (isDestroyed()) {
return;
}
mHandler.obtainMessage(EventHandler.MSG_NOTIFY_EVENT, t).sendToTarget();
}
private void doNotifyEvent(T t) {
Iterator<WeakReference<EventListener<T>>> it = listeners.iterator();
while (it.hasNext()) {
WeakReference<EventListener<T>> weakRef = it.next();
EventListener<T> listener = weakRef != null ? weakRef.get() : null;
if (listener != null) {
listener.onEvent(t);
} else {
it.remove();
}
}
}
@Nullable
private WeakReference<EventListener<T>> findListener(EventListener listener) {
Iterator<WeakReference<EventListener<T>>> it = listeners.iterator();
while (it.hasNext()) {
WeakReference<EventListener<T>> weakRef = it.next();
EventListener<T> exist = weakRef != null ? weakRef.get() : null;
if (exist == null) {
it.remove();
} else if (exist == listener) {
return weakRef;
}
}
return null;
}
public synchronized void addListener(EventListener listener) {
if (findListener(listener) == null) {
listeners.add(new WeakReference<EventListener<T>>(listener));
}
}
public synchronized void removeListener(EventListener listener) {
WeakReference<EventListener<T>> weakRef = findListener(listener);
if (weakRef != null) {
listeners.remove(weakRef);
}
}
}