消息中间件系列四、认识AMQP和RabbiyMq的简单使用

最新推荐文章于 2022-04-07 14:25:36 发布
最新推荐文章于 2022-04-07 14:25:36 发布
阅读量283 收藏
点赞数
文章标签： 大数据 java 网络
原文链接：https://yq.aliyun.com/articles/647523
版权

前言：这是中间件一个系列的文章之一，有需要的朋友可以看看这个系列的其他文章：
消息中间件系列一、消息中间件的基本了解
消息中间件系列二、Windows下的activeMQ和rabbitMQ的安装
消息中间件系列三、JMS和activeMQ的简单使用
消息中间件系列四、认识AMQP和RabbiyMq的简单使用
消息中间件系列五、rabbit消息的确认机制
消息中间件系列六，rabbit与spring集成实战

AMQP

AMQP(advanced message queuing protocol)是一个提供统一消息服务的应用层标准协议，基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同开发语言等条件的限制 。

一、AMQP的一些技术术语

  • AMQP模型（AMQP Model）：一个由关键实体和语义表示的逻辑框架，遵从AMQP规范的服务器必须提供这些 实体和语义。为了实现本规范中定义的语义，客户端可以发送命令来控制AMQP服务器。
  • 连接（Connection）：一个网络连接，比如TCP/IP套接字连接。
  • 会话（Session）：端点之间的命名对话。在一个会话上下文中，保证“恰好传递一次”。
  • 信道（Channel）：多路复用连接中的一条独立的双向数据流通道。为会话提供物理传输介质。虚拟的连接，建立在真实的tcp连接之上的。信道的创建没有限制的。
  • 交换器（Exchange）：服务器中的实体，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。
  • 消息队列（Message Queue）：一个命名实体，用来保存消息直到发送给消费者。
  • 绑定器（Binding）：消息队列和交换器之间的关联。
  • 绑定器关键字（Binding Key）：绑定的名称。一些交换器类型可能使用这个名称作为定义绑定器路由行为的模式。
  • 路由关键字（路由键）（Routing Key）：一个消息头，交换器可以用这个消息头决定如何路由某条消息。
  • 持久存储（Durable）：一种服务器资源，当服务器重启时，保存的消息数据不会丢失。
  • 临时存储（Transient）：一种服务器资源，当服务器重启时，保存的消息数据会丢失。
  • 持久化（Persistent）：服务器将消息保存在可靠磁盘存储中，当服务器重启时，消息不会丢失。
  • 非持久化（Non-Persistent）：服务器将消息保存在内存中，当服务器重启时，消息可能丢失。
  • 消费者（Consumer）：一个从消息队列中请求消息的客户端应用程序。
  • 生产者（Producer）：一个向交换器发布消息的客户端应用程序。
    消息处理过程：

队列通过路由键绑定到交换器，生产者把消息发送到了交换器，交换器根据绑定的路由键将消息路由到特定的队列，订阅了队列的消费者进行接收。

_1

说明（下文会证明这三点）

  • 如果消息达到无人订阅的队列会一直在队列中等待，rabbitmq会默认队列是无限长度的。
  • 如果多个消费者订阅到同一队列，消息会轮询的方式发送给消费者，每个消息只会发送给一个消费者
  • 消息路由到了不存在的队列，消息会忽略，当消息不存在，消息丢失了。

二、创建自定义队列

　　生产者和消费者都可以调用declareQueue方法创建队列，当没有目标队列时才会创建，如果已经存在相同的队列了就不在重复创建。
　　相关参数：exclusive 队列为应用程序私有，auto-delete 最后一个消费者取消订阅时，队列会自动删除，durable 队列持久化。
　　如果消费者订阅了队列，就不能再声明队列了。
先贴上后面会说到的一段代码，演示是怎么创建队列的

        Channel channel = connection.createChannel();//信道
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);//交换器
        String queueName = "direct_queue";
        //创建队列，参数分别为：队列名，durable是否进行持久化，exlusive是否私有，auto-delete没有消费者是自动删除，arguments相关参数
        channel.queueDeclare(queueName,false,false,false,null);

