Asynchronous CDI Events

最新推荐文章于 2024-07-05 14:51:01 发布
最新推荐文章于 2024-07-05 14:51:01 发布
阅读量77 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/zhaoqian/blog/351634
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

CDI事件本身是属于同步的，但在一些场景下，你可能会需要异步的CDI events。本文将概述异步cdi event事件。

1.Default Synchronous Events

先看一个基本的例子 

@Path("/produce")
public class EventGenerator {

    @Inject
    private Logger logger;

    @Inject
    private Event<MyEvent> events;

    @Path("/cdiBean/{eventsNum}")
    @GET
    public String generateEvents(@PathParam("eventsNum") int numberOfEventsToGenerate) {
        for (int i = 0; i < numberOfEventsToGenerate; i++) {
            MyEvent event = new MyEvent(i);

            logger.info("Generating Event: " + event);
            events.fire(event);
        }
        return "Finished. Generated " + numberOfEventsToGenerate + " events.";
    }
}
MyEvent只是一些事件对象，它在这里不是很重要。
消费者是一个非常简单的CDI bean： 
public class EventConsumer {

    @Inject
    private Logger logger;

    public void consumeEvent(@Observes MyEvent myEvent) throws InterruptedException {
        logger.info("Receiving event: " + myEvent);

        TimeUnit.MILLISECONDS.sleep(500);
    }
}
请注意，我写一个线程睡眠来模拟一些长时间运行的事件接收器模拟复杂费时的处理过程。
现在，让我们通过调用REST命令，这是EventProducer露出运行这个例子。 
14:15:59,196 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=0]
14:15:59,197 [com.piotrnowicki.EventConsumer] (http-/127.0.0.1:8080-1) Receiving event: MyEvent[seqNo=0]
14:15:59,697 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=1]
14:15:59,698 [com.piotrnowicki.EventConsumer] (http-/127.0.0.1:8080-1) Receiving event: MyEvent[seqNo=1]
14:16:00,199 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=2]
14:16:00,200 [com.piotrnowicki.EventConsumer] (http-/127.0.0.1:8080-1) Receiving event: MyEvent[seqNo=2]
通过观察，我们可以得到结论，其cdi event默认就是同步的。下面我们将折腾异步的。

Solution 1 – CDI Producer and Singleton EJB as Receiver

我们的生产者保持不变 

@Path("/produce") public class EventGenerator {

    @Path("/cdiBean/{eventsNum}")
    @GET
    public String generateEvents(@PathParam("eventsNum") int numberOfEventsToGenerate) { ... }
}
现在你把接受者设置为 @Singleton EJB，并且标记oberves方法为@Asynchronous 
@Singleton
public class EventConsumer {

    @Asynchronous
    public void consumeEvent(@Observes MyEvent myEvent) throws InterruptedException { ...  }
}
你将得到以下结果 
14:21:19,341 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=0]
14:21:19,343 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=1]
14:21:19,343 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=2]
14:21:19,347 [com.piotrnowicki.EventConsumer] (EJB default – 2) Receiving event: MyEvent[seqNo=1]
14:21:19,848 [com.piotrnowicki.EventConsumer] (EJB default – 1) Receiving event: MyEvent[seqNo=0]
14:21:20,350 [com.piotrnowicki.EventConsumer] (EJB default – 3) Receiving event: MyEvent[seqNo=2]
事件一个接一个被Singleton EJB在单独的线程处理(看看时间事件处理。), 其实这里的consumeEvent是隐式的write:
异步：是
Ob方法是线程安全的：是

Solution 2 – Use Singleton EJB as Receiver With Read Lock

这种方法是和解决方案1非常相似的，但是，它提供了高得多的吞吐量，因为所有的事件平行处理。produce仍然不变。 

@Path("/produce")
public class EventGenerator {

    @Path("/cdiBean/{eventsNum}")
    @GET
    public String generateEvents(@PathParam("eventsNum") int numberOfEventsToGenerate) { ... }
}
我们的接收者的OB上有@Lock（READ）;这使得能够在同一时间服务于多个事件(而在一中是Lock(Write))： 
@Singleton
public class EventConsumer {

