RabbitMQ

最新推荐文章于 2024-08-11 16:16:30 发布
最新推荐文章于 2024-08-11 16:16:30 发布
阅读量187 收藏
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45128709/article/details/110627630
版权

RabbitMQ

1.1 引言

  1. 模块之间的耦合度多高，导致一个模块宕机后，全部功能都不能用了
  2. 同步通讯的成本问题。

在这里插入图片描述

1.2 RabbitMQ的介绍

市面上比较火爆的几款MQ:
ActiveMQ，RocketMQ，Kafka，RabbitMQ。

  1. 语言的支持:AcfiveMQ，RocketMQ只支持Java语言。Kafka可以支持多种语言，RabbitMQ支持多种语言
  2. 效率方面:ActiveMQ, RocketMQ，Kafka效率都是毫秒级别，RabbitMo是微秒级别的。
  3. 消息丢失，消息重复问题：RabbitMQ针对消息的持久化，和重复问题都有比较成熟的解决方案。
  4. 学习成本:RabbitMQ非常简单。

RabbitMo是由Rabbit公司去研发和维护的，最终是在Pivotal。

RabbitMO严格的遵循AMO协议，高级消息队列协议，帮助我们在进程之间传递异步消息。

二、安装RabbitMQ

version: "3.1"
services:
  rabbitmq:
    image: daocloud.io/library/rabbitmq:management
    restart: always
    container_name: rabbitmq
    ports:
      - 5672:5672
      - 15672:15672
    volumes: 
      - ./data:/var/lib/rabbitmq

启动容器后访问

​ http://192.168.56.100:15672

默认用户名密码都是 guest

三、RabbitMQ架构

3.1 官方的简单架构图

  1. Pubisher-生产者：发布消息到RabbitMQ中的Exchange
  2. Consumer-消费者：监听RabbitMQ中的Queue中的消息
  3. Exchange-交换机：和生产者建立连接并接受生产者的消息
  4. Queue-队列：Exchange会将消息分发到指定的Queue，Queue和消费者进行交互
  5. Routes-路由（交换机以什么样的策略将消息发布到Queue）

在这里插入图片描述

3.2 RabbitMQ完整架构图

在这里插入图片描述

3.3 查看图形化界面并创建一个Virtual Host

创建一个全新的用户和全新的Virtual Host，并且将test用户设置上可以操作/test的权限

在这里插入图片描述

四、RabbitMQ的使用

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

在这里插入图片描述

4.4 Java连接RabbitMQ

1.导入依赖

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

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2.工具类

public static Connection getConnection() throws Exception {
    //1.创建ConnectionFactory工厂
    ConnectionFactory factory=new ConnectionFactory();
    factory.setHost("192.168.56.100");
    factory.setPort(5672);
    factory.setUsername("test");
    factory.setPassword("test");
    factory.setVirtualHost("/test");
    //2.创建Connection
    Connection conn=null;
    try {
        conn=factory.newConnection();
    }catch (Exception e){
        e.printStackTrace();
    }
    //3.返回
    return conn;
}

4.4.1 Hello-World

一个生产者，一个默认的交换机，一个队列，一个消费者

在这里插入图片描述

4.4.2 Work

一个生产者，一个默认的交换机，一个队列，两个个消费者
在这里插入图片描述

4.4.3 Publish/Subscribe

一个生产者，一个默认的交换机，凉个队列，两个个消费者
在这里插入图片描述

4.4.4 Routing

一个生产者，一个交换机，两个队列，两个消费者
在这里插入图片描述

4.4.5 Topic

一个生产者，一个交换机，两个队列，两个消费者

在这里插入图片描述

1、生产者创建Topic的exchange并且绑定到队列中，这次绑定可以通过*和#关键字，对指定RoutingKey内容，
编写时注意格式xox.xxx.xxx去编写，’>一个xx，而#->代表多个xxx.xxx，在发送消息时，指定具体的
RoutingKey到底是什么。

