学习RabbitMQ（三）

于 2022-03-05 15:15:59 发布
阅读量2k 收藏
点赞数
文章标签： rabbitmq 学习 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51966377/article/details/123270045
版权
本文详细介绍了RabbitMQ的交换机机制，包括Exchanges的概念、类型如Direct、Fanout、Topic，并探讨了临时队列的创建和删除。此外，还详细阐述了死信队列的原理，如消息成为死信的来源及实战应用。
摘要由CSDN通过智能技术生成

1、交换机

        假设工作队列背后，每个任务都恰好交付给一个消费者（工作进程）。在这一部分，我们将消息传达给多个消费者。这种模式称为“发布/订阅模式”。

1.1、Exchanges

1.1.1、Exchanges概念

RabbitMQ 消息传递模型的核心思想是：生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递到了哪些队列中。

        相反，生产者只能将消息发送到交换机（exchange），交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将他们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是把他们放到许多队列还是说应该丢弃它们。这就由交换机的类型来决定。

1.1.2、Exchanges的类型

直接（direct）、主题（topic）、标题（headers）、扇出（fanout）

1.1.3、默认Exchanges

        在之前的案例仍然能够将消息发送到队列，这是因为我们使用的是默认交换机，通过空字符串(" ")进行标识。

channel.basicPublish("",queueName,null,message.getBytes());

        第一个参数是交换机的名字。空字符串表示默认或无名称交换机：消息能路由发送到队列中其实是由routingKey(bindingkey) 绑定 key 指定的，如果它存在的话。

1.2、临时队列

        每当我们连接到 RabbitMQ 时，我们都需要一个全新的空队列，为此我们可以创建一个具有随机名称的队列，或者能让服务器为我们选择一个随机队列名称那就更好了。其次一旦我们断开了消费者的连接，队列将被自动删除。

        创建临时队列的方法：

String queue = channel.queueDeclare().getQueue(); //得到的是队列名字

         创建出来的队列：

1.3、绑定（bindings）

        binding其实是exchange和queue之间的桥梁，它告诉我们exchange和那个队列进行了绑定关系。比如说下面这张图告诉我们的就是X与Q1和Q2进行了绑定

 

       

         绑定过程：

 

 

 

1.4、Fanout

1.4.1、Fanout介绍

        Fanout这种类型非常简单，它是将接收到的所有消息广播到它知道的所有队列中。

1.4.2、Fanout实战

         一个生产者发送消息，全部消费者都能接收到消息。

        生产者代码

package com.hxh.rabbitmq.five;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.Channel;
import java.util.Scanner;

//发送消息
public class EmitLog {
    //交换机名称
    private static final String EXCHANGE_NAME="logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes());
            System.out.println("成功发送："+message);
        }
    }
}

        消费者代码：

package com.hxh.rabbitmq.five;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

//消息接收
public class ReceiveLogs01 {
    //交换机名称
    private static final String EXCHANGE_NAME="logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //声明一个临时队列
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机与队列
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        System.out.println("01等待接收消息");

        DeliverCallback deliverCallback=(var1,var2)->{
            System.out.println("01接收消息："+new String(var2.getBody()));
        };
        CancelCallback cancelCallback=(var1)->{
            System.out.println("01取消");
        };

        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

package com.hxh.rabbitmq.five;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

//消息接收
public class ReceiveLogs02 {
    //交换机名称
    private static final String EXCHANGE_NAME="logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //声明一个临时队列
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机与队列
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        System.out.println("02等待接收消息");

        DeliverCallback deliverCallback=(var1,var2)->{
            System.out.println("02接收消息："+new String(var2.getBody()));
        };
        CancelCallback cancelCallback=(var1)->{
            System.out.println("02取消");
        };

        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

1.5、Direct exchange

        

1.5.1、介绍

        Fanout这种交换类型并不能给我们带来很大的灵活性，它只能进行无意识的广播，在这里我们将使用direct这种类型来进行替换，这种类型的工作方式是，消息只去到它绑定的routingKey队列中去。

