Java事件总线

在平时写代码的过程中，我们需要实现这样一种功能：当执行某个逻辑时，希望能够进行其他逻辑的处理。最粗暴的方法是直接依赖其他模块，调用该模块的相应函数或者方法。但是，这样做带来一些问题。

  • 模块间相互依赖，耦合度高。以下订单为例，订单提交后需要进行支付以及进行一些其他处理，如发邮件等操作。相关的代码可能是这样。可以看到：订单模块依赖了支付服务以及用户服务。
  • 维护困难。由于模块间相互依赖，当需要修改订单逻辑时则需要修改submitOrder方法的源代码，而某些时候可能无法修改。再者，如果有多个这种逻辑，修改时可能涉及到多处操作。
public class OrderPage {

        private PaymentService paymentService;
        private UserService userService;

        public void submitOrder() {
                Integer userId = 1;
                BigDecimal amount = BigDecimal.TEN;

                paymentService.doPayment(userId, amount);
                userService.registerPayment(userId, amount);
        }
}
public class PaymentService {

        private MailService mailService;

        public void doPayment(Integer userId, BigDecimal amount) {
                //Do payment...
                mailService.sendPaymentEmail(userId, amount);
        }
}
public class UserService {

        public String getEmailAddress(Integer userId) {
                return "[email protected]";
        }

        public void registerPayment(Integer userId, BigDecimal amount) {
                //Register payment in database...
        }
}

public class MailService {

        private UserService userService;

        public void sendPaymentEmail(Integer userId, BigDecimal amount) {
                String emailAddress = userService.getEmailAddress(userId);
                //Send email...
        }
}

 一、观察者模式

有时被称作发布/订阅模式，观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

通过观察者模式来进行解耦，当对象发生变化时，通知其观察者，由观察者进行相应的处理。体现在订单逻辑中时即为,定义多个观察者观察下订单这个主题，当下订单的动作发生时，通知其所有观察者。再由每个观察者进行处理。依据观察者模式的实现，以上逻辑可改为如下代码：

interface OrderListener {

	public void onSubmitOrder(Integer userId, BigDecimal amount);
}

public class OrderPage {

	private List<OrderListener> orderListeners=new ArrayList<OrderListener>();

	public void submitOrder() {
		Integer userId = 1;
		BigDecimal amount = BigDecimal.TEN;

		for (OrderListener orderListener : orderListeners) {
			orderListener.onSubmitOrder(userId, amount);
		}
	}

	public void addOrderListener(OrderListener orderListener){
		this.orderListeners.add(orderListener);
	}
}

class PaymentService implements OrderListener {

	private MailService mailService;

	public void doPayment(Integer userId, BigDecimal amount) {
		// Do payment...
		mailService.sendPaymentEmail(userId, amount);
	}

	@Override
	public void onSubmitOrder(Integer userId, BigDecimal amount) {

		doPayment(userId, amount);
	}
}

class UserService implements OrderListener {

	public String getEmailAddress(Integer userId) {
		return "[email protected]";
	}

	public void registerPayment(Integer userId, BigDecimal amount) {
		// Register payment in database...
	}

	@Override
	public void onSubmitOrder(Integer userId, BigDecimal amount) {

		registerPayment(userId, amount);

	}
}

class MailService {

	private UserService userService;

	public void sendPaymentEmail(Integer userId, BigDecimal amount) {
		String emailAddress = userService.getEmailAddress(userId);
		// Send email...
	}
}

可以看到，首先定义了OrderListener接口，接口中有一个onSubmitOrder方法。原始的实现中的PayService和UserService实现了该接口。OrderPage中维护了一个OrderListener列表，当提交订单时调用所有监听者的onSubmitOrder方法。可以看到此实现的订单逻辑没有直接依赖付款模块和用户模块。 主程序通过添加监听器来使其得到通知

public static void main(String[] args) {
    	PaymentService paymentService=new PaymentService();
    	UserService userService=new UserService();

    	OrderPage orderPage=new OrderPage();

    	orderPage.addOrderListener(paymentService);
    	orderPage.addOrderListener(userService);
	}

二、Guava EventBus（监听者模式的优雅实现）

虽然监听者模式对源代码进行了解耦，但是还是有一些不足。

  • 相关模块需要实现相应接口；
  • 需要主动调用相关的addListener方法设置监听器。
  • 一个监听器智能监听一种操作.