检测队列是否存在

可以通过调用方法QueueDeclarePassive判断队列是否存在，看方法名是“消极的声明创建”的意思，事实上它没有去声明队列，所谓消极，去看看有没有名为xxx的queue，如果有我就把名字什么的信息告诉你，没有就直接报错，用来确认queue是否存在。

三、四种交换器：

1、direct：

路由键完全匹配时，消息投放到对应队列。Amqp实现都必须有一个direct交换器（默认交换器），名称为空白字符。队列不声明交换器，会自动绑定到默认交换器，队列的名称作为路由键。
补充：一个direct队列可以绑定多个路由键，一条消息可以发给多个direct队列（都有绑定相同的路由键），一个direct队列（有多个路由键）也可以接收不同类型的消息。

_2

2、Fanout：

可以理解为广播，绑定这中交换器的队列，可以接收该交换器上任何类型的消息。

_3

3、Topic：

主题，使来自不同源头的消息到达同一个队列

_4

路由键中的“*”和“#”

“.”会把路由键分为好几个标识符，“*”匹配一个标识符，“#”匹配一个或者多个；
例如：xxx.yyy.zzzz 可以： xxx.*. zzzz ， xxx.# ， #.zzzz

4、Headers:

匹配消息头，其余与direct一样，实用性不大

举例说明

日志处理场景：
1、有交换器（topic）log_exchange，日志级别有 error,info,warning，应用模块有 user,order,email，路由键的规则是 日志级别+“.”+应用模块名(例如info.user)
2、发送邮件失败，报告一个email的error，basicPublic(message,"log-exchange","error.email")
队列的绑定：queueBind("email-error-queue","log-exchange","error.email")
要监听email所有的日志怎么办？
queueBind("email-log-queue","log-exchange"," *.email")
监听所有模块所有级别日志？
queuebind(“all-log-queue”,"log-exchange","#")
“.”会把路由键分为好几个标识符，“*”匹配一个标识符，“#”匹配一个或者多个（xxx.yyy.zzzz 可以： xxx.*. zzzz ， xxx.# ， #.zzzz）。

补充：生产者要把消息发送到消费者，两者必须绑定同一个的交换器。

四、虚拟主机

Vhost，真实rabbitmq服务器上的mini型虚拟的mq服务器。有自己的权限机制。Vhost提供了一个逻辑上的分离，可以区分客户端，避免队列和交换器的名称冲突。RabbitMq包含了一个缺省的vhost :“/”，用户名guest，口令 guest（guest用户只能在本机访问）。

五、消息持久化

1、队列是必须持久化
2、交换器也必须是持久化
3、消息的投递模式必须（int型） 2
以上条件全部满足，消息才能持久化
问题：持久化会带来性能的严重下降（下降10倍）

六、Rabbit简要架构介绍

_5

消息队列的使用过程大概如下：
（1）客户端连接到消息队列服务器，打开一个channel（信道）。（生产者和消费者都可操作）
（2）客户端声明一个exchange（交换器），并设置相关属性。（生产者和消费者都可操作）
（3）客户端声明一个queue（队列），并设置相关属性。（一般在消费者中操作）
（4）客户端使用routing key（路由键），在exchange（交换器）和queue（队列）之间建立好绑定关系。（一般在消费者中操作）
（5）客户端投递消息到exchange（交换器）。（一般在生产者中进行）
客户端先给指定交换器（exchange）发送消息，交换器再根据路由键把消息发送给相应的队列，而订阅了相应队列的客户端就能收到消息。

七、使用RabbitMq原生Java客户端进行消息通信

1、添加依赖

客户端Jar包和源码包下载地址：
http://repo1.maven.org/maven2/com/rabbitmq/amqp-client/5.0.0/amqp-client-5.0.0.jar
http://repo1.maven.org/maven2/com/rabbitmq/amqp-client/5.0.0/amqp-client-5.0.0-sources.jar
如果是引入jar包的形式还需要引入slf4j-api-1.6.1.jar。

如果是Maven工程加入：