         在上面这张图中，我们可以看到X绑定了两个队列,绑定类型是direct。队列Q1绑定键为orange队列Q2绑定键有两个:一个绑定键为black，另一个绑定键为green.

        在这种绑定情况下，生产者发布消息到exchange上，绑定键为orange的消息会被发布到队列Q1。绑定键为black和green的消息会被发布到队列Q2，其他消息类型的消息将被丢弃。

1.5.2、多重绑定

        当然如果exchange的绑定类型是direct，但是它绑定的多个队列的key如果都相同，在这种情况下虽然绑定类型是direct，但是它表现的就和fanout有点类似了，就跟广播差不多，如下图所示。

1.5.3、实战

 

         生产者代码：

package com.hxh.rabbitmq.six;


import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.Channel;
import java.util.Scanner;

public class DirectLogs {
    //交换机名称
    private static final String EXCHANGE_NAME="direct_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish(EXCHANGE_NAME,"error",null,message.getBytes());  //修改routingKey 使消息被不同的消费者接受
            System.out.println("成功发送："+message);
        }
    }
}

        消费者代码：

package com.hxh.rabbitmq.six;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

public class ReceiveLogsDirect01 {
    //交换机名称
    private static final String EXCHANGE_NAME="direct_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        //声明一个队列
        channel.queueDeclare("console", false, true, true, null);
        //绑定交换机与队列
        channel.queueBind("console",EXCHANGE_NAME,"info");
        channel.queueBind("console",EXCHANGE_NAME,"warning");
        System.out.println("01等待接收消息");

        DeliverCallback deliverCallback=(var1, var2)->{
            System.out.println("01接收消息："+new String(var2.getBody()));
        };
        CancelCallback cancelCallback=(var1)->{
            System.out.println("01取消");
        };

        channel.basicConsume("console",true,deliverCallback,cancelCallback);
    }
}

package com.hxh.rabbitmq.six;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

public class ReceiveLogsDirect02 {
    //交换机名称
    private static final String EXCHANGE_NAME="direct_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        //声明一个队列
        channel.queueDeclare("disk", false, true, true, null);
        //绑定交换机与队列
        channel.queueBind("disk",EXCHANGE_NAME,"error");
        System.out.println("02等待接收消息");

        DeliverCallback deliverCallback=(var1, var2)->{
            System.out.println("02接收消息："+new String(var2.getBody()));
        };
        CancelCallback cancelCallback=(var1)->{
            System.out.println("02取消");
        };

        channel.basicConsume("disk",true,deliverCallback,cancelCallback);
    }
}

1.6、Topics

1.6.1、Topic的要求

        发送到类型是topic交换机的消息的 routingkey 不能随意写，必须满足一定的要求，它必须是一个单词列表，以点号分隔开。这些单词可以是任意单词，比如说:"stock.usd.nyse". "nyse.vmw","quick.orange.rabbit".这种类型的。当然这个单词列表最多不能超过255个字节。     

        在这个规则列表中，其中有两个替换符是大家需要注意的:

                *(星号)可以代替一个单词

                #(并号)可以替代零个或多个单词

1.6.2、Topic匹配案例

        下图

        Q1绑定的是：中间带 orange 带3个单词的字符串（*.orange.*）

        Q2绑定的是：最后一个单词是 rabbit 的3个单词（*.*.rabbit）、第一个单词是 lazy 的多个单词（lazy.#）

         例如：

                quick.orange.rabbit——被队列Q1Q2接收到

                lazy.orange.elephant——被队列Q1Q2接收到

                quick.orange.fox——被队列Q1接收到

                lazy.brown.fox——被队列Q2接收到

                lazy.pink.rabbit——虽然满足两个绑定但只被队列Q2接收一次

                quick.brown.fox——不匹配任何绑定不会被任何队列接收到会被丢弃

                quick.orange.male.rabbit——是四个单词不匹配任何绑定会被丢弃

                lazy.orange.male.rabbit——是四个单词但匹配Q2

        当队列绑定关系是下列这种情况时需要引起注意：

                当一个队列绑定键是#,那么这个队列将接收所有数据，就有点像fanout了

                如果队列绑定键当中没有#和*出现，那么该队列绑定类型就是direct 了

