3.3 用例2: job queue 示例

3.3 Use case two: the job queue example

3.3 用例2: job queue 示例

 

The second use case focuses on job queues to illustrate point-to-point messaging. This

example uses a Producer class to send job messages to a job queue and a Consumer

class for registering a Listener class to consume messages from queues in an asynchronous

manner. These three classes provide the functionality necessary to show

how JMS point-to-point messaging should work. The classes in this example are

extremely similar to those used in the stock portfolio example. The difference

between the two examples is the JMS messaging domain that each uses.

The Producer class in this example sends messages to the JOBS.suspend and

JOBS.delete queues and the Consumer class consumes. 

 

Figure 3.3 contains a high-level diagram of the job queue example’s functionality.

The Producer class uses a single JMS MessageProducer to send 1,000 job messages

in blocks of 10 randomly across the two queues. After sending 1,000 messages total,

it’ll shut down. The Consumer class uses one JMS MessageConsumer per queue and registers

a JMS MessageListener on each queue to utilize the message and output its contents.

 

第二个关于job queue的例子旨在说明点对点消息系统.这个例子使用Producer类发送job消息到

消息队列,同时使用Consumer类来注册Listener类以便以异步方式处理消息队列中的消息.

这三个类提供的功能展示了JMS点对点消息是如何发送和接收的.这个例子中的三个类和stock portfolio

例子中相应的类非常相似,两个例子的不同点在于各自使用了不同的消息系统.本例中Producer类发送

消息到消息队列JOBS.suspend和JOBS.delete,Consumer类从消息队列接收和处理消息.

图3.3概述了job queue例子的功能.Producer类使用单一的JMS MessageProducer发送1000个job消息,

这些消息以10个为一组随机的发送到两个消息队列之一.在发送1000个消息之后,Producer类自动关闭.

Consumer使用单一的JMS MessageConsumer为每一个消息队列注册JMS MessageListener,

JMS MessageListener在处理消息之后输出消息内容.

 

3.3.1 Running the job queue example

3.3.1 运行job queue实例

 

The steps for executing the job queues example are nearly identical to the previous

example:

1 Start up ActiveMQ

2 Run the Producer class

3 Run the Consumer class

Again, these steps are simple, but there’s one exception to note. When using PTP messaging,

queues will hold messages until they’re consumed or the messages expire. So

the Producer can be started before the Consumer and the Consumer won’t miss any

messages.

Just as in the stock portfolio example, the first task is to start up ActiveMQ. You’ll

be spared the output from this task, as it’s the same as shown in section1.6 and none

of the default configuration has been changed.

Next, open a second terminal or command line to execute the Producer as shown

here.

 

运行job queue这个例子的步骤和运行前面一个例子的步骤几乎相同:

1 启动ActiveMQ

2 运行Consumer类

3 运行Publisher类

 

同样,这些步骤很简单,但是有一点需要注意.当使用点对点消息时,消息队列会保存消息知道消息被处理

或者过期.所以,Producer类可以在Consumer类之前运行,并且Consumer类不会错过任何消息.

 

如同在stock portfolio实例中那样,第一步是启动ActiveMQ.这里省略了启动ActiveMQ时控制台的输出,

因为这里的输出和清单1.6中一样,ActiveMQ使用的默认配置信息没有修改.

 

下一步,打开第二个终端或命令行窗口,输入下面的命令运行Producer类.

 

Listing 3.5 Running the job queue publisher

 

[amq-in-action-example-src] $ mvn exec:java -Dexec.mainClass=org.apache.activemq.book.ch3.jobs.Publisher

[INFO] Scanning for projects...

[INFO] Searching repository for plugin with prefix: 'exec'.

[INFO] -------------------------------------------------------------------

-----

[INFO] Building ActiveMQ in Action Examples

[INFO] task-segment: [exec:java]

[INFO] -------------------------------------------------------------------

-----

[INFO] Preparing exec:java

