EventBus编程思想-实现简易版EventBus

Posted 2022-12-06 0 and 1

这是编程思想系列的第二篇，这里挑选用的比较多的EventBus讲解一下，不纠结实现细节。先理解设计思想，这也是研究学习开源框架的第一步。
代码：点击GitHub
一个开源框架的出现肯定是有原因的，便捷，性能基本离不开这两点。而EventBus设计的初衷应该是为了便捷。回想自己为什么要使用EventBus就明白了。简单提两句

组件通信方式

Intent：使用它实现组件跳转，并且能携带参数，但只能携带少量数据，同时在跨组件通信时局限性比较大
Handler：使用Handler进行组件通信耦合严重，容易造成内存泄漏
Broadcast：使用广播进行组件通信效率不高，安全性不高
Interface：不能跨线程通信
aidl：使用成本高
看了上面这些，是不是就明白了为什么会有EventBus的原因了吧。
设计框架的过程像是做一个产品。你首先要想一下设计这个框架的目的是什么？需求在哪里？存在即合理，
抛开源码，我们先想一想？如果要做一个组件之间通信工具，如何设计？。既然是为了方便，那么我们想怎么使用它呢？想让它有什么功能。可能会想到下面三点，（也可能想不到，哈哈），能想到的都是好的产品经理。。。
（1）在任意地方，发射数据。
（2）在任意地方，接收数据。
（3）可以指定接收数据的线程。

这个过程，类似产品经理根据需求设计产品的过程。然后我们根据图纸去实现。给我们的产品取一个名字吧：EventBus,其实我更喜欢叫DataBus,名字而已。萝卜青菜，各有所爱。想法有了，如何实现呢？操作起来，是不是可以运用设计模式中的观察者模式。
观察者（订阅者）：任意类下的任意方法
被观察者（被订阅者）：数据（任意类发射的数据）

实现思路

通过注解形式，标记观察者，然后被观察者提供订阅方法，通过注解扫描，把所有的观察者注入到容器中。被观察者提供发射数据的方法，遍历容器找到接收数据的方法（通过参数类型区分），然后通过反射方式调用观察者的方法。这就实现了被观察者发射数据通知观察者的需求。

代码实现

定义注解：Subscribe

@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Subscribe 
    ThreadMode threadMode() default ThreadMode.POSTING;

定义EventBus 的行为：IBus。其实就是约定用户如何使用

public interface IBus 

    /**
     * 订阅
     */
    void register(Object subscriber);

    /**
     * 取消订阅,防止内存泄露
     */
    void unRegister(Object subscriber);

    /**
     * 发射数据
     *
     * @param data
     */
    void send(Object data);

订阅者对象模型：SubscriptionMethod

public class SubscriptionMethod 
    private Method method;
    private Class<?> type;
    private ThreadMode threadMode;

    public Method getMethod() 
        return method;
    

    public void setMethod(Method method) 
        this.method = method;
    

    public Class<?> getType() 
        return type;
    

    public void setType(Class<?> type) 
        this.type = type;
    

    public ThreadMode getThreadMode() 
        return threadMode;
    

    public void setThreadMode(ThreadMode threadMode) 
        this.threadMode = threadMode;
    

线程模型枚举

public enum ThreadMode 
    POSTING,
    MAIN,
    BACKGROUND,
    ASYNC

被观察者：EventBus
mSubcription：保存观察者的容器
eventBusHelper 帮助类，做注解扫描，线程管理。 类的职责不能过重（遵循单一职责原则）

public class EventBus implements IBus
/**
* 订阅方法
* key 订阅类
* value 类中的订阅方法集合
*/
private final Map<Object, List> mSubcription;
private final EventBusHelper eventBusHelper;

private EventBus() 
    eventBusHelper = new EventBusHelper();
    this.mSubcription = new HashMap<>();


private static class Instance 
    private static final EventBus instance = new EventBus();


public static EventBus getInstance() 
    return Instance.instance;


@Override
public void register(Object subscriber) 
    List<SubscriptionMethod> methodList = mSubcription.get(subscriber);
    if (methodList == null || methodList.size() == 0) 
        methodList = new ArrayList<>();
        Class<?> clazz = subscriber.getClass();
        while (clazz != null) 
            String className = clazz.getName();
            if (className.startsWith("java.") || className.startsWith("javax.") || className.startsWith("android.")) 
                break;
            
            eventBusHelper.findAnnotationMethod(methodList, clazz);
            //查找父类，有继承关系
            clazz = clazz.getSuperclass();
        
        mSubcription.put(subscriber, methodList);
    


