Guava 12:Guava EventBus源码剖析

系列目录

Guava 1: 概览

Guava 2: Basic utilities基本工具

Guava 3: 集合Collections

Guava 4: Guava cache

Guava 6: Concurrency

Guava 12: Guava EventBus源码剖析

一、架构速读

传统上，Java的进程内事件分发都是通过发布者和订阅者之间的显式注册实现的。设计EventBus就是为了取代这种显示注册方式，使组件间有了更好的解耦。EventBus不是通用型的发布-订阅实现，不适用于进程间通信。

架构图如下：

。

二、简单使用

步骤如下：

1.构造一个事件总线

2.构造一个事件监听器

3.把事件监听器注册到事件总线上

4.事件总线发布事件，触发监听器方法

主测试类如下：

package guava.eventbus;

import com.google.common.eventbus.EventBus;

/**
 * @Description 主测试类
 * @author denny
 * @date 2018/7/18 上午9:54
 */
public class MainTest {


    public static void main(String[] args) {
        // 1.构造一个事件总线
        EventBus eventBus = new EventBus("test");

        // 2.构造一个事件监听器
        EventListener listener = new EventListener();

        // 3.把事件监听器注册到事件总线上
        eventBus.register(listener);

        // 4.事件总线发布事件，触发监听器方法
        eventBus.post(new TestEvent1(1));
        eventBus.post(new TestEvent2(2));
        // 事件3是事件2子类，虽然监听器只订阅了父类事件2，一样可以监听到子类
        eventBus.post(new TestEvent3(3));
        // 未被订阅的事件,用DeadEvent可订阅
        eventBus.post(new TestEvent4(4));
    }
}

事件监听器如下：

package guava.eventbus;

import com.alibaba.fastjson.JSON;
import com.google.common.eventbus.DeadEvent;
import com.google.common.eventbus.Subscribe;

/**
 * @Description 事件监听器
 * @author denny
 * @date 2018/7/18 上午9:53
 */
public class EventListener {

    private int message = 0;

    /**
     * @Description 订阅事件1
     * @param event 事件1
     * @return void
     * @author denny
     * @date 2018/7/18 上午9:46
     */
    @Subscribe
    public void onEvent1(TestEvent1 event) {
        message = event.getMessage();
        System.out.println("EventListener onEvent1 监听器接收到消息:"+message);
    }

    /**
     * @Description 订阅事件2
     * @param event 事件2
     * @return void
     * @author denny
     * @date 2018/7/18 上午9:59
     */
    @Subscribe
    public void onEvent2(TestEvent2 event) {
        message = event.getMessage();
        System.out.println("EventListener onEvent2 监听器接收到消息:"+message);
    }

    /**
     * @Description 死亡事件（该事件没有被订阅会触发）
     * @param event 未订阅事件
     * @return void
     * @author denny
     * @date 2018/7/18 上午9:59
     */
    @Subscribe
    public void onDeadEvent(DeadEvent event) {
        System.out.println("EventListener DeadEvent 有消费没有被订阅！！！！event="+ event.toString());
    }
}

事件类：

package guava.eventbus;

/**
 * @Description 事件1
 * @author denny
 * @date 2018/7/18 上午9:54
 */
public class TestEvent1 {

    private final int message;

    /**
     * 构造方法
     * @param message
     */
    public TestEvent1(int message) {
        this.message = message;
        System.out.println("TestEvent1 事件message:"+message);
    }

    public int getMessage() {
        return message;
    }
}


/**
 * @Description 事件2
 * @author denny
 * @date 2018/7/18 上午9:54
 */
public class TestEvent2 {

    private final int message;

    /**
     * 构造方法
     * @param message
     */
    public TestEvent2(int message) {
        this.message = message;
        System.out.println("TestEvent2 事件message:"+message);
    }

    public int getMessage() {
        return message;
    }
}

/**
 * @Description 事件3
 * @author denny
 * @date 2018/7/18 上午9:54
 */
public class TestEvent3 extends TestEvent2{

    private final int message;

    /**
     * 构造方法
     * @param message
     */
    public TestEvent3(int message) {
        super(message);
        this.message = message;
        System.out.println("TestEvent2 事件message:"+message);
    }

    @Override
    public int getMessage() {
        return message;
    }
}

