2.2 RabbitMQ工作模式

---

---

1.概述

1.1 常见模式

RabbitMQ是一个消息中间件，它支持多种工作模式来处理消息传递。以下是一些常见的RabbitMQ工作模式：

• 简单模式（Simple Mode）：一个生产者发送消息到一个队列，一个消费者从队列中接收和处理消息。
• 工作队列模式（Work Queue Mode）：一个生产者发送消息到一个队列，多个消费者从队列中接收和处理消息。消息将以循环方式分发给消费者。
• 发布/订阅模式（Publish/Subscribe Mode）：一个生产者发送消息到一个交换机（Exchange），多个消费者通过绑定到该交换机的队列接收和处理消息。消息会广播到所有绑定的队列。
• 路由模式（Routing Mode）：一个生产者发送消息到一个交换机，交换机根据消息的路由键（Routing Key）将消息发送给绑定了与该路由键匹配的队列的消费者。
• 主题模式（Topic Mode）：一个生产者发送消息到一个交换机，交换机根据消息的主题（Topic）将消息发送给绑定了与该主题匹配的队列的消费者。

这些工作模式提供了灵活的消息传递方式，可以根据不同的需求选择合适的模式来实现可靠和高效的消息通信。

1.2 工作空间

在RabbitMQ中，相关的消息都是通过创建消息队列来进行传递的，而消息队列又存放在对应的工作空间（虚拟主机）中，我们可以理解为，消息写到了信件中，信件又存放到了相应的邮局中，一般队列都存放到默认的工作空间/中，我们也可以在控制台创建自定义工作空间，用来管理我们的消息队列：

需要注意的是，自定义工作空间在创建连接的时候需要指定具体的工作空间名，而默认工作空间则不需要这一步骤：

//指定连接自定义空间
f.setVirtualHost("zhangsan");

2. 简单模式

2.1 概述

RabbitMQ是一个消息中间件，你可以想象它是一个邮局。当你把信件放到邮箱里时，能够确信邮递员会正确地递送你的信件。RabbitMq就是一个邮箱、一个邮局和一个邮递员。
- 发送消息的程序是生产者
- 队列就代表一个邮箱。虽然消息会流经RbbitMQ和你的应用程序，但消息只能被存储在队列里。队列存储空间只受服务器内存和磁盘限制，它本质上是一个大的消息缓冲区。多个生产者可以向同一个队列发送消息，多个消费者也可以从同一个队列接收消息.
- 消费者等待从队列接收消息

我们在工程下，创建m1文件夹，用来测试简单模式；

2.2 pom.xml

添加 slf4j 依赖, 和 rabbitmq amqp 依赖

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.tedu</groupId>
	<artifactId>rabbitmq</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<dependencies>
		<dependency>
			<groupId>com.rabbitmq</groupId>
			<artifactId>amqp-client</artifactId>
			<version>5.4.3</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.8.0-alpha2</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.8.0-alpha2</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.8.0</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

2.3 生产者发送消息

package m1;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672); // 5672是客户端收发消息的端口，15672是管理控制台的访问端口
        f.setUsername("admin");
        f.setPassword("admin");
        Connection con = f.newConnection();
        Channel c = con.createChannel(); // 通信的通道，所有的通信都使用Channel来做，有异常抛出异常
        /**
         *在服务器上创建队列 helloworld，如果已经存在不会重复创建
         *队列中值的属性：
         * -是否是持久队列：非持久队列在服务器重启后会消失
         * -是否是排他队列（独占队列）：独占队列只允许一个消费者接入
         * -是否自动删除：消费者接入在线情况队列会有计数，当计数为0队列是否自动删除
         * -null队列的其他属性
         */
        c.queueDeclare("helloworld",false,false,false,null);
        /**
         * 向 helloworld 队列发送消息使用basicPublish
         *第一个参数 ""： 默认的交换机
         *第三个参数 null： 消息的其他参数属性
         */
        c.basicPublish("", "helloworld", null, "Hello world!".getBytes());
        System.out.println("消息发送完成");
    }

}

2.4 消费者接收消息

package m1;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");  // wht6.cn
        f.setPort(5672); // 5672是客户端收发消息的端口，15672是管理控制台的访问端口
        f.setUsername("admin");
        f.setPassword("admin");
        Connection con = f.newConnection();
        Channel c = con.createChannel(); // 通信的通道

        // 在服务器上创建队列 helloworld，如果已经存在不会重复创建
        c.queueDeclare("helloworld",false,false,false,null);

        // 创建回调对象  ctrl+空格 代码辅助快捷键，修改成了 alt+/
        // 参考 csdn 笔记，开发工具专栏，idea快捷键笔记
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            byte[] a = message.getBody();
            String s = new String(a);
            System.out.println("收到： "+s);
        };
        CancelCallback cancelCallback = consumerTag -> {};
        /**
         * 从 helloworld 接收消息，传递到回调对象处理
         *第二个参数autoAck true：自动确认，服务器自己确认消息是否发送，直接删除已发送消息，不需要等待接收回执
         *                false:手动确认，需要手动将回执返回到服务器，服务器接收到回执后才执行删除已发送消息
         */
        c.basicConsume("helloworld", true, deliverCallback, cancelCallback);
    }
}

为什么我们在生产者中创建了队列，还要在消费者中创建队列呢？这是因为队列如果已经存在，是不会重复创建的，在实际调用中，生产者与消费者是使用同样的队列的，但是为了避免消费者先启动，调用时找不到队列，所以我们在消费者中也创建一个队列，谁先启动，谁去创建；

2.5 测试

将俩个类启动后，进行测试，观察消息发送是否成功，消息接收是否成功；如果持续的发送消息，消息接收方可以接收到多条信息：

我们将消息接收方关闭后，可以在控制台看到正在队列中等待接收的消息：

