RabbitMQ的核心组件和五种常用模式

最新推荐文章于 2024-05-15 11:59:28 发布
最新推荐文章于 2024-05-15 11:59:28 发布
阅读量1.5k 收藏 5
点赞数
分类专栏： 消息队列 文章标签： 队列 交换机 rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44623190/article/details/115921042
版权
RabbitMQ的核心组件

在这里插入图片描述

Broker组件 

Broker:接受和分发消息的应用，RabbitMQ Server就是Message Broker

virtual host组件 

出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个vhost，每个用户在自己的 vhost 创建 exchange／queue 等

Connection组件 

publisher／consumer 和 broker 之间的 TCP 连接

Channel组件 

如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，AMQP method 包含了channel id 帮助客户端和message broker 识别 channel，所以 channel 之间是完全隔离的。Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销

Exchange组件 

message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and fanout (multicast)

Queue组件 

消息最终被送到这里等待 consumer 取走

Binding组件 

exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息被保存到 exchange 中的查询表中，用于 message 的分发依据
1，简单模式

在这里插入图片描述
生产者Producer:

package com.lp.test;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

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

public class Producter {
    public static void main(String[] args) {
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        //设置连接的ip地址
        factory.setHost("192.168.31.181");
        try {
            //新建连接
            Connection connection = factory.newConnection();
            //创建通道
            Channel channel = connection.createChannel();
            //创建队列
            /**
             * String queue 队列的名称
             * boolean durable 是否该队列持久化rabbitMq服务重启后该存放是否存在
             * boolean exclusive 是否独占false
             * boolean autoDelete 是否自动删除 如果长时间没有发生消息，则自动删除
             * Map<String,Object> arguments 额外参数，可以给空
             */
             channel.queueDeclare("lipeng", true, false,false, null);
             //发生消息
            /**
             * String exchange: 交换机的名称 如果没有则使用”“ 它会自动采用默认
             * String routingKey 路由key,如果没有交换机的绑定  使用队列的名称
             * BasicProperties props 消息的一些额外配置 可以为null
             * byte[] body 消息的内容
             */
             String msg="hello world, I am coming!!!，Nice to meet you";
             channel.basicPublish("","lipeng",null,msg.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者Consumer：

package com.lp.test;

import com.rabbitmq.client.*;

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

public class Consumeer {
    public static void main(String[] args) {
        //创建连接工厂 ---配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        //设置连接ip
        factory.setHost("192.168.31.181");
        try {
            //创建连接对象
            Connection connection = factory.newConnection();
            //创建通道
            Channel channel = connection.createChannel();
            //接受消息
            /**
             * String queue 对列的名称
             * boolean autoAck 是否自动确认
             * Consumer callback 回调函数：当队列中存在信息，会自动触发回调函数
             */
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //body 接受的信息
                    System.out.println("消息内容是"+new String(body));
                }
            };
            channel.basicConsume("lipeng",true,consumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}
2,工作者模式

在这里插入图片描述
生产者Producer：

package com.lp.worker;

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 Producter {
    public static void main(String[] args) {
   		//声明全局队列的变量 ---queue1
        String queue1="lipeng_worker01";
        //创建连接工厂 ---配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
        	//创建连接
            Connection connection = factory.newConnection();
            //创建信道
            Channel channel = connection.createChannel();
            //创建队列
             /**
             * String queue 队列的名称
             * boolean durable 是否该队列持久化rabbitMq服务重启后该存放是否存在
             * boolean exclusive 是否独占false
             * boolean autoDelete 是否自动删除 如果长时间没有发生消息，则自动删除
             * Map<String,Object> arguments 额外参数，可以给空
             */
            channel.queueDeclare(queue1,true,false,false,null);
            //发生消息
             /**
             * String exchange: 交换机的名称 如果没有则使用”“ 它会自动采用默认
             * String routingKey 路由key,如果没有交换机的绑定  使用队列的名称
             * BasicProperties props 消息的一些额外配置 可以为null
             * byte[] body 消息的内容
             */
            for (int i = 0; i <10 ; i++) {
                String msg="你好呀"+":"+i;
                channel.basicPublish("",queue1,null,msg.getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者1Consumer01：

package com.lp.worker;

import com.rabbitmq.client.*;

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

public class Consumeer01 {
    public static void main(String[] args) {
    	//创建连接工厂 ---配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
       		//创建连接
            Connection connection = factory.newConnection();
            //创建信道
            Channel channel = connection.createChannel();
            //接受消息
             /**
             * String queue 对列的名称
             * boolean autoAck 是否自动确认
             * Consumer callback 回调函数：当队列中存在信息，会自动触发回调函数
             */
            DefaultConsumer consumer = new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {					 //body 接受的信息
                    System.out.println("消息01:"+new String(body));
                }
            };
            channel.basicConsume("lipeng_worker01",true,consumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者2Consumer02：

package com.lp.worker;

import com.rabbitmq.client.*;

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

public class Consumeer02 {
    public static void main(String[] args) {
    	//创建连接工厂 ---配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
       		//创建连接
            Connection connection = factory.newConnection();
            //创建信道
            Channel channel = connection.createChannel();
            //接受消息
             /**
             * String queue 对列的名称
             * boolean autoAck 是否自动确认
             * Consumer callback 回调函数：当队列中存在信息，会自动触发回调函数
             */
            DefaultConsumer consumer = new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {					 //body 接受的信息
                    System.out.println("消息02:"+new String(body));
                }
            };
            channel.basicConsume("lipeng_worker01",true,consumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}
3,广播模式

在这里插入图片描述
生产者Producer：

package com.lp.fanout;

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 Producter {
    public static void main(String[] args) {
    	//创建连接工厂  ---配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
        	//创建连接
            Connection connection = factory.newConnection();
            //创建信道
            Channel channel = connection.createChannel();
            //声明队列
            channel.queueDeclare("lipeng_fanout01",true,false,false,null);
            channel.queueDeclare("lipeng_fanout02",true,false,false,null);
            //声明交换机
            channel.exchangeDeclare("lipeng_exchange_fanout", BuiltinExchangeType.FANOUT,true);
			//绑定交换机            channel.queueBind("lipeng_fanout01","lipeng_exchange_fanout","");
            channel.queueBind("lipeng_fanout02","lipeng_exchange_fanout","");
            for (int i = 0; i <10 ; i++) {
                String msg="Do you love me ?"+i;
               //发生消息 channel.basicPublish("lipeng_exchange_fanout","",null,msg.getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者1Consumer01：

package com.lp.fanout;

import com.rabbitmq.client.*;

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

public class Consumeer01 {
    public static void main(String[] args) {
    	//创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
        	//创建连接
            Connection connection = factory.newConnection();
            //创建信道
            Channel channel = connection.createChannel();
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {					//body 接受的消息
                    System.out.println("消息01"+"=="+new String(body));
                }
            };
            channel.basicConsume("lipeng_fanout01",true,consumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者2Consumer02：

package com.lp.fanout;

import com.rabbitmq.client.*;

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

public class Consumeer02 {
    public static void main(String[] args) {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
        	//创建连接
            Connection connection = factory.newConnection();
            //创建信道
            Channel channel = connection.createChannel();
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {					//body 接受消息
                    System.out.println("消息02"+"=="+new String(body));
                }
            };
            channel.basicConsume("lipeng_fanout02",true,consumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}
4,路由模式

在这里插入图片描述
生产者Producer：

package com.lp.routing;

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 Producter {
    public static void main(String[] args) {
    	//声明用作全局变量的队列变量和交换机变量
        String queue1="lp_routing01";
        String queue2="lp_routing02";
        String exchange1="lp_exchange_direct";
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
        	//创建连接
            Connection connection = factory.newConnection();	
            //创建信道
            Channel channel = connection.createChannel();
            //声明对列
            channel.queueDeclare(queue1,true,false,false,null);
            channel.queueDeclare(queue2,true,false,false,null);
            //声明交换机
            channel.exchangeDeclare(exchange1, BuiltinExchangeType.DIRECT,true);
            //绑定交换机
            channel.queueBind(queue1,exchange1,"error");
            channel.queueBind(queue2,exchange1,"error");
            channel.queueBind(queue2,exchange1,"info");
            channel.queueBind(queue2,exchange1,"warning");
            //发生消息
            for (int i = 0; i <10 ; i++) {
                String msg="晚安,世界！"+":"+i;
                channel.basicPublish(exchange1,"error",null,msg.getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者1Consumer01：

package com.lp.routing;

import com.rabbitmq.client.*;

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

public class Consumeer01 {
    public static void main(String[] args) {
    	//创建连接对象
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
        	//创建连接
            Connection connection = factory.newConnection();
            //创建信道
            Channel channel = connection.createChannel();
            //接受消息
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {						//body 接受的消息内容
                    System.out.println("消息01:"+new String(body));
                }
            };
            channel.basicConsume("lp_routing01",true,consumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者2Consumer02：

package com.lp.routing;

import com.rabbitmq.client.*;

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

public class Consumeer02 {
    public static void main(String[] args) {
    	//创建连接对象
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
        	//创建连接
            Connection connection = factory.newConnection();
            //创建信道
            Channel channel = connection.createChannel();
            //接受消息
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {						//body 接受的消息内容
                    System.out.println("消息02:"+new String(body));
                }
            };
            channel.basicConsume("lp_routing01",true,consumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}
5,主题模式

在这里插入图片描述
生产者Producer：

package com.lp.topic;

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 Producter {
    public static void main(String[] args) {
    	//声明用作全局变量的队列变量和交换价变量
        String queue1="lp_topic01";
        String queue2="lp_topic02";
        String exchange1="lp_exchange_topic";
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
        	//创建连接
            Connection connection = factory.newConnection();
            //创建信道
            Channel channel = connection.createChannel();
            //声明队列
            channel.queueDeclare(queue1,true,false,false,null);
            channel.queueDeclare(queue2,true,false,false,null);
            //声明交换机
            channel.exchangeDeclare(exchange1, BuiltinExchangeType.TOPIC,true);
            //绑定队列
            channel.queueBind(queue1,exchange1,"*.orange.*");
            channel.queueBind(queue2,exchange1,"*.*.rabbit");
            channel.queueBind(queue2,exchange1,"lazy.#");
            //发生消息
            for (int i = 0; i <10 ; i++) {
                String msg="goodnight!My love world";
                channel.basicPublish(exchange1,"lazy.orange",null,msg.getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者1Consumer01：

package com.lp.topic;

import com.rabbitmq.client.*;

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

public class Consumeer01 {
    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("消息01:"+new String(body));
                }
            };
            channel.basicConsume("lp_topic01",true,consumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者2Consumer02：

package com.lp.topic;

import com.rabbitmq.client.*;

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

public class Consumeer02 {
    public static void main(String[] args) {
        String queue1="lp_topic02";
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.181");
        try {
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("消息02:"+new String(body));
                }
            };
            channel.basicConsume(queue1,true,consumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

每天努力一点点，终会有所收获！！！！

White Lee
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
掌握RabbitMQ几种常用模式的思想。本文将基于RabbitMQ官网提供相关的代码案例。
01-21
本文将深入探讨RabbitMQ的几种核心工作模式，并通过官方提供的代码示例进行解析，帮助读者理解和掌握其精髓。 一、简单模式（Simple） 在简单模式中，生产者发送消息到一个特定的队列，消费者则从这个队列接收并...
Apache RabbitMQ 的所有组件以及他是如何保证顺序消费消息的
weixin_42795092的博客
05-06 1090
Apache RabbitMQ 是一个开源消息队列系统，基于 Erlang 语言开发，实现了高级消息队列协议（AMQP）。RabbitMQ 提供了多种消息传递机制，包括点对点（direct）、发布/订阅（fanout）、路由（route）和事务（transactional）等。
RabbitMQ原理&RabbitMQ各组件作用&RabbitMQ使用场景
小宝儿的学习之路
04-12 1158
RabbitMQ原理 RabbitMQ介绍 MQ全称为Message Queue, 是一种分布式应用程序的的通信方法，它是消费-生产者模型的一个典型的代表 producer往消息队列中不断写入消息，而另一端consumer则可以读取或者订阅队列中的消息 RabbitMQ是一个遵循AMQP协议的消息中间件，它从生产者接受消息并传递给消费者，在这和过程中，根据路由规则就行路由、缓存和持久化 业务上，...
RabbitMQ的基本组件有哪些？
yuanlaile的博客
05-15 499
RabbitMQ的基本组件介绍，RabbitMQ不生产消息，他是消息的搬运工。
全面认识RabbitMQ各组件及消息传递机制
Pandfson的专栏
03-14 588
全面认识RabbitMQ各组件及消息传递机制
MQ——RabbitMQ基础组件
庄小焱
09-24 3412
讲述RabbitMQ的入门知识，包括生产者、消费者、队列、交换器、路由键、绑定、连接及信道等基本术语。本章还阐述了RabbitMQ与AMQP 协议的对应关系。并详细的阐述其原源码。RabbitMQ 整体上是一个生产者与消费者模型，主要负责接收、存储和转发消息。可以把消息传递的过程想象成:当你将一个包裹送到邮局，邮局会暂存并最终将邮件通过邮递员送到收件人的手上， RabbitMQ 就好比由邮局、邮箱和邮递员组成的一个系统。从计算机术语层面来说，RabbitMQ 模型更像是一种交换机模型。
RabbitMQ 组件介绍和功能
handancom的博客
07-16 2372
但是在某些情况下，如果我们在发送消息的时候，当前的exchange不存在或者指定的路由key路由不到，这个时候我们需要监听这种不可达消息，就需要使用到ReturrnListener。我们的消息生产者，通过指定一个Exchange和Routing，把消息送达到某一个队列中去，然后我们的消费者监听队列进行消息的消费处理操作。DLX也是一个正常的Exchange，和一般的Exchange没有区别，它能在任何的队列上被指定，实际上就是设置某个队列的属性。RabbitMQ支持消息的过期时间，一共2种。...
Spring整合RabbitMQ
04-05
定义`RabbitTemplate`和`ConnectionFactory`，这些是与RabbitMQ交互的核心组件。 #### 2.4 定义消息监听器 使用`@RabbitListener`注解创建一个方法，该方法将在接收到消息时被调用。可以指定队列名称，或者使用`...
RabbitMQ思维导图
11-17
4. 消费者从队列中获取消息，RabbitMQ支持两种消费模式：自动确认（auto-acknowledge）和手动确认（manual-acknowledge）。 5. 消息被消费后，从队列中删除。 **AMQP协议** AMQP是一种二进制应用层协议，用于标准...
new-rabbitMq
06-12
4. **工作模式**：RabbitMQ支持多种工作模式，包括简单模式、发布/订阅模式、路由模式和主题模式，每种模式适用于不同的应用场景。 5. **持久化与高可用性**：RabbitMQ可以通过持久化保证消息在服务器重启后不会...
rabbitmq 3.9.11 + Erlang 23.2
01-07
在IT行业中，消息队列（Message Queue）是分布式系统中常用的一种组件，它负责处理应用程序之间的异步通信和数据交换。RabbitMQ是一款开源的消息代理和队列服务器，基于先进的AMQP（Advanced Message Queuing ...
理解rabbitmq----Exchange几种模式详解
superyueguang的博客
11-19 982
AMQP 简介 在了解 RabbitMQ 的 Exchange（交换机）的概念之前，我们首先要对 RabbitMQ 相关的概念和名词有一个大概的了解，RabbitMQ 是 AMQP（高级消息队列协议）的标准实现： 从 AMQP 协议可以看出，Queue、Exchange 和 Binding 构成了 AMQP 协议的核心 Producer：消息生产者，即投递消息的程序。 Broker：消息队列服务器实体。 Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。 Binding：
RabbitMQ 的核心组件有哪些？
越努力越幸运。
02-02 661
此外，生产者和消费者也是RabbitMQ的核心组件，生产者负责发送消息到Exchange或者 Queue，消费者负责从Queue中订阅和处理消息。这些核心组件共同构建了 RabbitMQ 的消息传递系统，他们协同工作才能实现消息的可靠传递、路由和业务处理等功能。
二、RabbitMQ的核心组件及特性
weixin_45966976的博客
02-13 476
RabbitMQ的核心组件及特性
org.springframework.amqp.AmqpTimeoutException: java.util.concurrent.TimeoutException
qq_42685053的博客
11-27 5193
2021-11-27-rabbitmq连接超时报错 报错截图： 报错文字版： org.springframework.amqp.AmqpTimeoutException: java.util.concurrent.TimeoutException at org.springframework.amqp.rabbit.support.RabbitExceptionTranslator.convertRabbitAccessException(RabbitExceptionTranslator.java:7
RabbitMQ的基本概念与核心组件
禅与计算机程序设计艺术
01-28 579
1.背景介绍 1. 背景介绍 RabbitMQ 是一个开源的消息代理软件，它基于AMQP(Advanced Message Queuing Protocol，高级消息队列协议)协议实现。RabbitMQ 可以帮助开发者实现分布式系统中的异步通信，提高系统的可扩展性和可靠性。 RabbitMQ 的核心组件包括：Exchange、Queue、Binding 和 Message。Exchange ...
RabbitMQ基础组件介绍
jing956899449的博客
07-01 1343
RabbitMQ采用Erlang语言开发 概念 生产者（producer）：创建消息，发布到代理服务器（Message Broker）。 消费者（consumer）：消费消息 代理服务器（Message Broker）：接收和分发消息的应用，RabbitMQ Server就是消息代理服务器，其中包含概念很多，以RabbitMQ 为例：信道（channel）、队列（queue）、交换器（exchange）、路由键（routing key）、绑定（binding key）、虚拟主机（vhost）等。 信道（
RabbitMQ中的AMQP协议与核心组成介绍
weixin_59216829的博客
06-06 841
在RabbitMQ中为了传输数据，使用的是基于TCP/IP协议构造的AMQP协议。RabbitMQ的核心组成部分包括：Server、Connection、Channel、Message、ExChange、Virtual Host、Bingings、Routing key、Queue。
RabbitMQ五种工作模式
最新发布
06-02
RabbitMQ是一个流行的消息队列系统，支持多种工作模式。以下是RabbitMQ的五种工作模式： 1. 简单模式(Simple Mode)：生产者发送消息到队列，消费者从队列中获取消息并处理。 2. 工作队列模式(Work Queue Mode)：多个消费者共享同一个队列，竞争消费队列中的消息。 3. 发布/订阅模式(Publish/Subscribe Mode)：生产者将消息发送到Exchange(交换机)，Exchange将消息发送到与之绑定的所有队列中，每个队列都有一个消费者进行消费。 4. 路由模式(Routing Mode)：生产者将消息发送到Exchange，Exchange根据绑定的路由键将消息发送到指定的队列中，消费者从指定队列中获取消息并处理。 5. 主题模式(Topic Mode)：生产者将消息发送到Exchange，Exchange根据匹配规则将消息发送到匹配的队列中，消费者从指定队列中获取消息并处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值