/**
 * @Description 事件4
 * @author denny
 * @date 2018/7/18 上午9:54
 */
public class TestEvent4 {

    private final int message;

    /**
     * 构造方法
     * @param message
     */
    public TestEvent4(int message) {
        this.message = message;
        System.out.println("TestEvent4 事件message:"+message);
    }

    public int getMessage() {
        return message;
    }
}

运行结果如下：

TestEvent1 事件message:1
EventListener onEvent1 监听器接收到消息:1 ---》触发订阅的事件1
TestEvent2 事件message:2
EventListener onEvent2 监听器接收到消息:2---》触发订阅的事件2（一个监听器可以订阅多个事件）
TestEvent2 事件message:3
TestEvent2 事件message:3
EventListener onEvent2 监听器接收到消息:3---》订阅事件2，可触发订阅子类事件3
TestEvent4 事件message:4
EventListener DeadEvent 有消费没有被订阅！！！！event="DeadEvent{source=EventBus{test}, event=guava.eventbus.TestEvent4@19e1023e}"---》事件4没有被订阅，触发DeadEvent死亡事件。

注意：

1.事件总线EventBus：

不提供单列，用户自己看着用~

2.监听器Listener：

1)监听器使用@Subscribe标记的方法(参数为自定义事件)，即可实现事件的监听。要监听多个事件，就写多个方法(每个方法都用@Subscribe标记)即可。

2)注意一定要把Listener注册到eventbus上。

三、源码剖析

源码版本为：guava-22.0.jar，先来回顾下第一节的样例代码：

public static void main(String[] args) {
        // 1.构造一个事件总线
        EventBus eventBus = new EventBus("test");

        // 2.构造一个事件监听器
        EventListener listener = new EventListener();

        // 3.把事件监听器注册到事件总线上
        eventBus.register(listener);

        // 4.事件总线发布事件，触发监听器方法
        eventBus.post(new TestEvent1(1));
        eventBus.post(new TestEvent2(2));
        // 事件3是事件2子类，虽然监听器只订阅了父类事件2，一样可以监听到子类
        eventBus.post(new TestEvent3(3));
        // deadEvent未被订阅的事件，供用户自行处理
        eventBus.post(new TestEvent4(4));
    }

如上图，虽然是google封装的事件总线，但是依然是观察者模式，那么核心就是发布、订阅。下面就从这两个方面来看一下源码，看看有没有值得借鉴的地方。

 3.1 核心类速读

1.EventBus事件总线

核心方法

register：把监听器中申明的所有订阅事件方法注册到SubscriberRegistry（订阅者注册器）中。

post：发布事件给所有已注册过的订阅者，最终开启线程完成订阅方法。

具体如下图：

@Beta
public class EventBus {
  private final String identifier;//事件总线标识：用于自定义标识这个事件总线
  private final Executor executor;//默认的线程执行器，用于把事件转发给订阅者
  private final SubscriberRegistry subscribers = new SubscriberRegistry(this);//订阅注册器
  private final Dispatcher dispatcher;//事件转发器
 15   //构造器：使用默认字符串
  public EventBus() {
    this("default");
  }
  //构造器：使用自定义字符串
  public EventBus(String identifier) {
    this(
        identifier,
        MoreExecutors.directExecutor(),
        Dispatcher.perThreadDispatchQueue(),
        LoggingHandler.INSTANCE);
  } 58 
  //注册监听者中申明的所有订阅方法（@Subscribe标记的），用以接收事件
  public void register(Object object) {
    subscribers.register(object);
  }
  // 解除订阅
  public void unregister(Object object) {
    subscribers.unregister(object);
  }

  //发布事件给所有已注册过的订阅者
  public void post(Object event) {
        // 找到事件的所有订阅者
    Iterator<Subscriber> eventSubscribers = subscribers.getSubscribers(event);
    if (eventSubscribers.hasNext()) {
          // 事件转发器，把事件转发给订阅者
      dispatcher.dispatch(event, eventSubscribers);
    } else if (!(event instanceof DeadEvent)) {
      // 如果该事件即没有订阅者，也没事DeadEvent,那么封装成DeadEvent并重新发布
      post(new DeadEvent(this, event));
    }
...省略非重要方法167 }

2.Subscriber订阅者

核心方法：dispatchEvent使用executor线程执行器，单独开启线程执行订阅方法。

class Subscriber {

