RabbitMQ(三):发布订阅(Publish/Subscribe)

前言

先决条件
✔️ 正确安装 RabbitMQ 并将其运行在 localhost:5672 上
✔️ 已经了解了 RabbitMQ 中的一些基础概念

第一篇教程中,我们展示了如何利用 Spring Initializr 创建一个具有 RabbitMQ 依赖项的项目,以创建一个 Spring AMQP 程序。

上篇教程中,我们创建了一个包含两个消费者的工作队列,每个任务只分发给一个工作者(worker)。

在本篇教程中,我们要做的跟之前完全不一样——分发一个消息给多个消费者(consumers)。这种模式被称为”发布/订阅”。

交换器(Exchanges)

在本教程的前面部分,我们发送和接收到队列中的消息,现在是时候在 RabbitMQ 中引入完整的消息传递模式了。

让我们快速回顾一下之前了解的内容:

  • 生产者(producer):发送消息的程序
  • 队列(queue):存储消息的缓冲器
  • 消费者(consumer):接收消息的程序

RabbitMQ 消息模型的核心理念是:发布者(producer)不会直接发送任何消息给队列。事实上,发布者(producer)甚至不知道消息是否已经被投递到队列。

发布者(producer)只需要把消息发送给一个交换器(exchange)。交换器非常简单,它一边从发布者方接收消息,一边把消息推送到队列。交换器必须知道如何处理它接收到的消息,是应该推送到指定的队列还是多个队列,或者是直接忽略消息。这些规则是通过交换器类型(exchange type)来定义的。

有几个可供选择的交换器类型:direct, topic, headers和fanout。我们在这里主要说明最后一个——fanout。fanout exchange 很简单,你可能从名字上就能猜测出来,它把消息发送给它所知道的所有队列。这正是我们所需要的。

先创建一个fanout类型的交换器,命名为”tut.fanout”

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
@Profile({"tut3", "pub-sub"})
@Configuration
public class Tut3Config {

/**
* 定义一个 Exchange
*
* @return FanoutExchange
*/
@Bean
public FanoutExchange queue() {
return new FanoutExchange("tut.fanout");
}

/**
* 消费者一端的配置:queues、bindings
*/
@Profile("receiver")
private static class ReceiverConfig {

@Bean
public Queue autoDeleteQueue1() {
return new AnonymousQueue();
}

@Bean
public Queue autoDeleteQueue2() {
return new AnonymousQueue();
}

@Bean
public Binding binding1(FanoutExchange fanout, Queue autoDeleteQueue1) {
return BindingBuilder.bind(autoDeleteQueue1).to(fanout);
}

@Bean
public Binding binding2(FanoutExchange fanout, Queue autoDeleteQueue2) {
return BindingBuilder.bind(autoDeleteQueue2).to(fanout);
}

@Bean
public Tut3Receiver receiver() {
return new Tut3Receiver();
}

}

@Bean
@Profile("sender")
public Tut3Sender sender() {
return new Tut3Sender();
}

}

和之前的两个教程一样,我们定义了两个profiles(tut3、pub-sub)以保证我们能运行指定的示例。然后创建了一个消费者端的配置,并在其中定义了两个AnonymousQueue和两个Binding以便将相应的队列和交换器绑定起来。

交换器列表
rabbitmqctl 能够列出服务器上所有的交换器。这个列表中有一些叫做 amq.* 的交换器。这些都是默认创建的,不过这时候你还不需要使用他们。

1
2
3
4
5
6
7
8
$ sudo rabbitmqctl list_exchanges
Listing exchanges ...
logs fanout
amq.direct direct
amq.topic topic
amq.fanout fanout
amq.headers headers
...done.

未命名交换器(Nameless exchange)
在之前,我们对交换一无所知,但依然能够将消息发送到队列。这是怎么回事?因为我们使用了默认的交换器,它是用空字符串(””)来标识的。
我们之前是这样发送消息的:

1
template.convertAndSend(queue.getName(), message);
而具体源码如下,可以看出之前我们使用的是默认的空字符定义的交换器
1
2
3
4
5
6
7
8
9
10
// RabbitTemplate
@Override
public void convertAndSend(String routingKey, final Object object) throws AmqpException {
convertAndSend(this.exchange, routingKey, object, (CorrelationData) null);
}

private volatile String exchange = DEFAULT_EXCHANGE;