五、RabbitMQ整合SpringBoot

5.1 SpringBoot整合RabbitMQ

1.导入pom.xml

       <!--RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

2.编写配置文件

spring:
  rabbitmq:
    host: 192.168.56.100
    port: 5672
    username: test
    password: test
    virtual-host: /test

3.编写配置类，声明exchange和queue，并且绑定到一起

@Configuration
public class RabbitMQConfig {

    //1.创建exchange  -topic
    @Bean
    public TopicExchange getTopicExchange(){
        return new TopicExchange("boot-topic-exchange",true,false);
    }
    //2.创建queue
    @Bean
    public Queue getQueue(){
        return new Queue("boot-queue",true,false,false,null);
    }
    //3.绑定在一起
    @Bean
    public Binding getBinding(TopicExchange topicExchange,Queue queue){
        return BindingBuilder.bind(queue).to(topicExchange).with("*.red.*");
    }

}

4.发布消息

@Autowired
private RabbitTemplate rabbitTemplate;

@Test
void contextLoads() {
    rabbitTemplate.convertAndSend("boot-topic-exchange","slow.red.dog","红色大狼狗");
}

5.创建消费者监听消息

@Component
public class Consumer {

    @RabbitListener(queues = "boot-queue")
    public void getMassage(Object message){
        System.out.println("接收到的消息："+message);
    }
}

5.2 手动ACK

1.添加配置文件

spring:
  rabbitmq:
    host: 192.168.56.100
    port: 5672
    username: test
    password: test
    virtual-host: /test
    listener:
      simple:
        acknowledge-mode: manual  #手动

2.在消费消息的位置，修改方法，再手动ack

@Component
public class Consumer {

    @RabbitListener(queues = "boot-queue")
    public void getMassage(String msg, Channel channel, Message message) throws IOException {
        System.out.println("接收到的消息："+message);
        //手动ACK
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
    }
}

六、RabbitMQ的其他操作

6.1 消息的可靠性

RabbitMQ的事务:事务可以保证消息100%传递，可以通过事务的回滚去记录日志，后面定时再次发送当前消
息。事务的操作，效率太低，加了事务操作后，比平时的操作效率的至少要慢100倍。

confrim机制

RabbitMQ除了事务，还提供了Confirm的确认机制，这个效率比事务高很多。

  1. 普通Confirm方式
  2. 异步Confirm方式
  3. 批量Confirm方式

在这里插入图片描述

普通Confirm方式

@Test
public void publish() throws Exception {
    //1.获取Connection
    Connection connection= RabbitMQClient.getConnection();
    //2.创建Channel
    Channel channel = connection.createChannel();

    //3.创建exchange
    //3.1开启confirm
    channel.confirmSelect();
    //3.2发送消息
    String msg="Hello-World";
    channel.basicPublish("","HelloWorld",null,msg.getBytes());
    //3.3判断消息是否发送成功
    if(channel.waitForConfirms()){
        System.out.println("消息发送成功");
    }else {
        System.out.println("发送消息失败");
    }
    System.out.println("生产者发布消息成功");
    //4.释放
    channel.close();
    connection.close();
}

批量Confirm方式

//开启confrim
channel.confirmSelect();
//发送消息
for (int i=0;i<1000;i++){
    String msg="Hello-World";
    channel.basicPublish("","HelloWorld",null,msg.getBytes());
}
//当你发送的全部消息，有一个失败的时候，就直接全部失败，抛出IOException
channel.waitForConfirms();

异步Confirm方式

public class Publisher3 {

