初识RabbitMQ_Java连接RabbitMQ（附源码）

最新推荐文章于 2024-07-18 21:45:00 发布
最新推荐文章于 2024-07-18 21:45:00 发布
阅读量1.1k 收藏 18
点赞数 5
分类专栏： RabbitMQ 文章标签： rabbitmq java 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42601136/article/details/108860548
版权
本文详细介绍了RabbitMQ的基础知识，包括AMQP协议和RabbitMQ的安装。通过Java代码展示了如何创建非持久化和持久化队列，实现工作队列和公平消息分发。还提供了消息确认机制，确保消息的可靠传递。
摘要由CSDN通过智能技术生成

初识RabbitMQ_Java连接RabbitMQ（附源码）

引言：

       本文主要分享有关RabbitMQ的相关知识，包括：RabbitMQ的简介、利用main进行演示各种情况下的消息队列、非持久化的简单案例、工作队列、公平的分发消息、实现持久化队列的方法；

文章目录

1. RabbitMQ简介

         rabbitMQ是一个在AMQP协议标准基础上完整的，可服用的企业消息系统，遵循Mozilla Public License开源协议，服务器端用Erlang语言编写，支持多种客户端的工业级的消息队列(MQ)服务器，RabbitMQ 是建立在Erlang OTP平台上；

1.1 AMQP

AMQP（Advanced Message Queuing Protocol），高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。

​ AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。

AMQP协议本身包含三层：

  • Model Layer：位于协议最高层，主要定义了一些供客户端调用的命令，客户端可以通过这些命令实现自己的业务逻辑，例如，客户端可以通过queue declare声明一个队列，利用consume命令获取队列的消息；

  • Session Layer：主要负责将客户端命令发送给服务器，在将服务器端的应答返回给客户端，主要为客户端与服务器之间通信提供可靠性、同步机制和错误处理；

  • Transport Layer：主要传输二进制数据流，提供帧的处理、信道复用、错误检测和数据表示；

1.2 RabbitMQ环境的安装

RabbitMQ的安装环境配置：https://blog.csdn.net/weixin_42601136/article/details/108672763

2. 环境的搭建

创建SpringBoot项目，加入web和lombook；

导入依赖

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

2. 非持久化队列的接收和发送

简单的入门案例

  • P: producer 生产者
  • C: consumer 消费者
  • 中间红色的部分是一个队列,在RabbitMQ中代表消息缓冲区

在这里插入图片描述

2.1 发送消息

创建一个生产者，默认非持久化，这里发送了两次

六步：

  1. 创建连接工厂
  2. 创建连接
  3. 创建信道
  4. 创建消息
  5. 发送消息
  6. 释放资源
/**
 * 生产者，消息发送者
 * Created by Kak on 2020/9/21.
 */

public class ProducerMessage {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//编程端口
        connectionFactory.setUsername("kaka");//本机可以使用guest
        connectionFactory.setPassword("kaka");
        connectionFactory.setVirtualHost("/");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建消息
        String msg = "This is rabbitMQ message!!!";
        //发送消息
        channel.basicPublish("","hello",null,msg.getBytes());
        //释放资源
        channel.close();
        connection.close();
    }
}

在这里插入图片描述

在这里插入图片描述

2.2 接收消息

从队列中获取消息

五步：

  1. 创建连接工厂
  2. 创建连接
  3. 创建信道
  4. 消费队列里面的消息
  5. 释放资源
/**
 * 消息接受者
 * Created by Kak on 2020/9/21.
 */
public class ConsumerMessage {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//编程端口
        connectionFactory.setUsername("kaka");//本机可以使用guest
        connectionFactory.setPassword("kaka");
        connectionFactory.setVirtualHost("/");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        System.out.println("准备接收消息！！！");
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumer--------" + new String(body, "UTF-8"));
            }
        };
        /**
         * 1:侦听的队列
         * 2：是否自动提醒
         * 3：接收消息后回调执行的逻辑
         */
        channel.basicConsume("hello", true, consumer);
        //使用标准输入中断
        System.in.read();
        channel.close();
        connection.close();
    }
}

在这里插入图片描述

发送成功！！！

在这里插入图片描述

3. 工作队列

看似公平实则不公平，两个收消息的一人一个，忽略了每个接受端的工作效率；