1.6.3、实战

        生产者代码：

package com.hxh.rabbitmq.seven;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.Channel;
import java.util.HashMap;
import java.util.Map;

//生产者
public class EmitLogTopic {
    private static final String EXCHANGE_NAME="topic_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();

        HashMap<String, String> map = new HashMap<>();
        map.put("quick.orange.rabbit","被队列Q1Q2接收到");
        map.put("lazy.orange.elephant","被队列Q1Q2接收到");
        map.put("quick.orange.fox","被队列Q1接收到");
        map.put("lazy.brown.fox","被队列Q2接收到");
        map.put("quick.brown.fox","虽然满足两个绑定但只被队列Q2接收一次");
        map.put("lazy.pink.rabbit","不匹配任何绑定不会被任何队列接收到会被丢弃");
        map.put("quick.orange.male.rabbit","是四个单词不匹配任何绑定会被丢弃");
        map.put("lazy.orange.male.rabbit","是四个单词但匹配Q2");

        for (Map.Entry<String, String> bindingKey : map.entrySet()) {
            String key = bindingKey.getKey();
            String message = bindingKey.getValue();
            channel.basicPublish(EXCHANGE_NAME,key,null,message.getBytes());
            System.out.println("生产者发出："+message);
        }
    }
}

        消费者代码：

package com.hxh.rabbitmq.seven;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

//消费者
public class ReceiveLogsTopic01 {

    private static final String EXCHANGE_NAME="topic_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");
        String queueName="Q1";
        channel.queueDeclare(queueName,false,false,false,null);
        channel.queueBind(queueName,EXCHANGE_NAME,"*.orange.*");
        System.out.println("01等待接收...");

        DeliverCallback deliverCallback=(var1, var2)->{
            System.out.println("01接收消息："+new String(var2.getBody()));
            System.out.println("绑定键："+var2.getEnvelope().getRoutingKey());
        };
        CancelCallback cancelCallback=(var1)->{
            System.out.println("01取消");
        };
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

package com.hxh.rabbitmq.seven;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

//消费者
public class ReceiveLogsTopic02 {

    private static final String EXCHANGE_NAME="topic_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");
        String queueName="Q2";
        channel.queueDeclare(queueName,false,false,false,null);
        channel.queueBind(queueName,EXCHANGE_NAME,"*.*.rabbit");
        channel.queueBind(queueName,EXCHANGE_NAME,"lazy.#");
        System.out.println("02等待接收...");

        DeliverCallback deliverCallback=(var1, var2)->{
            System.out.println("02接收消息："+new String(var2.getBody()));
            System.out.println("绑定键："+var2.getEnvelope().getRoutingKey());
        };
        CancelCallback cancelCallback=(var1)->{
            System.out.println("02取消");
        };
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

2、死信队列

2.1、死信的概念

        死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer 从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。

        应用场景:为了保证订单业务的消息数据不丢失，需要使用到RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中，还有比如说:用户在商城下单成功并点击去支付后在指定时间未支付时自动失效

2.2、死信的来源

        消息TTL过期

        队列达到最大长度（队列满了，无法在添加数据到mq中）

        消息被拒绝（basic.reject或basic.nack）并且 requeue=false。

2.3、死信实战

2.3.1、代码架构图

     

2.3.2、消息TTL过期

        生产者

package com.hxh.rabbitmq.eight;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;

//生产者
public class Producer {

    private static final String NORMAL_EXCHANGE="normal_exchange";
    private static final String NORMAL_QUEUE="normal_queue";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();

        //死信消息 设置TTL时间 单位是ms
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
        for (int i = 1; i < 11; i++) {
            String message=i+"";
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",properties,message.getBytes());
            System.out.println("发送消息："+i);
        }
    }
}

         消费者01

