设计模式-观察者模式eventBus（下）

David_Zhang2

已于 2022-04-06 11:47:01 修改

阅读量969

点赞数 1

文章标签：设计模式观察者模式 EventBus

于 2022-03-31 16:19:48 首次发布

1、实现方式类型：

同步阻塞是最经典的实现方式，主要是为了代码解耦；异步非阻塞除了能实现代码解耦之外，还能提高代码的执行效率；进程间的观察者模式解耦更加彻底，一般是基于消息队列来实现，用来实现不同进程间的被观察者和观察者之间的交互。

2、异步非阻塞观察者模式的简易实现：

其中一种是：在每个 regSuccess() 函数中创建一个新的线程执行代码逻辑；另一种是：在 UserController 的 register() 函数中使用线程池来执行每个观察者的 handleRegSuccess() 函数。

对于第一种实现方式，频繁地创建和销毁线程比较耗时，并且并发线程数无法控制，创建过多的线程会导致堆栈溢出。第二种实现方式，尽管利用了线程池解决了第一种实现方式的问题，但线程池、异步执行逻辑都耦合在了 register() 函数中，增加了这部分业务代码的维护成本。

框架的作用有：隐藏实现细节，降低开发难度，做到代码复用，解耦业务与非业务代码，让程序员聚焦业务开发。针对异步非阻塞观察者模式，我们现在有一个比较好的实现->EventBus。

3、EventBus 框架功能需求介绍:

EventBus 翻译为“事件总线”，它提供了实现观察者模式的骨架代码。我们可以基于此框架，非常容易地在自己的业务场景中实现观察者模式，不需要从零开始开发。其中，Google Guava EventBus 就是一个比较著名的 EventBus 框架，它不仅仅支持异步非阻塞模式，同时也支持同步阻塞模式。

用eventBus对其实现，代码如下：

/**
 * 基于eventBus实现对代码的解耦
 * @author PengMvc
 *
 */
public class UserInfoController {
	
	// 注入自己实现的eventBus
	private EventBus eventBus;
	
	private static final int FIX_SIZE_THREAD_POOL=5;
	
	public UserInfoController() {
		 // eventBus:异步非阻塞
		 eventBus = new AsyncEventBus(Executors.newFixedThreadPool(FIX_SIZE_THREAD_POOL));
		 
//		 // ͬeventBus:同步阻塞
//		 eventBus = new EventBus();
	}

	/**
	 * 用户注册接口
	 * @return
	 */
	public  Boolean register() {
		List<Object> observerList = new ArrayList<>();
		Collections.addAll(observerList, new EventBusEmailNoticeObserver(),new EventBusSendMoneyObserver());
		
		// 用户注册成功
		System.out.println("用户注册成功");
		
		// 注册成功后执行
		observerList.forEach(obsever->{
			eventBus.register(obsever);
		});
		
		// 执行了注册eventBus的方法
		eventBus.post("新用户小张");
		 
	    return true;
	}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Beta
public @interface Subscribe {

}
/**
 *相当于eventBus的注册表
 *@author PengMvc
 *
 */

public class ObserverRegistry {
  private ConcurrentMap<Class<?>, CopyOnWriteArraySet<ObserverAction>> registry = new ConcurrentHashMap<>();

  public void register(Object observer) {
    Map<Class<?>, Collection<ObserverAction>> observerActions = findAllObserverActions(observer);
    for (Map.Entry<Class<?>, Collection<ObserverAction>> entry : observerActions.entrySet()) {
      Class<?> eventType = entry.getKey();
      Collection<ObserverAction> eventActions = entry.getValue();
      CopyOnWriteArraySet<ObserverAction> registeredEventActions = registry.get(eventType);
      if (registeredEventActions == null) {
        registry.putIfAbsent(eventType, new CopyOnWriteArraySet<>());
        registeredEventActions = registry.get(eventType);
      }
      registeredEventActions.addAll(eventActions);
    }
  }