    @Test
    public void publish() throws Exception {
        //1.获取Connection
        Connection connection= RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();

        //3.创建exchange
        //3.1开启confrim
        channel.confirmSelect();
        //3.2发送消息
        for (int i=0;i<1000;i++){
            String msg="Hello-World";
            channel.basicPublish("","HelloWorld",null,msg.getBytes());
        }
        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleAck(long l, boolean b) throws IOException {
                System.out.println("消息发送成功，标识："+l+"是否批量:"+b);
            }

            @Override
            public void handleNack(long l, boolean b) throws IOException {
                System.out.println("消息发送失败，标识："+l+"是否批量:"+b);
            }
        });
        System.in.read();
        System.out.println("生产者发布Publisher2消息成功");
        //4.释放
        channel.close();
        connection.close();
    }
}

6.1.2 Return机制

Confirm只能保证消息到达exchange,无法保证消息可以被exchange分发到指定queue。
而且exchange是不能持久化消息的，queue是可以持久化消息

采用Return机制来监听消息是否从exchange送到了指定的queue中

在这里插入图片描述

//开启Return机制
channel.addReturnListener(new ReturnListener() {
    @Override
    public void handleReturn(int i, String s, String s1, String s2, AMQP.BasicProperties basicProperties, byte[] body) throws IOException {
        //当消息没有送达到队列中时才会执行
        System.out.println(new String(body,"UTF-8")+"没有送达到Queue");
    }
});
//发送消息时候，需要指定mandatory为true,发送消息调用以下构造方法
//void basicPublish(String exchange, String routingKey, boolean mandatory, BasicProperties props, byte[] body)

6.1.3 Springboot实现Confirm以及Return

1.添加配置文件，开启confrim以及return

spring:
  rabbitmq:
    publisher-confirm-type: simple
    publisher-returns: true

2.指定RabbitTemplate对象，开启Confrim和Return

@Component
public class PublisherConfrimAndReturnConfig implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void initMethod(){
        rabbitTemplate.setConfirmCallback(this);
    }
    
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if(ack){
            System.out.println("消息以及送到到ack");
        }else{
            System.out.println("消息没有送达exchange");
        }
    }

    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        System.out.println("消息没有送达queue");
    }
}

6.2 消息重复消费

重复消费消息，会对非幂等行操作造成问题
重复消费消息的原因是，消费者没有给RabbitMQ一个ack

在这里插入图片描述

为了解决消息重复消费的问题，可以采用Redis，在消费者消费消息之前，现将消息的id放到Redis中

id-0 (正在执行业务)

id-1 (执行业务成功)

如果ack失败，在RabbitMQ将消息交给其他的消费者时，先执行setnx，如果key已经存在，获取他的值，如果是0，当前消费者就什么都不做，如果是1，直接ack。

极端情况:第一个消费者在执行业务时，出现了死锁，在setnx的基础上，再给key设置一个生存时

1.生产者，发送消息时，指定messageld

AMQP.BasicProperties properties=new AMQP.BasicProperties().builder()
        .deliveryMode(1) //1:需要持久化 2：不需要
        .messageId(UUID.randomUUID().toString())
        .build();
String msg="Hello-World";
channel.basicPublish("","HelloWorld",true,properties,msg.getBytes());

2.消费者，在消费消息时，根据具体业务逻辑去操作redis

Jedis jedis=new Jedis("192.168.56.100",6379);
jedis.auth("xxxx");
String messageId = properties.getMessageId();
//1.setnx到Redis中，默认指定value=0
String result = jedis.set(messageId, "0", "NX", "EX", 10);
System.out.println("result"+result);
if(result!=null&&result.equalsIgnoreCase("OK")){
    System.out.println("接收到消息："+new String(body,"UTF-8"));
    //2.消费成功，set messageId  1
    jedis.set(messageId,"1");
    channel.basicAck(envelope.getDeliveryTag(),false);
}else {
    //3.如果1中的
    String s = jedis.get(messageId);
    if("1".equalsIgnoreCase(s)){
        channel.basicAck(envelope.getDeliveryTag(),false);
    }
}

6.2.2 SpringBoot如何实现

导入依赖

<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

编写配置文件

