RabbitMQ

最新推荐文章于 2024-08-16 23:11:37 发布
最新推荐文章于 2024-08-16 23:11:37 发布
阅读量182 收藏 1
点赞数
文章标签： rabbitmq centos linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61395392/article/details/122077523
版权

目录

RabbitMQ搭建

Nat网络网段

加载虚拟机镜像

解决网络设置问题

安装Docker虚拟机

搭建 Rabbitmq 服务器

RabbitMQ六种工作模式

简单模式

工作模式

发布订阅模式

路由模式

主题模式

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);
    }
}

Q.iao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ详解
m0_38033199的博客
11-11 4094
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。
rabbitmq
yangm_ingliang的博客
03-02 205
Springboot 使用RabbitMQ使用RabbitMQ,发送消息时并不是直接发送到Queue中，而是发送到exchange中然后依据发送时的routing key和绑定到exchange上的binding key将消息路由到Queue中。queue&exchange&bingding key //发送消息 public void sendMessage() { SimpleDate
RabbitMQ 入门介绍
qq_24991197的博客
06-17 2540
MQ 的相关概念 什么是 MQ MQ(message queue)，从字面意思上看，本质是个队列，FIFO 先入先出，只不过队列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ 是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了 MQ 之后，消息发送上游只需要依赖 MQ，不用依赖其他服务。 为什么要用 MQ 1.流量消峰 举个例子，如果订单系统最多能处理一万次订单，这个处理能力应付正常时段的下单时绰绰有余，正常时段我们下单一秒后就能返回结
【RabbitMQ】MQ的基本概念、RabbitMQ简介及安装
十八岁讨厌编程的博客
01-11 2万+
本文涉及MQ的基本概念、RabbitMQ简介、RabbitMQ的安装等内容
rabbitMQ的详细介绍
热门推荐
wang20010104的博客
04-07 7万+
rabbitMQ的详细介绍
RabbitMQ的详解和使用
创作不易，请多支持，将为本站提供更多「有价值的文章」。
04-10 1万+
一、AMQP协议 1、AMQP协议介绍 AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有RabbitMQ等。 2、功能范围 存储转发（多个消息发送者，单个消息接收者） 分布式事务（多个消息发送者，多个消息接收者） 发布订阅（多个消息发送者，多个消息
RabbitMQ Server3.13.0
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
rabbitmqadmin
07-08
RabbitMQ命令行手动创建队列rabbitmqadmin用法 手动创建队列方法：登录http://ip:15672/cli下载 将下载的rabbitmqadmin放到/usr/sbin目录下，并赋予权限：chmod 755 rabbitmqadmin 查看命令帮助信息： python ...
rabbitmq开发规范
07-04
**RabbitMQ开发规范详解** 在使用RabbitMQ进行分布式消息传输时，遵循一定的开发规范至关重要，这不仅可以提高系统的可维护性，也有助于保证数据的一致性和稳定性。本篇文章将详细阐述RabbitMQ的命名规范、消息传输...
rabbitmq3.10.4
06-07
RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中的消息传递。它基于AMQP（Advanced Message Queuing Protocol）协议，为多种编程语言提供API，使得开发人员能够轻松地实现消息的发送和接收。在...
RabbitMq六种工作模式
小盐粒吖的博客
08-04 764
1.简单模式 RabbitMQ是一个消息中间件，你可以想象它是一个邮局。当你把信件放到邮箱里时，能够确信邮递员会正确地递送你的信件。RabbitMq就是一个邮箱、一个邮局和一个邮递员。 发送消息的程序是生产者 队列就代表一个邮箱。虽然消息会流经RbbitMQ和你的应用程序，但消息只能被存储在队列里。队列存储空间只受服务器内存和磁盘限制，它本质上是一个大的消息缓冲区。多个生产者可以向同一个队列发送消息，多个消费者也可以从同一个队列接收消息. 消费者等待从队列接收消息 pom.xml 添加slf4j依赖,
rabbitmq详解
m0_67393342的博客
07-28 2685
RabbitMQ是一个实现了AMQP（AdvancedMessageQueuingProtocol）高级消息队列协议的消息队列服务，用Erlang语言。是面向消息的中间件。你可以把它想像成一个邮局你把信件放入邮箱，邮递员就会把信件投递到你的收件人处。在这个比喻中，RabbitMQ是一个邮箱、邮局、邮递员。RabbitMQ和邮局的主要区别是，它处理的不是纸，而是接收、存储和发送二进制的数据——消息。主要流程。...
RabbitMQ 详解
m0_53067943的博客
05-09 1万+
文章主要对关于RabbitMQ的知识总结
ActiveMQ、RabbitMQ、Kafka、RocketMQ在事务性消息、性能、高可用和容错、定时消息、负载均衡、刷盘策略的区别
最新发布
猪猪
08-16 1112
ActiveMQ、RabbitMQ、Kafka、RocketMQ这四种消息队列在事务性消息、性能、高可用和容错、定时消息、负载均衡、刷盘策略等方面各有其特点和差异。
RabbitMQ实战指南
"RabbitMQ Cookbook：由Sigismondo Boschi和Gabriele Santomaggio合著，该书提供了超过70个实用的食谱，旨在帮助读者利用RabbitMQ开发消息传递应用程序，通过大量现实生活中的例子进行教学。" 《RabbitMQ Cookbook...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值