3.工作队列模式

3.1 概述

工作队列(即任务队列)背后的主要思想是避免立即执行资源密集型任务，并且必须等待它完成。相反，我们将任务安排在稍后完成。

我们将任务封装为消息并将其发送到队列。后台运行的工作进程将获取任务并最终执行任务。当运行多个消费者时，任务将在它们之间分发。

使用任务队列的一个优点是能够轻松地并行工作。如果我们正在积压工作任务，我们可以添加更多工作进程，这样就可以轻松扩展。

我们在工程下，创建m2文件夹，用来测试工作模式；

3.2 生产者发送消息

package m2;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");  // wht6.cn
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();
        // 创建 task_queue队列
        c.queueDeclare("task_queue",true,false,false,null);
        // 发送消息
        while (true) {
            System.out.print("输入消息：");
            String s = new Scanner(System.in).nextLine();
            c.basicPublish("", "task_queue", MessageProperties.PERSISTENT_BASIC, s.getBytes());
        }
    }
}

3.3 消费者接收消息

package m2;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");  
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();
        // 创建 helloworld 队列
        c.queueDeclare("task_queue",true,false,false,null);
        // 创建回调对象
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String s = new String(message.getBody());
            System.out.println("收到："+s);
            // 遍历字符串找'.'字符
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '.') {
                    try {
                        Thread.sleep(1000);//遇到'.'暂停1秒，模拟耗时消息
                    } catch (InterruptedException e) {
                    }
                }
            }
            System.out.println("---------------------消息处理完成");
        };
        CancelCallback cancelCallback = consumerTag -> {};

        // 开始接收消息
        c.basicConsume("task_queue", true, deliverCallback, cancelCallback);
    }
}

3.4 运行测试

首先设置消费者，允许其启动多个实例：

启动的时候要先启动生产者，再启动消费者。不然先启动消费者的话，创建的队列就会是普通队列了，后面再启动生产者的话就会报错了（已经存在队列了）：

如果启动时报队列已经存在的错误：

可以在控制台中删除相关队列：

当前启动实例：

一个生产者
两个消费者

生产者发送多条消息,如: 1,2,3,4,5. 两个消费者分别收到:

消费者一: 1,3,5
消费者二: 2,4

rabbitmq在所有消费者中轮询分发消息,把消息均匀地发送给所有消费者

3.5 消息确认

一个消费者接收消息后,在消息没有完全处理完时就挂掉了,那么这时会发生什么呢?

就现在的代码来说,rabbitmq把消息发送给消费者后,会立即删除消息,那么消费者挂掉后,它没来得及处理的消息就会丢失

如果生产者发送以下消息:

1…

2

3...

4

5...

两个消费者分别收到:

    消费者一: 1…, 3, 5
    消费者二: 2, 4

当消费者一收到所有消息后,要话费7秒时间来处理第一条消息,这期间如果关闭该消费者,那么1未处理完成,3,5则没有被处理

我们并不想丢失任何消息, 如果一个消费者挂掉,我们想把它的任务消息派发给其他消费者

为了确保消息不会丢失，rabbitmq支持消息确认(回执)。当一个消息被消费者接收到并且执行完成后，消费者会发送一个ack (acknowledgment) 给rabbitmq服务器, 告诉他我已经执行完成了，你可以把这条消息删除了。

如果一个消费者没有返回消息确认就挂掉了（信道关闭，连接关闭或者TCP链接丢失），rabbitmq就会明白，这个消息没有被处理完成，rebbitmq就会把这条消息重新放入队列，如果在这时有其他的消费者在线，那么rabbitmq就会迅速的把这条消息传递给其他的消费者，这样就确保了没有消息会丢失。

这里不存在消息超时, rabbitmq只在消费者挂掉时重新分派消息, 即使消费者花非常久的时间来处理消息也可以

手动消息确认默认是开启的，前面的例子我们通过autoAck=ture把它关闭了。我们现在要把它设置为false，然后工作进程处理完意向任务时,发送一个消息确认(回执)，修改消费者中的相关代码：

package m2;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();
        // 创建 task_queue队列
        c.queueDeclare("task_queue",false,false,false,null);
        // 创建回调对象
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String s = new String(message.getBody());
            System.out.println("收到："+s);
            // 遍历字符串找'.'字符
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '.') {
                    try {
                        Thread.sleep(1000);//遇到'.'暂停1秒，模拟耗时消息
                    } catch (InterruptedException e) {
                    }
                }
            }

            //c.basicAck(回执, 是否确认之前收到过的所有消息);
            c.basicAck(message.getEnvelope().getDeliveryTag(), false);
            System.out.println("---------------------消息处理完成");
        };
        CancelCallback cancelCallback = consumerTag -> {};
        // 开始接收消息
        //c.basicConsume("task_queue", true, deliverCallback, cancelCallback);
        //autoAck设置为false,则需要手动确认发送回执
        c.basicConsume("task_queue", false, deliverCallback, cancelCallback);
    }
}

使用以上代码，就算杀掉一个正在处理消息的工作进程也不会丢失任何消息，工作进程挂掉之后，没有确认的消息就会被自动重新传递。

忘记确认(ack)是一个常见的错误, 这样后果是很严重的, 由于未确认的消息不会被释放, rabbitmq会吃掉越来越多的内存，可以使用下面命令打印工作队列中未确认消息的数量：

rabbitmqctl list_queues name messages_ready messages_unacknowledged

当处理消息时异常中断, 可以选择让消息重回队列重新发送.，nack 操作可以是消息重回队列, 可以使用 basicNack() 方法:

// requeue为true时重回队列, 反之消息被丢弃或被发送到死信队列
c.basicNack(tag, multiple, requeue)

3.6 合理地分发

