EventBus

最新推荐文章于 2024-05-23 16:46:28 发布
最新推荐文章于 2024-05-23 16:46:28 发布
阅读量1.2k 收藏 1
点赞数

目录

1. 创建EventBus

2. 创建Listener

3. 把Listener注册到EventBus上：eventBus.register(listener)

3.1 获得listener对应的所有订阅方法Multimap<Class<?>,EventSubscriber>

3.1.1 findAllSubscribers(listener)

3.1.2 EventSubscriber订阅器

3.2 获取事件对应的事件订阅者Set

4. 事件总线发布事件，触发监听器方法：eventBus.post(event)

4.1 根据缓存得到event及其子类Set<Class<?>> dispatchTypes

4.2 将EventSubscriber添加进转发队列：enqueueEvent(event, wrapper);

4.3 转发队列中event事件：dispatchQueuedEvents()

4.4 DeadEvent

5. 总结

步骤：

  1. 构造一个事件总线EventBus
  2. 构造一个事件监听器Listener
  3. 把事件监听器注册到事件总线上EventBus#register(listener)
  4. 事件总线发布事件，触发监听器方法EventBus#post(event)

1. 创建EventBus

EventBus eventBus = new EventBus()

构造方法：

private SubscriberExceptionHandler subscriberExceptionHandler;

  /**
   * Creates a new EventBus named "default".
   */
  public EventBus() {
    this("default");
  }

  /**
   * Creates a new EventBus with the given {@code identifier}.
   *
   * @param identifier  a brief name for this bus, for logging purposes.  Should
   *                    be a valid Java identifier.
   */
  public EventBus(String identifier) {
    this(new LoggingSubscriberExceptionHandler(identifier));
  }

  /**
   * Creates a new EventBus with the given {@link SubscriberExceptionHandler}.
   * 
   * @param subscriberExceptionHandler Handler for subscriber exceptions.
   * @since 16.0
   */
  public EventBus(SubscriberExceptionHandler subscriberExceptionHandler) {
    this.subscriberExceptionHandler = checkNotNull(subscriberExceptionHandler);
  }

2. 创建Listener

通过@Subscribe将类的方法注解为listener。

例如：

public class FruitEaterListener {
    private final static Logger LOGGER = LoggerFactory.getLogger(FruitEaterListener.class);

    @Subscribe
    public void eat(Fruit event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Fruit eat[{}]. ", event);
        }
    }
    @Subscribe
    public void eat(Apple event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Apple eat[{}]. ", event);
        }
    }
}

3. 把Listener注册到EventBus上：eventBus.register(listener)

  1. 获得listener对应的所有订阅方法Multimap<Class<?>, EventSubscriber>
  2. 从methodsInListener并发map中获取事件对应的事件订阅者set
private final SubscriberFindingStrategy finder = new AnnotatedSubscriberFinder();
private final SetMultimap<Class<?>, EventSubscriber> subscribersByType =
      HashMultimap.create();
public void register(Object listener) {
    //1. 获取该监听器类型对应的所有订阅方法，key是事件类型,value是订阅者集合
    //Multimap实例（它是Google Guava集合框架提供的一个多值Map类型，也就是说一个key可以对应多个
    //value），该Multimap用于存储事件类型对应的该订阅者内所有关于该事件的处理器方法集合，
    //其key为事件的Class类型。
    Multimap<Class<?>, EventSubscriber> methodsInListener =
        finder.findAllSubscribers(listener);
    subscribersByTypeLock.writeLock().lock();
    try {
      //2. 从methodsInListener并发map中获取事件对应的事件订阅者set
      subscribersByType.putAll(methodsInListener);
    } 
    finally {
      subscribersByTypeLock.writeLock().unlock();
    }
  }

3.1 获得listener对应的所有订阅方法Multimap<Class<?>, EventSubscriber>

3.1.1 findAllSubscribers(listener)

SubscriberFindingStrategy 接口，通过实现类AnnotatedSubscriberFinder（收集所有被@Subscribe注解的订阅者方法）实例化finder，fider.findAllSubscribers(listener)

