RabbitMQ入门

最新推荐文章于 2024-07-04 08:39:50 发布
最新推荐文章于 2024-07-04 08:39:50 发布
阅读量356 收藏 1
点赞数
分类专栏： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ROAOR1/article/details/105017140
版权

RabbitMQ简介

官方定义：RabbitMQ是一种消息中间件，用于处理来自客户端的异步消息。服务端将要发送的消息放入到队列池中。接收端可以根据RabbitMQ配置的转发机制接收服务端发来的消息。RabbitMQ依据指定的转发规则进行消息的转发、缓冲和持久化操作，主要用在多服务器间或单服务器的子系统间进行通信，是分布式系统标准的配置。RabbitMQ是使用 Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的

RabbitMQ整体架构：
在这里插入图片描述
RabbitMQ核心概念：
Server:又称Broker，接受客户端的连接，实现AMQP实体服务
Connection:连接，应用程序与Broker的网络连接
Channel:网络信道，几乎所有的操作都在Channel中进行，Channel是进行消息读写的通道。客户端可建立多个Channel，每个Channel代表一个会话任务
Message:消息，服务器和应用程序之间传送的数据，由Properties和Body组成。Properties可以对消息进行修饰，比如消息的优先级、延迟等高级特性；Body则是消息体的内容
Virtual host:虚拟地址，用于进行逻辑隔离，最上层的消息路由。同一个Virtual Host里面不能有相同名称的Exchange或Queue
Exchange:交换机，接收消息，根据路由键转发消息到绑定的队列
Binding:Exchange和Queue之间的虚拟连接,binding中可以包含routing key
Routing key:一个路由规则，虚拟机可用它确定如何路由一个特定消息
Queue:也称为Message Queue，消息队列，保存消息并将它们转发给消费者

MQ的优点：
1、异步处理 - 相比于传统的串行、并行方式，提高了系统吞吐量。
2、应用解耦 - 系统间通过消息通信，不用关心其他系统的处理。
3、流量削锋 - 可以通过消息队列长度控制请求量；可以缓解短时间内的高并发请求，一般在秒杀活动中应用广泛 。

发送消息的过程
1、生产者和Broker通过TCP连接建立通道。
2、生产者通过通道消息发送给Broker，由Exchange将消息进行转发。
3、Exchange通过Routing Key将消息转发到指定的Queue（队列）

接收消息的过程
1、生产者和Broker通过TCP连接建立通道。
2、消费者监听指定的Queue（队列）
3、当有消息到达Queue时Broker默认将消息推送给消费者。
4、消费者接收到消息。

RabbitMQ入门

环境：SpringBoot+RabbitMQ 5.8.0

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

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

创建消息生产者，不指定交换机

public class ProducerDemo {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //通过工厂创建连接
        Connection connection = connectionFactory.newConnection();

        //通过连接创建通道
        Channel channel = connection.createChannel();

        String exchangeName = "";
        String routingKey= "defaultQueue";
        String data = "hello";
        
        //通过通道发送信息，第三个参数是消息属性，可以配置消息的过期时间
        channel.basicPublish(exchangeName,routingKey,null,data.getBytes());

        //关闭连接
        channel.close();
        connection.close();
    }
}

创建消息消费者，不指定交换机

public class ConsumerDemo {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //通过工厂创建连接
        Connection connection = connectionFactory.newConnection();

        //通过连接创建通道
        Channel channel = connection.createChannel();

        String queueName = "defaultQueue";

        /**
         * 配置监听的队列
         * 第一个参数 队列名
         * 第二个参数 durable 是否持久化
         * 第三个参数 exclusive 是否独占的  相当于加了一把锁
         * 第四个参数 autoDelete 是否自动删除
         * 第五个参数 map类型，表示对队列中的消息进行详细设置，例如绑定死信队列
         */
        channel.queueDeclare(queueName,true,false,false,null);

        //创建消费者
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body);
                System.out.println(msg);
            }
        };

        //对消息作出应答，第二个参数表示自动ACK
        channel.basicConsume(queueName,true,consumer);
    }
}

Direct Exchange（直连交换机）

direct为默认的交换器类型，如果路由键匹配的话，消息就投递到相应的队列。有一个需要注意的地方：如果找不到指定的exchange，就会报错。但routing key找不到的话，不会报错，这条消息会直接丢失，所以此处要小心。
大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key 。
然后当一个消息携带着路由键为X，这个消息通过生产者发送给交换机时，交换机就会根据这个路由值X去寻找绑定值也是X的队列。