rabbitmq会一次把多个消息分发给消费者, 这样可能造成有的消费者非常繁忙, 而其它消费者空闲. 而rabbitmq对此一无所知, 仍然会均匀的分发消息

我们可以在开始接收消息之前使用 basicQos(1) 方法, 这告诉rabbitmq一次只向消费者发送一条消息, 在返回确认回执前, 不要向消费者发送新消息. 而是把消息发给下一个空闲的消费者

3.7 消息持久化

当rabbitmq关闭时, 我们队列中的消息仍然会丢失, 除非明确要求它不要丢失数据

要求rabbitmq不丢失数据要做如下两点: 把队列和消息都设置为可持久化(durable)

队列设置为可持久化, 可以在定义队列时指定参数durable为true

由于之前我们已经定义过队列"task_queue"是不可持久化的, 对已存在的队列, rabbitmq不允许对其定义不同的参数, 否则会出错, 所以这里我们定义一个不同名字的队列"task_queue_new"

// 创建 task_queue队列
//c.queueDeclare("task_queue",true,false,false,null);
//定义一个新的队列,名为 ask_queue_new
//第二个参数是持久化参数 durable
c.queueDeclare("task_queue_new", true, false, false, null);

生产者和消费者代码都要修改

这样即使rabbitmq重新启动, 队列也不会丢失. 现在我们再设置队列中消息的持久化, 使用MessageProperties.PERSISTENT_TEXT_PLAIN参数

//第三个参数设置消息持久化
c.basicPublish("", "task_queue_new", MessageProperties.PERSISTENT_TEXT_PLAIN, s.getBytes());

4.发布订阅模式

4.1 概述

在前面的例子中，我们任务消息只交付给一个工作进程。在这部分，我们将做一些完全不同的事情——我们将向多个消费者传递同一条消息。这种模式称为“发布/订阅”。

为了说明该模式，我们将构建一个简单的日志系统。它将由两个程序组成——第一个程序将发出日志消息，第二个程序接收它们。

在我们的日志系统中，接收程序的每个运行副本都将获得消息。这样，我们就可以运行一个消费者并将日志保存到磁盘; 同时我们可以运行另一个消费者在屏幕上打印日志。

最终, 消息会被广播到所有消息接受者

我们在工程下，创建m3文件夹，用来测试发布订阅模式；

4.2 Exchanges 交换机

RabbitMQ群发消息传递模型的核心思想是，生产者永远不会将任何消息直接发送到队列。实际上，通常生产者甚至不知道消息是否会被传递到任何队列。

相反，生产者只能向交换机(Exchange)发送消息。交换机是一个非常简单的东西。一边接收来自生产者的消息，另一边将消息推送到队列。交换器必须确切地知道如何处理它接收到的消息。它应该被添加到一个特定的队列中吗?它应该添加到多个队列中吗?或者它应该被丢弃。这些规则由exchange的类型定义。

有几种可用的交换类型:direct、topic、header和fanout。我们将关注最后一个——fanout。让我们创建一个这种类型的交换机，并称之为 logs: ch.exchangeDeclare("logs", "fanout");

fanout交换机非常简单。它只是将接收到的所有消息广播给它所知道的所有队列。这正是我们的日志系统所需要的。

我们前面使用的队列具有特定的名称(hello、task_queue_new等)能够为队列命名对我们来说至关重要——我们需要将工作进程指向同一个队列,在生产者和消费者之间共享队列。

但日志记录案例不是这种情况。我们想要接收所有的日志消息，而不仅仅是其中的一部分。我们还只对当前的最新消息感兴趣，而不是旧消息。

要解决这个问题，我们需要两件事。首先，每当我们连接到Rabbitmq时，我们需要一个新的空队列。为此，我们可以创建一个具有随机名称的队列，或者，更好的方法是让服务器为我们选择一个随机队列名称。其次，一旦断开与使用者的连接，队列就会自动删除。在Java客户端中，当我们不向queueDeclare()提供任何参数时，会创建一个具有生成名称的、非持久的、独占的、自动删除队列

//自动生成队列名
//非持久,独占,自动删除
String queueName = ch.queueDeclare().getQueue();

4.3绑定 Bindings

我们已经创建了一个fanout交换机和一个队列。现在我们需要告诉exchange向指定队列发送消息。exchange和队列之间的关系称为绑定。

//指定的队列,与指定的交换机关联起来
//成为绑定 -- binding
//第三个参数时 routingKey, 由于是fanout交换机, 这里忽略 routingKey
ch.queueBind(queueName, "logs", "");

现在, logs交换机将会向我们指定的队列添加消息

列出绑定关系:

rabbitmqctl list_bindings

完成的代码

4.4 生产者

生产者发出日志消息，看起来与前一教程没有太大不同。最重要的更改是，我们现在希望将消息发布到logs交换机，而不是无名的日志交换机。我们需要在发送时提供一个routingKey，但是对于fanout交换机类型，该值会被忽略。

package m3;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import java.util.Scanner;

public class Producer {
    public static void main(String[] args) throws Exception{
        //创建连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();
        /*
         * 定义名字为logs的交换机,交换机类型为fanout
         * 这一步是必须的，因为禁止发布到不存在的交换。
         * 下面给共展示了俩种创建方式，这俩种方式没有区别
         * */
        c.exchangeDeclare("logs", "fanout");
        //c.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);

        /**
         * 向logs交换机发送消息
         * 第一个参数,向指定的交换机发送消息
         * 第二个参数,不指定队列,由消费者向交换机绑定队列
         * 如果还没有队列绑定到交换器，消息就会丢失，
         * 但这对我们来说没有问题;即使没有消费者接收，我们也可以安全地丢弃这些信息。
         * */

        while (true){
            System.out.println("请输入消息：");
            String s = new Scanner(System.in).nextLine();
            c.basicPublish("logs", "", null,s.getBytes());
        }
    }
}