/* Alias for amq.direct default exchange. /
private static final String DEFAULT_EXCHANGE = “”;

临时队列(Temporary queues)

我们之前使用的是具有指定名称的队列(hello 和 work-queues)。能够命名队列对我们而言至关重要——我们需要将工作进程指向同一个队列。当我们想要在生产者和消费者之间共享队列时,给队列一个名字很重要。

但是我们的日志记录器并不是这样。我们希望记录到所有的日志消息,而不仅仅是它们的一部分。我们也只对当前的消息感兴趣,而对旧的消息不感兴趣。为了解决这个问题,我们需要做两件事情。
首先,每当我们连接到 RabbitMQ,我们需要一个新的空的队列。我们可以创建一个具有随机名称的队列,或者最好让服务器为我们选择一个随机的队列名。
其次,当与消费者(consumer)断开连接的时候,这个队列应当被立即删除。

在 Spring AMQP 中,我们可以使用AnonymousQueue来作为临时队列。它是一个非持久化的、独占的、可自动删除的队列。

1
2
3
4
5
6
7
8
9
@Bean
public Queue autoDeleteQueue1() {
return new AnonymousQueue();
}

@Bean
public Queue autoDeleteQueue2() {
return new AnonymousQueue();
}

此时我们的队列名字看起来会像这样:amq.gen-JzTY20BRgKO-HjmUJj0wLg

绑定(Bindings)

我们已经创建了一个fanout exchange和两个队列,现在我们需要告诉交换所将消息发送到我们的队列。交换器和队列之间的关系称为绑定。在上面的Tut3Config中,您可以看到我们有两个绑定,每个AnonymousQueue都有一个绑定。

1
2
3
4
@Bean
public Binding binding1(FanoutExchange fanout, Queue autoDeleteQueue1) {
return BindingBuilder.bind(autoDeleteQueue1).to(fanout);
}

绑定列表
你可以使用 rabbitmqctl list_bindings 列出所有现存的绑定。

1
rabbitmqctl list_bindings

代码整合

生产者


发出消息的生产者程序与以前的没有多大区别。最重要的变化是我们现在要发布消息给我们的fanout exchange,而不是默认的交换器。发送时我们需要提供一个routingKey,但是对于fanout exchange,这个值将被忽略。

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
public class Tut3Sender {

@Autowired
private AmqpTemplate template;

@Autowired
private FanoutExchange fanout;

private int dots = 0;
private int count = 0;

@Scheduled(fixedDelay = 1000, initialDelay = 500)
public void send() {
StringBuilder builder = new StringBuilder("Hello");
if (dots++ == 3) {
dots = 1;
}
for (int i = 0; i < dots; i++) {
builder.append('.');
}
builder.append(Integer.toString(++count));
String message = builder.toString();
template.convertAndSend(fanout.getName(), "", message);
System.out.println(" [x] Sent '" + message + "'");
}

}

说明:

  1. 禁止发布到不存在的交换器
  2. 如果没有任何队列绑定到交换器,消息将丢失

消费者

我们定义两个消费者分别监听两个队列

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
public class Tut3Receiver {

@RabbitListener(queues = "#{autoDeleteQueue1.name}")
public void receiver1(String in) throws InterruptedException {
receive(in, 1);
}

@RabbitListener(queues = "#{autoDeleteQueue2.name}")
public void receiver2(String in) throws InterruptedException {
receive(in, 2);
}

private void receive(String in, int instance) throws InterruptedException {
StopWatch watch = new StopWatch();
watch.start();
System.out.println("instance " + instance + " [x] Received '" + in + "'");
doWork(in);
watch.stop();
System.out.println("instance " + instance + " [x] Done in "
+ watch.getTotalTimeSeconds() + "s");
}


private void doWork(String in) throws InterruptedException {
for (char ch : in.toCharArray()) {
if (ch == '.') {
Thread.sleep(1000);
}
}
}
}

运行

maven 编译

1
mvn clean package -Dmaven.test.skip=true

运行(建议先运行消费者,再运行生产者)

1
2
java -jar target/rabbitmq-tutorial-0.0.1-SNAPSHOT.jar --spring.profiles.active=tut3,receiver  --tutorial.client.duration=60000
java -jar target/rabbitmq-tutorial-0.0.1-SNAPSHOT.jar --spring.profiles.active=tut3,sender --tutorial.client.duration=60000

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Sender
Ready ... running for 60000ms
[x] Sent 'Hello.1'
[x] Sent 'Hello..2'
[x] Sent 'Hello...3'

// Receiver
Ready ... running for 60000ms
instance 2 [x] Received 'Hello.1'
instance 1 [x] Received 'Hello.1'
instance 2 [x] Done in 1.002s
instance 1 [x] Done in 1.002s
instance 2 [x] Received 'Hello..2'
instance 1 [x] Received 'Hello..2'
instance 2 [x] Done in 2.003s
instance 1 [x] Done in 2.003s
instance 1 [x] Received 'Hello...3'
instance 2 [x] Received 'Hello...3'
instance 1 [x] Done in 3.011s
instance 2 [x] Done in 3.011s

代码地址:https://github.com/zhaoyibo/rabbitmq-tutorial
相关文章:

  1. RabbitMQ(零):基础概念
  2. RabbitMQ(一):Hello World
  3. RabbitMQ(二):工作队列(Work queues)
  4. RabbitMQ(三):发布订阅(Publish/Subscribe)
  5. RabbitMQ(四):路由(Routing)
  6. RabbitMQ(五):主题(Topics)
  7. RabbitMQ(六):远程过程调用(RPC)

参考

RabbitMQ Tutorial Three