package com.hxh.rabbitmq.eight;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

import java.util.HashMap;
import java.util.Map;

//普通队列 消费者01
public class Consumer01 {
    //声明普通和死信的交换机、队列
    private static final String NORMAL_EXCHANGE="normal_exchange";
    private static final String DEAD_EXCHANGE="dead_exchange";
    private static final String NORMAL_QUEUE="normal_queue";
    private static final String DEAD_QUEUE="dead_queue";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明普通和死信的交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE,"direct");
        channel.exchangeDeclare(DEAD_EXCHANGE,"direct");

        //声明普通队列
        Map<String, Object> arguments = new HashMap<>();
        //设置死信交换机
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信RoutingKey
        arguments.put("x-dead-letter-routing-key","lisi");
        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);
        //声明死信队列
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //绑定队列与交换机
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");
        System.out.println("等待消息...");

        DeliverCallback deliverCallback=(var1,var2)->{
            System.out.println("01接收消息："+new String(var2.getBody(),"utf-8"));
        };
        CancelCallback cancelCallback=var1->{
            System.out.println("01取消了....");
        };

        channel.basicConsume(NORMAL_QUEUE,true,deliverCallback,cancelCallback);
    }
}

        消费者02

package com.hxh.rabbitmq.eight;

import com.hxh.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

import java.util.HashMap;
import java.util.Map;

//死信队列 消费者02
public class Consumer02 {
    //声明死信队列
    private static final String DEAD_QUEUE="dead_queue";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        System.out.println("等待消息...");

        DeliverCallback deliverCallback=(var1,var2)->{
            System.out.println("02接收消息："+new String(var2.getBody(),"utf-8"));
        };
        CancelCallback cancelCallback=var1->{
            System.out.println("02取消了....");
        };

        channel.basicConsume(DEAD_QUEUE,true,deliverCallback,cancelCallback);
    }
}

2.3.3、队列达到最大长度

        生产者

        消费者01

 

         消费者02不变

2.3.4、消息被拒绝

        生产者

        消费者01

 

        消费者02不变 