@Override
public void send(Object event) 
    if (mSubcription.size() == 0) 
        return;
    
    Set<Object> set = mSubcription.keySet();
    Iterator<Object> iterable = set.iterator();
    while (iterable.hasNext()) 
        Object next = iterable.next();
        List<SubscriptionMethod> methodList = mSubcription.get(next);
        if (methodList == null) 
            continue;
        
        int size = methodList.size();
        for (int i = 0; i < size; i++) 
            SubscriptionMethod method = methodList.get(i);
            //method.getType()是获取方法参数类型，这里是判断发布的对象类型是否与订阅方法的参数类型一致
            if (method.getType().isAssignableFrom(event.getClass())) 
                eventBusHelper.invokeWithThread(next, method, event);
            
        
    


@Override
public void unRegister(Object target) 
    List<SubscriptionMethod> methodList = mSubcription.get(target);
    if (methodList == null) return;
    methodList.clear();
    mSubcription.remove(target);

帮助类：EventBusHelper，把注解扫描的代码抽离出来，避免被观察者EventBus职责过重，遵循单一职责的原则

class EventBusHelper 
    private final Handler mHandler;
    private final ExecutorService mExecutorService;

    public EventBusHelper() 
        this.mHandler = new Handler(Looper.getMainLooper());
        this.mExecutorService = Executors.newCachedThreadPool();
    

    public void findAnnotationMethod(List<SubscriptionMethod> methodList, Class<?> clazz) 
        Method[] m = clazz.getDeclaredMethods();
        int size = m.length;
        for (int i = 0; i < size; i++) 
            Method method = m[i];
            Subscribe annotation = method.getAnnotation(Subscribe.class);
            if (annotation == null) 
                continue;
            
            Type genericReturnType = method.getGenericReturnType();
            if (!"void".equals(genericReturnType.toString())) 
                throw new EventBusException("方法返回值必须是void");
            
            int modifiers = method.getModifiers();
            if ((modifiers & Modifier.PUBLIC) != 1) 
                throw new EventBusException("方法修饰符必须是public，且是非静态，非抽象");
            
            Class<?>[] parameterTypes = method.getParameterTypes();
            if (parameterTypes.length != 1) 
                throw new EventBusException("方法参数个数必须是一个");
            

            //这里就需要实例化订阅方法对象了
            SubscriptionMethod subscriptionMethod = new SubscriptionMethod();
            subscriptionMethod.setMethod(method);
            subscriptionMethod.setType(parameterTypes[0]);
            subscriptionMethod.setThreadMode(annotation.threadMode());
            methodList.add(subscriptionMethod);
        
    


    public void invokeWithThread(final Object next, final SubscriptionMethod method, final Object event) 
        //进行线程切换
        switch (method.getThreadMode()) 
            case POSTING:
                invoke(next, method, event);
                break;
            case MAIN:
                //通过Looper判断当前线程是否是主线程
                //也可以通过线程名判断 "main".equals(Thread.currentThread().getName())
                if (Looper.getMainLooper() == Looper.myLooper()) 
                    invoke(next, method, event);
                 else 
                    mHandler.post(new Runnable() 
                        @Override
                        public void run() 
                            invoke(next, method, event);
                        
                    );
                
                break;
            case BACKGROUND:
                if (Looper.getMainLooper() == Looper.myLooper()) 
                    mExecutorService.execute(new Runnable() 
                        @Override
                        public void run() 
                            invoke(next, method, event);
                        
                    );
                 else 
                    invoke(next, method, event);
                
                break;
            case ASYNC:
                mExecutorService.execute(new Runnable() 
                    @Override
                    public void run() 
                        invoke(next, method, event);
                    
                );
                break;
        
    

    private void invoke(Object next, SubscriptionMethod method, Object event) 
        Method m = method.getMethod();
        try 
            m.invoke(next, event);
         catch (IllegalAccessException e) 
            e.printStackTrace();
         catch (InvocationTargetException e) 
            e.printStackTrace();
        
    

大功告成，开始使用

public class MainActivity extends AppCompatActivity 

    @Override
    protected void onCreate(Bundle savedInstanceState) 
        super.onCreate(savedInstanceState);
        EventBus.getInstance().register(this);
        setContentView(R.layout.activity_main);
        new Thread(new Runnable() 
            @Override
            public void run() 
                EventBus.getInstance().send(new Message(1, "activity启动了"));
            
        ).start();
    

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void eventBus(Message message) 
        Log.i("event_bus", message.getMsg());
    

    @Override
    protected void onDestroy() 
        super.onDestroy();
        EventBus.getInstance().unRegister(this);
    

以上如果有理解不对，或者代码错误的地方，请大神在评论区留言，谢谢！