<dependency>
  <groupId>com.rabbitmq</groupId>
  <artifactId>amqp-client</artifactId>
  <version>5.0.0</version>
</dependency>

注意：5系列的版本最好使用JDK8及以上， 低于JDK8可以使用4.x(具体的版本号到Maven的中央仓库查)的版本。

2、生产者通过DIRECT类型的交换器发布消息

AMQP一样要连接工厂、连接，与JMS中间件不同的是，AMQP多了信道、交换器、路由键等这些概念。处理过程看下面代码：

package dongnaoedu.normal;
import com.rabbitmq.client.BuiltinExchangeType;
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 DirectProducer {

    private final static String EXCHANGE_NAME = "direct_logs";//交换器

    public static void main(String[] args) throws IOException, TimeoutException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        //gust用户只能在本机访问
        //非本机访问需要设置以下属性
/*        factory.setUsername(..);
        factory.setPort();
        factory.setVirtualHost();*/
        Connection connection = factory.newConnection();//连接

        Channel channel = connection.createChannel();//信道

        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);//定义连接交换器

        String[]serverities = {"error","info","warning"};//路由键

        for(int i=0;i<3;i++){
            String server = serverities[i];
            String message = "Hello world_"+(i+1);
            //basicProperties是设置一些消息属性的，不需要可以传null
            //通过信道把消息、路由键传给交换器，交换器会根据路由键把消息传给相应的队列
            channel.basicPublish(EXCHANGE_NAME,server,null,message.getBytes());
            System.out.println("Sent "+server+":"+message);
        }
        channel.close();
        connection.close();
    }
}

3、生产者通过FANOUT类型的交换器发布消息

FANOUT和DIRECT在原生代码的实现方式上基本一样，只有在调用channel的exchangeDeclare方法声明交换器时把交换器类型改成FANOUT即可。

package dongnaoedu.normal;

import com.rabbitmq.client.BuiltinExchangeType;
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 FanoutProducer {
    private final static String EXCHANGE_NAME = "fanout_logs";//交换器
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
/*        factory.setUsername(..);
        factory.setPort();
        factory.setVirtualHost();*/
        Connection connection = factory.newConnection();//连接
        Channel channel = connection.createChannel();//信道
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);//交换器
        String[]serverities = {"error","info","warning"};//路由键
        for(int i=0;i<3;i++){
            String server = serverities[i];
            String message = "Hello world_"+(i+1);
            channel.basicPublish(EXCHANGE_NAME,server,null,message.getBytes());
            System.out.println("Sent "+server+":"+message);
        }
        channel.close();
        connection.close();
    }
}

4、指定路由键的消费者

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

public class ConsumerError {

    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] argv) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        Connection connection = factory.newConnection();//连接
        Channel channel = connection.createChannel();//信道
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);//交换器
        //声明随机队列
        String queueName = channel.queueDeclare().getQueue();
        String server = "error";
        //队列和交换器的绑定
        channel.queueBind(queueName,EXCHANGE_NAME,server);//把队列按路由键绑定到交换器上
        System.out.println("Waiting message.......");

        Consumer consumerB = 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("Accept:"+envelope.getRoutingKey()+":"+message);
            }
        };
        //三个参数：队列名，是否自动确认，消息监听回调
        channel.basicConsume(queueName,true,consumerB);//对消息进行消费
    }
}

补充：这里涉及到rabbit的确认机制，相关内容我会在下一篇博客消息中间件系列五、rabbit消息的确认机制再做详细介绍。

5、绑定多个路由键的消费者

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

public class ConsumerAll {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] argv) throws IOException,
            InterruptedException, TimeoutException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        Connection connection = factory.newConnection();//连接
        Channel channel = connection.createChannel();//信道
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);//交换器
        //声明随机队列
        String queueName = channel.queueDeclare().getQueue();
        String[]serverities = {"error","info","warning"};
        for(String server:serverities){
            //队列和交换器的绑定
            channel.queueBind(queueName,EXCHANGE_NAME,server);//server是路由建，一个队列可以绑定多个路由建
        }
        System.out.println("Waiting message.......");

        Consumer consumerA = 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("Accept:"+envelope.getRoutingKey()+":"+message);//getRoutingKey拿到路由建
            }
        };
        //三个参数：队列名，是否自动确认，消息监听回调
        channel.basicConsume(queueName,true,consumerA);//对消息进行消费
    }
}