  /**
   * 构造  5    */
  static Subscriber create(EventBus bus, Object listener, Method method) {
    return isDeclaredThreadSafe(method)
        ? new Subscriber(bus, listener, method)
        : new SynchronizedSubscriber(bus, listener, method);
  }

  /** 订阅者所属的事件总线*/
  @Weak private EventBus bus;

  /** 监听器 listener*/
  @VisibleForTesting final Object target;

  /** 订阅者方法 */
  private final Method method;

  /** 线程执行器，用来分发事件给订阅者 */
  private final Executor executor;

  /** 构造器：使用事件总线、监听器、订阅方法 */
  private Subscriber(EventBus bus, Object target, Method method) {
    this.bus = bus;
    this.target = checkNotNull(target);
    this.method = method;
    method.setAccessible(true);

    this.executor = bus.executor();
  }

  /**
   * 使用executor线程执行器，执行订阅方法*/
  final void dispatchEvent(final Object event) {
    executor.execute(
        new Runnable() {
          @Override
          public void run() {
            try {
              invokeSubscriberMethod(event);
            } catch (InvocationTargetException e) {
              bus.handleSubscriberException(e.getCause(), context(event));
            }
          }
        });
  }

  /**
   * 调用订阅者方法*/
  @VisibleForTesting
  void invokeSubscriberMethod(Object event) throws InvocationTargetException {
    try {
      method.invoke(target, checkNotNull(event));
    } catch (IllegalArgumentException e) {
      throw new Error("Method rejected target/argument: " + event, e);
    } catch (IllegalAccessException e) {
      throw new Error("Method became inaccessible: " + event, e);
    } catch (InvocationTargetException e) {
      if (e.getCause() instanceof Error) {
        throw (Error) e.getCause();
      }
      throw e;
    }
  }
...
}

本节我们了解了2个核心类EventBus（注册监听器、发布事件）、Subscriber订阅者（执行订阅方法），下面我们从源码流程上来串连一遍。

 3.2.注册监听器

我们从注册监听器开始看，eventBus.register(listener); 如下图所示：

public void register(Object object) {
    subscribers.register(object);
}

/**
   * 把listener中申明的所有订阅方法都注册
   */
  void register(Object listener) {
       // 获取该监听器类型对应的所有订阅方法，key是事件类型,value是订阅者集合
    Multimap<Class<?>, Subscriber> listenerMethods = findAllSubscribers(listener);
    // 遍历map     Map<K, Collection<V>>
    for (Map.Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) {
      //key:事件类型
　　　　　 Class<?> eventType = entry.getKey();
         //value:订阅者集合
      Collection<Subscriber> eventMethodsInListener = entry.getValue();
      //从subscribers并发map 中获取事件对应的事件订阅者set，subscribers：private final ConcurrentMap<Class<?>, CopyOnWriteArraySet<Subscriber>> subscribers = Maps.newConcurrentMap();
      CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType);
      //不存在，就构造
      if (eventSubscribers == null) {
        CopyOnWriteArraySet<Subscriber> newSet = new CopyOnWriteArraySet<Subscriber>();
        eventSubscribers =
            MoreObjects.firstNonNull(subscribers.putIfAbsent(eventType, newSet), newSet);
      }
      //存在，把订阅者集合添加进subscribers
      eventSubscribers.addAll(eventMethodsInListener);
    }
  }

1.调用SubscriberRegistry的register(listener)来执行注册监听器。

2.register步骤如下：

EventBus-包含-》SubscriberRegistry-包含-》ConcurrentMap<Class<?>, CopyOnWriteArraySet<Subscriber>> subscribers 用以维护事件和订阅者的映射

1). findAllSubscribers从缓存中获取该监听器类型对应的所有订阅方法，key是event class,value是Subscriber集合

2).遍历map，把订阅者集合添加进SubscriberRegistry-》subscribers。