创建消息生产者，使用Direct Exchange

public class PeoducerDirectExchange {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //通过工厂创建连接
        Connection connection = connectionFactory.newConnection();

        //通过连接创建通道
        Channel channel = connection.createChannel();

        String exchangeName = "directExchange";
        String exchangeType = "direct";
        String routingKey = "directKey";
        String data = "hello";

        //声明交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        //指定routingKey
        channel.basicPublish(exchangeName,routingKey,null,data.getBytes());

        channel.close();
        connection.close();
    }
}

创建消息消费者，使用Direct Exchange

public class ConsumerDirectExchange {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //通过工厂创建连接
        Connection connection = connectionFactory.newConnection();

        //通过连接创建通道
        Channel channel = connection.createChannel();

        String exchangeName = "directExchange";
        String exchangeType = "direct";
        String queueName = "directQueue";
        String routingKey = "directKey";

        //声明一个direct类型的交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        //声明一个队列
        channel.queueDeclare(queueName,true,false,false,null);
        //建立绑定关系，所有发送到Direct Exchange的消息被转发到RouteKey指定的Queue
        channel.queueBind(queueName,exchangeName,routingKey);

        //创建消费者
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body);
                System.out.println(msg);
            }
        };

        channel.basicConsume(queueName,true,consumer);
    }
}

Topic Exchange（主题交换机）

这个交换机其实跟直连交换机流程差不多，但是它的特点就是在它的路由键和绑定键之间是有规则的。

创建消息生产者，使用Topic Exchange

public class ProducerTopicExchange {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //通过工厂创建连接
        Connection connection = connectionFactory.newConnection();

        //通过连接创建通道
        Channel channel = connection.createChannel();

        //使用exchangeName交换器
        String exchangeName = "topicExchange";
        String exchangeType = "topic";
        //指定routingKey
        String routingKey1 = "user.topicKey1";
        String routingKey2 = "user.topicKey2";
        String routingKey3 = "user.topicKey3";

        //声明一个topic类型的交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);

        //这里发送三条消息，指定三个routingKey
        channel.basicPublish(exchangeName,routingKey1,null,"hello1".getBytes());
        channel.basicPublish(exchangeName,routingKey2,null,"hello2".getBytes());
        channel.basicPublish(exchangeName,routingKey3,null,"hello3".getBytes());

        channel.close();
        connection.close();
    }
}
        channel.basicPublish(exchangeName,routingKey3,null,"hello3".getBytes());

        channel.close();
        connection.close();
    }
}

创建消息消费者，使用Topic Exchange

public class ConsumerTopicExchange {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //通过工厂创建连接
        Connection connection = connectionFactory.newConnection();

        //通过连接创建通道
        Channel channel = connection.createChannel();

        String exchangeName = "topicExchange";
        String exchangeType = "topic";
        String queueName = "topicQueue";
        //这里routingKey使用模糊匹配
        String routingKey = "user.#";

        //声明一个topic类型的交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        //声明一个队列
        channel.queueDeclare(queueName,true,false,false,null);
        //建立绑定关系
        channel.queueBind(queueName,exchangeName,routingKey);

        //创建消费者
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body);
                System.out.println(msg);
            }
        };

        channel.basicConsume(queueName,true,consumer);
    }
}

routingKey中的通配符
符号＊ 用来表示一个单词.
符号＃ 用来表示任意数量（零个或多个）单词
例如：user.* 可以匹配 user.topicKey1，user.topicKey2
user.#可以匹配user.topicKey1， user.topicKey1.add

Fanout Exchange（扇型交换机）

扇形交换机把消息发送给它所知道的所有队列，不处理路由键，所以Fanout交换机转发消息是最快的

创建消息生产者，使用Fanout Exchange

public class ProducerFanoutExchange {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //通过工厂创建连接
        Connection connection = connectionFactory.newConnection();

        //通过连接创建通道
        Channel channel = connection.createChannel();

        String exchangeName = "fanoutExchange";
        String exchangType = "fanout";
        //不需要指定路由key
        String routingKey = "";
        String data = "hello";
        
        //声明一个fanout类型的交换机
        channel.exchangeDeclare(exchangeName,exchangType,true,false,false,null);

        channel.basicPublish(exchangeName,routingKey,null,data.getBytes());