4.5 消费者

如果还没有队列绑定到交换器，消息就会丢失，但这对我们来说没有问题;如果还没有消费者在听，我们可以安全地丢弃这些信息。

在消费者中，我们需要创建消费者自己的队列，因为此种模式下，会有很多消费者，每一个消费者都有自己的队列，所以我们可以使用随机队列名的方式来命名队列；

队列中的相关参数设置：
- 在当前模式下，每个消费者都从自己的队列中接收消息，而不会共享独立，所以队列应该是独占的
- 因为队列是跟随消费者的存在而存在的，所以其队列不是持久的，将其设置为非持久队列
- 并且其队列应该是可以自动删除的

package m3;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.TimeoutException;

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();
        //创建消费者自己的队列
        String queue = UUID.randomUUID().toString();
        //随机队列名；非持久；独占；自动删除；
        c.queueDeclare(queue, false,true,true,null);
        //创建交换机
        c.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
        /**
         * 绑定队列与交换机:
         * 队列名：我们这里使用定义的随机队列名
         * 交换机名
         * 第三个参数无效，可以写任何内容
         * */
        c.queueBind(queue, "logs", "");

        //接收处理消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String s = new String(message.getBody());
            System.out.println("收到："+s);
        };
        CancelCallback cancelCallback = consumerTag -> {};
        c.basicConsume(queue, true, deliverCallback, cancelCallback);
    }
}

4.6 测试

为了模拟多个消费者的情况，需要对消费者设置允许运行多个实例，启动多个消费者后测试消息发送和接收：

5.路由模式

5.1 概述

路由模式是direct交换机通过关键词绑定随机队列来实现的；

生产者发送的消息中也需要携带关键词，交换机通过消息中的关键词进行匹配，发送到对应的队列；如果多个队列都匹配相同的一个关键词，那相应的对个队列均可以接收到相应的消息；

在上一小节，我们构建了一个简单的日志系统。我们能够向多个接收者广播日志消息。

在这一节，我们将向其添加一个特性—我们将只订阅所有消息中的一部分。例如，我们只接收关键错误消息并保存到日志文件(以节省磁盘空间)，同时仍然能够在控制台上打印所有日志消息。

我们在工程下，创建m4文件夹，用来测试路由模式；

5.2 绑定 Bindings

在上一节，我们已经创建了队列与交换机的绑定。使用下面这样的代码:

ch.queueBind(queueName, "logs", "");

绑定是交换机和队列之间的关系。这可以简单地理解为:队列对来自此交换的消息感兴趣。

绑定可以使用额外的routingKey参数。为了避免与basic_publish参数混淆，我们将其称为bindingKey。这是我们如何创建一个键绑定:

ch.queueBind(queueName, EXCHANGE_NAME, "black");

bindingKey的含义取决于交换机类型。我们前面使用的fanout交换机完全忽略它。

5.3 直连交换机 Direct exchange

上一节中的日志系统向所有消费者广播所有消息。我们希望扩展它，允许根据消息的严重性过滤消息。例如，我们希望将日志消息写入磁盘的程序只接收关键error，而不是在warning或info日志消息上浪费磁盘空间。

前面我们使用的是fanout交换机，这并没有给我们太多的灵活性——它只能进行简单的广播。

我们将用直连交换机(Direct exchange)代替。它背后的路由算法很简单——消息传递到bindingKey与routingKey完全匹配的队列。为了说明这一点，请考虑以下设置

其中我们可以看到直连交换机X，它绑定了两个队列。第一个队列用绑定键orange绑定，第二个队列有两个绑定，一个绑定black，另一个绑定键green。

这样设置，使用路由键orange发布到交换器的消息将被路由到队列Q1。带有black或green路由键的消息将转到Q2。而所有其他消息都将被丢弃。

5.4 多重绑定 Multiple bindings

使用相同的bindingKey绑定多个队列是完全允许的。如图所示，可以使用binding key black将X与Q1和Q2绑定。在这种情况下，直连交换机的行为类似于fanout，并将消息广播给所有匹配的队列。一条路由键为black的消息将同时发送到Q1和Q2。

5.5 发送日志

我们将在日志系统中使用这个模型。我们把消息发送到一个Direct交换机，而不是fanout。我们将提供日志级别作为routingKey。这样，接收程序将能够选择它希望接收的级别。让我们首先来看发出日志。

和前面一样，我们首先需要创建一个exchange:

//参数1: 交换机名
//参数2: 交换机类型
ch.exchangeDeclare("direct_logs", "direct");

接着来看发送消息的代码

//参数1: 交换机名
//参数2: routingKey, 路由键,这里我们用日志级别,如"error","info","warning"
//参数3: 其他配置属性
//参数4: 发布的消息数据 
ch.basicPublish("direct_logs", "error", null, message.getBytes());

5.6 订阅

接收消息的工作原理与前面章节一样，但有一个例外——我们将为感兴趣的每个日志级别创建一个新的绑定, 示例代码如下:

ch.queueBind(queueName, "logs", "info");
ch.queueBind(queueName, "logs", "warning");

5.7 完整的代码

5.7.1 生产者

package m4;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();
        /**
         *  创建Direct交换机：direct_logs
         *  参数1: 交换机名
         * 	参数2: 交换机类型
         */
        c.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);

        //发送消息（携带路由键关键词）
        while (true) {
            System.out.print("输入消息: ");
            String msg = new Scanner(System.in).nextLine();
            if ("exit".equals(msg)) {
                break;
            }

            //随机产生日志级别
            String[] a = {"warning", "info", "error"};
            String level = a[new Random().nextInt(a.length)];

            /**
             * 参数1: 交换机名
             *参数2: routingKey, 路由键,这里我们用日志级别,如"error","info","warning"
             *参数3: 其他配置属性
             *参数4: 发布的消息数据
             */
            c.basicPublish("direct_logs", level, null, msg.getBytes());
            System.out.println("消息已发送: "+level+" - "+msg);
        }
        c.close();
    }
}

