RabbitMQ入门

最新推荐文章于 2024-09-23 10:48:13 发布
最新推荐文章于 2024-09-23 10:48:13 发布
阅读量369 收藏 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的死信队列与延时队列

rabbitMq入门
08-08
【标题】：“rabbitMQ入门” 在IT行业中，消息队列是一种常见的中间件技术，用于解耦应用程序组件，提高系统的可扩展性和可靠性。RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中。本篇文章将带...
Rabbitmq入门到精通.doc
08-21
【RabbitMQ 入门到精通】：RabbitMQ 是一款流行的消息中间件，它基于 AMQP（Advanced Message Queuing Protocol）协议实现，用于在分布式系统中高效地传输消息，从而实现异步处理、解耦和流量控制。本教程旨在帮助...
Android 使用rabbitmq实现点对点的推送
android_bird_bird的博客
06-02 1094
在实际项目中，客户的推送通知不需要类似极光推送或者友盟的推送，后端人员实现了通过mq实现点对点的推送通知。作为移动端的，实现起来还是很简单的。 1. 首先依赖： implementation 'com.rabbitmq:amqp-client:4.1.0' 2.在需要接收通知的地方： //这是一些配置信息： private void setupConnectionFactory() { try { factory=new Conne...
Android端发布消息到RabbitMQ、从RabbitMQ获取消息（一）
Sunshine
04-22 249
https://blog.csdn.net/csdnzouqi/article/details/79043248
RabbitMQ如何处理消息的优先级？
最新发布
qq_33240556的博客
09-23 430
此外，使用消息优先级可能会对性能产生影响，因为 RabbitMQ 需要额外的工作来维护消息的优先级顺序。当消息到达队列后，RabbitMQ 会根据消息的优先级自动排序。需要注意的是，一旦设置了队列的最大优先级，就无法更改。如果尝试发布超过最大优先级的消息，那么该消息将不会被拒绝，而是按照最大允许的优先级进行处理。RabbitMQ 支持消息优先级的处理，这使得某些消息可以比其他消息更早地被消费。最后，确保你的应用逻辑正确地利用了消息优先级，避免滥用可能导致不必要的复杂性和性能问题。在声明队列时，需要设置。
Android Studio使用RabbitMQ
gxflh的博客
01-09 3788
本指南介绍了如何 使用Android Studio和 RabbitMQ在Android中创建简单的聊天应用程序 。每个拥有该应用程序的人都能够发送和接收来自使用相同应用程序的所有其他用户的消息。 如果您使用的是Eclipse，请查看 此博客文章 。 在给定的代码中，消息将首先被添加到内部队列，发布者将在建立连接时从内部队列发送消息到RabbitMQ。如果连接断开，消息将被添加回队列。
rabbitmq+JAVA中发送端的区别
zp704393004的专栏
05-07 231
发送端方式一：     //创建hello队列          channel.queueDeclare(QUEUE_NAME, false, false, false, null);         //发送消息          channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());  方式二： //创建hello队列     ...
RoketMQ综述-学习笔记
chenyong6301567的博客
08-30 277
第1章 RoketMQ综述
「RabbitMQ」实现消息的优先级
技术路上的探险家
06-09 1340
RabbitMQ 支持消息优先级（message priority）功能，可以用于优先消费和插队。具体来说，可以在生产者端将具有高优先级的消息设置为优先级更高，然后在消费者端使用优先级队列（Priority Queue）进行消费。
RocketMQ 原理介绍及详细安装教程
知道的越多 不知道的就越多
01-29 4555
本文详细介绍了RocketMq的相关概念，以图文的方式描述了相关运行原理，以及详细的安装教程和管理端工具的安装和使用。
RabbitMQ中的消息优先级是如何实现的？
jakelihua
09-14 775
需要注意的是，RabbitMQ中的消息优先级是相对的，即优先级高的消息会被优先处理，但并不能保证绝对的顺序。如果需要保证绝对的顺序，可以考虑使用单个队列或者使用多个队列并根据优先级将消息发送到不同的队列中。RabbitMQ中的消息优先级是通过设置消息的优先级属性来实现的。在RabbitMQ中，每条消息都可以附带一个优先级属性，该属性的值在0到255之间，其中0表示最低优先级，255表示最高优先级。设置队列的最大优先级，发送消息时设置消息的优先级，消费消息时按照优先级顺序接收并处理消息。
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给消
Git 基础教程 - 分支操作、合并分支、解决冲突
smart_an的专栏
05-12 418
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！
RabbitMQ入门视频
04-05
在“RabbitMQ入门视频”中，你将学习到以下关键知识点： 1. **AMQP协议**：首先，了解AMQP协议的基础知识是非常重要的。AMQP定义了一种标准的、面向消息的中间件协议，支持多种语言和平台。它提供了一种可靠的消息...
RabbitMQ中如何实现消息的优先级队列？
qq_33240556的博客
09-20 447
以上就是如何在 RabbitMQ 中配置和使用优先级队列的基本方法。确保你的 RabbitMQ 服务器版本支持这一特性，并且已经正确配置了相关插件或功能。请注意，启用消息优先级可能会对性能产生一定影响，因为 RabbitMQ 需要额外的工作来维护消息的优先级顺序。此外，在实际应用中，应当谨慎选择。在 RabbitMQ 中实现消息优先级队列，可以通过设置队列属性和消息属性来完成。的值，因为过高的优先级范围可能导致内存使用增加。
RabbitMQ学习笔记：消息优先级（priority）
OceanSky的专栏
10-26 5892
概括 RabbitMQ在版本3.5.0中有优先级队列的实现，任何队列可以通过设置可选参数x-max-priority转换为优先级队列；这个参数应该是1到255之间的正整数，推荐设置1到10之间的数值，表示队列应该支持的最大优先级； 声明优先级队列 Channel ch = ...; Map<String, Object> args = new HashMap<String, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值