        channel.close();
        connection.close();
    }
}

创建消息消费者，使用Fanout Exchange

public class ConsumerFanoutExchange1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //通过工厂创建连接
        Connection connection = connectionFactory.newConnection();

        //通过连接创建通道
        Channel channel = connection.createChannel();

        String exchangeName = "fanoutExchange";
        String exchangeType = "fanout";
        String queueName = "fanoutQueue1";
        //不需要指定路由key
        String routingKey = "";

        //声明一个fanout类型的交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        //声明一个队列
        channel.queueDeclare(queueName,true,false,false,null);
        //建立绑定关系
        channel.queueBind(queueName,exchangeName,routingKey);

        //创建消费者
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body);
                System.out.println(msg);
            }
        };

        channel.basicConsume(queueName,true,consumer);
    }
}

创建消息生产者2

public class ConsumerFanoutExchange2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //通过工厂创建连接
        Connection connection = connectionFactory.newConnection();

        //通过连接创建通道
        Channel channel = connection.createChannel();

        String exchangeName = "fanoutExchange";
        String exchangeType = "fanout";
        String queueName = "fanoutQueue2";
        //不需要指定路由key
        String routingKey = "";

        //声明一个fanout类型的交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        //声明一个队列
        channel.queueDeclare(queueName,true,false,false,null);
        //建立绑定关系
        channel.queueBind(queueName,exchangeName,routingKey);

        //创建消费者
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body);
                System.out.println(msg);
            }
        };

        channel.basicConsume(queueName,true,consumer);
    }
}

注意：1、如果交换机、队列属性发生改变，需要去控制台将之前的交换机、队列删除，才能重新启动成功
2、上面所有的例子都是持久化消息，先启动生产者，消息会被保存到消息队列，登消费者上线可以进行消费。消息队列中必须要有交换机和队列的绑定信息才能被持久化。

项目代码：项目代码
相关阅读：
SpringBoot整合RabbitMQ
RabbitMQ的消息确认机制，消息重试机制
RabbitMQ的死信队列与延时队列