5.7.2 消费者

package rabbitmq.routing;

import java.io.IOException;
import java.util.Scanner;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import com.rabbitmq.client.Delivery;

public class Test2 {
	public static void main(String[] args) throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setUsername("admin");
		f.setPassword("admin");
		Connection c = f.newConnection();
		Channel ch = c.createChannel();
		
		//定义名字为 direct_logs 的交换机, 它的类型是 "direct"
		ch.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);
		
		//自动生成对列名,
		//非持久,独占,自动删除
		String queueName = ch.queueDeclare().getQueue();
		
		System.out.println("输入接收的日志级别,用空格隔开:");
		String[] a = new Scanner(System.in).nextLine().split("\\s");
		
		//把该队列,绑定到 direct_logs 交换机
		//允许使用多个 bindingKey
		for (String level : a) {
			ch.queueBind(queueName, "direct_logs", level);
		}
		
		System.out.println("等待接收数据");
		
		//收到消息后用来处理消息的回调对象
		DeliverCallback callback = new DeliverCallback() {
			@Override
			public void handle(String consumerTag, Delivery message) throws IOException {
				String msg = new String(message.getBody(), "UTF-8");
				String routingKey = message.getEnvelope().getRoutingKey();
				System.out.println("收到: "+routingKey+" - "+msg);
			}
		};
		
		//消费者取消时的回调对象
		CancelCallback cancel = new CancelCallback() {
			@Override
			public void handle(String consumerTag) throws IOException {
			}
		};
		
		ch.basicConsume(queueName, true, callback, cancel);
	}
}

5.8 测试

启动多个消费者后，我们进行消息接收测试：

6.主题模式

6.1 概述

在上一小节，我们改进了日志系统。我们没有使用只能进行广播的fanout交换机，而是使用Direct交换机，从而可以选择性接收日志。

虽然使用Direct交换机改进了我们的系统，但它仍然有局限性——它不能基于多个标准进行路由。

在我们的日志系统中，我们可能不仅希望根据级别订阅日志，还希望根据发出日志的源订阅日志。

这将给我们带来很大的灵活性——我们可能只想接收来自“cron”的关键错误，但也要接收来自“kern”的所有日志。

要在日志系统中实现这一点，我们需要了解更复杂的Topic交换机。

我们在工程下，创建m5文件夹，用来测试主题模式；

6.2 主题交换机 Topic exchange

发送到Topic交换机的消息,它的的routingKey,必须是由点分隔的多个单词。单词可以是任何东西，但通常是与消息相关的一些特性。几个有效的routingKey示例:“stock.usd.nyse”、“nyse.vmw”、“quick.orange.rabbit”。routingKey可以有任意多的单词，最多255个字节。

bindingKey也必须采用相同的形式。Topic交换机的逻辑与直连交换机类似——使用特定routingKey发送的消息将被传递到所有使用匹配bindingKey绑定的队列。bindingKey有两个重要的特殊点:

- `*` 可以通配单个单词。
- `#` 可以通配零个或多个单词。

用一个例子来解释这个问题是最简单的

在本例中，我们将发送描述动物的消息。这些消息将使用由三个单词(两个点)组成的routingKey发送。routingKey中的第一个单词表示速度，第二个是颜色,第三个是物种:“<速度>.<颜色>.<物种>”。

我们创建三个绑定:Q1与bindingKey “*.orange.*” 绑定。和Q2是 “*.*.rabbit” 和 “lazy.#” 。

这些绑定可概括为:

• Q1对所有橙色的动物感兴趣。
• Q2想接收关于兔子和慢速动物的所有消息。

将routingKey设置为"quick.orange.rabbit"的消息将被发送到两个队列。消息 "lazy.orange.elephant“也发送到它们两个。另外”quick.orange.fox“只会发到第一个队列，”lazy.brown.fox“只发给第二个。”lazy.pink.rabbit“将只被传递到第二个队列一次，即使它匹配两个绑定。”quick.brown.fox"不匹配任何绑定，因此将被丢弃。

如果我们违反约定，发送一个或四个单词的信息，比如"orange“或”quick.orange.male.rabbit"，会发生什么?这些消息将不匹配任何绑定，并将丢失。

另外，“lazy.orange.male.rabbit”，即使它有四个单词，也将匹配最后一个绑定，并将被传递到第二个队列。

6.3 完成的代码

6.3.1 生产者

package m5;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();

        // 创建 Topic 交换机：topic_logs
        c.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);
        // 发送消息，携带路由键关键词
        while (true) {
            System.out.print("输入消息：");
            String s = new Scanner(System.in).nextLine();
            System.out.print("输入路由键：");
            String k = new Scanner(System.in).nextLine();
            /**
             *第二个参数是路由键关键词
             *在简单模式和工作模式中，使用的默认交换机自动使用队列名做绑定
             */
            c.basicPublish("topic_logs", k, null, s.getBytes());

        }
    }
}

6.3.2 消费者