spring:
  redis:
    host: 192.168.56.100
    port: 6379

修改生产者

@Test
void contextLoads() throws IOException {
    CorrelationData messageId=new CorrelationData(UUID.randomUUID().toString());
    rabbitTemplate.convertAndSend("boot-topic-exchange","slow.red.dog","红色大狼狗",messageId);
    System.in.read();
}

修改消费者

@RabbitListener(queues = "boot-queue")
public void getMassage(String msg, Channel channel, Message message) throws IOException {
    //0.获取messageId
    String messageId = message.getMessageProperties().getHeader("spring_returned_message_correlation");
    //1.设置key到Redis
    if (redisTemplate.opsForValue().setIfAbsent(messageId,"0",10, TimeUnit.SECONDS)) {
        //2.消费消息
        System.out.println("接收到的消息"+msg);
        //3.设置key的value为1
        redisTemplate.opsForValue().set(messageId,"1",10,TimeUnit.SECONDS);
        //4.手动ACK
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }else {
        //5.获取Redis中的value 即可，如果是1，手动ack
        if("1".equalsIgnoreCase(redisTemplate.opsForValue().get(messageId))){
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }
    }

}

七、RabbitMQ应用

客户模块

1.导入依赖

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

2.编写配置文件

spring:
  rabbitmq:
    host: 192.168.56.100
    port: 5672
    username: test
    password: test
    virtual-host: /test

3.编写配置类

package com.it.openapi.customer.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("openapi-customer-exchange",true,false);
    }


    @Bean
    public Queue queue(){
        return new Queue("openapi-customer-queue");
    }

    @Bean
    public Binding binding(Queue queue, TopicExchange topicExchange){
        return BindingBuilder.bind(queue).to(topicExchange).with("openapi.customer.*");
    }
}

4.修改Service (发送消息的方式（第三步）)

@Transactional
public void saveCustomer(Customer customer) {
    //1.调用mapper添加数据到mysql
    Integer count = customerMapper.saveCustomer(customer);
    //2.判断是否成功
    if(count!=1){
        log.error("【添加客户信息失败】customer={}",customer);
        throw new RuntimeException("【添加客户信息失败】");
    }
    //3.发送消息
    rabbitTemplate.convertAndSend("openapi-customer-exchange","openapi.customer.add",JSON.toJSON(customer));
}

搜索模块

1.导入依赖

org.springframework.boot spring-boot-starter-amqp

2.编写配置文件

spring:
  rabbitmq:
    host: 192.168.56.100
    port: 5672
    username: test
    password: test
    virtual-host: /test
    listener:
      simple:
        acknowledge-mode: manual

3.编写配置类

package com.it.openapi.search.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;

@Configuration
public class RabbitMQConfig {

    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("openapi-customer-exchange",true,false);
    }

    @Bean
    public Queue queue(){
        return new Queue("openapi-customer-queue");
    }

    @Bean
    public Binding binding(Queue queue,TopicExchange topicExchange){
        return BindingBuilder.bind(queue).to(topicExchange).with("openapi.customer.*");
    }

}

4.编写消费者

package com.it.openapi.search.listener;

import com.it.openapi.search.entity.Customer;
import com.it.openapi.search.service.CustomerService;
import com.it.openapi.search.utils.JSON;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;


@Component
public class CustomerListener {

    @Autowired
    private CustomerService customerService;
    @RabbitListener(queues = "openapi-customer-queue")
    public void consume(String json, Channel channel, Message message) throws IOException {
        //1.获取RoutingKey
        String routingKey = message.getMessageProperties().getReceivedRoutingKey();
        //2.使用switch
        switch(routingKey){
            case "openapi.customer.add":
                //3.add操作调用Service操作
                customerService.saveCustomer(JSON.parseJSON(json,Customer.class));
                //4.手动ack
                channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        }
    }
}