过程：

  1. 通过反射得到listener的class类
  2. 从缓存中获取listener类型对应的所有订阅方法
  3. 将订阅方法封装为一个EventSubscriber
  4. 事件类eventType<-->事件订阅方法eventSbuscriber
class AnnotatedSubscriberFinder implements SubscriberFindingStrategy {
/**
* 返回所有该监听器订阅者，以事件分组
*所有很有可能某个订阅者其父类（或者父类实现的某个接口）也订阅了某个事件。
*因此这里的查找需要顺着继承链向上查找父类的方法是否也被注解标注
*/
  @Override
  public Multimap<Class<?>, EventSubscriber> findAllSubscribers(Object listener) {
    Multimap<Class<?>, EventSubscriber> methodsInListener = HashMultimap.create();
    //1.通过反射得到listener的class类
    Class<?> clazz = listener.getClass();
    //2.从缓存中获取该监听器类型对应的所有订阅方法，遍历塞进Multimap
    for (Method method : getAnnotatedMethods(clazz)) {
      Class<?>[] parameterTypes = method.getParameterTypes();
      Class<?> eventType = parameterTypes[0];
      //将订阅方法封装为一个EventSubscriber
      EventSubscriber subscriber = makeSubscriber(listener, method);
      //事件类eventType<->事件订阅方法EventSubscriber 
      methodsInListener.put(eventType, subscriber);
    }
    return methodsInListener;
  }

//从缓存中取 listener中订阅方法的不可变列表

private static ImmutableList<Method> getAnnotatedMethods(Class<?> clazz) {
    try {
      return subscriberMethodsCache.getUnchecked(clazz);
    } catch (UncheckedExecutionException e) {
      throw Throwables.propagate(e.getCause());
    }
  }

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 getAnnotatedMethodsInternal(concreteClass);
            }
          });

//一个线程安全的缓存，包含从每个类到该类中的所有方法和所有超类的映射，这些超类都用
//{@code @Subscribe}注释。缓存是跨该类的所有实例共享的;如果创建了多个EventBus实例，
//并且在所有这些实例上注册了同一个类的对象，这将大大提高性能。
//所有很有可能某个订阅者其父类（或者父类实现的某个接口）也订阅了某个事件。
//因此这里的查找需要顺着继承链向上查找父类的方法是否也被注解标注
private static ImmutableList<Method> getAnnotatedMethodsInternal(Class<?> clazz) {
    //获取超类class集合
    Set<? extends Class<?>> supers = TypeToken.of(clazz).getTypes().rawTypes();
    Map<MethodIdentifier, Method> identifiers = Maps.newHashMap();
    //遍历超类
    for (Class<?> superClazz : supers) {
      //遍历超类中的所有定义的方法　
      for (Method superClazzMethod : superClazz.getMethods()) {
        //如果方法上有@Subscribe注解
        if (superClazzMethod.isAnnotationPresent(Subscribe.class)
            && !superClazzMethod.isBridge()) {
          // 方法的参数类型数组
          Class<?>[] parameterTypes = superClazzMethod.getParameterTypes();
          // 校验：事件订阅方法必须只能有一个参数，即事件类
          if (parameterTypes.length != 1) {
            throw new IllegalArgumentException("Method " + superClazzMethod
                + " has @Subscribe annotation, but requires " + parameterTypes.length
                + " arguments.  Event subscriber methods must require a single argument.");
          }
          // 封装方法定义对象
          MethodIdentifier ident = new MethodIdentifier(superClazzMethod);
          // 去重并添加进map
          if (!identifiers.containsKey(ident)) {
            identifiers.put(ident, superClazzMethod);
          }
        }
      }
    }
    // map转ImmutableList
    return ImmutableList.copyOf(identifiers.values());
  }
}

3.1.2 EventSubscriber订阅器

class EventSubscriber {
 /** Object sporting the subscriber method. */
/** 监听器 listener*/
  private final Object target;
  /** Subscriber method. */
/** 订阅者方法 */
  private final Method method;

  /**
   * Creates a new EventSubscriber to wrap {@code method} on @{code target}.
   *
   * @param target  object to which the method applies.
   * @param method  subscriber method.
   */
  EventSubscriber(Object target, Method method) {
    Preconditions.checkNotNull(target,
        "EventSubscriber target cannot be null.");
    Preconditions.checkNotNull(method, "EventSubscriber method cannot be null.");

    this.target = target;
    this.method = method;
    method.setAccessible(true);
  }