其中findAllSubscribers详细代码如下：

  /**
   * 返回所有该监听器订阅者，以事件分组
   */
  private Multimap<Class<?>, Subscriber> findAllSubscribers(Object listener) {
    Multimap<Class<?>, Subscriber> methodsInListener = HashMultimap.create();
    Class<?> clazz = listener.getClass();
       //从缓存中获取该监听器类型对应的所有订阅方法，遍历塞进Multimap
    for (Method method : getAnnotatedMethods(clazz)) {
      Class<?>[] parameterTypes = method.getParameterTypes();
      Class<?> eventType = parameterTypes[0];
      methodsInListener.put(eventType, Subscriber.create(bus, listener, method));
    }
    return methodsInListener;
  }

如上图，

1.方法getAnnotatedMethods：从缓存中取 listener中订阅方法的不可变列表，

2.遍历塞进Multimap：一个key,多个value，每次put进去，往Collection<V>中add(value)。

getAnnotatedMethods源码如下：

private static ImmutableList<Method> getAnnotatedMethods(Class<?> clazz) {
    return subscriberMethodsCache.getUnchecked(clazz);
  }

private static final LoadingCache<Class<?>, ImmutableList<Method>> subscriberMethodsCache =
      CacheBuilder.newBuilder()
          .weakKeys()
          .build(
              new CacheLoader<Class<?>, ImmutableList<Method>>() {
                @Override
                public ImmutableList<Method> load(Class<?> concreteClass) throws Exception {
                  return getAnnotatedMethodsNotCached(concreteClass);
                }
              });

如上图，我们发现这里用到了google cache来做缓存，关于google cache飞机票。

这个cache的源码注释翻译如下：一个线程安全的缓存，包含从每个类到该类中的所有方法和所有超类的映射，这些超类都用{@code @Subscribe}注释。缓存是跨该类的所有实例共享的;如果创建了多个EventBus实例，并且在所有这些实例上注册了同一个类的对象，这将大大提高性能。

值得借鉴点：EventBus-包含->SubscriberRegistry-->static final subscriberMethodsCache,即所有EventBus类的实例共享一个静态cache,性能高且线程安全。

下面来看看具体怎么获取的订阅事件方法（监听器@Subscribe注解的订阅事件方法），核心方法getAnnotatedMethodsNotCached如下：

private static ImmutableList<Method> getAnnotatedMethodsNotCached(Class<?> clazz) {
       //获取超类class集合
    Set<? extends Class<?>> supertypes = TypeToken.of(clazz).getTypes().rawTypes();
    Map<MethodIdentifier, Method> identifiers = Maps.newHashMap();
　　　　//遍历超类
    for (Class<?> supertype : supertypes) {
 5     　　//遍历超类中的所有定义的方法　　
       　　for (Method method : supertype.getDeclaredMethods()) {
           //如果方法上有@Subscribe注解
        if (method.isAnnotationPresent(Subscribe.class) && !method.isSynthetic()) {
          // 方法的参数类型数组
          Class<?>[] parameterTypes = method.getParameterTypes();
          // 校验：事件订阅方法必须只能有一个参数，即事件类
　　　　　　　　checkArgument(
              parameterTypes.length == 1,
              "Method %s has @Subscribe annotation but has %s parameters."
                  + "Subscriber methods must have exactly 1 parameter.",
              method,
              parameterTypes.length);
　　　　　　// 封装方法定义对象
          MethodIdentifier ident = new MethodIdentifier(method);
　　　　　　　　// 去重并添加进map
          if (!identifiers.containsKey(ident)) {
            identifiers.put(ident, method);
          }
        }
      }
    }
　　　　// map转ImmutableList
    return ImmutableList.copyOf(identifiers.values());
  }

3.3 发布事件

eventBus.post(new TestEvent1(1));

调用事件转发器Dispatcher，分发事件给订阅者,

public void post(Object event) {
      //从注册器中获取当前事件对应的订阅者集合：eventBus-包含-》SubscriberRegistry-包含-》ConcurrentMap<Class<?>, CopyOnWriteArraySet<Subscriber>> subscribers
    Iterator<Subscriber> eventSubscribers = subscribers.getSubscribers(event);
    if (eventSubscribers.hasNext()) {
      dispatcher.dispatch(event, eventSubscribers);
    } else if (!(event instanceof DeadEvent)) {
      //如果该事件即没有订阅者，也没事DeadEvent,那么封装成DeadEvent并重新发布
7       post(new DeadEvent(this, event)); 
    } 
}

