Java事件总线

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

  • 模块间相互依赖，耦合度高。以下订单为例，订单提交后需要进行支付以及进行一些其他处理，如发邮件等操作。相关的代码可能是这样。可以看到：订单模块依赖了支付服务以及用户服务。
  • 维护困难。由于模块间相互依赖，当需要修改订单逻辑时则需要修改submitOrder方法的源代码，而某些时候可能无法修改。再者，如果有多个这种逻辑，修改时可能涉及到多处操作。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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 "foo@bar.com";
        }
          
        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...
        }
}

 一、观察者模式

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

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
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 "foo@bar.com";
    }
 
    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方法。可以看到此实现的订单逻辑没有直接依赖付款模块和用户模块。 主程序通过添加监听器来使其得到通知

?
1
2
3
4
5
6
7
8
9
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事件总线来实现，大概是以下这个样子：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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 "foo@bar.com";
    }
 
    @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方法来注册处理相应事件的类

?
1
2
3
4
5
6
7
8
9
10
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保证了一种事件可以有多个监听者来处理。

?
1
2
3
4
5
6
7
8
9
10
11
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方法来发布事件，首先通过事件类型找到需要处理的事件：事件本身以及其父类。根据事件类型从事件订阅的缓存中取出处理该事件的订阅者，并将其入队。最后处理该队列中的数据.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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();
  }

 

posted @   moonandstar08  阅读(4804)  评论(1)  编辑  收藏  举报
编辑推荐：
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 【译】Visual Studio 中新的强大生产力特性
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构
点击右上角即可分享
微信分享提示
AI IDE Trae