启动消费者之后，两个消费者的打印信息都是一样的，会一直监听消息，当生产者发了消息的时候消费者会调用handleDelivery监听方法。

image

此时有两个消费者，连接，通道，交换器队列的信息如下

image
image
image
image

可以看到产生了两个队列，所以这两个消费者接收消息是互不影响的。

再启动生产者DirectProducer
image
这个简单的生产者执行完了就退出了，
ConsumerError通过路由键的匹配只能收到error类的消息
image
ConsumerAll收到了全部的消息：
image

6、自己创建队列，不同消费者订阅相同的队列

在上面例子的基础上进行改动，
调用通道的queueDeclare方法即可创建指定名字的队列，相关参数在目录二解释过了

package dongnaoedu.normal;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConsumerAll {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] argv) throws IOException,
            InterruptedException, TimeoutException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        Connection connection = factory.newConnection();//连接
        Channel channel = connection.createChannel();//信道
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);//交换器
        //声明随机队列
//        String queueName = channel.queueDeclare().getQueue();
        String queueName = "direct_queue";
        //创建队列，参数分别为：队列名，durable是否进行持久化，exlusive是否私有，auto-delete没有消费者是自动删除，arguments相关参数
        channel.queueDeclare(queueName,false,false,false,null);
        String[]serverities = {"error","info","warning"};
        for(String server:serverities){
            //队列和交换器的绑定
            channel.queueBind(queueName,EXCHANGE_NAME,server);//server是路由建，一个队列可以绑定多个路由建
        }
        System.out.println("Waiting message.......");

        Consumer consumerA = 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("Accept:"+envelope.getRoutingKey()+":"+message);//getRoutingKey拿到路由建
            }
        };
        //三个参数：队列，自动确认，消息监听回调
        channel.basicConsume(queueName,true,consumerA);//对消息进行消费
    }
}
package dongnaoedu.normal;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConsumerError {

    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] argv) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        Connection connection = factory.newConnection();//连接
        Channel channel = connection.createChannel();//信道
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);//交换器
//        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);//交换器
        //声明随机队列
//        String queueName = channel.queueDeclare().getQueue();
        String queueName = "direct_queue";
 //       direct_queue这个队列已经在ConsumerAll 绑定了三个路由键，这里不用再绑定了，也不用重复创建了
        //参数分别为：队列名，durable是否进行持久化，exlusive是否私有，auto-delete没有消费者是自动删除，arguments相关参数
//        channel.queueDeclare(queueName,false,false,false,null);
 //       String server = "error";
//        channel.queueBind(queueName,EXCHANGE_NAME,server);//把队列按路由键绑定到交换器上
        
        System.out.println("Waiting message.......");

        Consumer consumerB = 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("Accept:"+envelope.getRoutingKey()+":"+message);
            }
        };
        channel.basicConsume(queueName,true,consumerB);
    }
}

两个类运行后的队列：
image

可以看到只有一个队列，两个消费者都是订阅这个队列。

生产者DirectProducer不用改变，运行DirectProducer后消费者接收信息的打印结果：

image
image

可以看到消息是轮询的方式发送给消费者，这时再把消费者关掉，可以看到队列已经没有消息了，由于创建队列的时候auto-delete设置为false，这时队列并没有删除。

image

再一次运行生产者，可以看到队列收到了3条新消息，没有被消费者消费。

image
在生产者这边，添加一个没有队列绑定的路由键，发现在direct交换器下队列和消费者和都没有受到任何影响。

        String[]serverities = {"error","info","warning","test"};//路由键
        for(int i=0;i<4;i++){
            String server = serverities[i];
            String message = "Hello world_"+(i+1);
            //basicProperties是设置一些消息属性的，不需要可以传null
            //通过信道把消息、路由键传给交换器，交换器会根据路由键把消息传给相应的队列
            channel.basicPublish(EXCHANGE_NAME,server,null,message.getBytes());
            System.out.println("Sent "+server+":"+message);
        }