    @Asynchronous
    @Lock(LockType.READ)
    public void consumeEvent(@Observes MyEvent myEvent) throws InterruptedException { ... }
}
result： 
14:24:44,202 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=0]
14:24:44,204 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=1]
14:24:44,205 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=2]
14:24:44,207 [com.piotrnowicki.EventConsumer] (EJB default – 4) Receiving event: MyEvent[seqNo=0]
14:24:44,207 [com.piotrnowicki.EventConsumer] (EJB default – 6) Receiving event: MyEvent[seqNo=2]
14:24:44,207 [com.piotrnowicki.EventConsumer] (EJB default – 5) Receiving event: MyEvent[seqNo=1]

因此,我们结论是,这样的写法给你更大的吞吐量.

异步：是 
Ob方法是线程安全的：不是

Solution 3 – EJB Producer and CDI Consumer

CDI可以让你在事务的特定阶段去处理观察者位置的事件。
你可以指定使用@Observes(during=TransactionPhase...).
在我们的例子中，我们希望CDI观察者事件在事务结束之后才进行。要做到这一点，我们只需要把属性添加到我们的CDI Bean的观察者方法注解上： 
public class EventConsumer { 
   public void consumeEvent(@Observes(during = TransactionPhase.AFTER_COMPLETION) MyEvent myEvent) { ... } 
}

现在我们只需要确认我们在Event Generator方法运行的事务。我们可以通过改变我们的CDI Bean成为EJB @Stateless 和使用其隐含的事务--REQUIRED TransactionAttribute： 

@Stateless
@Path("/produce")
public class EventGenerator {

    @Path("/cdiBean/{eventsNum}")
    @GET
    public String generateEvents(@PathParam("eventsNum") int numberOfEventsToGenerate) { ... }
}

结果: 

14:39:06,776 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=0]
14:39:06,776 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=1]
14:39:06,776 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=2]
14:39:06,778 [com.piotrnowicki.EventConsumer] (http-/127.0.0.1:8080-1) Receiving event: MyEvent[seqNo=2]
14:39:07,279 [com.piotrnowicki.EventConsumer] (http-/127.0.0.1:8080-1) Receiving event: MyEvent[seqNo=1]
14:39:07,780 [com.piotrnowicki.EventConsumer] (http-/127.0.0.1:8080-1) Receiving event: MyEvent[seqNo=0]
EJB Event Generator启动一个事务，CDI bean的观察者将在事务完成后，才可以调用。

Asynchronous: yes
Thread-safe observer method: yes

Solution 4 – EJB Producer and EJB Consumer

与3类似 
@Stateless
@Path("/produce")
public class EventGenerator {

    @Path("/cdiBean/{eventsNum}")
    @GET
    public String generateEvents(@PathParam("eventsNum") int numberOfEventsToGenerate) { ... }
}

但是更改了观察者方法 

@Singleton
public class EventConsumer {

    @Asynchronous
    @Lock(LockType.READ)
    public void consumeEvent(@Observes(during = TransactionPhase.AFTER_COMPLETION) MyEvent myEvent) throws InterruptedException { ...  }
}

result  

14:44:09,363 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=0]
14:44:09,464 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=1]
14:44:09,564 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=2]
14:44:09,670 [com.piotrnowicki.EventConsumer] (EJB default – 8) Receiving event: MyEvent[seqNo=2]
14:44:09,670 [com.piotrnowicki.EventConsumer] (EJB default – 2) Receiving event: MyEvent[seqNo=1]
14:44:09,670 [com.piotrnowicki.EventConsumer] (EJB default – 1) Receiving event: MyEvent[seqNo=0]
我们在这里使用的两个特点 - 一是该事件消费者的方法是异步的，第二个是生产者事务完成之前，消费者将不会通知。
Asynchronous: yes
Thread-safe observer method: no

Solution 4 vs Solution 2

这两个解决方案似乎是相同的。他们只是消费者的注释不同：@Observes vs @Observes(during = TransactionPhase.AFTER_COMPLETION). 
我们的测试的情况表明它们的作用是相同的：它们是异步的，并且多个线程可以在同一时间进行事件处理。但是，他们之间有一个很大的不同。
在我们的测试情况下，我们触发的事件一个接一个。试想一下，有一些其它的操作之间的事件触发。在这种情况下：
Solution 2 (@Observes)在第一个就会fire,启动处理events.
Solution 4 (@Observes(during = TransactionPhase.AFTER_COMPLETION)) 它只会在事务完成后开始处理，所以那个时候所有的events将被fired. 
Solution 2 (@Observes)