  public List<ObserverAction> getMatchedObserverActions(Object event) {
    List<ObserverAction> matchedObservers = new ArrayList<>();
    Class<?> postedEventType = event.getClass();
    for (Map.Entry<Class<?>, CopyOnWriteArraySet<ObserverAction>> entry : registry.entrySet()) {
      Class<?> eventType = entry.getKey();
      Collection<ObserverAction> eventActions = entry.getValue();
      if (postedEventType.isAssignableFrom(eventType)) {
        matchedObservers.addAll(eventActions);
      }
    }
    return matchedObservers;
  }

  private Map<Class<?>, Collection<ObserverAction>> findAllObserverActions(Object observer) {
    Map<Class<?>, Collection<ObserverAction>> observerActions = new HashMap<>();
    Class<?> clazz = observer.getClass();
    for (Method method : getAnnotatedMethods(clazz)) {
      Class<?>[] parameterTypes = method.getParameterTypes();
      Class<?> eventType = parameterTypes[0];
      if (!observerActions.containsKey(eventType)) {
        observerActions.put(eventType, new ArrayList<>());
      }
      observerActions.get(eventType).add(new ObserverAction(observer, method));
    }
    return observerActions;
  }

  private List<Method> getAnnotatedMethods(Class<?> clazz) {
    List<Method> annotatedMethods = new ArrayList<>();
    for (Method method : clazz.getDeclaredMethods()) {
      if (method.isAnnotationPresent(Subscribe.class)) {
        Class<?>[] parameterTypes = method.getParameterTypes();
//        Preconditions.checkArgument(parameterTypes.length == 1,
//                "Method %s has @Subscribe annotation but has %s parameters."
//                        + "Subscriber methods must have exactly 1 parameter.",
//                method, parameterTypes.length);
        annotatedMethods.add(method);
      }
    }
    return annotatedMethods;
  }
}

public class ObserverAction {
	
	private Method method;
	private Object target;
	
	// 构造函数
	public ObserverAction(Object target, Method method) {
		super();
		this.method = method;
		this.target = target;
		this.method.setAccessible(true);
	}
	
    public void execute(Object param) {
    	try {
			method.invoke(target, param);
		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }

}

/**
 * 用户注册成功，发送奖金
 * @author PengMvc
 *
 */
public class EventBusSendMoneyObserver {
	
	// private SendMoneyServiceImpl sendMoneyServiceImpl;
	
	@Subscribe
	public Boolean registerSuccess(String userId) {
	    // 注册成功发送奖金
		// sendMoneyServiceImpl.registerSucesssSendMoney()
		System.out.println("用eventBus订阅->用户注册成功了,发送奖金给"+userId);
		return true;
	}

}


/**
 * 用户注册成功，发送email
 * @author PengMvc
 *
 */
public class EventBusEmailNoticeObserver {
	
	// private EmailNoticeImpl emailNoticeImpl;
	@Subscribe
	public Boolean registerSuccess(String userId) {
		// 注册成功发送email
		// emailNoticeImpl.sendRegisterSuccessEmail();
		System.out.println("用eventBus订阅->用户注册成功，发送email提醒"+userId);
		return true;
	}

}


public class EventBus {
  private Executor executor;
  private ObserverRegistry registry = new ObserverRegistry();

  public EventBus() {
   
  }

  protected EventBus(Executor executor) {
    this.executor = executor;
  }

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