[INFO] No goals needed for project - skipping

[WARNING] POM for 'woodstox:wstx-asl:pom:3.2.7:compile' is invalid.

 

Its dependencies (if any) will NOT be available to the current build.

[INFO] [exec:java {execution: default-cli}]

Sending: id: 1000000 on queue: queue://JOBS.delete

Sending: id: 1000001 on queue: queue://JOBS.delete

Sending: id: 1000002 on queue: queue://JOBS.delete

Sending: id: 1000003 on queue: queue://JOBS.delete

Sending: id: 1000004 on queue: queue://JOBS.delete

Sending: id: 1000005 on queue: queue://JOBS.delete

Sending: id: 1000006 on queue: queue://JOBS.delete

Sending: id: 1000007 on queue: queue://JOBS.delete

Sending: id: 1000008 on queue: queue://JOBS.delete

Sending: id: 1000009 on queue: queue://JOBS.delete

Published '10' of '10' job messages

Sending: id: 1000010 on queue: queue://JOBS.delete

Sending: id: 1000011 on queue: queue://JOBS.suspend

...

Published '10' of '30' job messages

...

 

Note that no arguments are necessary to execute the Producer in listing 3.5. The

Publisher class contains two queues to which it publishes named delete and suspend;

hence, the use of those words in the output. The Producer will continue until it sends

a total of 1,000 messages to the two queues and then it’ll shut down.

The third task is to open another terminal or command line and execute the Consumer

to consume the messages from the two queues. This command is shown next.

 

注意,清单3.5中运行Producer类不需要任何参数.Producer发送消息到两个名称分别为delete和suspend的消息队列.

因此,在输出中会用到两个消息对列的名称.Producer发送1000个消息到两个消息队列后自动关闭.

 

第三步是打开第三个终端或命令行控制台并执行Consumer类以接受和发送消息.执行Consumer类的命令如下:

 

Listing 3.6 Running the job queue consumer

 

[amq-in-action-example-src] $ mvn exec:java -Dexec.mainClass=org.apache.activemq.book.ch3.jobs.Consumer

[INFO] Scanning for projects...

[INFO] Searching repository for plugin with prefix: 'exec'.

[INFO] -------------------------------------------------------------------

-----

[INFO] Building ActiveMQ in Action Examples

[INFO] task-segment: [exec:java]

[INFO] -------------------------------------------------------------------

-----

[INFO] Preparing exec:java

[INFO] No goals needed for project - skipping

[WARNING] POM for 'woodstox:wstx-asl:pom:3.2.7:compile' is invalid.

Its dependencies (if any) will NOT be available to the current build.

[INFO] [exec:java {execution: default-cli}]

suspend id:1000003

suspend id:1000010

suspend id:1000012

suspend id:1000013

suspend id:1000015

suspend id:1000022

suspend id:1000025

suspend id:1000027

delete id:1000000

delete id:1000001

delete id:1000002

delete id:1000004

delete id:1000005

...

The Consumer will run fast at first, consuming all the messages already on the queues.

When it catches up to where the Producer is in sending the 1,000 messages, the

Consumer slows down and keeps up with the Publisher until it completes. When all

the messages have been sent and the Producer shuts itself down, you’ll need to press

CTRL-C in the third terminal where the Consumer is running to shut it down.

This concludes the job queue example. Now you’ve seen how well ActiveMQ works

in a point-to-point messaging scenario.

 

Consumer类在开始的时候快速执行,处理消息队列中的的消息.当Producer发送的1000个消息处理完后,

Consumer慢下来,等待Publisher类发送消息直到Publisher完成发送1000个消息并自动关闭.当Producer

发送完1000个消息后,Producer自动关闭后,你需要在第三个终端或命令行控制台窗口按下CTRL+C键以便

关闭Consumer类.这就是job queue的例子.现在你已经知道点对点消息是如何在ActiveMQ中工作的.