ponent
public class CustomerListener {

@Autowired
private CustomerService customerService;
@RabbitListener(queues = "openapi-customer-queue")
public void consume(String json, Channel channel, Message message) throws IOException {
    //1.获取RoutingKey
    String routingKey = message.getMessageProperties().getReceivedRoutingKey();
    //2.使用switch
    switch(routingKey){
        case "openapi.customer.add":
            //3.add操作调用Service操作
            customerService.saveCustomer(JSON.parseJSON(json,Customer.class));
            //4.手动ack
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
    }
}

}
小笼包o.o
关注
专栏目录
rabbitMQ的三种发布确认效率测试
weixin_44988724的博客
11-05 427
参考了尚硅谷的教学做的笔记使用channel发布1000条数据测试单独发布、批量发布、异步发布的效率。
RabbitMQ笔记
普通还不自信的程序员
09-14 1285
文章目录一、引言二、RabbitMQ介绍三、RabbitMQ安装四、RabbitMQ架构【`重点`】4.1 官方的简单架构图4.2 RabbitMQ的完整架构图4.3 查看图形化界面并创建一个Virtual Host五、RabbitMQ的使用【`重点`】5.1 RabbitMQ的通讯方式5.2 Java连接RabbitMQ5.2.1 创建maven项目5.2.2 导入依赖5.2.3 创建工具类连接RabbitMQ5.3 Hello-World5.4 Work5.5 Publish/Subscribe5.6
RabbitMQ 使用教程
最新发布
白白白鲤鱼的博客
08-11 2420
RabbitMQ使用教程
RabbitMQ统一消息处理
weixin_71020872的博客
05-18 640
实际使用中，没有必要每次都创建一个Message类，然后手动添加。使用RabbitMQ进行异步通信时，可能不仅仅需要传递消息本身，有时需要包含一些额外的信息，比如登录状态。可以参考前端发送请求时的做法，把登录状态保存在请求头中。一般情况下，消费更倾向于使用监听机制，也就是使用@RabbitListener注解，这种方式也可以自动的声明交换机、队列以及建立绑定，因此使用更加广泛。然而这种方式无法执行前面设置的后置处理器逻辑，也就是拿不到消息头中的信息。在异步场景下显然这两种方法都不满足要求。
RabbitMQ消息队列
qq_48114126的博客
01-09 520
AMQP，即Advanced Message Queuing Protocol，一个提供的应用层标准高级消息队列协议，是的一个，为面向消息的中间件设计。基于此协议的客户端与可传递消息，并不受客户端/不同产品，不同的开发语言等条件的限制。中的实现有等。异步异步的使用场景对性能要求高对对方执行结果不关心，不影响当前业务。
RabbitMQ Server3.13.0
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
kettle rabbitmq 插件开发
10-26
标题 "kettle rabbitmq 插件开发" 涉及的是如何在 Pentaho Kettle（也称为 Spoon）中创建和使用 RabbitMQ 插件。Kettle 是一个开源的数据集成工具，它允许用户进行数据抽取、转换和加载（ETL）操作。RabbitMQ 是一个...
RabbitMQ实战指南-rabbitmq-action.zip
11-07
**RabbitMQ实战指南** RabbitMQ是一款广泛应用的开源消息队列系统，它基于Advanced Message Queuing Protocol（AMQP）标准，提供高可用性、可靠性和可扩展性。本实战指南将带你深入理解RabbitMQ的核心概念、安装与...
rabbitMQ实战java版-rabbitMQ-demo.zip
11-07
《RabbitMQ实战Java版——基于rabbitMQ-demo.zip的详解》 在当今的分布式系统中，消息队列作为异步处理、解耦组件的关键技术，得到了广泛应用。RabbitMQ作为一款开源的消息代理和队列服务器，以其稳定性和易用性...
RabbitMQ性能测试报告
01-10
RabbitMQ性能测试报告，对rabbitmq容器内的单机模式和集群模式进行了压力测试盒稳定性测试。
com.rabbitmq.client.Connection connection = ConnectionUtil.getConnection
bryangp的博客
01-27 433
package com.techman.rabbitmq.littlerabbit; import com.techman.rabbitmq.util.ConnectionUtil; import java.sql.Connection; 这里包到错了！！！ public class Producer { private final static String QUEUE_NAME="hello"; public static Connection getConnetion (S
java rabbitmq topic_java rabbitmq 发送消息是topic模式， 消费者 怎么消费多个不同名字的队列？...
weixin_27130513的博客
02-24 484
这里有几个不同的队列 名字没有什么规则 就是xxx.xxx exchange也是和队列的名字一样的package com.monitor.receiver.queue;import java.util.List;import java.util.Map;import org.springframework.amqp.rabbit.annotation.RabbitListener;import...
RabbitMQ优先级消息
醉鱼的博客
06-20 1183
使用场景 对于Mq中可能产生堆积消息的情景来说，如果消息都是不需要实时处理的，那可以等待消费者慢慢的去处理就行了，然后实际使用中我们会遇到这样一种情况，就是mq队列堆积消息很多，但是每条消息处理的有的很慢有的很快，所以此时这种场景就比较适合使用mq的优先级来保证消息的提前消费，让处理慢的消息最后消费 下面使用java链接mq演示一下消息的处理 初始化优先级队列 #交换机publicstaticfinalStringEXCHANGE_TEST...
rabbitmq细节说明与效率（三）
suqinyi的博客
04-14 3320
文章目录一、MQ说明1.1、MQ种类：1.2、MQ选择：二、rabbitmq3种发送消息的策略和模式1.1、策略1.2、模式三、rabbitmq信道的方法四、死信队列和延迟队列1.1、队列的特点1.2、死信队列1.1.1、应用场景:1.1.2、死信的来源1.3、延迟队列1.1.1、延迟队列使用场景1.4、消息设置过期，还是队列设置1.1、队列的先进先出的影响1.5、归纳五、消息兜底方案1.1、Mandatory 参数1.1.1、问题所在1.2、备份交换机六、优先级队列1.1、使用场景1.2、使用七、惰性队列
RabbitMQ 简单使用
MXqihang的博客
04-12 1842
RabbitMQ 文章目录RabbitMQRabbitMQ 消息发送模式直接模式 direct发布订阅模式 fanout普通队列模式工作队列模式主题模式 topic交换机直接交换机 Direct扇形交换机主题交换机springboot 整合RabbitMQ常用APIRabbitTemplate 常用api简单案列‼️依赖配置文件发送消息监听消息延迟队列配置类发送消息底部 RabbitMQ 消息发送模式 消息在RabbitMQ队列传输过程中，根据不同的传输方式，以及所使用的队列种类不同，一共划分了5个消
RabbitMQ消息中间件技术精讲（四）—— 整合RabbitMQ与Spring家族
Orcas
01-09 987
Spring AMQP的相关知识：RabbitAdmin、RabbitTemplate、SimpleMessageListenerContainer、MessageListenerAdapter、MessageConverter；RabbitMQ整合Spring、SpringBoot、Spring Cloud Stream
RabbitMQ高级
demo小王子
03-11 1713
高级特性 0.持久化 exchange，queue，message持久化 只需要在创建时设置durable="true"即可 exchange <rabbit:fanout-exchange id="spring_fanout_exchange" durable="true" name="spring_fanout_exchange" auto-declare="true"> queue <rabbit:queue id="spring_queue" name="spring_queu
RabbitMQ实战指南
"RabbitMQ Cookbook：由Sigismondo Boschi和Gabriele Santomaggio合著，该书提供了超过70个实用的食谱，旨在帮助读者利用RabbitMQ开发消息传递应用程序，通过大量现实生活中的例子进行教学。" 《RabbitMQ Cookbook...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值