Dispatcher是个抽象类，有多个内部类复写不同dispatch方法。EventBus默认构造时使用PerThreadQueuedDispatcher，即每个线程一个待转发事件队列。如下图所示：

  private static final class PerThreadQueuedDispatcher extends Dispatcher {

    // This dispatcher matches the original dispatch behavior of EventBus.

    /**
     * 每个线程待转发事件队列
     */
    private final ThreadLocal<Queue<Event>> queue =
        new ThreadLocal<Queue<Event>>() {
          @Override
          protected Queue<Event> initialValue() {
            return Queues.newArrayDeque();
          }
        };

    /**
     * 每个线程的转发状态，用于避免重入事件转发，初始化状态为fasle,即不在转发。
     */
    private final ThreadLocal<Boolean> dispatching =
        new ThreadLocal<Boolean>() {
          @Override
          protected Boolean initialValue() {
            return false;
          }
        };

    @Override
    void dispatch(Object event, Iterator<Subscriber> subscribers) {
      checkNotNull(event);
      checkNotNull(subscribers);
      Queue<Event> queueForThread = queue.get();
         // 事件添加进队列
      queueForThread.offer(new Event(event, subscribers));
      // 当前不在转发中，开始转发
      if (!dispatching.get()) {
        dispatching.set(true);
        try {
          Event nextEvent;
             // 迭代从线程队列中取事件
          while ((nextEvent = queueForThread.poll()) != null) {
               // 迭代事件的Iterator<Subscriber> subscribers,调用订阅者转发事件
            while (nextEvent.subscribers.hasNext()) {
              nextEvent.subscribers.next().dispatchEvent(nextEvent.event);
            }
          }
        } finally {
          dispatching.remove();
          queue.remove();
        }
      }
    }

    private static final class Event {
      private final Object event;
      private final Iterator<Subscriber> subscribers;

      private Event(Object event, Iterator<Subscriber> subscribers) {
        this.event = event;
        this.subscribers = subscribers;
      }
    }
  }

可见核心方法在dispatchEvent，调用订阅者转发事件

  final void dispatchEvent(final Object event) {
    executor.execute(
        new Runnable() {
          @Override
          public void run() {
            try {
              invokeSubscriberMethod(event);
            } catch (InvocationTargetException e) {
              bus.handleSubscriberException(e.getCause(), context(event));
            }
          }
        });
  }

  /**
   * 执行订阅者方法18    */
  @VisibleForTesting
  void invokeSubscriberMethod(Object event) throws InvocationTargetException {
    try {
      method.invoke(target, checkNotNull(event));
    } catch (IllegalArgumentException e) {
      throw new Error("Method rejected target/argument: " + event, e);
    } catch (IllegalAccessException e) {
      throw new Error("Method became inaccessible: " + event, e);
    } catch (InvocationTargetException e) {
      if (e.getCause() instanceof Error) {
        throw (Error) e.getCause();
      }
      throw e;
    }
  }

四、总结

本文我们先快速了解Google EventBus总体架构,然后从一个简单的应用入手知道如何使用，再深入剖析源码彻底了解原理，并分析了有哪些值得借鉴的地方，最后我们来看一下传统观察者模式和EventBus的区别：

传统观察者模式和EventBus区别

	监听者管理	监听特定事件	把监听者注册到生产者	按事件超类监听	检测没有监听者的事件	分发事件
传统观察者模式	用列表管理监听者，还要考虑线程同步；或者使用工具类	定义相应的事件监听者类	调用事件生产者的register方法，开发者必须知道所有事件生产者的类型，才能正确地注册监听者	很困难，需要开发者自己去实现匹配逻辑	在每个事件分发方法中添加逻辑代码	开发者自己写代码，包括事件类型匹配、异常处理、异步分发
EventBus	内部已经实现了监听者管理	以自定义Event为唯一参数创建方法， 并用Subscribe注解标记。	EventBus.register(Object)	EventBus自动把事件分发给事件超类的监听者	EventBus会把所有发布后没有监听者处理的事件包装为DeadEvent	EventBus.post(Object) 异步分发可以直接用EventBus的子类AsyncEventBus

 

==参考==

官方介绍https://github.com/google/guava/wiki/EventBusExplained