package m5;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.Scanner;
import java.util.UUID;
import java.util.concurrent.TimeoutException;
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();
        /**
         * 创建随机队列:
         * 非持久，独占，自动删除队列
         */
        String queue = UUID.randomUUID().toString();
        c.queueDeclare(queue,false,true,true,null);
        //创建交换机
        c.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);
        //绑定队列，设置绑定键
        System.out.println("输入接收的日志级别,用空格隔开:");
        String[] a = new Scanner(System.in).nextLine().split("\\s");
        for (String k : a ) {
            c.queueBind(queue, "topic_logs", k);
        }
        //从队列接收处理消息
        //处理消息
        DeliverCallback deliverCallback = (ConsumerTag,message)->{
            String msg = new String(message.getBody());
            String key = new String(message.getEnvelope().getRoutingKey());
            System.out.println("msg:"+msg+"；key:"+key);
        };
        CancelCallback cancelCallback = consumerTag -> {};
        c.basicConsume(queue, true,deliverCallback,cancelCallback);
    }
}

6.4 测试

启动多个消费者后，我们进行消息传递测试：

7.RPC模式

7.1 概述

如果我们需要在远程电脑上运行一个方法，并且还要等待一个返回结果该怎么办？这和前面的例子不太一样, 这种模式我们通常称为远程过程调用,即RPC.

在本节中，我们将会学习使用RabbitMQ去搭建一个RPC系统：一个客户端和一个可以升级(扩展)的RPC服务器。为了模拟一个耗时任务，我们将创建一个返回斐波那契数列的虚拟的RPC服务。

7.2 客户端

在客户端定义一个RPCClient类,并定义一个call()方法,这个方法发送一个RPC请求,并等待接收响应结果

RPCClient client = new RPCClient();
String result = client.call("4");
System.out.println( "第四个斐波那契数是: " + result);

7.3 回调队列 Callback Queue

使用RabbitMQ去实现RPC很容易。一个客户端发送请求信息，并得到一个服务器端回复的响应信息。为了得到响应信息，我们需要在请求的时候发送一个“回调”队列地址。我们可以使用默认队列。下面是示例代码：

//定义回调队列,
//自动生成对列名,非持久,独占,自动删除
callbackQueueName = ch.queueDeclare().getQueue();

//用来设置回调队列的参数对象
BasicProperties props = new BasicProperties
                            .Builder()
                            .replyTo(callbackQueueName)
                            .build();
//发送调用消息
ch.basicPublish("", "rpc_queue", props, message.getBytes());

消息属性 Message Properties

AMQP 0-9-1协议定义了消息的14个属性。大部分属性很少使用，下面是比较常用的4个:

deliveryMode:将消息标记为持久化(值为2)或非持久化(任何其他值)。

contentType:用于描述mime类型。例如，对于经常使用的JSON格式，将此属性设置为:application/json。

replyTo:通常用于指定回调队列。

correlationId:将RPC响应与请求关联起来非常有用。

7.4 关联id (correlationId)：

在上面的代码中，我们会为每个RPC请求创建一个回调队列。 这是非常低效的，这里还有一个更好的方法:让我们为每个客户端创建一个回调队列。

这就提出了一个新的问题，在队列中得到一个响应时，我们不清楚这个响应所对应的是哪一条请求。这时候就需要使用关联id（correlationId）。我们将为每一条请求设置唯一的的id值。稍后，当我们在回调队列里收到一条消息的时候，我们将查看它的id属性，这样我们就可以匹配对应的请求和响应。如果我们发现了一个未知的id值，我们可以安全的丢弃这条消息，因为它不属于我们的请求。

7.5 小结

RPC的工作方式是这样的:

• 对于RPC请求，客户端发送一条带有两个属性的消息:replyTo,设置为仅为请求创建的匿名独占队列,和correlationId,设置为每个请求的惟一id值。
• 请求被发送到rpc_queue队列。
• RPC工作进程(即:服务器)在队列上等待请求。当一个请求出现时，它执行任务,并使用replyTo字段中的队列将结果发回客户机。
• 客户机在回应消息队列上等待数据。当消息出现时，它检查correlationId属性。如果匹配请求中的值，则向程序返回该响应数据。

7.6 完成的代码

7.6.1 服务器端

package rabbitmq.rpc;

import java.io.IOException;
import java.util.Random;
import java.util.Scanner;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import com.rabbitmq.client.Delivery;
import com.rabbitmq.client.AMQP.BasicProperties;

public class RPCServer {
	public static void main(String[] args) throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setPort(5672);
		f.setUsername("admin");
		f.setPassword("admin");
		
		Connection c = f.newConnection();
		Channel ch = c.createChannel();
		/*
		 * 定义队列 rpc_queue, 将从它接收请求信息
		 * 
		 * 参数:
		 * 1. queue, 对列名
		 * 2. durable, 持久化
		 * 3. exclusive, 排他
		 * 4. autoDelete, 自动删除
		 * 5. arguments, 其他参数属性
		 */
		ch.queueDeclare("rpc_queue",false,false,false,null);
		ch.queuePurge("rpc_queue");//清除队列中的内容
		
		ch.basicQos(1);//一次只接收一条消息
		
		
		//收到请求消息后的回调对象
		DeliverCallback deliverCallback = new DeliverCallback() {
			@Override
			public void handle(String consumerTag, Delivery message) throws IOException {
				//处理收到的数据(要求第几个斐波那契数)
				String msg = new String(message.getBody(), "UTF-8");
				int n = Integer.parseInt(msg);
				//求出第n个斐波那契数
				int r = fbnq(n);
				String response = String.valueOf(r);
				
				//设置发回响应的id, 与请求id一致, 这样客户端可以把该响应与它的请求进行对应
				BasicProperties replyProps = new BasicProperties.Builder()
						.correlationId(message.getProperties().getCorrelationId())
						.build();
				/*
				 * 发送响应消息
				 * 1. 默认交换机
				 * 2. 由客户端指定的,用来传递响应消息的队列名
				 * 3. 参数(关联id)
				 * 4. 发回的响应消息
				 */
				ch.basicPublish("",message.getProperties().getReplyTo(), replyProps, response.getBytes("UTF-8"));
				//发送确认消息
				ch.basicAck(message.getEnvelope().getDeliveryTag(), false);
			}
		};
		