15:01:34,318 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=0]
15:01:34,320 [com.piotrnowicki.EventConsumer] (EJB default – 3) Receiving event: MyEvent[seqNo=0]
15:01:34,419 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=1]
15:01:34,420 [com.piotrnowicki.EventConsumer] (EJB default – 6) Receiving event: MyEvent[seqNo=1]
15:01:34,520 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=2]
15:01:34,521 [com.piotrnowicki.EventConsumer] (EJB default – 9) Receiving event: MyEvent[seqNo=2]
Solution 4 (@Observes(during = TransactionPhase.AFTER_COMPLETION))

15:00:41,126 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=0]
15:00:41,226 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=1]
15:00:41,326 [com.piotrnowicki.EventGenerator] (http-/127.0.0.1:8080-1) Generating Event: MyEvent[seqNo=2]
15:00:41,432 [com.piotrnowicki.EventConsumer] (EJB default – 10) Receiving event: MyEvent[seqNo=2]
15:00:41,432 [com.piotrnowicki.EventConsumer] (EJB default – 4) Receiving event: MyEvent[seqNo=1]
15:00:41,432 [com.piotrnowicki.EventConsumer] (EJB default – 5) Receiving event: MyEvent[seqNo=0]

Solution 5 – EJB Producer and CDI Consumer II

上述我们一直让观察者异步.我们也可以让事件生产者异步. 
@Stateless
@Path("/produce")
public class EventGenerator {
    // ...

    @Resource
    private SessionContext sctx;

    @Path("/cdiBean/{eventsNum}")
    @GET
    public String generateEvents(@PathParam("eventsNum") int numberOfEventsToGenerate) {
        for (int i = 0; i < numberOfEventsToGenerate; i++) {
            sctx.getBusinessObject(EventGenerator.class).fireEvent(new MyEvent(i));
        }

        return "Finished. Generated " + numberOfEventsToGenerate + " events.";
    }

    @Asynchronous
    public void fireEvent(final MyEvent event) {
        events.fire(event);
    }
}
仔细看看EJB使用sessioncontext。在此情况下，因为我们希望在容器派遣我们方法的调用，并添加了它的异步性质。我们不希望使之成为本地呼叫，所以我们拒绝使用隐含此对象。 
public class EventConsumer {
    public void consumeEvent(@Observes MyEvent myEvent) throws InterruptedException { ... }
}
00:40:32,820 [com.piotrnowicki.EventGenerator] (EJB default – 2) Generating Event: MyEvent[seqNo=1]
00:40:32,820 [com.piotrnowicki.EventGenerator] (EJB default – 3) Generating Event: MyEvent[seqNo=2]
00:40:32,820 [com.piotrnowicki.EventGenerator] (EJB default – 1) Generating Event: MyEvent[seqNo=0]
00:40:32,821 [com.piotrnowicki.EventConsumer] (EJB default – 1) Receiving event: MyEvent[seqNo=0]
00:40:32,821 [com.piotrnowicki.EventConsumer] (EJB default – 2) Receiving event: MyEvent[seqNo=1]
00:40:32,821 [com.piotrnowicki.EventConsumer] (EJB default – 3) Receiving event: MyEvent[seqNo=2]
Asynchronous: yes
Thread-safe observer method: no

Solution 6 – CDI With JMS

https://weblogs.java.net/blog/jjviana/archive/2010/04/13/decoupling-event-producers-and-consumers-jee6-using-cdi-and-jms


转载于:https://my.oschina.net/zhaoqian/blog/351634