  public void post(Object event) {
    List<ObserverAction> observerActions = registry.getMatchedObserverActions(event);
    for (ObserverAction observerAction : observerActions) {
      executor.execute(new Runnable() {
        @Override
        public void run() {
          observerAction.execute(event);
        }
      });
    }
  }
}

public class AsyncEventBus extends EventBus {
  public AsyncEventBus(Executor executor) {
    super(executor);
  }
}

利用 EventBus 框架实现的观察者模式，跟从零开始编写的观察者模式相比，从大的流程上来说，实现思路大致一样，都需要定义 Observer，并且通过 register() 函数注册 Observer，也都需要通过调用某个函数（比如，EventBus 中的 post() 函数）来给 Observer 发送消息（在 EventBus 中消息被称作事件 event）。

总结：

首先一个业务类需要用eventBus，第一：需要在本类中注入eventBus,且选好用同步阻塞的EventBus还是异步非阻塞的AsyncEventBus ；第二：将需要订阅的Observer类注册到eventBus中；第三：在需要订阅Observer类的方法上加@Subcribe注解，来标明类中的那个方法可以接受被观察者的发送的消息。

4、Guava EventBus 的几个主要的类和函数详解：

4.1：EventBus、AsyncEventBus

Guava EventBus 对外暴露的所有可调用接口，都封装在 EventBus 类中。其中，EventBus 实现了同步阻塞的观察者模式，AsyncEventBus 继承自 EventBus，提供了异步非阻塞的观察者模式。具体使用方式如下所示：


EventBus eventBus = new EventBus(); // 同步阻塞模式
EventBus eventBus = new AsyncEventBus(Executors.newFixedThreadPool(8))；// 异步阻塞模式

4.2：register() 函数

EventBus 类提供了 register() 函数用来注册观察者。具体的函数定义如下所示。它可以接受任何类型（Object）的观察者。而在经典的观察者模式的实现中，register() 函数必须接受实现了同一 Observer 接口的类对象。


public void register(Object object);

4.3：unregister() 函数

相对于 register() 函数，unregister() 函数用来从 EventBus 中删除某个观察者。我就不多解释了，具体的函数定义如下所示：


public void unregister(Object object);

4.4：post() 函数

EventBus 类提供了 post() 函数，用来给观察者发送消息。具体的函数定义如下所示：

public void post(Object event);

跟经典的观察者模式的不同之处在于，当我们调用 post() 函数发送消息的时候，并非把消息发送给所有的观察者，而是发送给可匹配的观察者。所谓可匹配指的是，能接收的消息类型是发送消息（post 函数定义中的 event）类型的父类。举例：

AObserver 能接收的消息类型是 XMsg，BObserver 能接收的消息类型是 YMsg，CObserver 能接收的消息类型是 ZMsg。其中，XMsg 是 YMsg 的父类。当我们如下发送消息的时候，相应能接收到消息的可匹配观察者如下所示：


XMsg xMsg = new XMsg();
YMsg yMsg = new YMsg();
ZMsg zMsg = new ZMsg();
post(xMsg); => AObserver接收到消息
post(yMsg); => AObserver、BObserver接收到消息
post(zMsg); => CObserver接收到消息

4.5：@Subscribe 注解

EventBus 通过 @Subscribe 注解来标明，某个函数能接收哪种类型的消息。具体的使用代码如下所示。在 DObserver 类中，我们通过 @Subscribe 注解了两个函数 f1()、f2()。


public DObserver {
  //...省略其他属性和方法...
  
  @Subscribe
  public void f1(PMsg event) { //... }
  
  @Subscribe
  public void f2(QMsg event) { //... }
}

当通过 register() 函数将 DObserver 类对象注册到 EventBus 的时候，EventBus 会根据 @Subscribe 注解找到 f1() 和 f2()，并且将两个函数能接收的消息类型记录下来（PMsg->f1，QMsg->f2）。当我们通过 post() 函数发送消息（比如 QMsg 消息）的时候，EventBus 会通过之前的记录（QMsg->f2），调用相应的函数（f2）;

总结：

当调用EventBus的register函数时，会将观察者类Observer注册到eventBus中，eventBus会根据@Subscribe注解找到该观察者类里面的方法，会将方法和方法的参数类型记录下来形成所谓的注册表（sample:f1->String,f2->Integar...）,当我们在被观察者类里调用post方法时；eventBus会根据参数类型与之前形成的记录（注册表）进行匹配，然后去调用观察者类里面匹配上的方法；

参考图示：

至此我们实现了从功能上来讲，它跟 Google Guava EventBus 几乎一样的eventBus。

David_Zhang2

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
设计模式-观察者模式eventBus（下）

1、实现方式类型：同步阻塞是最经典的实现方式，主要是为了代码解耦；异步非阻塞除了能实现代码解耦之外，还能提高代码的执行效率；进程间的观察者模式解耦更加彻底，一般是基于消息队列来实现，用来实现不同进程间的被观察者和观察者之间的交互。2、异步非阻塞观察者模式的简易实现：其中一种是：在每个 regSuccess() 函数中创建一个新的线程执行代码逻辑；另一种是：在 UserController 的 register() 函数中使用线程池来执行每个观察者的 handleRe...
复制链接

扫一扫