在这里插入图片描述

3.1 消息发送

/**
 * 生产者，消息发送者
 * Created by Kak on 2020/9/21.
 */

public class ProducerMessage {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//编程端口
        connectionFactory.setUsername("kaka");//本机可以使用guest
        connectionFactory.setPassword("kaka");
        connectionFactory.setVirtualHost("/");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        for(int i = 0; i<10;i++){


        //创建消息
        String msg = "This is rabbitMQ message!!!"+i;
        //发送消息
        channel.basicPublish("","hello",null,msg.getBytes());
            System.out.println("------producer------:"+msg);
        }
        //释放资源
        channel.close();
        connection.close();
    }
}

3.2 接受消息（两个）

/**
 * 消息接受者
 * Created by Kak on 2020/9/21.
 */
public class ConsumerMessage_01 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//编程端口
        connectionFactory.setUsername("kaka");//本机可以使用guest
        connectionFactory.setPassword("kaka");
        connectionFactory.setVirtualHost("/");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        System.out.println("准备接收消息！！！");
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumer1--------" + new String(body, "UTF-8"));
            }
        };
        /**
         * 1:侦听的队列
         * 2：是否自动提醒
         * 3：接收消息后回调执行的逻辑
         */
        channel.basicConsume("hello", true, consumer);
        //使用标准输入中断
        System.in.read();
        channel.close();
        connection.close();
    }
}

/**
 * 消息接受者
 * Created by Kak on 2020/9/21.
 */
public class ConsumerMessage_02 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//编程端口
        connectionFactory.setUsername("kaka");//本机可以使用guest
        connectionFactory.setPassword("kaka");
        connectionFactory.setVirtualHost("/");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        System.out.println("准备接收消息！！！");
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumer2--------" + new String(body, "UTF-8"));
            }
        };
        /**
         * 1:侦听的队列
         * 2：是否自动提醒
         * 3：接收消息后回调执行的逻辑
         */
        channel.basicConsume("hello", true, consumer);
        //使用标准输入中断
        System.in.read();
        channel.close();
        connection.close();
    }
}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

  • 发布者发布的消息会平均分配到每一个消费者,采用默认的任务分发机制(轮询),这种任务队列的优点之一就是可以轻易的并行工作,如果我们积压很多任务，我们可以通过增加工作者(consumer)来解决这一问题,使得系统的伸缩性更强。但是这种分发机制没有考虑处理处理任务的时间问题(因为他分配任务的时候是一次性分配，并非是一个一个分配)，按照轮询的方式将任务等分给了两个消费者,可能某一个消费者性能比较差，累积任务会越来越多,所以一直忙个不停；而另一个消费者性能比较好，处理任务块,可能闲的不行，这就造成了资源浪费；

4. 消息队列的公平分发

轮询机制会造成资源浪费的问题,原因是因为RabbitMQ在分发任务的时候盲目的一次性平均分配任务,它分发给消费者的任务后,不看消费者是否完成,直接在分配就造成了累积；

通过限制RabbitMQ只发不超过1条的消息给同一个消费者，且当消息处理完毕后，有了反馈，才会进行第二次发送；

int prefetchCount = 1;
channel.basicQos(prefetchCount);

当然在使用basicQos方法的时候还需要设置autoAck: 设置应答模式,默认是自动应答

  • 自动应答:只要消息从队列中获取，无论消费者获取到消息后是否成功消息，都认为是消息已经成功消费
  • 手动应答:消费者从队列中获取消息后，服务器会将该消息标记为不可用状态，等待消费者的反馈，如果消费者一直没有反馈，那么该消息将一直处于不可用状态,打开手动确认还有一个好处就是当消费者不正常死亡，RabbitMQ会将这个消息进行重新加入队列进行排队

在这里插入图片描述

4.1 发送消息

/**
 * 生产者，消息发送者
 * Created by Kak on 2020/9/21.
 */

public class ProducerMessage {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//编程端口
        connectionFactory.setUsername("kaka");//本机可以使用guest
        connectionFactory.setPassword("kaka");
        connectionFactory.setVirtualHost("/");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //确保同时只发送1个消息
        channel.basicQos(1);
        for(int i = 0; i<10;i++){
        //创建消息
        String msg = "This is rabbitMQ message!!!"+i;
        //发送消息
        channel.basicPublish("","hello",null,msg.getBytes());
            System.out.println("------producer------:"+msg);
        }
        //释放资源
        channel.close();
        connection.close();
    }
}