这证实了上文说到的：

  • 如果多个消费者订阅到同一队列，消息会轮询的方式发送给消费者，每个消息只会发送给一个消费者。
  • 如果消息达到无人订阅的队列会一直在队列中等待，rabbitmq会默认队列是无限长度的。
  • 消息路由到了不存在的队列，消息会忽略，当消息不存在，消息丢失了。
weixin_33957648
关注
RabbitMQ整合Spring AMQP实战！（全）
java专栏的博客
08-12 8268
前言 1. AMQP 核心组件 RabbitAdmin SpringAMQP声明 RabbitTemplate SimpleMessageListenerContainer MessageListenerAdapter MessageConverter 2. RabbitAdmin RabbitAdmin类可以很好的才注意RabbitMQ,在Spring中直接进行诸如即可。 ...
RabbitMQ：AMQP 0-9-1方法的简单使用
编程学习者的博客
05-16 327
1.声明 当前内容主要用于本人学习和复习，当前内容主要包含exchang和queue的声明，删除、绑定(以及queue中消息的清除) 当前内容来源：RabbitMQ官方文档 和 AMQP 0-9-1 2.关于Exchange的使用 1.声明或创建Exchange // 声明并创建一个exchange @Test public void declareExchange() throws Exception { RabbitMqUtils mqUtils = new RabbitMqUtils(); t
rabbitMQ的详细介绍
热门推荐
wang20010104的博客
04-07 7万+
rabbitMQ的详细介绍
RabbitMQ 入门介绍
qq_24991197的博客
06-17 2616
MQ 的相关概念 什么是 MQ MQ(message queue)，从字面意思上看，本质是个队列，FIFO 先入先出，只不过队列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ 是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了 MQ 之后，消息发送上游只需要依赖 MQ，不用依赖其他服务。 为什么要用 MQ 1.流量消峰 举个例子，如果订单系统最多能处理一万次订单，这个处理能力应付正常时段的下单时绰绰有余，正常时段我们下单一秒后就能返回结
2019年12道RabbitMQ高频面试题你都会了吗？（含答案解析）
程序员追风的博客
12-20 1万+
RabbitMQ 面试题 1、什么是 rabbitmq 2、为什么要使用 rabbitmq 3、使用 rabbitmq 的场景 4、如何确保消息正确地发送至 RabbitMQ？ 如何确保消息接收方消费了消息？ 5.如何避免消息重复投递或重复消费？ 6、消息基于什么传输？ 7、消息如何分发？ 8、消息怎么路由？ 9、如何确保消息不丢失？ 10、使用 RabbitMQ 有什么好处？...
AMQP-CPP是用于与RabbitMq消息中间件通信的c++库
06-07
AMQP-CPP是一个开源的C++库，专为与RabbitMQ消息中间件进行通信而设计。RabbitMQ是一款广泛使用的开源消息代理，基于Advanced Message Queuing Protocol (AMQP)标准，提供高效、可靠的异步消息传递。AMQP-CPP库使得...
基于消息中间件的学习记录以及源码示例【JMS、AMQP、ActiveMQ、RocketMQ】.zip
05-08
通过上述四个消息中间件的学习和源码分析，你可以掌握消息中间件的核心概念和技术，这对于构建高效、稳定的分布式系统至关重要。在实践中，你可以结合具体的业务场景，选择适合的消息中间件，并优化其配置，以满足...
RabbitMQ原理和使用详解：AMQP协议与消息中间件
RabbitMQ是基于Advanced Message Queuing Protocol（AMQP）协议的开源实现，是一种消息中间件，用于组件之间的解耦。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。RabbitMQ支持...
RabbitMQ是一款基于AMQP的中间件.docx
最新发布
09-30
RabbitMQ是一款基于AMQP（Advanced Message Queuing Protocol，高级消息队列协议）的中间件，它用于服务间通信，实现解耦，并提供了消息持久化、异步处理、流量削峰等功能。以下是对RabbitMQ的详细介绍： 一、基本...
maven项目用的amqp-client-5.30.jar
08-08
maven项目用的amqp-client-5.30.jar，亲测有效，这是我在项目中使用过的。放心下载吧
RabbitMQ 消息队列
weixin_43813267的博客
12-29 547
1.什么是rabbitMQ RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue 高级消息队列协议 ）的开源实现，能够实现异步消息处理 RabbitMQ是一个消息代理：它接受和转发消息。 你可以把它想象成一个邮局：当你把你想要发布的邮件放在邮箱中时，你可以确定邮差先生最终将邮件发送给你的收件人。在这个比喻中，RabbitMQ是邮政信箱，邮局和邮递员。 R...
RabbiMQ基础以及spring-boot-starter-amqp使用
诚的博客
11-19 2143
​ RabbitMQ是一种基于amq协议的消息队列，本文主要记录一下rabbitmq的基础内容以及使用spring-boot-starter-amqp操作rabbitmq。 1，rabbitmq中的几个重要概念 a) 虚拟主机(vhost) ​ 虚拟主机：一个虚拟主机持有一组交换机、队列和绑定。虚拟主机的作用在于进行权限管控，rabbitmq默认有一个虚拟主机"/"。可以使用rabbitmqctl add_vhost命令添加虚拟主机，然后使用rabbitmqctl set_permissions命令设
Maven写rabbitMQ教程01
Sun
07-13 910
Maven写ribbitMQ教程 提示：如果有不知道ribbitMQ的朋友建议先去看看相关教程 先上一个RibbitMQ的工作原理图 组成部分说明如下： Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue。 Exchange：消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过虑 Queue：消息队列，存储消息的队列，消息到达队列并转发给指定的消费方。 Producer：消息生产者，即生产方客户端，生产方客户端将消息发送到MQ。 Consumer：消息消费者，即
RabbitMQ下的生产消费者模式与订阅发布模式
茅庐
12-11 2万+
生产消费者模式与订阅发布模式是使用消息中间件时常用的两种模式，用于功能解耦和分布式系统间的消息通信。本文在总结了RabbitMQ核心概念的基础上，以“数据接入”和“事件分发”两个场景来探讨如何实现生产消费者模式和订阅发布模式。
RabbitMQ的使用
piaoslowly的专栏
08-13 7068
RabbitMQ的使用 RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。 AMQP，即Advanced Message Queuing Pr...
amqp协议 面试_消息中间件——RabbitMQ（三）理解RabbitMQ核心概念和AMQP协议
weixin_39867066的博客
01-03 104
求关注理解RabbitMQ核心概念和AMQP协议！前言本章学习，我们可以了解到以下知识点：互联网大厂为什么选择RabbitMQ？RabbiMQ的高性能之道是如何做到的？什么是AMQP高级协议？AMQP核心概念是什么？RabbitMQ整体架构模型是什么样子的？RabbitMQ消息是如何流转的？1. 初识RabbitMQRabbitMQ 是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应...
AMQP消息队列的测试方法
weixin_34268310的博客
11-21 1855
作者简介 羊老师，目前就职于饿了么物流研发部，运单与服务业务线的测试负责人，同时也负责测试基础设施的开发与维护，致力于自动化测试及工程效率的提升工作 前言 在大型互联网架构中经常会用到消息队列（Message Queue）这种中间件，在服务端测试时，许多测试同学通过工具对API和数据库都能熟练地进行测试，一说到消息队列的测试就有点不知道怎么入手了。那么对于看不见摸不着的消息队列，如何进行有效的...
RabbitMQ 实战教程（一）
菜鸟路上的小白
10-11 2万+
MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取或者订阅队列中的消息。RabbitMQ是信息传输的中间者。本质上，他从生产者接收消息，转发这些消息给消费者。换句话说，RabbitMQ能够按根据你指定的规则进行消息转发、缓冲、和持久化。 在项目中，将一些无需即时返回且耗时的操作提取出来，进行了异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值