「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Asynchronous Android Programming
08-28
"Asynchronous Android Programming" English | ISBN: 1785883240 | 2016 | 394 pages About This Book Construct scalable and performant applications to take advantage of multi-thread asynchronous ...
Pro Asynchronous Programming with .NET
04-28
Pro Asynchronous Programming with .NET teaches the essential skill of asynchronous programming in .NET. It answers critical questions in .NET application development, such as: how do I keep my program...
CDI services--Event（事件）
weixin_30791095的博客
04-14 96
Cdi中的event事件,是整个CDI的精华所在之一.其有点类似设计模式中的观察者模式.但也有不同的地方.如下3点: 不仅是生产者(producers)从观察者(observers)解耦.观察者也从生产者解耦. 观察者可以指定“选择器”的组合来缩小的事件通知 观察者可以立即通知,或者可以指定交付的事件应该推迟到当前事务的结束。 即用一种维护生产者和观察者之间的分离代码的方式，来产生...
Handling of asynchronous events---reference
01-23 129
http://www.win.tue.nl/~aeb/linux/lk/lk-12.html 12.Handling of asynchronous events One wants to be notified of various events, like data that has become available, files that have changed, and ...
异步CDI事件
最佳 Java 编程
05-15 300
几天前，在我们的常规代码审查中，我的一位同事提出了一个问题，即如果可能，一次同时调用CDI观察者（这样的方法带有参数@Observes的方法）会发生什么？用于不同的事件实例。 换句话说，在产生少量事件之后，以下方法是否可能同时被多个线程处理： public void observe(@Observes MyEvent myEvent) { ... } 考虑一下之后，我决定运行一些测试并在...
CDI Event解析
weixin_33743661的博客
07-20 78
CDI(Contexts And Dependency Injection)是JavaEE 6标准中一个规范，将依赖注入IOC/DI上升到容器级别， 它提供了Java EE平台上服务注入的组件管理核心，简化应该是CDI的目标，让一切都可以被注解被注入。Contexts概念和我们之前在DCI架构中 讨论的业务场景不一样，包含有容器技术架构场景的意思，场景包括四种：request (event), ...
论文阅读：EventSR: From Asynchronous Events to Image Reconstruction, Restoration...[CVPR 2020]
Jee_King的博客
08-13 394
php cdi_异步CDI事件
最佳 Java 编程
06-08 109
php cdi 几天前，在我们的常规代码审查中，我的一位同事提出了一个问题，即如果可能，一次同时调用CDI观察者（这样的方法带有参数@Observes ）将发生多次？用于不同的事件实例。 换句话说，在产生少量事件之后，是否有可能同时由多个线程处理以下方法： public void observe(@Observes MyEvent myEvent) { ... } 考虑一下之后，我决定运行一...
activiti中的bug列表
热门推荐
分享牛
11-21 2万+
分享牛原创(尊重原创 转载对的时候第一行请注明，转载出处来自分享牛http://blog.csdn.net/qq_30739519)Bug[ACT-1968] - Custom Database schema on PostgreSQL not working[ACT-4113] - REST Task API Not working: /service/runtime/tasks?assigne
Asynchronous Design Methodologies.pdf
11-04
Asynchronous design has been an active area of research since at least the mid 1950’s, but has yet to achieve widespread use. We examine the benefits and problems inherent in asynchronous ...
Asynchronous Programming Patterns .net异步编程模型
12-21
The .NET Framework provides three patterns for performing asynchronous operations: Asynchronous Programming Model (APM) pattern Event-based Asynchronous Pattern (EAP) Task-based Asynchronous Pattern ...
Asynchronous_FIFO_asynchronousfifo_verliog_空化_
09-30
异步FIFO（First-In-First-Out）是数字系统设计中的一个重要组件，特别是在处理高速数据传输和时钟域跨越问题时。在这个项目中，我们关注的是一个使用Verilog实现的异步FIFO，它包含了空满判断、指针同步以及内存...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 531
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
ShardingSphere
Casual_Lei的博客
07-04 651
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 343
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
maven配置使用nexus仓库
ApexPredator的博客
07-03 227
maven配置使用nexus仓库
图片压缩代码和实际操作页面
最新发布
英雄汉孑的博客
07-05 921
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
JavaSE阶段面试题（一）
tq02的博客
07-03 608
本章节主要讲述SE阶段的常见面试题
asynchronous reset
09-06
Asynchronous reset is used to initialize a system when it is first turned on. It is an input signal that is not synchronized with the clock signal of a sequential system. The purpose of using an ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值