4.2 接受消息(两个)

将1接收者设置睡眠时间，模拟低效率；

/**
 * 消息接受者
 * Created by Kak on 2020/9/21.
 */
public class ConsumerMessage_01 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//编程端口
        connectionFactory.setUsername("kaka");//本机可以使用guest
        connectionFactory.setPassword("kaka");
        connectionFactory.setVirtualHost("/");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        System.out.println("准备接收消息！！！");
        channel.basicQos(1);
        DeliverCallback deliverCallback = new DeliverCallback() {
            @Override
            public void handle(String s, Delivery delivery) throws IOException {
                System.out.println("consumcrl:-----" + new String(delivery.getBody(), "UTF-8"));
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 手动通知
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            }
        };

        /**
         * 1:侦听的队列
         * 2：是否自动提醒
         * 3：接收消息后回调执行的逻辑
         * 4:取消或者异常消费时，执行的回调逻辑
         */
        channel.basicConsume("hello", false, deliverCallback, new CancelCallback() {
            @Override
            public void handle(String s) throws IOException {

            }
        });
        //使用标准输入中断
        System.in.read();
        channel.close();
        connection.close();
    }
}

/**
 * 消息接受者
 * Created by Kak on 2020/9/21.
 */
public class ConsumerMessage_02 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//编程端口
        connectionFactory.setUsername("kaka");//本机可以使用guest
        connectionFactory.setPassword("kaka");
        connectionFactory.setVirtualHost("/");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        System.out.println("准备接收消息！！！");
        channel.basicQos(1);
        DeliverCallback deliverCallback = new DeliverCallback() {
            @Override
            public void handle(String s, Delivery delivery) throws IOException {
                System.out.println("consumcr2:-----" + new String(delivery.getBody(), "UTF-8"));
                // 手动通知
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            }
        };

        /**
         * 1:侦听的队列
         * 2：是否自动提醒
         * 3：接收消息后回调执行的逻辑
         * 4:取消或者异常消费时，执行的回调逻辑
         */
        channel.basicConsume("hello", false, deliverCallback, new CancelCallback() {
            @Override
            public void handle(String s) throws IOException {

            }
        });
        //使用标准输入中断
        System.in.read();
        channel.close();
        connection.close();
    }
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

5. 消息队列中的持久化

上面说的队列在RabbitMQ退出或者崩溃时就会消失的队列，如果当时队列里面还有消息未被消费，那么异常退出会造成任务丢失；为了防止RabbitMQ意外退出造成队列中的任务丢失就用到了消息队列的持久化；

设置持久化队列需要在提供者和消费者中设置：

channel.queueDeclare(QUEUE_NAME,true,false,false,null); //第二个参数设置为true

当我们消息发布者发布一条消息之后，然后我们重启RabbitMQ服务器，查看web管理页面会发现，消息还在；

5.1 发送消息

/**
 * 消息接受者
 * Created by Kak on 2020/9/21.
 */
public class ConsumerMessage {
    static String queueName = "hellox";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//编程端口
        connectionFactory.setUsername("kaka");//本机可以使用guest
        connectionFactory.setPassword("kaka");
        connectionFactory.setVirtualHost("/");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //配置信道绑定的队列为持久化队列
        channel.queueDeclare(queueName, true, false, false, null);
        System.out.println("准备接收消息！！！");
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumer--------" + new String(body, "UTF-8"));
            }
        };
        /**
         * 1:侦听的队列
         * 2：是否自动提醒
         * 3：接收消息后回调执行的逻辑
         */
        channel.basicConsume(queueName, true, consumer);
        //使用标准输入中断
        System.in.read();
        channel.close();
        connection.close();
    }
}

5.2 接收消息

/**
 * 生产者，消息发送者
 * 持久化队列
 * Created by Kak on 2020/9/21.
 */

public class ProducerMessage {
    static String queueName = "hellox";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//编程端口
        connectionFactory.setUsername("kaka");//本机可以使用guest
        connectionFactory.setPassword("kaka");
        connectionFactory.setVirtualHost("/");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //配置信道绑定的队列为持久化队列
        channel.queueDeclare(queueName, true, false, false, null);
        //创建消息
        String msg = "This is rabbitMQ message!!!";
        //发送消息
        channel.basicPublish("", queueName, null, msg.getBytes());
        //释放资源
        channel.close();
        connection.close();
    }
}