不想取名字_
关注
RabbitMQ入门教程(十)：队列声明queueDeclare
人不风流枉少年
11-29 4万+
简介本节主要讨论队列声明的各个参数queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments); queue: 队列名称 durable： 是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存
RabbitMQ学习
touluzhu3552的博客
01-31 333
rabbitMq学习笔记
rabbitMqUtils
qq_42570684的博客
07-30 1295
package com.bootdo.jiai.util; import com.rabbitmq.client.*; import java.io.IOException; public class ActiveMqUtils { private final static String QUEUE_NAME = "healthQuee"; public static S...
rabbitmq中的queueDeclare方法
诚的博客
04-16 4130
queueDeclare Queue.DeclareOk queueDeclare() throws IOException; /** * Declare a queue * @see com.rabbitmq.client.AMQP.Queue.Declare * @see com.rabbitmq.client.AMQP.Queue.DeclareOk ...
《消息中间件》~ Rabbit工具类 RabbitMQUtil
qq_45928727的博客
08-30 1380
public class RabbitMQUtil { private static ConnectionFactory connectionFactory; static { //创建mq的连接工厂对象 connectionFactory = new ConnectionFactory(); //设置连接rabbit的主机地址 connectionFactory.setHost("192.168.17.156");
Java RabbitMQUtil
weixin_43865977的博客
09-04 477
Maven依赖： <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.3.RELEASE</version> <relativePath/&gt
rabbitmq学习笔记和软件和插件
05-05
在学习RabbitMQ时，理解Erlang的基本语法和并发模型对深入理解RabbitMQ的工作原理很有帮助。 **三、Socat工具** Socat是一个命令行工具，用于建立各种网络连接。在RabbitMQ中，它有时被用来创建TCP隧道，帮助调试...
springboot+RabbitMQ三种模式demo
07-03
通过运行这个示例，你可以更好地理解这三个模式的工作原理，并学习如何在实际项目中使用它们。 总结，SpringBoot结合RabbitMQ提供了一种高效且灵活的方式来处理异步通信和解耦。Direct模式适用于一对一的消息传递，...
RabbitMQ学习 笔记
04-27
### RabbitMQ 学习笔记知识点总结 #### 一、RabbitMQ 历史与背景 RabbitMQ 是一个基于 AMQP（高级消息队列协议）的开源消息中间件，由 Erlang 语言编写而成。AMQP 的出现填补了异步消息处理领域的标准化空白，特别...
rabbitmq常用三种模式的配置
03-16
在配置RabbitMQ时，通常会在不同的文件夹中保存配置文件，便于管理和学习。这些文件可能包含关于交换机类型、队列定义、路由键绑定等内容。在RabbitMQ的配置文件中，我们可以通过XML或者JSON格式来定义这些参数，...
Rabbitmq工具类，java工具类RabbitmqUtil
10-29
1、java工具类RabbitmqUtil是本人封装好的直接使用 2、常用的方法都在里面 3、改一下初始化配置参数就行
RabbitMQ工具类及测试类(完整版)
12-24
RabbitMQClientUtil是MQ的测试工具类，他封装了fanout、direct、topic三种exchange模式，并包括发送数据和接收数据。 Test1、Test2是测试类 使用maven管理，在pom.xml文件中引入如下代码： <!-- Rabbitmq工具包 --> com.rabbitmq amqp-client 3.6.5 rabbitmq.properties配置文件根据自己需要自行放在，放置完毕后，请自己修改util中的文件地址
RabbitMQ工具类封装实现
10-26
封装了RabbitMQ的订阅者线程和发布者线程（还有个初始化工厂的连接工具类），另外附加一个安卓的使用demo
RabbitMq学习(2) queueDeclare()/ basicPublish() API详解
IlickCat的博客
06-16 4858
一、queueDeclare(…) queueDeclare()用于实现通道与队列的绑定。它包含5个参数。 String queue: 被绑定的消息队列名，当该消息队列不存在时，将新建该消息队列 Boolean durable: 是否持久化消息队列， 该参数持久化的仅为队列，而不包含队列中的消息 Boolean exclusive: 该通道是否独占该队列 Boolean autoDelete: 消费完成时是否删除队列， 该删除操作在消费者彻底断开连接之后进行。 Map<String, Object&
springCloud使用rabbitMq
czm179885的博客
10-13 2972
一.安装rabbitMq 安装rabbitMq(需要安装延时插件)。 二.rabbitMq 使用 1.导入maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2.在application.yml配置文件中加入Ra
rabbitmq工具类
YIYIYIPEI的博客
07-30 3004
package com.gi.util; import java.io.IOException; import com.alibaba.fastjson.JSONObject; import com.gi.entrty.HealthDO; import com.gi.entrty.HttpParamEntity; import com.rabbitmq.client.*; public cla...
RabbitMQ
Cavolo_cinese的博客
01-24 172
MySQL概述（含安装）模型整合SpringBoot项目 概述（含安装） MQ (Message Quene):翻译为消息队列，通过典型的生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，轻松的实现系统间解耦。别名为消息中间件通过利用高效可靠的消息传递机制进行平 台无关的数据交流，并基于数据通信来进行分布式系统的集成。 MQ的分类 当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、R
RabbitMQ(四)：RabbitMQ-queueDeclare
weixin_40805079的博客
01-02 1116
转载地址：https://www.jianshu.com/p/5634a9c71559 声明创建队列 ConnectionFactory connectionFactory = new ConnectionFactory(); /** * 设置ip * port * 用户名 * 密码 ...
深入学习rabbitmq
最新发布
07-28
RabbitMQ 是一个功能强大的开源消息中间件，...除了官方文档，还有一些优秀的第三方资源可以帮助你深入学习 RabbitMQ，比如书籍、博客文章、视频教程等。不断实践和探索是学习 RabbitMQ 的关键，希望你能享受这个过程！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值