目录
RabbitMQ搭建
Nat网络网段
使用192.168.64.0网段
编辑-->虚拟网络编辑器-->选择vmnet8-->左下角修改网段
加载虚拟机镜像
1.解压centos-8-2105.zip
2.双击centos-8-2105.vmx,加载虚拟机
3.启动虚拟机,按提示选择‘已复制虚拟机’
4.用户名密码都是‘root’
5.执行./ip-dhcp命令
6.- ping宿主机在nat网络中的地址,不通可能需要关闭windows防火墙
- 在windows的dos命令窗口中ping虚拟机
解决网络设置问题
centos 8 开启VMware托管
nmcli n on
systemctl restart NetworkManager
如果还有问题,可以重置VMware虚拟网络
编辑-->虚拟网络编辑器-->还原默认设置
然后再设置nat网络网段64
安装Docker虚拟机
1.关闭centos-8-2105
2.克隆centos-8-2105:docker-base
3.用mobaxterm工具上传文件到/root/
- 下载 Docker 离线包
https://download.docker.com/linux/static/stable/x86_64/docker-20.10.6.tgz
- 在这里可以选择自己需要的版本进行下载
https://download.docker.com/linux/static/stable/
- 离线安装工具
https://github.com/Jrohy/docker-install/
4.将前面下载的以下文件放入服务器的 /root/docker-install
文件夹下:
- [docker-install]
- docker-20.10.6.tgz
- install.sh
- docker.bash
5.执行安装
# 进入 docker-install 文件夹
cd docker-install
# 为 docker-install 添加执行权限
chmod +x install.sh
# 安装
./install.sh -f docker-20.10.6.tgz
6.由于国内网络问题,需要配置加速器来加速。
修改配置文件 /etc/docker/daemon.json
下面命令直接生成文件 daemon.json
cat <<EOF > /etc/docker/daemon.json
{
"registry-mirrors": [
"https://docker.mirrors.ustc.edu.cn",
"http://hub-mirror.c.163.com"
],
"max-concurrent-downloads": 10,
"log-driver": "json-file",
"log-level": "warn",
"log-opts": {
"max-size": "10m",
"max-file": "3"
},
"data-root": "/var/lib/docker"
}
EOF
之后重启服务
# 重新加载docker配置
sudo systemctl daemon-reload
#重启docker服务
sudo systemctl restart docker
确认安装结果
docker info
docker run hello-world
搭建 Rabbitmq 服务器
1.从docker-base克隆:rabbitmq
2.设置ip地址: ./ip-static
3.将镜像压缩文件上传到/root/
下载镜像,rabbitmq:management
镜像中已经安装了管理界面
docker pull rabbitmq:management
4.执行导入 `docker load -i rabbit-image.gz`
5.配置管理员用户名和密码
mkdir /etc/rabbitmq
vim /etc/rabbitmq/rabbitmq.conf
# 添加两行配置:
default_user = admin
default_pass = admin
6.启动Rabbitmq
docker run -d --name rabbit \
-p 5672:5672 \
-p 15672:15672 \
-v /etc/rabbitmq/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
-e RABBITMQ_CONFIG_FILE=/etc/rabbitmq/rabbitmq.conf \
--restart=always \
rabbitmq:management
访问管理控制台 http://192.168.64.140:15672
用户名密码是 admin
RabbitMQ六种工作模式
简单模式
- 发送消息的程序是生产者
- 队列就代表一个邮箱。虽然消息会流经RbbitMQ和你的应用程序,但消息只能被存储在队列里。队列存储空间只受服务器内存和磁盘限制,它本质上是一个大的消息缓冲区。多个生产者可以向同一个队列发送消息,多个消费者也可以从同一个队列接收消息.
- 消费者等待从队列接收消息
pom.xml
添加rabbitmq依赖
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.4.3</version>
</dependency>
生产者发送消息
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.setHost("wht6.cn");
f.setPort(5672); //5672是客户端收发消息的端口,15672是管理控制台的访问端口
f.setUsername("admin");
f.setPassword("admin");
Connection con = f.newConnection();
Channel c = con.createChannel();//通信的通道
//创建队列 helloworld-qiao,如果已经存在不会重复创建
/*
队列的三个布尔值属性:
- 是否是持久队列
- 是否是排他队列(独占队列)
- 是否自动删除
null - 队列的其他属性
*/
c.queueDeclare("helloworld-qiao",false,false,false,null);
//向 helloworld 队列发送消息
/*
- 第一个参数 "",默认的交换机
- 队列名称
- 第三个参数 null,消息的其他参数属性
- 向队列发送的消息
*/
c.basicPublish("", "helloworld-qiao", null, "Hello World!".getBytes());
System.out.println("消息发送完成");
}
}
消费者接受消息
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");
//f.setHost("wht6.cn");
f.setPort(5672); //5672是客户端收发消息的端口,15672是管理控制台的访问端口
f.setUsername("admin");
f.setPassword("admin");
Connection con = f.newConnection();
Channel c = con.createChannel();//通信的通道
//创建队列
c.queueDeclare("helloworld-qiao",false,false,false,null);
//创建回调对象
DeliverCallback deliverCallback = (consumerTag,message) -> {
byte[] a = message.getBody();
String s = new String(a);
System.out.println("收到: "+s);
}; //处理消息
CancelCallback cancelCallback = consumerTag -> {}; //取消消息处理的回调对象
//从 helloworld 接收消息
/*
第二个参数 true:
autoAck - 自动确认 auto Acknowledgement
*/
c.basicConsume("helloworld-qiao", true,deliverCallback,cancelCallback);
}
}
工作模式
工作队列(即任务队列)背后的主要思想是避免立即执行资源密集型任务,并且必须等待它完成。相反,我们将任务安排在稍后完成。
我们将任务封装为消息并将其发送到队列。后台运行的工作进程将获取任务并最终执行任务。当运行多个消费者时,任务将在它们之间分发。
使用任务队列的一个优点是能够轻松地并行工作。如果我们正在积压工作任务,我们可以添加更多工作进程,这样就可以轻松扩展。
生产者发送消息
package m2;
import com.rabbitmq.client.AMQP;
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("wht6.cn");
f.setHost("192.168.64.140");
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
//创建 helloworld-qiao 队列
c.queueDeclare("task_queue", true, false, false, null);
//发送消息
while(true) {
System.out.println("输入消息:");
String s = new Scanner(System.in).nextLine();
c.basicPublish("", "task_queue", MessageProperties.PERSISTENT_BASIC, s.getBytes());
}
}
}
消费者接受消息
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("wht6.cn");
f.setHost("192.168.64.140");
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
//创建队列
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);
} catch (InterruptedException e) {
}
}
}
/*
- 第一个参数 回执数据
- 第二个参数 是否确认之前收到过的所有消息
*/
c.basicAck(message.getEnvelope().getDeliveryTag(),false);
System.out.println("------------------------消息处理完成");
};
CancelCallback cancelCallback = consumerTag -> {};
//每次收1条,处理完之前不收下一条
c.basicQos(1);
//接收消息
c.basicConsume("task_queue", false, deliverCallback, cancelCallback);
}
}
运行测试
运行:
- 一个生产者
- 两个消费者
生产者发送多条消息,
如: 1,2,3,4,5. 两个消费者分别收到:
- 消费者一: 1,3,5
- 消费者二: 2,4
rabbitmq在所有消费者中轮询分发消息,把消息均匀地发送给所有消费者
消息确认
一个消费者接收消息后,在消息没有完全处理完时就挂掉了,那么这时会发生什么呢?
就现在的代码来说,rabbitmq把消息发送给消费者后,会立即删除消息,那么消费者挂掉后,它没来得及处理的消息就会丢失
如果生产者发送以下消息:
1…
2
3
4
5两个消费者分别收到:
- 消费者一: 1…, 3, 5
- 消费者二: 2, 4
当消费者一收到所有消息后,要话费7秒时间来处理第一条消息,这期间如果关闭该消费者,那么1未处理完成,3,5则没有被处理
我们并不想丢失任何消息, 如果一个消费者挂掉,我们想把它的任务消息派发给其他消费者
为了确保消息不会丢失,rabbitmq支持消息确认(回执)。当一个消息被消费者接收到并且执行完成后,消费者会发送一个ack (acknowledgment) 给rabbitmq服务器, 告诉他我已经执行完成了,你可以把这条消息删除了。
如果一个消费者没有返回消息确认就挂掉了(信道关闭,连接关闭或者TCP链接丢失),rabbitmq就会明白,这个消息没有被处理完成,rebbitmq就会把这条消息重新放入队列,如果在这时有其他的消费者在线,那么rabbitmq就会迅速的把这条消息传递给其他的消费者,这样就确保了没有消息会丢失。
这里不存在消息超时, rabbitmq只在消费者挂掉时重新分派消息, 即使消费者花非常久的时间来处理消息也可以
合理地分发
rabbitmq会一次把多个消息分发给消费者, 这样可能造成有的消费者非常繁忙, 而其它消费者空闲. 而rabbitmq对此一无所知, 仍然会均匀的分发消息
我们可以使用 basicQos(1) 方法, 这告诉rabbitmq一次只向消费者发送一条消息, 在返回确认回执前, 不要向消费者发送新消息. 而是把消息发给下一个空闲的消费者
消息持久化
当rabbitmq关闭时, 我们队列中的消息仍然会丢失, 除非明确要求它不要丢失数据
要求rabbitmq不丢失数据要做如下两点: 把队列和消息都设置为可持久化(durable)
队列设置为可持久化, 可以在定义队列时指定参数durable为true
//第二个参数是持久化参数durable
c.queueDeclare("helloworld", true, false, false, null);
由于之前我们已经定义过队列"hello"是不可持久化的, 对已存在的队列, rabbitmq不允许对其定义不同的参数, 否则会出错, 所以这里我们定义一个不同名字的队列"task_queue"
//定义一个新的队列,名为 task_queue
//第二个参数是持久化参数 durable
c.queueDeclare("task_queue", true, false, false, null);
生产者和消费者代码都要修改
这样即使rabbitmq重新启动, 队列也不会丢失. 现在我们再设置队列中消息的持久化, 使用MessageProperties.PERSISTENT_TEXT_PLAIN
参数
//第三个参数设置消息持久化
c.basicPublish("", "task_queue",
MessageProperties.PERSISTENT_TEXT_PLAIN,
msg.getBytes());
发布订阅模式
在前面的例子中,我们任务消息只交付给一个工作进程。在这部分,我们将做一些完全不同的事情——我们将向多个消费者传递同一条消息。这种模式称为“发布/订阅”。
Exchanges 交换机
RabbitMQ消息传递模型的核心思想是,生产者永远不会将任何消息直接发送到队列。实际上,通常生产者甚至不知道消息是否会被传递到任何队列。
相反,生产者只能向交换机(Exchange)发送消息。交换机是一个非常简单的东西。一边接收来自生产者的消息,另一边将消息推送到队列。交换器必须确切地知道如何处理它接收到的消息。它应该被添加到一个特定的队列中吗?它应该添加到多个队列中吗?或者它应该被丢弃。这些规则由exchange的类型定义。
有几种可用的交换类型:direct、topic、header和fanout。我们将关注最后一个——fanout。让我们创建一个这种类型的交换机,并称之为 logs: ch.exchangeDeclare("logs", "fanout");
fanout交换机非常简单。它只是将接收到的所有消息广播给它所知道的所有队列。
我们前面使用的队列具有特定的名称(还记得hello和task_queue吗?)能够为队列命名对我们来说至关重要——我们需要将工作进程指向同一个队列,在生产者和消费者之间共享队列。
绑定 Bindings
我们已经创建了一个fanout交换机和一个队列。现在我们需要告诉exchange向指定队列发送消息。exchange和队列之间的关系称为绑定。
//指定的队列,与指定的交换机关联起来
//成为绑定 -- binding
//第三个参数时 routingKey, 由于是fanout交换机, 这里忽略 routingKey
c.queueBind(queueName, "logs", "");
生产者发送消息
package m3;
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();
//创建 Fanout 交换机:logs
//c.exchangeDeclare("logs", "fanout");
c.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
//向 logs 交换机发送消息
while(true){
System.out.println("输入消息:");
String s = new Scanner(System.in).nextLine();
//对于fanout类型交换机,第二个参数无效
c.basicPublish("logs", "", null, s.getBytes());
}
}
}
消费者接收消息
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.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
//1.创建随机队列 2.创建交换机 3.绑定
String queue = UUID.randomUUID().toString();
c.queueDeclare(queue, false, true,true ,null);
c.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
//对 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);
}
}
路由模式
绑定 Bindings
绑定是交换机和队列之间的关系。这可以简单地理解为:队列对来自此交换的消息感兴趣。
绑定可以使用额外的routingKey参数。为了避免与basic_publish参数混淆,我们将其称为bindingKey。这是我们如何创建一个键绑定:
c.queueBind(queueName, EXCHANGE_NAME, "black");
直连交换机 Direct exchange
前面我们使用的是fanout交换机,这并没有给我们太多的灵活性——它只能进行简单的广播。
我们将用直连交换机(Direct exchange)代替。它背后的路由算法很简单——消息传递到bindingKey与routingKey完全匹配的队列。为了说明这一点,请考虑以下设置
其中我们可以看到直连交换机X,它绑定了两个队列。第一个队列用绑定键orange绑定,第二个队列有两个绑定,一个绑定black,另一个绑定键green。
这样设置,使用路由键orange发布到交换器的消息将被路由到队列Q1。带有black或green路由键的消息将转到Q2。而所有其他消息都将被丢弃。
多重绑定 Multiple bindings
使用相同的bindingKey绑定多个队列是完全允许的。如图所示,可以使用binding key black将X与Q1和Q2绑定。在这种情况下,直连交换机的行为类似于fanout,并将消息广播给所有匹配的队列。一条路由键为black的消息将同时发送到Q1和Q2。
生产者
package m4;
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.setHost("wht6.cn");
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
f.setVirtualHost("qiao");
Channel c = f.newConnection().createChannel();
//创建Direct交换机:direct_logs
c.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);
//发送消息,携带路由关键字
while(true){
System.out.println("输入消息:");
String s = new Scanner(System.in).nextLine();
System.out.println("输入路由键:");
String k = new Scanner(System.in).nextLine();
/*
第二个参数是路由键关键词
在简单模式和工作模式中,使用的默认交换机自动使用队列名做绑定
*/
c.basicPublish("direct_logs", k, null, s.getBytes());
}
}
}
消费者
package m4;
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");
f.setVirtualHost("qiao");
Channel c = f.newConnection().createChannel();
//1.创建随机队列 2.创建交换机 3.绑定,设置绑定建
String queue = UUID.randomUUID().toString();
c.queueDeclare(queue, false, true, true, null);
c.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);
System.out.println("输入绑定建,用空格隔开:"); //aa bb cc
String s = new Scanner(System.in).nextLine();
String[] a = s.split("\\s+");// \s表示空白字符 +表示1到多个
for (String k : a) {
c.queueBind(queue, "direct_logs", k);
}
//从队列接收,处理消息
DeliverCallback deliverCallback = (consumerTag, message) -> {
String msg = new String(message.getBody());
String key = message.getEnvelope().getRoutingKey(); //取出路由键
System.out.println(key+" -- "+msg);
};
CancelCallback cancelCallback = consumerTag -> {};
c.basicConsume(queue, true, deliverCallback, cancelCallback);
}
}
主题模式
虽然使用Direct交换机改进了我们的系统,但它仍然有局限性——它不能基于多个标准进行路由。
要实现这一点,我们需要了解更复杂的Topic交换机。
主题交换机 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",即使它有四个单词,也将匹配最后一个绑定,并将被传递到第二个队列。
生产者
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.setHost("wht6.cn");
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
f.setVirtualHost("qiao");
Channel c = f.newConnection().createChannel();
//Topic:topic_logs
c.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);
//发送消息,携带路由关键字
while(true){
System.out.println("输入消息:");
String s = new Scanner(System.in).nextLine();
System.out.println("输入路由键:");
String k = new Scanner(System.in).nextLine();
/*
第二个参数是路由键关键词
在简单模式和工作模式中,使用的默认交换机自动使用队列名做绑定
*/
c.basicPublish("topic_logs", k, null, s.getBytes());
}
}
}
消费者
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");
f.setVirtualHost("qiao");
Channel c = f.newConnection().createChannel();
//1.创建随机队列 2.创建交换机 3.绑定,设置绑定建
String queue = UUID.randomUUID().toString();
c.queueDeclare(queue, false, true, true, null);
c.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);
System.out.println("输入绑定建,用空格隔开:"); //aa bb cc
String s = new Scanner(System.in).nextLine();
String[] a = s.split("\\s+");// \s表示空白字符 +表示1到多个
for (String k : a) {
c.queueBind(queue, "topic_logs", k);
}
//从队列接收,处理消息
DeliverCallback deliverCallback = (consumerTag, message) -> {
String msg = new String(message.getBody());
String key = message.getEnvelope().getRoutingKey(); //取出路由键
System.out.println(key+" -- "+msg);
};
CancelCallback cancelCallback = consumerTag -> {};
c.basicConsume(queue, true, deliverCallback, cancelCallback);
}
}