RabbitMQ指南(Java)
原文地址:http://www.rabbitmq.com/getstarted.html 翻译得不好,欢迎指出。
一、Hello World
1、基本概念介绍
RabbitMQ是一个消息代理(或者说消息队列),它的主要意图很明显,就是接收和转发消息。你可以把它想象成一个邮局:当你把一封邮件放入邮箱,邮递员会帮你把邮件送到收件人的手上。在这里,RabbitMQ就好比一个邮箱、邮局或者邮递员。
RabbitMQ和邮局的主要区别在于,RabbitMQ不是处理邮件,而是接收、存储和将消息以二进制的方式转发出去。
在这里,我们先说明一些RabbitMQ中涉及到的术语。
-
生产者(Producer)。生产表示只负责发送的意思,一个只负责发送消息的程序称为一个生产者,我们通过一个P来表示一个生产者,如下图:
-
队列(Queue)。队列就好比一个邮箱,它在RabbitMQ的内部。虽然消息在RabbitMQ和程序之间传递,但是它们是存储在队列中的。一个队列没有大小的限制,你想存储多少条消息就存储多少条,它的本质是一个无限大的缓冲区。任何生产者都可以往一个队列里发送消息,同样的,任何消费者也可以从一个队列那接收到消息。我们用下图来表示一个队列,队列上面的文字表示这个队列的名字:
-
消费者(Consumer)。接收和发送的过程很类似,一个消费者程序通常是等待别人发送消息给它。我们通过一个C来表示一个消费者,如下图:
注意一点,消费者、生产者和消息队列可以不用运行在同一台机器上。实际上,在大多数的应用程序中,它们并不是在同一台机器上运行的。
##**2、"Hello World"**在这一小节中,我们将编写两个Java程序,一个作为生产者,发送一条简单的消息;另一个作为消费者,接收并打印出接收到的消息。在这里,我们先不讨论Java API的具体细节,而是先编写出一个可运行的“Hello World”程序。
在下图中,“P”表示一个生产者,"C"表示一个消费者,中间的矩形表示一个队列。
![一个简单的结构](//img-blog.csdn.net/20160902222011523)RabbitMQ会涉及许多协议,其中AMQP协议是一个开放式的、通用的消息协议。RabbitMQ支持很多编程语言,我们这里通过RabbitMQ提供的Java客户端来进行演示。请自行下载、安装RabbitMQ和相关jar包。
(1)发送
在下面的代码中,我们用Send来表示一个发送端,用Recv来表示一个接收端。发送端会先连接RabbitMQ,并发送一个简单的消息后关闭。
对于Send而言,我们需要导入一些相关的类:
``` import com.rabbitmq.client.ConnectionFactory; import com.rabbitmq.client.Connection; import com.rabbitmq.client.Channel; ```
首先,先建立一个类,并为队列起一个名:
``` public class Send {private final static String QUEUE_NAME = "hello";
public static void main(String[] argv)
throws Exception {
...
}
}
<p>然后我们创建一个connection:</p>
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
<p>connection是一个抽象的sockect连接,在连接时,我们需要注意一下登录认证信息。在这里我们连接到本地机器,所以填写上“localhost”。如果我们想要连接到其他机器上,只需要填写上其他机器的IP地址即可。</p>
<p>接下来,我们创建一个channel,大多数的API都可以通过这个channel来获取。</p>
<p>如果要发送消息,我们必须先声明一个队列,然后我们才可以把消息发送到这个队列里去:</p>
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
String message = "Hello World!";
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println(" [x] Sent '" + message + "'");
<p>声明一个队列后,仅当队列不存在时,队列才会被创建。另外,消息的内容是一个字节数组,所以我们需要先对消息进行编码。最后,我们需要关闭连接。</p>
channel.close();
connection.close();
<p><b>以上就是Send.java类的所有代码</b></p>
><p><b>发送端运行不起来</b></p>
> <p>如果你是第一次使用RabbitMQ,而且没有看到打印的“Sent”信息,你可能会奇怪是哪里出问题了。这里有可能是RabbitMQ在启动时没有足够的磁盘空间(默认情况下最少需要1Gb的空间),所以它会拒绝接收任何消息。通过查看日志文件可以确定是否是由这个原因所造成的。如果有必要,我们也可以通过修改配置文件中的disk_free_limit来降低大小的限制。</p>
###**(2)接收**
<p>上面的代码是发送端的。我们的接收端是从RabbitMQ那获取消息,所以并不是像发送端那样发送一个简单的消息,而是需要一直监听获取消息,并打印输出。</p>
![接收端](//img-blog.csdn.net/20160902232231436)
<p>对于接收端而言,它需要导入如下的类:</p>
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
<p>DefaultConsumer是一个实现了Consumer接口的类,我们可以使用它来获取发送过来的消息。</p>
<p>跟Send一样,我们先创建一个connection和channel,并声明一个接收消息的队列。注意一点,这里的队列名要和Send的相匹配。</p>
public class Recv {
private final static String QUEUE_NAME = "hello";
public static void main(String[] argv)
throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
...
}
}
<p>在这里我们同样声明了一个队列,因为我们可能在启动发送端之前就先启动了接收端,在我们开始接收消息之前,我们要先确认队列是否存在。</p>
<p>我们告诉RabbitMQ通过这个队列给我们发送消息,因此RabbitMQ会异步的给我们推送消息,我们需要提供一个回调对象用来缓存消息,直到我们准备使用它。这就是DefaultConsumer所做的事情。</p>
Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
throws IOException {
String message = new String(body, "UTF-8");
System.out.println(" [x] Received '" + message + "'");
}
};
channel.basicConsume(QUEUE_NAME, true, consumer);
<p><b>以上就是Recv.java类的所有代码</b></p>
##**3、代码整合**
<p>编译并运行以上程序,你会看到接收端将会收到并打印出来自发送端的“Hello World!”消息。</p>
<p>你可以在类路径下编译这些文件:</p>
$ javac -cp rabbitmq-client.jar Send.java Recv.java
<p>为了运行它们,你需要rabbitma-client.jar和它的依赖文件。在一个终端运行发送者:</p>
$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar Send
<p>然后运行接收者:</p>
$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar Recv
<p>在windows环境中,我们使用分号代替冒号来分隔classpath上的选项。</p>
<blockquote>
<p><b>Hint</b></p>
<p>你可以设置一个环境变量到classpath中:</p>
<pre>
$ export CP=.:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar
$ java -cp $CP Send
</pre>
在windows上:
<pre>
> set CP=.;commons-io-1.2.jar;commons-cli-1.1.jar;rabbitmq-client.jar
> java -cp %CP% Send
</pre>
</blockquote>
##**4、个人补充**
###**(1)登录认证**
<p>在实际使用中,RabbitMQ并不是简单的通过指定一个IP就可以进行连接的,它还需要指定端口号、用户名和密码。就像是这样:</p>
factory.setHost("127.0.0.1");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
<p>当没有明确指明登录认证信息的时候,就会使用默认值来进行登录,以上都是默认的认证信息。</p>
<p>另外,我们也可以通过设置URI来进行连接,URI的格式如下:</p>
amqp://username:password@host:port
factory.setUri("amqp://guest:guest@localhost:5672");
#**二、工作队列**
![这里写图片描述](//img-blog.csdn.net/20160903111440412)
在第一部分中,我们的程序结构非常简单。在接下来,我们将会创建一个工作队列,向多个消费者分发任务。
##**1、准备**
<p>在之前的程序中,我们发送了一个包含“Hello World!”的消息,现在我们发送一些字符串用来表示复杂的任务。在这里,因为我们没有真正意义上的任务,比如调整图片的大小或者渲染pdf文件,所以我们通过Thread.sleep()函数来模拟程序的处理时间。我们用字符串中的句号来代表它的复杂度,每一个句号表示要花费一秒的工作时间。例如,一个“Hello...”的字符串就表示它需要3秒钟的处理时间。</p>
<p>我们会稍微修改我们之前程序中的Send.java代码,使其允许发送包含任意内容的消息。这个程序将会定时向队列中发送任务,我们把它命名为NewTask.java:</p>
String message = getMessage(argv);
channel.basicPublish("", "hello", null, message.getBytes());
System.out.println(" [x] Sent '" + message + "'");
<p>一些帮助我们从命令行的参数中获取消息的函数:</p>
private static String getMessage(String[] strings){
if (strings.length < 1)
return "Hello World!";
return joinStrings(strings, " ");
}
private static String joinStrings(String[] strings, String delimiter) {
int length = strings.length;
if (length == 0) return "";
StringBuilder words = new StringBuilder(strings[0]);
for (int i = 1; i < length; i++) {
words.append(delimiter).append(strings[i]);
}
return words.toString();
}
<p>我们的Recv.java程序也需要作出一些修改:它需要从队列中获取消息,并统计消息中有多少个“.”,然后sleep相应的时间。我们把它取名为Worker.java:</p>
final Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String message = new String(body, "UTF-8");
System.out.println(" [x] Received '" + message + "'");
try {
doWork(message);
} finally {
System.out.println(" [x] Done");
}
}
};
boolean autoAck = true; // acknowledgment is covered below
channel.basicConsume(TASK_QUEUE_NAME, autoAck, consumer);
private static void doWork(String task) throws InterruptedException {
for (char ch: task.toCharArray()) {
if (ch == '.') Thread.sleep(1000);
}
}
<p>编译以上程序:</p>
$ javac -cp rabbitmq-client.jar NewTask.java Worker.java
##**2、轮询分发**
<p>使用任务队列的优势之一是任务的并行处理。如果现在积压了一大堆任务,我们仅需要添加更多的消费者即可,这是很容易扩展的。</p>
<p>首先,我们尝试同时运行两个消费者实例,他们都会从队列里去获取消息,如下。</p>
<p>你需要打开三个控制台,其中两个用来运行消费者程序,分别称为C1和C2</p>
shell1$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar
Worker
[*] Waiting for messages. To exit press CTRL+C
shell2$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar
Worker
[*] Waiting for messages. To exit press CTRL+C
<p>第三个控制台用来运行生产者程序。一旦你开启了消费者程序,就可以启动生产者了:</p>
shell3$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar
NewTask First message.
shell3$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar
NewTask Second message..
shell3$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar
NewTask Third message...
shell3$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar
NewTask Fourth message....
shell3$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar
NewTask Fifth message.....
<p>让我们看看消费者得到了什么消息:</p>
shell1$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar
Worker
[*] Waiting for messages. To exit press CTRL+C
[x] Received 'First message.'
[x] Received 'Third message...'
[x] Received 'Fifth message.....'
shell2$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar
Worker
[*] Waiting for messages. To exit press CTRL+C
[x] Received 'Second message..'
[x] Received 'Fourth message....'
<p>默认情况下,RabbitMQ会一直把消息发送给下一个消费者,平均情况下,每个消费者获得的消息是一样多的。这种分发方式叫做轮询,你可以尝试运行更多的消费者。</p>
##**3、消息确认**
<p>处理一个任务可能需要花费数秒时间,你可能会好奇如果一个消费者执行了一个长任务,并且在完成处理前就挂了的情况下会发送什么事。就拿我们当前的代码来说,一旦RabbitMQ将消息传递给消费者,消息就会从内存中删除。在这种情况下,如果你强行关闭正在运行的消费者,那么它正在处理的消息就会丢失。那些发送给这个消费者但还没有开始处理的消息也会一并丢失。</p>
<p>但是,我们并不想丢失任何消息。实际上,如果一个消费者挂了,我们更希望将消息传递给其他的消费者消费。</p>
<p>为了保证消息不会丢失,RabbitMQ支持消息确认(acknowledgments)机制。Ack是由消费者发送的,用来告诉RabbitMQ这个消息已经接收到并处理完成,可以从内存中删除它了。</p>
<p>如果一个消费者没有发送ack就挂了,RabbitMQ会认为这个消息没有处理完成并将消息重新入队。如果这时有其他消费者在运行,它将会把这个消息发送给另一个消费者。通过这种方式,即使消费者挂了,也可以确保消息不会丢失。</p>
<p>在这里不存在超时的概念,只有在消费者挂了的情况下,RabbitMQ才会重发消息,否则就会一直等待消息的处理,即使需要花费很长的时间来处理。</p>
<p>消息确认机制默认情况下是开启的。现在我们要关闭它,改为手动提交确认信号。当处理完一个任务后,我们将手动提交。</p>
channel.basicQos(1); // accept only one unack-ed message at a time (see below)
final Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String message = new String(body, "UTF-8");
System.out.println(" [x] Received '" + message + "'");
try {
doWork(message);
} finally {
System.out.println(" [x] Done");
channel.basicAck(envelope.getDeliveryTag(), false);
}
}
};
boolean autoAck = false;
channel.basicConsume(TASK_QUEUE_NAME, autoAck, consumer);
<p>通过这段代码,我们可以保证即使你通过Ctrl+C来关闭一个消费者,也不会丢失任何消息。那些没有发送确认信号的消息将会很快被重发。</p>
> <p><b>忘记发送确认信号</b></p>
> <p>忘记写basicAck是一个很普遍的错误,但是这会产生严重的后果。当你的客户端退出后,所有的消息将会被重新发送,RabbitMQ会越来越占内存,因为它不会删除那些没有发送确认信号的消息。</p>
> <p>想要调试这种类型的错误,你可以使用rabbitmqctl打印出messages_unacknowledged属性:</p>
> <pre>$ sudo rabbitmqctl list_queues name messages_ready messages_unacknowledged
Listing queues ...
hello 0 0
...done.</pre>
##**4、消息持久化**
<p>我们已经学习了如何保证在消费者挂了的情况下,消息也不会丢失。但是如果RabbitMQ挂了,我们的消息仍然会丢失。</p>
<p>当RabbitMQ退出或崩溃时,它将会丢失所有队列和消息,除非你让它不要这么做。通过两个方面可以保证消息不会丢失:对消息和队列进行持久化处理。</p>
<p>首先,我们需要保证RabbitMQ不会丢失我们的队列。为此,我们需要将一个队列声明为一个持久化的队列:</p>
boolean durable = true;
channel.queueDeclare("hello", durable, false, false, null);
<p>虽然这个代码是正确的,但是它却不会执行,因为我们已经定义了一个非持久化的hello队列。RabbitMQ不允许使用不同的参数去重新定义一个已经存在的队列,如果你强行这样做,它将会返回一个错误。有一个快速的解决方案,就是重新声明一个不同名字的队列,比如task_queue:</p>
boolean durable = true;
channel.queueDeclare("task_queue", durable, false, false, null);
<p>需要在生产者和消费者的代码中对queuqDeclare进行修改。</p>
<p>至此,我们可以保证即使RabbitMQ重启,task_queue队列也不会丢失。现在,我们需要对消息进行持久化,通过设置MessageProperties(实现了BasicProperties)的值为PERSISTENT_TEXT_PLAIN即可。</p>
import com.rabbitmq.client.MessageProperties;
channel.basicPublish("", "task_queue",
MessageProperties.PERSISTENT_TEXT_PLAIN,
message.getBytes());
> <p><b>注意:</b></p>
> <p>消息的持久化并不能完全保证消息不会丢失,虽然它会告诉RabbitMQ把消息保存在硬盘上,但是从接收消息到保存消息之间,还是需要一定的时间的。同样,RabbitMQ没有对每个消息做fsync(2)——消息仅仅存在于缓存中,并没有真正的写入硬盘。所以这个持久化并不是健壮的,但是对于简单的工作队列来说已经完全足够了。如果你需要更强大的持久化的话,你可以考虑使用publisher confirms机制。</p>
##**5、公平分发**
<p>你可能会注意到,分发的过程并不是我们所希望的那样。例如在某一情况下有两个消费者,RabbitMQ默认将序号为奇数的消息发送给第一个消费者,序号为偶数的消息发送给另一个消费者,当序号为奇数的消息都是一些很耗时的任务,而序号为偶数的消息都是一些小任务,那么就会造成第一个消费者一直处于忙碌状态,而另一个消费者处理完毕后会处于空等待的状态。RabbitMQ并不会在意这些事情,它只会一直均匀的分发消息。</p>
<p>这种情况的发生是因为RabbitMQ只负责分发消息,它并不关心一个消费者返回了多少个确认信号(即处理了多少条消息),它只是盲目的将第n条消息往第n个消费者发送罢了。</p>
![这里写图片描述](//img-blog.csdn.net/20160903231003801)
<p>为了解决这个问题,我们可以使用basicQos方法,设置prefetchCount = 1。它将会告诉RabbitMQ不要同时给一个消费者超过一个任务,换句话说,就是在一个消费者发送确认信息之前,不要再给它发送新消息了。取而代之的是将消息发送给下一个空闲的消费者。</p>
int prefetchCount = 1;
channel.basicQos(prefetchCount);
> <p><b>注意队列的大小</b></p>
> <p>如果所有的消费者都处于繁忙中,你的队列很快就会被占满。你需要注意这件事,并且添加更多的消费者或者通过其他策略来解决他。</p>
##**6、代码整合**
<p>最终的NewTask.java如下:</p>
import java.io.IOException;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.MessageProperties;
public class NewTask {
private static final String TASK_QUEUE_NAME = "task_queue";
public static void main(String[] argv)
throws java.io.IOException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
String message = getMessage(argv);
channel.basicPublish( "", TASK_QUEUE_NAME,
MessageProperties.PERSISTENT_TEXT_PLAIN,
message.getBytes());
System.out.println(" [x] Sent '" + message + "'");
channel.close();
connection.close();
}
//...
}
<p>Worker.java的代码:</p>
import java.io.IOException;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;
public class Worker {
private static final String TASK_QUEUE_NAME = "task_queue";
public static void main(String[] argv)
throws java.io.IOException,
java.lang.InterruptedException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
channel.basicQos(1);
QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(TASK_QUEUE_NAME, false, consumer);
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
System.out.println(" [x] Received '" + message + "'");
doWork(message);
System.out.println(" [x] Done" );
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
//...
}
#**三、发布和订阅**
<p>在之前的示例中,我们创建了一个工作队列,在这之前,我们都假设每一个消息都准确的发送到一个消费者那里。在接下来,我们将做一些完全不同的事情——将一个消息发送到多个消费者,这种模式被称为发布和订阅模式。</p>
<p>为了说明这个模式,我们将会创建一个简单的日志系统,它由两部分程序组成,一个是发送日志消息,另一个是接收并打印日志消息。</p>
<p>在我们的日志系统中,每一个运行的接收程序都会获取一个消息的拷贝副本。通过这种方式,我们可以让一个消费者把日志记录到硬盘中,同时可以让另一个消费者把日志输出到屏幕上。</p>
<p>在本质上,发送日志消息相当于广播到所有接收者。</p>
##**1、交换机**
<p>在之前,我们都是直接从一个队列中发送或获取消息。现在是时候介绍RabbitMQ中的full messaging模型了。</p>
<p>让我们快速复习下在先前部分中我们所学的知识:</p>
- 一个发送消息的生产者是一个用户程序。
- 一个存储消息的队列是一个缓冲区。
- 一个接收消息的消费者是一个用户程序。
<p>在RabbitMQ的消息模型中,核心思想是生产者不直接将消息发送给队列。实际上,生产者甚至完全不知道消息会被发送到哪个队列中。</p>
<p>相反,生产者只能将消息发送到交换机上。交换机是一个非常简单的东西,它一边从生产者那里接收消息,一边向队列推送消息。交换机必须确切的知道它想要把消息发送给哪些接收者。例如是否发送到一个特定的队列中?还是发送给很多个队列?或者是把消息丢弃等等。这些东西都通过交换机的类型来规定。</p>
![这里写图片描述](//img-blog.csdn.net/20160904002130551)
<p>交换机的类型包括:direct, topic, headers和fanout。我们先关注fanout。让我们先创建一个这种类型的交换机,并称呼它为logs:</p>
channel.exchangeDeclare("logs", "fanout");
<p>fanout类型的交换机非常简单,通过它的名字,你可能已经猜出它的用处了。它将会以广播的方式把接收到的消息发送到它所知道的队列中去,这个正是我们所需要的。</p>
> <p><b>交换机列表</b></p> <p>通过使用rabbitmqctl命令,我们可以列出服务器中的所有交换机:</p> <pre>$
> sudo rabbitmqctl list_exchanges Listing exchanges ...
> direct amq.direct direct amq.fanout fanout amq.headers headers amq.match headers amq.rabbitmq.log
> topic amq.rabbitmq.trace topic amq.topic topic logs
> fanout ...done.</pre>
> <p>在这个列表里,有一些以amq.*开头的交换机和默认(没有名字)的交换机。这些都是默认创建的,而且你不太可能会使用到它们。</p>
> <p><b>匿名交换机</b></p>
> <p>在之前的部分中,我们对交换机毫无概念,但仍然能将消息发送到队列中,那是因为我们使用了默认的交换机,通过使用空串("")来标识它。</p>
> <p>回想一下之前是如何发送消息的:</p>
>
> ``` channel.basicPublish("", "hello", null, message.getBytes()); ```
>
> <p>这里的第一个参数就是交换机的名字。空串表示它是默认交换机或者是匿名交换机:如果routingKey存在的话,消息将通过routingKey路由到特定的队列中去。</p>
<p>现在,我们定义自己命名的交换机:</p>
channel.basicPublish( "logs", "", null, message.getBytes());
##**2、临时队列**
<P>你可能会想起我们之前使用的队列是有特定的名称的(hello和task_queue)。对于我们来说,为一个队列命名是非常有必要的,我们需要指定多个消费者到同一个队列获取消息。当你想在多个生产者和消费者之间共用一个队列,那么为队列命名就非常重要了。</p>
<p>但是对于我们目前来说还不需要。我们想要监听所有日志消息,而不是它的一个子集。同样,我们只会对最新的消息感兴趣,而不是旧消息。为了解决这个问题,我们需要做两件事。</p>
<p>第一,无论什么时候连接RabbitMQ,我们都需要一个新的空队列。为了这样做,我们会创建一个随机的名字,或者直接让服务器给我们一个随机的名字。</p>
<p>第二,一旦我们与消费者断开,队列应该被自动删除。</p>
<p>在Java中,当我们使用无参的queueDeclare(),它将会为我们创建一个非持久化的、专用的、自动删除、带随机名字的队列:</p>
String queueName = channel.queueDeclare().getQueue();
<p>在这里,队列名queueName的值是一个随机产生的字符串,例如amq.gen-JzTY20BRgKO-HjmUJj0wLg。</p>
##**3、绑定**
![这里写图片描述](//img-blog.csdn.net/20160904010328406)
<p>我们已经创建一个fanout类型的交换机和一个队列。现在我们需要告诉交换机发送消息到我们的队列里。在这里,把交换机和队列之间的关系称为绑定。</p>
channel.queueBind(queueName, "logs", "");
<p>从现在开始,logs交换机将会把消息发送到我们的队列中去。</p>
> <p><b>绑定列表</b></p> <p>你可以通过使用rabbitmqctl list_bindings来列出所有绑定。</p>
##**4、代码整合**
![这里写图片描述](//img-blog.csdn.net/20160904010831783)
<p>生产者程序负责发送日志消息,看起来跟以前的代码没有什么区别。最重要的改变是,现在我们把消息发送到我们的logs交换机中,而不是匿名交换机。在发送时我们需要指定一个routingKey,但是在使用fanout类型的交换机时,routingKey的值会被忽略。这是我们的EmitLog.java程序:</p>
import java.io.IOException;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
public class EmitLog {
private static final String EXCHANGE_NAME = "logs";
public static void main(String[] argv)
throws java.io.IOException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
String message = getMessage(argv);
channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
System.out.println(" [x] Sent '" + message + "'");
channel.close();
connection.close();
}
//...
}
<p>正如你所看到的,在建立一个connection之后,我们声明了一个交换机。这个步骤是必须的,因为RabbitMQ禁止把消息发送到一个不存在的交换机。</p>
<p>如果交换机上没有绑定任何队列的话,消息将会被丢弃。但是这个对我们来说是可以接受的,如果没有消费者监听,我们可以安全的丢弃消息。</p>
<p>ReceiveLogs.java的代码如下:</p>
import com.rabbitmq.client.*;
import java.io.IOException;
public class ReceiveLogs {
private static final String EXCHANGE_NAME = "logs";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
String queueName = channel.queueDeclare().getQueue();
channel.queueBind(queueName, EXCHANGE_NAME, "");
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String message = new String(body, "UTF-8");
System.out.println(" [x] Received '" + message + "'");
}
};
channel.basicConsume(queueName, true, consumer);
}
}
<p>像之前那样编译程序,我已经编译完成了。</p>
$ javac -cp .:rabbitmq-client.jar EmitLog.java ReceiveLogs.java
<p>如果你想要把日志保存到文件中,你只需要打开控制台并输入:</p>
$ java -cp .:rabbitmq-client.jar ReceiveLogs > logs_from_rabbit.log
<p>如果你希望在屏幕中看到日志,新建一个终端并运行:</p>
$ java -cp .:rabbitmq-client.jar ReceiveLogs
<p>当然,为了发送日志,输入:</p>
$ java -cp .:rabbitmq-client.jar EmitLog
<p>使用rabbitmqctl list_bindings,你可以验证这代码确实创建和绑定了我们想要的队列。随着两个ReceiveLogs.java程序的运行,你可以看到如下的信息:</p>
$ sudo rabbitmqctl list_bindings
Listing bindings ...
logs exchange amq.gen-JzTY20BRgKO-HjmUJj0wLg queue []
logs exchange amq.gen-vso0PVvyiRIL2WoV3i48Yg queue []
...done.
<p>这个结果简单明了:数据从logs交换机发送到服务器安排的两个队列中去,那正是我们所期望的。</p>
#**四、路由**
<p>在上一节,我们建立了一个简单的日志系统,我们可以将日志信息广播到多个接收者那里去。</p>
<p>接下来,我们将要实现只订阅部分消息。例如,我们只将error类型的日志信息保存到硬盘中去,当然依旧在控制台中打印出所有的日志信息。</p>
##**1、绑定**
<p>在之前的例子中,我们已经建立了绑定,你可以回顾一下代码:</p>
channel.queueBind(queueName, EXCHANGE_NAME, "");
<p>一个交换机跟一个队列之间的绑定,可以理解为:就是这个队列只对这个交换机发送过来的消息感兴趣。</p>
<p>绑定还有另外的一个routingKey参数,为了避免跟basic_publish的参数搞混,我们把它称为binding key。以下是我们通过一个key创建的一个绑定:</p>
channel.queueBind(queueName, EXCHANGE_NAME, "black");
<p>这个binding key的意义取决于交换机的类型,我们之前使用的fanout类型的交换机是会忽略它的值的。</p>
##**2、direct交换类型**
<p>我们之前的日志系统是将所有消息广播到所有消费者那里去。我们想要扩展它,让它能根据消息的严重性来进行过滤。例如,我们只把error类型的错误日志记录到硬盘中去,而不是将硬盘空间浪费在warning或info类型的日志上。</p>
<p>我们使用的fanout类型的交换机没有太多的灵活性,它只能无脑的进行广播。</p>
<p>所以我们将会使用direct类型的交换机来替换它。direct类型交换机的路由规则很简单——它只将消息发送到那些binding key和routing key完全匹配的队列中去。</p>
<p>为了说明清楚,我们看一下下面的结构图:</p>
![这里写图片描述](//img-blog.csdn.net/20160904092318455)
<p>在这里,我们可以看到direct类型的交换机X绑定了两个队列。第一个队列通过一个orange关键字来绑定,第二个队列绑定了两个关键字,分别为black和green。</p>
<p>通过这样的绑定,当交换器接收到routing key为orange的消息的时候,就会发送到队列Q1中去;当接收到 routing key为black或green的消息的时候,就会发送到队列Q2中去;其他类型的消息则会被丢弃。</p>
##**3、多重绑定**
![这里写图片描述](//img-blog.csdn.net/20160904092910071)
<p>用一个binding key绑定多个队列是合法的,在上面的例子中,我们还可以使用black将X和Q1绑定起来。在这里,direct类型的交换机就跟fanout类型的交换机一样,会把消息发送到所有的匹配的队列中去。一个routing key为black的消息将会被发送到Q1和Q2中去。</p>
##**4、发送日志**
<p>我们将会在我们的日志系统中使用这种模型,使用direct类型的交换机来替换fanout类型的交换机。我们可以把routing key作为日志消息的严重级别,通过这种方式,接收程序就可以选择对应的级别进行接收。总之,让我们先看一下如何发送日志:</p>
<p>首先,我们需要创建一个交换机:</p>
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
<p>然后我们准备发送一条消息:</p>
channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes());
<p>在这里为了简化,我们先约定日志的级别分为info、warning和error三种。</p>
##**5、订阅**
<p>接收消息的部分跟之前的程序没有什么不同。唯一的区别就是我们要为队列创建它感兴趣的binding key。</p>
String queueName = channel.queueDeclare().getQueue();
for(String severity : argv){
channel.queueBind(queueName, EXCHANGE_NAME, severity);
}
##**6、代码整合**
![这里写图片描述](//img-blog.csdn.net/20160904094249308)
<p>EmitLogDirect.java的代码:</p>
public class EmitLogDirect {
private static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] argv)
throws java.io.IOException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
String severity = getSeverity(argv);
String message = getMessage(argv);
channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes());
System.out.println(" [x] Sent '" + severity + "':'" + message + "'");
channel.close();
connection.close();
}
//..
}
<p>ReceiveLogsDirect.java的代码</p>
import com.rabbitmq.client.*;
import java.io.IOException;
public class ReceiveLogsDirect {
private static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
String queueName = channel.queueDeclare().getQueue();
if (argv.length < 1){
System.err.println("Usage: ReceiveLogsDirect [info] [warning] [error]");
System.exit(1);
}
for(String severity : argv){
channel.queueBind(queueName, EXCHANGE_NAME, severity);
}
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String message = new String(body, "UTF-8");
System.out.println(" [x] Received '" + envelope.getRoutingKey() + "':'" + message + "'");
}
};
channel.basicConsume(queueName, true, consumer);
}
}
<p>像之前那样编译它们。为了方便,当我们运行实例时,我们使用一个$CP的环境变量来表示类的路径。</p>
<p>如果你只想保存warning和error类型的日志到文件里去,你可以打开控制台,并输入:</p>
$ java -cp $CP ReceiveLogsDirect warning error > logs_from_rabbit.log
<p>如果你想要在屏幕中看到所有的日志信息,你可以打开一个新的终端并做如下操作:</p>
$ java -cp $CP ReceiveLogsDirect info warning error
[*] Waiting for logs. To exit press CTRL+C
<p>另外,例如想要发送error类型的日志信息,可以输入:</p>
$ java -cp $CP EmitLogDirect error "Run. Run. Or it will explode."
[x] Sent 'error':'Run. Run. Or it will explode.'
#**五、topic类型**
<p>在上一部分中,我们改进了我们的日志系统,使用direct类型的交换机代替fanout类型的交换机,得到了一个具有选择性的日志接收系统。</p>
<p>虽然使用了direct类型的交换机改进了我们的系统,但是它依然不完善,它不能根据多个条件进行路由。</p>
<p>在我们的日志系统中,我们可能不仅想要得到各种级别的日志,还想要得到日志的发送源。你可能从syslog unix tool了解过这个概念,它基于severity(info/warn/crit...) 和facility (auth/cron/kern...)来路由日志信息。</p>
<p>那将会给我们带来更多的灵活性,因为我们可能只需要监听那些来自cron的critical日志,而不是所有的kern日志。</p>
<p>为了在我们的日志系统中实现此功能,我们需要使用更加复杂的类型——topic类型的交换机</p>
##**1、topic类型的交换机**
<p>发送到topic类型的交换机的消息不能是随意的routing key,它必须是一个通过点分隔的字符串列表。字符串的内容什么都可以,但是我们一般会给它一个有意义的名字。例如一些合法的routing key就像这样:"stock.usd.nyse", "nyse.vmw", "quick.orange.rabbit"。Routing key中你想要写多少个单词都可以,它的长度上线是255个字节。</p>
<p>Binding key也是一样。Topic类型的交换机的逻辑跟direct类型的非常相似,它也是把消息发送到与routing key匹配的队列中去。然而,它的binding key却有两种非常特殊的用法:</p>
- *(星号)能代替任何一个单词。
- #(井号)能代替0个或任意多个单词。
<p>下面这个例子很容易理解:</p>
![这里写图片描述](//img-blog.csdn.net/20160904103611241)
<p>在这个例子中,我们发送的消息都是用来描述动物的。每个消息的routing key都包含三个单词,第一个单词用来描述动物的速度,第二个用来表示颜色,第三个用来表示物种:"<speed>.<colour>.<species>"。</p>
<p>我们为交换机和队列创建三个绑定关系,队列Q1通过"*.orange.*"来绑定,队列Q2通过 "*.*.rabbit"和"lazy.#"来绑定。</p>
<p>这些绑定关系可以概括为:</p>
- Q1只对橙色的动物感兴趣。
- Q2想要了解兔子和那些行动缓慢的动物。
<p>一个routing key为"quick.orange.rabbit"的消息将会被发送到所有队列。带有"lazy.orange.elephant"的消息也会被发往所有队列中去。而对于"quick.orange.fox"来说,它只会被发送到Q1队列中,"lazy.brown.fox"只会被发送到Q2队列中。而"lazy.pink.rabbit"只会被发送到Q2队列中一次,尽管它匹配了Q2队列的两个routing key。对于"quick.brown.fox"来说,没有routing key和它匹配,所以它会被丢弃。</p>
<p>如果我们不遵守之前的约定,发送一条只带一个单词或四个单词的消息,例如"orange"或"quick.orange.male.rabbit",会发生什么事呢?好吧,这些消息都会因为没有找到匹配routing key而被丢弃。</p>
<p>另一方面,对于"lazy.orange.male.rabbit"来说,虽然它包含四个单词,但是它却和最后一个routing key("lazy.#")匹配,所以它会被发送到Q2队列中去。</p>
> <p><b>Topic类型的交换机</b></p> <p>Topic类型的交换机的功能十分强大,可以媲美其他类型的交换机。</p>
> <p>当一个队列的binding key为一个“#”,它将接收所有消息,就像fanout类型的交换机一样。</p>
> <p>当binding key中没有包含“*”或“#”字符的话,topic类型的交换机就相当于direct类型的交换机。</p>
##**2、代码整合**
<p>我们将在我们的日志系统中使用topic类型的交换机。我们假设日志消息的routing key通过两个单词组成,就像"<facility>.<severity>"。</p>
<p>代码几乎跟先前的一样。</p>
<p>EmitLogTopic.java的代码如下:</p>
public class EmitLogTopic {
private static final String EXCHANGE_NAME = "topic_logs";
public static void main(String[] argv)
throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "topic");
String routingKey = getRouting(argv);
String message = getMessage(argv);
channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());
System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");
connection.close();
}
//...
}
<p>ReceiveLogsTopic.java的代码如下:</p>
import com.rabbitmq.client.*;
import java.io.IOException;
public class ReceiveLogsTopic {
private static final String EXCHANGE_NAME = "topic_logs";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "topic");
String queueName = channel.queueDeclare().getQueue();
if (argv.length < 1) {
System.err.println("Usage: ReceiveLogsTopic [binding_key]...");
System.exit(1);
}
for (String bindingKey : argv) {
channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
}
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String message = new String(body, "UTF-8");
System.out.println(" [x] Received '" + envelope.getRoutingKey() + "':'" + message + "'");
}
};
channel.basicConsume(queueName, true, consumer);
}
}
<p>接收所有日志类型:</p>
$ java -cp $CP ReceiveLogsTopic "#"
<p>从"kern"那接收日志信息:</p>
$ java -cp $CP ReceiveLogsTopic "kern.*"
<p>或者只接收“critical”类型的日志:</p>
$ java -cp $CP ReceiveLogsTopic "*.critical"
<p>你还可以建立多个绑定关系:</p>
$ java -cp $CP ReceiveLogsTopic "kern." ".critical"
<p>或者直接发送routing key为"kern.critical"类型的日志:</p>
$ java -cp $CP EmitLogTopic "kern.critical" "A critical kernel error"
一些有趣的问题:
- "*"会匹配到routing key为空的消息吗?
- "#.*"会匹配到". ."吗?或者只匹配一个单词吗?
- "a.*.#”和"a.#"有什么不同?