  /**
   * Invokes the wrapped subscriber method to handle {@code event}.
   *
   * @param event  event to handle
   * @throws InvocationTargetException  if the wrapped method throws any
   *     {@link Throwable} that is not an {@link Error} ({@code Error} instances are
   *     propagated as-is).
   */
  public void handleEvent(Object event) throws InvocationTargetException {
    checkNotNull(event);
    try {
      method.invoke(target, new Object[] { 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;
    }
  }
}

3.2 获取事件对应的事件订阅者Set

private final SetMultimap<Class<?>, EventSubscriber> subscribersByType =
      HashMultimap.create();
private final ReadWriteLock subscribersByTypeLock = new ReentrantReadWriteLock();


  public void register(Object object) {
    ...

    subscribersByTypeLock.writeLock().lock();
    try {
      subscribersByType.putAll(methodsInListener);
    } finally {
      subscribersByTypeLock.writeLock().unlock();
    }
  }

  /**
   * Stores all key-value pairs of {@code multimap} in this multimap, in the
   * order returned by {@code multimap.entries()}.
   *
   * @return {@code true} if the multimap changed
   */
  boolean putAll(Multimap<? extends K, ? extends V> multimap);

4. 事件总线发布事件，触发监听器方法：eventBus.post(event)

  1. 根据缓存得到event及其子类（eventType）
  2. 将每种eventType对应的EventSubscriber添加进转发队列
  3. 转发队列中event
  /**
   * Posts an event to all registered subscribers.  This method will return
   * successfully after the event has been posted to all subscribers, and
   * regardless of any exceptions thrown by subscribers.
   *
   * <p>If no subscribers have been subscribed for {@code event}'s class, and
   * {@code event} is not already a {@link DeadEvent}, it will be wrapped in a
   * DeadEvent and reposted.
   *
   * @param event  event to post.
   */
  public void post(Object event) {
    //1.根据缓存得到event及其子类
    Set<Class<?>> dispatchTypes = flattenHierarchy(event.getClass());

    boolean dispatched = false;
    for (Class<?> eventType : dispatchTypes) {
      subscribersByTypeLock.readLock().lock();
      try {
        Set<EventSubscriber> wrappers = subscribersByType.get(eventType);

        if (!wrappers.isEmpty()) {
          dispatched = true;
          for (EventSubscriber wrapper : wrappers) {
            //2.将每种eventType对应的EventSubscriber添加进转发队列
            enqueueEvent(event, wrapper);
          }
        }
      } finally {
        subscribersByTypeLock.readLock().unlock();
      }
    }
    //如果该事件即没有订阅者，也没事DeadEvent,那么封装成DeadEvent并重新发布
    if (!dispatched && !(event instanceof DeadEvent)) {
      post(new DeadEvent(this, event));
    }

    //3.转发队列中event
    dispatchQueuedEvents();
  }

4.1 根据缓存得到event及其子类Set<Class<?>> dispatchTypes

  /**
   * Flattens a class's type hierarchy into a set of Class objects.  The set
   * will include all superclasses (transitively), and all interfaces
   * implemented by these superclasses.
   *
   * @param concreteClass  class whose type hierarchy will be retrieved.
   * @return {@code clazz}'s complete type hierarchy, flattened and uniqued.
   */
  @VisibleForTesting
  Set<Class<?>> flattenHierarchy(Class<?> concreteClass) {
    try {
      return flattenHierarchyCache.getUnchecked(concreteClass);
    } catch (UncheckedExecutionException e) {
      throw Throwables.propagate(e.getCause());
    }
  }

  /**
   * A thread-safe cache for flattenHierarchy(). The Class class is immutable. This cache 
   * is shared across all EventBus instances, which greatly improves performance if 
   * multiple such instances are created and objects of the same class are posted 
   *on all of them.
   */
  private static final LoadingCache<Class<?>, Set<Class<?>>> flattenHierarchyCache =
      CacheBuilder.newBuilder()
          .weakKeys()
          .build(new CacheLoader<Class<?>, Set<Class<?>>>() {
            @SuppressWarnings({"unchecked", "rawtypes"}) // safe cast
            @Override
            public Set<Class<?>> load(Class<?> concreteClass) {
              return (Set) TypeToken.of(concreteClass).getTypes().rawTypes();
            }
          });

4.2 将EventSubscriber添加进转发队列：enqueueEvent(event, wrapper);

每个线程待转发队列eventsToDispatch  ->  .get()得到Queue<EventWithSubscriber>  ->  .offer()事件添加进队列

  /**
   * Queue the {@code event} for dispatch during
   * {@link #dispatchQueuedEvents()}. Events are queued in-order of occurrence
   * so they can be dispatched in the same order.
   */
  void enqueueEvent(Object event, EventSubscriber subscriber) {
    eventsToDispatch.get().offer(new EventWithSubscriber(event, subscriber));
  }

  /** queues of events for the current thread to dispatch */
  private final ThreadLocal<Queue<EventWithSubscriber>> eventsToDispatch =
      new ThreadLocal<Queue<EventWithSubscriber>>() {
    @Override protected Queue<EventWithSubscriber> initialValue() {
      return new LinkedList<EventWithSubscriber>();
    }
  };

4.3 转发队列中event事件：dispatchQueuedEvents()

  /**
   * Drain the queue of events to be dispatched. As the queue is being drained,
   * new events may be posted to the end of the queue.
   */
  void dispatchQueuedEvents() {
    // don't dispatch if we're already dispatching, that would allow reentrancy
    // and out-of-order events. Instead, leave the events to be dispatched
    // after the in-progress dispatch is complete.
    if (isDispatching.get()) {
      return;
    }

    isDispatching.set(true);
    try {
      //得到EventWithSubscriber事件队列
      Queue<EventWithSubscriber> events = eventsToDispatch.get();
      EventWithSubscriber eventWithSubscriber;
      // 迭代从线程队列中取事件
      while ((eventWithSubscriber = events.poll()) != null) {
        dispatch(eventWithSubscriber.event, eventWithSubscriber.subscriber);
      }
    } finally {
      isDispatching.remove();
      eventsToDispatch.remove();
    }
  }


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


  /**
   * Dispatches {@code event} to the subscriber in {@code wrapper}.  This method
   * is an appropriate override point for subclasses that wish to make
   * event delivery asynchronous.
   *
   * @param event  event to dispatch.
   * @param wrapper  wrapper that will call the subscriber.
   */
  void dispatch(Object event, EventSubscriber wrapper) {
    try {
      //执行订阅者方法
      wrapper.handleEvent(event);
    } catch (InvocationTargetException e) {
      try {
        subscriberExceptionHandler.handleException(
            e.getCause(),
            new SubscriberExceptionContext(
                this,
                event,
                wrapper.getSubscriber(),
                wrapper.getMethod()));
      } catch (Throwable t) {
        // If the exception handler throws, log it. There isn't much else to do!
        Logger.getLogger(EventBus.class.getName()).log(Level.SEVERE,
             String.format(
            "Exception %s thrown while handling exception: %s", t,
            e.getCause()),
            t);
      }
    }
  }

4.4 DeadEvent

如果事件既没有订阅者，也不是DeadEvent，那么封装成DeadEvent并重新发布。

  • source：事件源（通常指发布事件的EventBus对象）
  • event：事件对象
  public DeadEvent(Object source, Object event) {
    this.source = checkNotNull(source);
    this.event = checkNotNull(event);
  }

5. 总结

eventType<->EventSubscriber：SetMultimap<Class<?>, EventSubscriber> subscribersByType

  private final SetMultimap<Class<?>, EventSubscriber> subscribersByType =
      HashMultimap.create();

register(listener)：找到listener类及超类的订阅方法（注解）->根据参数得到eventType->对应EventSubscriber

注册了一个Listener，使用eventBus发送消息Listener父类的Subscribe也会对此消息进行处理。

post(event)（线程异步分发事件）：得到event类及子类所有eventType->将对应EventSubscriber添加进分发队列->分发event

当作为参数的event之间有继承关系时，使用eventBus发送消息，event父类的listener也会对此消息进行处理。

传统观察者模式和EventBus的区别：

传统观察者模式和EventBus区别
 

监听者管理

监听特定事件

把监听者注册到生产者

按事件超类监听检测没有监听者的事件分发事件

传统观察者模式

用列表管理监听者，还要考虑线程同步；或者使用工具类定义相应的事件监听者类

调用事件生产者的register方法，开发者必须知道所有事件生产者的类型，才能正确地注册监听者

很困难，需要开发者自己去实现匹配逻辑在每个事件分发方法中添加逻辑代码开发者自己写代码，包括事件类型匹配、异常处理、异步分发
EventBus内部已经实现了监听者管理

以自定义Event为唯一参数创建方法，

并用Subscribe注解标记。

EventBus.register(Object)EventBus自动把事件分发给事件超类的监听者EventBus会把所有发布后没有监听者处理的事件包装为DeadEvent

EventBus.post(Object)

异步分发可以直接用EventBus的子类AsyncEventBus

 

 

 

原文：

https://blog.csdn.net/yanghua_kobe/article/details/46317297

https://www.cnblogs.com/dennyzhangdd/p/9324483.html 

https://blog.csdn.net/wangdong5678999/article/details/80561198#1_Listener_9

 

liyanan21
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
EventBus监听模式实例
厚积薄发
03-19 1573
目录 先定义一个注解 自定义一个EventBus EventBus启动配置 定义事件类型实体, 和对应的监听操作 发布事件 小结 先定义一个注解 /** * eventbus开启注解，只有开启了该注解的类的方法才可用Subscribe注解监听event事件 * @author zsd */ @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) @Component public @int
EventBus 3.1.1
12-02
EventBus 3.1.1版本。 EventBus is a publish/subscribe event bus for Android and Java. simplifies the communication between components decouples event senders and receivers performs well with ...
EventBus使用教程
lhc66666的博客
09-21 746
EventBus是一个基于发布订阅的事件总线，在Java和Android里都可以使用。
EventBus学习&事件
嘉树麻麻
08-19 345
一、简介 EventBus是guava中的一个工具，EventBus允许组件之间通过发布-订阅进行通信，而不需要组件之间显示的注册。它专门设计为了代替使用显示注册的传统的Java进程内事件分发。它不是通用的发布-订阅系统，也不是用于进程间通信的。 优点：简化组件之间的通信。是发布者和订阅之间解耦，同时避免了复杂且容易出错的依赖性和生命周期问题。使代码更加简洁 1.1 三要素 1）Event 事件。它可以是任意类型。 2）Publisher 事件的发布者（生产者）。管理和追踪监听者，EventBus
java中的EventBus事件总线技术
最新发布
letter song的博客
05-23 709
EventBus既是事件的接收站（收集发布的事件），也是转发器（将事件传递给订阅者），实质上起到了事件总线的作用。事件总线扮演着中介的角色，负责在事件发生时，根据事件类型将事件分发给所有对此事件感兴趣的（即已经注册的）订阅者。采用发布订阅的模式（有时描述为注册监听的模式），通过 【注册器】将【订阅者】注册到【总线】中，维护【事件】和【订阅者】的订阅关系；再通过【事件发送器】发布具体【事件载体】，第一步使用【事件分发器】调用【订阅者】来执行具体的订阅者消费逻辑。
c++事件总线模型
Fireplusplus的博客
06-29 1514
一种简单的事件总线模型。
EventBus的理解及应用
深耕技术
02-07 806
面试：你懂什么是分布式系统吗？Redis分布式锁都不会？>>> 1 简介 EventBus是一种用于Android的事件发布-订阅总线，由GreenRobot开发，Gihub地址是：EventBus。它简化了应用程序内各个组件之间进行通信的复杂度，尤其是碎片之间进行通信的问题，可以避免由于使用广播通信而带来的诸多不便。 1.1 三个角色 Event：事件，它可...
EventBus jar
08-22
EventBus 是一个轻量级的发布/订阅事件总线库，专为 Android 平台设计，但也可以在 Java 应用中使用。它的主要目的是为了简化 Android 应用中的组件间通信，使得类之间的耦合度降低，提高代码的可维护性和可测试性。...
EventBus3.0
01-31
EventBus 是一个流行的消息总线库，用于 Android 应用程序中的组件间通信。它简化了应用程序中的事件发布和订阅，使得组件之间的耦合度降低，提高了代码的可维护性和可测试性。在本示例中，我们关注的是 EventBus ...
EventBus.rar
03-23
EventBus 是一个在Android开发中广泛使用的发布/订阅事件总线库。它简化了应用程序组件之间的通信，使得组件之间能够解耦，降低复杂性。在Android应用开发中，通常使用Intent来传递数据和触发事件，但Intent对于大量...
android EventBus
08-08
**Android EventBus 深度解析** EventBus 是一个在 Android 应用开发中广泛使用的发布/订阅事件总线库，由 GreenRobot 开发。它简化了组件间的通信，避免了传统回调或静态方法的繁琐，使得应用程序的架构更加清晰。...
事件总线 eventBus 详解
facial_123的博客
09-12 1184
eventBus事件总线详解，使用Vue实例并手撕其内部原理
EventBus 使用（全面分析，细节提醒）
热门推荐
宇宝守护神(rainyang)的博客
12-08 6万+
EventBus使用 概述 关于 EventBus 在开发中经常会选择使用它来进行模块间通信、解耦。平常使用这个库只是很浅显的操作三部曲，register，post，unregister。来达到开发目的。始终有种不明确，模糊的操作感。因此准备对EventBus进行一个深入，全面的理解，消除模糊，片面感，让以后在使用这个库的时候，有更好的掌握和使用。并记录下来，方便以后查阅。关于EventBus会分...
EventBus原理深度解析
weixin_34364135的博客
09-26 779
2019独角兽企业重金招聘Python工程师标准>>> ...
EventBus 3.0使用详解
陈炼的博客
05-17 5744
EventBus是一款Android下的发布/订阅事件总线机制。可以代替Intent、Handler、Broadcast等在Fragment、Activity之间传递消息。 优点：开销小，代码优雅。将发送者和接受者解耦。
google Guava之EventBus
栋先生
06-03 1万+
EventBus基本用法 1. 创建Listener 2. 创建EventBus并发送消息 Listener之间的继承关系 Subscriber 不同类型参数的Subscribe event 继承关系的event DeadEvent EventBus之异常处理 EventBus是Guava的事件处理机制，是设计模式中的观察者模式（生产/消费者编程模型）的优雅实现，在应...
EventBus使用
狂奔的蜗牛
06-08 1424
EventBus 1. EventBus,事件总线，guava基于观察者模式的优雅实现。对于事件监听和发布订阅模式，使用guava eventbus可以省去开发人员很多事情，不用在去定义那些复杂的类或接口来实现事件发布与订阅。在guava eventbus中，开发人员只需要在订阅方法上添加上@Subscribe注解就可以了,这样一来就省去了大量共用的编码工作。guava eventbus提供了同步
EventBus3.0 性能提升之添加索引
zhangke
03-30 2420
EventBus3.0 源码解析 一文中，在分析Subscriber的register()过程中，说到过一个方法方法findUsingReflectionInSingleClass，在该方法的作用是在RunTime期间通过反射获取Subscriber中的SubscriberMethod。 这样就会产生一个问题，在RunTime期间使用反射对程序运行的性能有较大影响。这里我们可以看看EventBu...
Android框架之路——EventBus的使用
等一杯咖啡的博客
05-09 3万+
一、简介 EventBus是由greenrobot 组织贡献的一个Android事件发布/订阅轻量级框架。EventBus是一个Android端优化的publish/subscribe消息总线，简化了应用程序内各组件间、组件与后台线程间的通信。比如请求网络，等网络返回时通过Handler或Broadcast通知UI，两个Fragment之间需要通过Listener通信，这些需求都可以通过Even
eventbus vue
10-14
EventBus是Vue.js中的一个插件，用于在组件之间进行通信。它实现了发布/订阅模式，允许您在应用程序中的任何地方触发事件并在其他地方监听它们。 使用EventBus非常简单。首先，您需要在Vue实例中创建一个EventBus：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值