EventBus是Guava对于监听者模式的实现，其使用非常简单。使用EventBus来实现监听者模式，只需要三步操作。

  1. 通过注解@Subscribe来声明事件回调方法；
  2. 调用EventBus的register方法来注册监听器；
  3. 通过post方法来触发事件；

订单逻辑通过EventBus事件总线来实现，大概是以下这个样子：

public class OrderPage {

	public static EventBus eventBus = new EventBus();

	public void submitOrder() {
		Integer userId = 1;
		BigDecimal amount = BigDecimal.TEN;

		eventBus.post(new PayEvent(userId, amount));
	}

}

class PaymentService {

	private MailService mailService;

	@Subscribe
	public void doPayment(PayEvent  payEvent) {
		// Do payment...
		mailService.sendPaymentEmail(payEvent.getUserId(), payEvent.getAmount());
	}

}

class UserService {

	public String getEmailAddress(Integer userId) {
		return "[email protected]";
	}

	@Subscribe
	public void registerPayment(PayEvent payEvent) {
		// Register payment in database...
	}
}

class PayEvent {

	private Integer userId;
	private BigDecimal amount;

	public PayEvent(Integer userId, BigDecimal amount) {
	}

	public Integer getUserId() {
		return userId;
	}
	public BigDecimal getAmount() {
		return amount;
	}
}

 public static void main(String[] args) {
    	PaymentService paymentService=new PaymentService();
    	UserService userService=new UserService();

    	OrderPage orderPage=new OrderPage();

    	orderPage.eventBus.register(paymentService);
    	orderPage.eventBus.register(userService);
	}

要实现监听者模式，时需要调用eventBus的register方法进行注册，在需要处理事件的方法上使用@Subscribe注解。最后通过eventBus发布事件即可。使用事件总线，不需要定义特定的接口，不需要主动添加监听器；

三、事件订阅

EventBus通过register方法来注册处理相应事件的类

public void register(Object object) {
    Multimap<Class<?>, EventSubscriber> methodsInListener =
        finder.findAllSubscribers(object);
    subscribersByTypeLock.writeLock().lock();
    try {
      subscribersByType.putAll(methodsInListener);
    } finally {
      subscribersByTypeLock.writeLock().unlock();
    }
  }

其核心是findAllSubscribers，找到实例中所有有Subscribe注解的方法并保存。返回的是一个Multimap < Class<?>,EventSubscriber>类型，其中Class是事件类型，EventSubsciber包含了类实例和具体处理事件的方法。Multimap保证了一种事件可以有多个监听者来处理。

public Multimap<Class<?>, EventSubscriber> findAllSubscribers(Object listener) {
    Multimap<Class<?>, EventSubscriber> methodsInListener = HashMultimap.create();
    Class<?> clazz = listener.getClass();
    for (Method method : getAnnotatedMethods(clazz)) {
      Class<?>[] parameterTypes = method.getParameterTypes();
      Class<?> eventType = parameterTypes[0];
      EventSubscriber subscriber = makeSubscriber(listener, method);
      methodsInListener.put(eventType, subscriber);
    }
    return methodsInListener;
  }

发布事件

EventBus通过post方法来发布事件，首先通过事件类型找到需要处理的事件：事件本身以及其父类。根据事件类型从事件订阅的缓存中取出处理该事件的订阅者，并将其入队。最后处理该队列中的数据.

public void post(Object 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) {
            enqueueEvent(event, wrapper);
          }
        }
      } finally {
        subscribersByTypeLock.readLock().unlock();
      }
    }

    if (!dispatched && !(event instanceof DeadEvent)) {
      post(new DeadEvent(this, event));
    }

    dispatchQueuedEvents();
  }
时间： 2024-08-26 03:33:06

Java事件总线的相关文章

【Java】一个最简单的事件总线实现