		//
		CancelCallback cancelCallback = new CancelCallback() {
			@Override
			public void handle(String consumerTag) throws IOException {
			}
		};
		
		//消费者开始接收消息, 等待从 rpc_queue接收请求消息, 不自动确认
		ch.basicConsume("rpc_queue", false, deliverCallback, cancelCallback);
	}

	protected static int fbnq(int n) {
		if(n == 1 || n == 2) return 1;
		
		return fbnq(n-1)+fbnq(n-2);
	}
}

7.6.2 客户端

package rabbitmq.rpc;

import java.io.IOException;
import java.util.Scanner;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import com.rabbitmq.client.Delivery;
import com.rabbitmq.client.AMQP.BasicProperties;

public class RPCClient {
	Connection con;
	Channel ch;
	
	public RPCClient() throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setUsername("admin");
		f.setPassword("admin");
		con = f.newConnection();
		ch = con.createChannel();
	}
	
	public String call(String msg) throws Exception {
		//自动生成对列名,非持久,独占,自动删除
		String replyQueueName = ch.queueDeclare().getQueue();
		//生成关联id
		String corrId = UUID.randomUUID().toString();
		
		//设置两个参数:
		//1. 请求和响应的关联id
		//2. 传递响应数据的queue
		BasicProperties props = new BasicProperties.Builder()
				.correlationId(corrId)
				.replyTo(replyQueueName)
				.build();
		//向 rpc_queue 队列发送请求数据, 请求第n个斐波那契数
		ch.basicPublish("", "rpc_queue", props, msg.getBytes("UTF-8"));
		
		//用来保存结果的阻塞集合,取数据时,没有数据会暂停等待
		BlockingQueue<String> response = new ArrayBlockingQueue<String>(1);
		
		//接收响应数据的回调对象
		DeliverCallback deliverCallback = new DeliverCallback() {
			@Override
			public void handle(String consumerTag, Delivery message) throws IOException {
				//如果响应消息的关联id,与请求的关联id相同,我们来处理这个响应数据
				if (message.getProperties().getCorrelationId().contentEquals(corrId)) {
					//把收到的响应数据,放入阻塞集合
					response.offer(new String(message.getBody(), "UTF-8"));
				}
			}
		};

		CancelCallback cancelCallback = new CancelCallback() {
			@Override
			public void handle(String consumerTag) throws IOException {
			}
		};
		
		//开始从队列接收响应数据
		ch.basicConsume(replyQueueName, true, deliverCallback, cancelCallback);
		//返回保存在集合中的响应数据
		return response.take();
	}
	
	public static void main(String[] args) throws Exception {
		RPCClient client = new RPCClient();
		while (true) {
			System.out.print("求第几个斐波那契数:");
			int n = new Scanner(System.in).nextInt();
			String r = client.call(""+n);
			System.out.println(r);
		}
	}
}

8.virtual host

在RabbitMQ中叫做虚拟消息服务器VirtualHost，每个VirtualHost相当于一个相对独立的RabbitMQ服务器，每个VirtualHost之间是相互隔离的。exchange、queue、message不能互通

8.1 创建virtual host: /pd

• 进入虚拟机管理界面

• 添加新的虚拟机’/pd’,名称必须以"/"开头

• 查看添加的结果

8.2 设置虚拟机的用户访问权限

点击 /pd 虚拟主机, 设置用户 admin 对它的访问权限

9.拼多商城整合 rabbitmq

当用户下订单时,我们的业务系统直接与数据库通信,把订单保存到数据库中

当系统流量突然激增,大量的订单压力,会拖慢业务系统和数据库系统

我们需要应对流量峰值,让流量曲线变得平缓,如下图

削峰
订单存储的解耦

为了进行流量削峰,我们引入 rabbitmq 消息队列,当购物系统产生订单后,可以把订单数据发送到消息队列;而订单消费者应用从消息队列接收订单消息,并把订单保存到数据库

订单

这样,当流量激增时,大量订单会暂存在rabbitmq中,而订单消费者可以从容地从消息队列慢慢接收订单,向数据库保存
生产者-发送订单
pom.xml 添加依赖

spring提供了更方便的消息队列访问接口,它对RabbitMQ的客户端API进行了封装,使用起来更加方便

org.springframework.boot spring-boot-starter-amqp

application.yml

添加RabbitMQ的连接信息

spring:
rabbitmq:
host: 192.168.64.140
port: 5672
virtualHost: /pd
username: admin
password: admin

修改主程序 RunPdAPP

在主程序中添加下面的方法创建Queue实例

当创建RabbitMQ连接和信道后,Spring的RabbitMQ工具会自动在服务器中创建队列,代码在RabbitAdmin.declareQueues()方法中

@Bean
public Queue getQueue() {
	Queue q = new Queue("orderQueue", true);
	return q;
}

修改 OrderServiceImpl

//RabbitAutoConfiguration中创建了AmpqTemplate实例
@Autowired
AmqpTemplate amqpTemplate;