ROAOR1
关注
专栏目录
rabbitMq入门
08-08
【标题】：“rabbitMQ入门” 在IT行业中，消息队列是一种常见的中间件技术，用于解耦应用程序组件，提高系统的可扩展性和可靠性。RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中。本篇文章将带...
「RabbitMQ」实现消息的优先级
技术路上的探险家
06-09 1280
RabbitMQ 支持消息优先级（message priority）功能，可以用于优先消费和插队。具体来说，可以在生产者端将具有高优先级的消息设置为优先级更高，然后在消费者端使用优先级队列（Priority Queue）进行消费。
RocketMQ 原理介绍及详细安装教程
知道的越多 不知道的就越多
01-29 4318
本文详细介绍了RocketMq的相关概念，以图文的方式描述了相关运行原理，以及详细的安装教程和管理端工具的安装和使用。
RabbitMQ学习笔记：消息优先级（priority）
smart_an的专栏
07-04 359
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！
RocketMQ全解
拱卒的博客
04-18 1640
1 介绍 RocketMQ作为一款纯java、分布式、队列模型的开源消息中间件，支持事务消息、顺序消息、批量消息、定时消息、消息回溯等。 1.1 RocketMQ 特点 支持发布/订阅（Pub/Sub）和点对点（P2P）消息模型 在一个队列中可靠的先进先出...
RabbitMQ中的消息优先级是如何实现的？
jakelihua
09-14 727
需要注意的是，RabbitMQ中的消息优先级是相对的，即优先级高的消息会被优先处理，但并不能保证绝对的顺序。如果需要保证绝对的顺序，可以考虑使用单个队列或者使用多个队列并根据优先级将消息发送到不同的队列中。RabbitMQ中的消息优先级是通过设置消息的优先级属性来实现的。在RabbitMQ中，每条消息都可以附带一个优先级属性，该属性的值在0到255之间，其中0表示最低优先级，255表示最高优先级。设置队列的最大优先级，发送消息时设置消息的优先级，消费消息时按照优先级顺序接收并处理消息。
RabbitMQ的高级特性消息的优先级和过期时间
互联网知识分享
11-03 542
然后，我们通过channel.basic_publish()方法发布一条消息，并通过properties参数设置消息的优先级为5，过期时间为10秒。上述代码中，我们通过channel.basic_publish()方法发布一条消息，并通过properties参数设置消息的过期时间为10秒，即expiration属性的值为"10000"。以上是RabbitMQ的高级特性：消息的优先级和过期时间的详细介绍。通过设置消息的优先级和过期时间，我们可以更好地控制消息的处理顺序和时效性，以满足不同场景的需求。
RabbitMQ入门视频
04-05
在“RabbitMQ入门视频”中，你将学习到以下关键知识点： 1. **AMQP协议**：首先，了解AMQP协议的基础知识是非常重要的。AMQP定义了一种标准的、面向消息的中间件协议，支持多种语言和平台。它提供了一种可靠的消息...
RabbitMQ入门教程
最新发布
09-12
RabbitMQ入门教程
Rabbitmq入门到精通.doc
08-21
【RabbitMQ 入门到精通】：RabbitMQ 是一款流行的消息中间件，它基于 AMQP（Advanced Message Queuing Protocol）协议实现，用于在分布式系统中高效地传输消息，从而实现异步处理、解耦和流量控制。本教程旨在帮助...
rabbitmq 入门教程
07-23
RabbitMQ 入门教程 RabbitMQ 是一个消息服务器，负责接收生产者生产的消息，并将其发送给消费者。在这个过程中，RabbitMQ 可以根据用户给定的规则来路由、缓存、持久化这些消息。下面是 RabbitMQ 中的一些专业术语...
RabbitMQ入门案例
05-15
AMQP(advanced message queuing protocol)是一个提供统一消息服务的应用层标准协议，基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同开发语言...RabbitMQ（支持更多语言，基于AMQP规范）
RabbitMQ入门操作手册.pdf
12-11
【RabbitMQ入门操作手册】提供了全面的RabbitMQ学习指南，从基础概念到实际操作，帮助初学者快速掌握这个强大的消息队列系统。RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）的开源消息代理，其核心...
RabbitMQ入门教程.docx
05-16
### RabbitMQ入门知识点详解 #### 一、RabbitMQ简介 RabbitMQ是一款开源的消息中间件，基于Erlang语言开发而成。它支持多种消息发布/订阅模式，并且能够跨多平台运行。作为消息中间件，RabbitMQ的核心功能是接受、...
RabbitMQ入门代码
06-30
在这个“RabbitMQ入门代码”中，我们将深入探讨如何使用Java来与RabbitMQ进行交互，包括队列持久化、消息持久化、Direct交换机、Fanout交换机和Topic交换机的基础测试代码。 首先，让我们从基础开始，了解如何在...
RoketMQ综述-学习笔记
chenyong6301567的博客
08-30 263
第1章 RoketMQ综述
RocketMQ 介绍及基本概念
热门推荐
Hello World
01-26 12万+
1 介绍 RocketMQ作为一款纯java、分布式、队列模型的开源消息中间件，支持事务消息、顺序消息、批量消息、定时消息、消息回溯等。 1.1 RocketMQ 特点 支持发布/订阅（Pub/Sub）和点对点（P2P）消息模型 在一个队列中可靠的先进先出（FIFO）和严格的顺序传递 （RocketMQ可以保证严格的消息顺序，而ActiveMQ无法保证） 支持拉（pull）和推（push）两种消息模式 pull其实就是消费者主动从MQ中去拉消息，而push则像rabbit MQ一样，是MQ给消
RabbitMQ系列【13】优先级队列
记录知识、锤炼自我
11-22 1797
RabbitMQ将消息写入队列中都是按顺序写的，消费时也是按顺序进行消费，队列中的消息是先进先出(FIFO).。首先测试一下没有优先级的效果。先注释掉所有的消费者，不然发一个就消费一个，看不出优先级的效果，只有消息堆积在一起时，才能看到效果。先发送10条消息：发送完成后，再开启消费者进行消费，没有设置优先级，那么先到达队列的消息先消费，收到的消息会从按照0-9的顺序消费。可以看到其时按照投递顺序消费，先进先出：在一些场景中我们需要将某些消息优先处理，也就是设置优先级，优先级高的消息优先被消费。
rabbitmq入门
07-27
\[3\] RabbitMQ入门指南文章 希望这些信息对你有帮助！ #### 引用[.reference_title] - *1* *2* *3* [超详细的RabbitMQ入门](https://blog.csdn.net/Rok728/article/details/123106242)[target="_blank" data-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值