一个最简单的事件总线实现 MicroBus 使用 注册 class Receiver implements MicroBus.BusEventReceiver { public onCreate() { bus.register(this, String.class); } public onDestroy() { bus.unregister(this, String.class); } @Override public void onBusEvent(Object event) { if (

事件总线框架---Otto

我们假设这样一种业务场景,现在在做一款及时聊天应用,我们在聊天页面进行收发信息,同时也要实时更新前一页面的聊天记录,这时我们该如何去实现?说说我以前的实现策略,我使用的是广播接收器BroadCastReceiver,在接收和发送消息的时候就不停去发送广播,然后在需要实时更新的地方进行接收更新.实现的思想比较简单,也不存在代码上的耦合问题,但是有个弊端.弊端就是需要去在很多地方实现BroadCastRecevier,代码虽不算冗余,但比较多,看起来很是不爽. 今天为大家介绍的Otto,就能彻底解决

Guava: 事件总线EventBus

EventBus 直译过来就是事件总线,它使用发布订阅模式支持组件之间的通信,不需要显式地注册回调,比观察者模式更灵活,可用于替换Java中传统的事件监听模式,EventBus的作用就是解耦,它不是通用的发布订阅系统,也不能用于进程间通信.可用于Android的EventBus库主要有这几个:Google出品的Guava,Guava是一个庞大的库,EventBus 只是它附带的一个小功能,因此实际项目中使用并不多.用的最多的是greenrobot/EventBus,这个库的优点是接口简洁,集成方

AndroidEventBus新特性：添加粘性事件、不需要手动注销事件总线

刚看了下作者发布的新版本AndroidEventBus v1.0.4版本,发现加了很多好东东,最大的两个特性就是添加了粘性sticky事件和无需手动注销事件 AndroidEventBus的github地址为:github 下面是作者给出的粘性sticky事件运用场景,感觉挺给力的,这里直接粘贴复制了 User.java类 : // 实体类实现序列化 public class User { String name ; String phoneNum; // 其他字段省略 public User(

EventBus事件总线分发库

本文围绕以下六个部分展开: 一.事件总线管理 二.EventBus 三.EventBus与BroadcastReceiver的区别 案例一 案例二:一处点击发送数据,另一处或多处注册点可以及时获取更新传输过来的数据 案例三:Activity和Service之间互相发布与接收事件 一.事件总线管理 将事件放入队列里,用于管理和分发. (1)保证应用的各个部分之间高效的通信及数据.事件分发. (2)模块间解耦:通过事件的分发,可以让各个模块间关联程序变小. 当在开发一些庞大的的项目时,模块比较多,这

领域驱动设计学习笔记（一 事件总线）

何为领域驱动设计? 2004年著名建模专家Eric Evans发表了他最具影响力的书籍:<Domain-Driven Design: Tackling Complexity in the Heart of Software>(中文译名:领域驱动设计:软件核心复杂性应对之道),书中提出了领域驱动设计(简称 DDD)的概念. 领域驱动设计事实上是针对OOAD的一个扩展和延伸,DDD基于面向对象分析与设计技术,对技术架构进行了分层规划,同时对每个类进行了策略和类型的划分. 领域模型是领域驱动的核心.

【第三篇】学习 android 事件总线androidEventbus之发布事件，子线程中接收

发送和接收消息的方式类似其他的发送和接收消息的事件总线一样,不同的点或者应该注意的地方: 1,比如在子线程构造方法里面进行实现总线的注册操作: 2,要想子线程中接收消息的功能执行,必须启动线程. 3,添加tag和不添加tag类似其他. 1 package com.example.mysimpleeventbus; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 import org.simple.eventbus.Even

Android EventBus事件总线剖析

概述 EventBus是一款针对Android优化的发布/订阅事件总线.主要功能是替代Intent,Handler,BroadCast在Fragment,Activity,Service,线程之间传递消息. 它是一个基于观察者模式的事件发布/订阅框架,开发者可以通过极少的代码去实现多个模块之间的通信,而不需要以层层传递接口的形式去单独构建通信桥梁.从而降低因多重回调导致的模块间强耦合,同时避免产生大量内部类.它拥有使用方便,性能高,接入成本低和支持多线程的优点,实乃模块解耦.代码重构必备良药.

Android事件总线（一）EventBus3.0用法全解析

前言 EventBus是一款针对Android优化的发布/订阅事件总线.简化了应用程序内各组件间.组件与后台线程间的通信.优点是开销小,代码更优雅,以及将发送者和接收者解耦.如果Activity和Activity进行交互还好说,如果Fragment和Fragment进行交互着实令人头疼,我们会使用广播来处理,但是使用广播稍显麻烦并且效率也不高,如果传递的数据是实体类需要序列化,那么很显然成本会有点高.今天我们就来学习下EventBus3.0的使用方法. 1.EventBus概述 EventBus