//saveOrder原来的数据库访问代码全部注释,添加rabbitmq消息发送代码
public String saveOrder(PdOrder pdOrder) throws Exception {
	String orderId = generateId();
	pdOrder.setOrderId(orderId);

	amqpTemplate.convertAndSend("orderQueue", pdOrder);
	return orderId;

	
	//		String orderId = generateId();
	//		pdOrder.setOrderId(orderId);
	//
	//		
	//		PdShipping pdShipping = pdShippingMapper.selectByPrimaryKey(pdOrder.getAddId());
	//		pdOrder.setShippingName(pdShipping.getReceiverName());
	//		pdOrder.setShippingCode(pdShipping.getReceiverAddress());
	//		pdOrder.setStatus(1);// 
	//		pdOrder.setPaymentType(1);
	//		pdOrder.setPostFee(10D);
	//		pdOrder.setCreateTime(new Date());
	//
	//		double payment = 0;
	//		List<ItemVO> itemVOs = selectCartItemByUseridAndItemIds(pdOrder.getUserId(), pdOrder.getItemIdList());
	//		for (ItemVO itemVO : itemVOs) {
	//			PdOrderItem pdOrderItem = new PdOrderItem();
	//			String id = generateId();
	//			//String id="2";
	//			pdOrderItem.setId(id);
	//			pdOrderItem.setOrderId(orderId);
	//			pdOrderItem.setItemId("" + itemVO.getPdItem().getId());
	//			pdOrderItem.setTitle(itemVO.getPdItem().getTitle());
	//			pdOrderItem.setPrice(itemVO.getPdItem().getPrice());
	//			pdOrderItem.setNum(itemVO.getPdCartItem().getNum());
	//
	//			payment = payment + itemVO.getPdCartItem().getNum() * itemVO.getPdItem().getPrice();
	//			pdOrderItemMapper.insert(pdOrderItem);
	//		}
	//		pdOrder.setPayment(payment);
	//		pdOrderMapper.insert(pdOrder);
	//		return orderId;
}

消费者-接收订单,并保存到数据库
pd-web项目复制为pd-order-consumer

复制项目
修改 application.yml

把端口修改成 81

server:
port: 81

spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/pd_store?useUnicode=true&characterEncoding=utf8
username: root
password: root

rabbitmq:
host: 192.168.64.140
port: 5672
virtualHost: /pd
username: admin
password: admin

mybatis:
#typeAliasesPackage: cn.tedu.ssm.pojo
mapperLocations: classpath:com.pd.mapper/*.xml

logging:
level:
cn.tedu.ssm.mapper: debug

删除无关代码

pd-order-consumer项目只需要从 RabbitMQ 接收订单数据, 再保存到数据库即可, 所以项目中只需要保留这部分代码

删除 com.pd.controller 包
删除 com.pd.payment.utils 包
删除无关的 Service,只保留 OrderService 和 OrderServiceImpl

新建 OrderConsumer

package com.pd;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.pd.pojo.PdOrder;
import com.pd.service.OrderService;

@Component
public class OrderConsumer {
//收到订单数据后,会调用订单的业务代码,把订单保存到数据库
@Autowired
private OrderService orderService;

//添加该注解后,会从指定的orderQueue接收消息,
//并把数据转为 PdOrder 实例传递到此方法
@RabbitListener(queues="orderQueue")
public void save(PdOrder pdOrder)
{
	System.out.println("消费者");
	System.out.println(pdOrder.toString());
	try {
		orderService.saveOrder(pdOrder);
	} catch (Exception e) {
		e.printStackTrace();
	}
}

}

修改 OrderServiceImpl 的 saveOrder() 方法

public String saveOrder(PdOrder pdOrder) throws Exception {
	//		String orderId = generateId();
	//		pdOrder.setOrderId(orderId);
	//
	//		amqpTemplate.convertAndSend("orderQueue", pdOrder);
	//		return orderId;
	//
	//		
	//		
	//		String orderId = generateId();
	//		pdOrder.setOrderId(orderId);
	
	//从RabbitMQ接收的订单数据,
	//已经在上游订单业务中生成过id,这里不再重新生成id
	//直接获取该订单的id
	String orderId = pdOrder.getOrderId();

	
	PdShipping pdShipping = pdShippingMapper.selectByPrimaryKey(pdOrder.getAddId());
	pdOrder.setShippingName(pdShipping.getReceiverName());
	pdOrder.setShippingCode(pdShipping.getReceiverAddress());
	pdOrder.setStatus(1);// 
	pdOrder.setPaymentType(1);
	pdOrder.setPostFee(10D);
	pdOrder.setCreateTime(new Date());

	double payment = 0;
	List<ItemVO> itemVOs = selectCartItemByUseridAndItemIds(pdOrder.getUserId(), pdOrder.getItemIdList());
	for (ItemVO itemVO : itemVOs) {
		PdOrderItem pdOrderItem = new PdOrderItem();
		String id = generateId();
		//String id="2";
		pdOrderItem.setId(id);
		pdOrderItem.setOrderId(orderId);
		pdOrderItem.setItemId("" + itemVO.getPdItem().getId());
		pdOrderItem.setTitle(itemVO.getPdItem().getTitle());
		pdOrderItem.setPrice(itemVO.getPdItem().getPrice());
		pdOrderItem.setNum(itemVO.getPdCartItem().getNum());

		payment = payment + itemVO.getPdCartItem().getNum() * itemVO.getPdItem().getPrice();
		pdOrderItemMapper.insert(pdOrderItem);
	}
	pdOrder.setPayment(payment);
	pdOrderMapper.insert(pdOrder);
	return orderId;
}   

手动确认
application.yml

spring:
rabbitmq:
listener:
simple:
acknowledge-mode: manual

OrderConsumer

package com.pd;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.pd.pojo.PdOrder;
import com.pd.service.OrderService;
import com.rabbitmq.client.Channel;

@Component
public class OrderConsumer {
//收到订单数据后,会调用订单的业务代码,把订单保存到数据库
@Autowired
private OrderService orderService;

//添加该注解后,会从指定的orderQueue接收消息,
//并把数据转为 PdOrder 实例传递到此方法
@RabbitListener(queues="orderQueue")
public void save(PdOrder pdOrder, Channel channel, Message message)
{
	System.out.println("消费者");
	System.out.println(pdOrder.toString());
	try {
		orderService.saveOrder(pdOrder);
		channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
	} catch (Exception e) {
		e.printStackTrace();
	} 
}

}