在这里插入图片描述

Willing卡卡
关注
  • 5
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
java连接rabbitmq_RabbitMQ基础
weixin_39822629的博客
11-27 635
1. 消息中间件概述1.1. 什么是消息中间件MQ全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。为什么使用MQ在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。开发中消息队列通常有如下应用场景：1、任务异步处理将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异...
RabbitMQ学习第一记：用java连接RabbitMQ
javaQQ561487941的博客
09-09 652
1、什么是RabbitMQ 　　MQ（Message Queue）：消息队列，是服务端设计的一个可以存储大量消息的队列，并提供客户端操作队列的方法：生产队列（向队列中添加数据）、消费队列（从队列中取数据）。RabbitMQ就是基于消息队列的一个典型应用。RabbitMQ除了普通的生产消费功能，还有一些高级功能：公平分发，轮询分发，路由模式，通配符模式，发布订阅，队列持久化。 2、java实现...
Rabbitmq中常用的五种连接方式
xjl3951872的博客
10-25 1万+
前提准备 rabbitmq官方手册 RabbitMQ Tutorials — RabbitMQ （可以对照手册进行对比） 在编写连接方式之前， 我们先做一些前提的操作，用于我们编写连接代码时更方便 a). 创建一个连接rabbitmq的工具类 public class RabbitmqUtil { private static ConnectionFactory factory; static{ factory = new ConnectionFact...
RabbitMQ消息队列实战（2）—— Java调用RabbitMQ的三种方式
Hyman的博客
02-01 5356
spring cloud stream的强大之处就在于它的封装，但是不足之处也在于它的封装，封装的太强，必然增加了学习成本和调试难度，而且类似RabbitMQ和Kafka这种中间件的使用，一般在系统创建之处就一定确定，进行无缝切换就显得有些鸡肋了。第5个参数是队列的一些结构化信息，比如声明死信队列、磁盘队列会用到。第12行，创建了一个bind对象，将交换机和队列进行绑定，queueBind的三个参数中：第1个参数指定了队列名称，第2个参数指定了交换机名称，第3个参数是路由键，在直连模式下为队列名称。
RabbitMQ安装及介绍
最新发布
时间如瑾 代码如诗
07-18 913
Channel 是在 connection 内部建立的逻辑连接，如果应用程 序支持多线程，通常每个 thread 创建单独的 channel 进行通讯，AMQP method 包含了 channel id 帮助客 户端和 message broker 识别 channel，所以 channel 之间是完全隔离的。队列仅受主机的内存和磁盘限制的约束，本质上是一个大的消息缓冲区。可以把它当做一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人那里，按照这种逻辑。
RabbitMQ
weixin_46131409的博客
07-17 198
一.安装 1.安装: pip install pika or easy_install pika 2.源码: https://pypi.python.org/pypi/pika 二.介绍 1.介绍: RabbitMQ是1个消息中间件,即实现了高级消息队列协议(AMQP)的开源消息代理软件,由Erlang编写 2.消息队列(Message Queue;MQ): 消息是指在应用间传送的数据,可以很简单,如只包含文本字符串,也可以更复杂,如包含嵌入对象 消息队列是1种应用间的通信方式:发送消息
java连接rabbitMQ
y525794266的博客
11-01 3651
maven依赖              &lt;dependency&gt;             &lt;groupId&gt;com.rabbitmq&lt;/groupId&gt;             &lt;artifactId&gt;amqp-client&lt;/artifactId&gt;             &lt;version&gt;5.2.0&lt;/versi...
RabbitMQ 消息中间件
weixin_34146986的博客
02-12 171
为什么80%的码农都做不了架构师？>>> ...
rabbitmq_delayed_message_exchange-3.9.0.ez
05-09
RabbitMQ延迟消息交换机（rabbitmq_delayed_message_exchange）则是RabbitMQ中的一个特色插件，允许我们设定消息在特定时间后才被投递，这对于实现定时任务、延迟通知等功能具有极大的价值。本文将深入探讨RabbitMQ ...
rabbitmq_delayed_message_exchange-3.8.0 延迟队列插件
05-30
RabbitMQ延迟队列插件，即rabbitmq_delayed_message_exchange-3.8.0，是一个针对RabbitMQ消息代理的扩展，旨在提供一种机制，使得消息能够在特定延迟后才被投递到相应的队列。这个功能在很多业务场景中非常有用，...
Release_rabbitmq_C#源码_
09-30
标题中的"Release_rabbitmq_C#源码_"表明这是一个关于RabbitMQ的C#源代码发布版本，可能包含了实现RabbitMQ在C#环境中使用的示例或者库。RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中，用于...
rabbitmq_delayed_message_exchange-20171215-3.6.x.zip
12-20
rabbitmq_delayed_message_exchange插件3.6.x版本，用于实现延迟队列； rabbitmq_delayed_message_exchange-20171215-3.6.x.zip； 官网找不到了，提供下~
prometheus rabbitmq_exporter
11-27
为了能够有效地监控 RabbitMQ 的性能和状态，Prometheus 提供了一个名为 `rabbitmq_exporter` 的工具。然而，在某些情况下，官方网站可能不直接提供这个插件，这时我们需要从第三方源获取，例如在本例中提到的 `...
RabbitMQ的使用详解
Zero摄氏度的博客
07-12 3384
MQ（message queue），本质是个队列，FIFO先入先出。只不过队列中放的是message，是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ是一种非常常见的上下游解耦的消息通信服务。使用了MQ之后，消息发送上游只需要依赖MQ，不用依赖其他服务。
RabbitMQ（四）远程连接RabbitMQ
热门推荐
diweikang的博客
08-09 1万+
为了避免污染宿主系统环境，于是在虚拟机中搭建了一个linux环境并且安装了rabbitmq-server。然后在远程连接的时候一直连接失败。官网上面给的例子都是在本地使用系统默认的guest用户连接的。没有给出远程连接的例子，于是阅读文档发现： When the serverfirst starts running, and detects that its database is u...
RabbitMQ 学习（三）---- 连接工具类
rain67的博客
09-17 2413
之前我们写生产者消费者模型的时候，会有很多冗余代码，比如生产者和消费者都需要创建连接工厂、设置连接配置、以及关闭资源等操作。我们打算将这些冗余的操作封装成一个工具类，我们直接调用类得到相关的信息即可，不必每次都写一些连接的配置信息。使用连接工厂，使用单例模式，static只设置一次配置，创建获取连接的方法，创建关闭资源的方法。所以现在，在之前的生产者、消费者Hello World 模型的代码中可以省略很多代码了。
rabbitMQ
jianqingshan1的博客
05-28 479
生产者的流程 1 连接工厂 2 创建连接 Connection 3 创建通道 Channel 4 创建交换机 BuiltinExchangeType . TOPIC 交换机类型 5 发送数据消费者者的流程 1 连接工厂 2 创建连接 Connection 3 创建通道 Channel 4 创建交换机 BuiltinExchangeType . TOPIC 交换机类型 5 创建队列 6 交换机与队列绑定 8 回调函数 7 接收信息 监听队列 执行回调。
RabbitMQ的详解和使用
创作不易，请多支持，将为本站提供更多「有价值的文章」。
04-10 1万+
一、AMQP协议 1、AMQP协议介绍 AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有RabbitMQ等。 2、功能范围 存储转发（多个消息发送者，单个消息接收者） 分布式事务（多个消息发送者，多个消息接收者） 发布订阅（多个消息发送者，多个消息
Java RabbitMQ API 对接说明
谁念西风独自凉
06-12 2025
最近研发的物联网底层框架使用了RabbitMQ作为消息队列，如果监控消息队列对其通道是否出现阻塞能够及时获知与让管理员收到预警并及时处理，这里我们会采用RabbitMQ的rabbitmq_management插件。利用其提供的API进行获取信息，从而实现队列监控的目标。
RABBITMQ_MASTER_DISCOVERY_NODES
02-20
RABBITMQ_MASTER_DISCOVERY_NODES是RabbitMQ中的一个环境变量，用于配置RabbitMQ集群中的主节点发现机制。当RabbitMQ集群中的节点启动时，它们会通过这个环境变量来指定其他节点的主机名或IP地址，以便进行主节点的...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Willing卡卡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值