消息队列-RabbitMQ学习1

最新推荐文章于 2022-08-08 08:44:50 发布
最新推荐文章于 2022-08-08 08:44:50 发布
阅读量209 收藏 1
点赞数
文章标签： java rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33972550/article/details/113920405
版权

RabbitMQ

1.工作模型

在这里插入图片描述

在这里插入图片描述

上图说明：
producer：生产者
channel：信道（多路复用，虚连接Connection）
Broker：主机
VHost：虚拟主机
Exchange：交换机，主要用于消息的路由。常见类型：direct、fanout、headers、topic
Queue：队列
Consumer：消费者

2.交换器

2.1 Direct Exchange 直连

在这里插入图片描述

2.2 Fanout Exchange 广播

在这里插入图片描述

2.3 Topic Exchange 主题

在这里插入图片描述

3.SpringBoot整合RabbitMQ

3.1 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.1.0.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>2.1.0.RELEASE</version>
</dependency>

<!-- springboot引入rabbitmq -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
    <version>2.1.0.RELEASE</version>
</dependency>

<!-- RabbitMQ原生的客户端 -->
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.0.0</version>
</dependency>

3.2 properties配置文件

spring.application.name=springboot-rabbitmq
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/

3.3 配置类：

服务器配置、创建交换机、创建队列、创建绑定关系

package com.zwt.rabbitmq.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {

    @Value("${spring.rabbitmq.host}")
    private String address;

    @Value("${spring.rabbitmq.port}")
    private String port;

    @Value("${spring.rabbitmq.username}")
    private String username;

    @Value("${spring.rabbitmq.password}")
    private String password;

    @Value("${spring.rabbitmq.virtual-host}")
    private String virtualHost;

    // 连接工厂
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(address + ":" + port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        return connectionFactory;
    }

    // rabbitAdmin封装了对rabbitMQ的管理操作
    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory){
        return new RabbitAdmin(connectionFactory);
    }

    // 使用template
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        return new RabbitTemplate(connectionFactory);
    }

    // 声明交换器
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("directExchange");
    }
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanoutExchange");
    }
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topicExchange");
    }

    // 声明队列
    @Bean
    public Queue queue1(){
        return new Queue("queue1");
    }
    @Bean
    public Queue queue2(){
        return new Queue("queue2");
    }

    // 绑定关系
    @Bean
    public Binding bindQueue1AndDirectExchange(Queue queue1, DirectExchange directExchange){
        return BindingBuilder.bind(queue1).to(directExchange).with("red");
    }
    @Bean
    public Binding bindQueue2AndDirectExchange(Queue queue2, DirectExchange directExchange){
        return BindingBuilder.bind(queue2).to(directExchange).with("white");
    }
    @Bean
    public Binding bindQueue1AndFanoutExchange(Queue queue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(queue1).to(fanoutExchange);
    }
    @Bean
    public Binding bindQueue2AndFanoutExchange(Queue queue2, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(queue2).to(fanoutExchange);
    }
    @Bean
    public Binding bindQueue1AndTopicExchange(Queue queue1, TopicExchange topicExchange){
        return BindingBuilder.bind(queue1).to(topicExchange).with("red.*");
    }
    @Bean
    public Binding bindQueue2AndTopicExchange(Queue queue2, TopicExchange topicExchange){
        return BindingBuilder.bind(queue2).to(topicExchange).with("white.82");
    }
}

在这里插入图片描述

3.4 生产者：

使用路由键发送消息（使用template）

package com.zwt.rabbitmq.producer;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;

@RestController
@RequestMapping("/rabbitmq")
public class RabbitProducer {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/direct")
    public String direct(@RequestParam String key){
        String msg = "key(" + key + ")，exchange(direct)-" + System.currentTimeMillis();
        System.out.println("DirectSender: " + msg);
        rabbitTemplate.convertAndSend("directExchange", key, msg);
        return "发送direct消息成功";
    }

    @GetMapping("/topic")
    public String topic(@RequestParam String key){
        String msg = "key(" + key + ")，exchange(topic)-" + System.currentTimeMillis();
        System.out.println("TopicSender: " + msg);
        rabbitTemplate.convertAndSend("topicExchange", key, msg);
        return "发送topic消息成功";
    }

    @GetMapping("/fanout")
    public String fanout(@RequestParam String key){
        String msg = "key(" + key + ")，exchange(fanout)-" + System.currentTimeMillis();
        System.out.println("FanoutSender: " + msg);
        rabbitTemplate.convertAndSend("fanoutExchange", key, msg);
        return "发送fanout消息成功";
    }
}

3.5 消费者

监听类（监听队列	）

package com.zwt.rabbitmq.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "queue1")
public class RabbitConsumer1 {

    @RabbitHandler
    public void process(String msg){
        System.out.println("Consumer1: " + msg);
    }
}


package com.zwt.rabbitmq.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "queue2")
public class RabbitConsumer2 {

    @RabbitHandler
    public void process(String msg){
        System.out.println("Consumer2: " + msg);
    }
}

4.消息可靠性分析

在这里插入图片描述

1.确保消息到MQ
2.确保消息路由到正确的队列，即路由保证
3.确保消息在队列正确的存储，即消息持久化
4.确保消息从队列中正确的投递到消费者，即消费者确认

4.1 确保消息到MQ

采用确认模式，来确保。这里需要1.修改配置类中的连接工厂ConnectionFactory 2.修改配置类中的rabbitTemplate

// 连接工厂
@Bean
public ConnectionFactory connectionFactory(){
    CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
    connectionFactory.setAddresses(address + ":" + port);
    connectionFactory.setUsername(username);
    connectionFactory.setPassword(password);
    connectionFactory.setVirtualHost(virtualHost);

    // 修改1：确保消息到MQ-开启确认模式
    connectionFactory.setPublisherConfirms(true);

    return connectionFactory;
}

// 使用template
@Bean
public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
    RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
    // 修改2：确保消息到MQ-开启一个异步回调
    rabbitTemplate.setConfirmCallback(confirmCallback());
    return rabbitTemplate;
}

// 生产者发送确认
private RabbitTemplate.ConfirmCallback confirmCallback(){
    return new RabbitTemplate.ConfirmCallback() {
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            if(ack){
                System.out.println("确认消息发送到mq成功");
            }else {
                System.out.println("确认消息发送到mq失败，考虑重发:" + cause);
            }
        }
    };
}

4.2 路由保证

1.失败通知（mandatory+ReturnListener）
  这里需要1.修改配置类中的rabbitTemplate
2.备用交换机

// 使用template
@Bean
public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
    RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
    // 设置监听
    rabbitTemplate.setConfirmCallback(confirmCallback());
    // 修改1：另外一个监听，失败通知
    rabbitTemplate.setMandatory(true);
    rabbitTemplate.setReturnCallback(returnCallback());

    return rabbitTemplate;
}

// 路由失败通知
private RabbitTemplate.ReturnCallback returnCallback(){
    return new RabbitTemplate.ReturnCallback() {
        public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
            System.out.println("无法路由的消息，需要考虑另行处理");
            System.out.println("returned message: " + new String(message.getBody()));
            System.out.println("returned replyCode: " + replyCode);
            System.out.println("returned replyText: " + replyText);
            System.out.println("returned exchange: " + exchange);
            System.out.println("returned routingKey: " + routingKey);
        }
    };
}

4.3 消息持久化

在3.3环节中的配置类：
有关Queue的初始化、Exchange的初始化都是持久化的

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

4.4 消费者确认

在3.3环节中的配置类：
1.新增配置SimpleMessageListenerContainer

@Resource
private Receiver receiver;

@Bean
public SimpleMessageListenerContainer messageContainer(ConnectionFactory connectionFactory, Queue queue1, Queue queue2){
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
    // 绑定队列
    container.setQueues(queue1, queue2);
    // 手动提交
    container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
    // 消费确认方法
    container.setMessageListener(receiver);
    return container;
}

package com.zwt.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;
import java.io.IOException;

@Component
public class Receiver implements ChannelAwareMessageListener {


    public void onMessage(Message message, Channel channel) {
        try {
            String msg = new String(message.getBody());
            System.out.println("Receiver------>接收到的信息: " + msg);
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
            System.out.println("Receiver------>消息已经消费");
        } catch (Exception e) {
            System.out.println(e.getMessage());
            try {
                // true的意思就是重发
                channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
            } catch (IOException e1) {
                System.out.println("Receiver------>拒绝消息，要求MQ重新发送");
            }
        }

    }

    public void onMessage(Message message) {

    }
}

5.项目结构与代码

环节3、4整合后的项目结构与代码

在这里插入图片描述

5.1 完整的RabbitConfig代码

package com.zwt.rabbitmq.config;

import com.zwt.rabbitmq.consumer.Receiver;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;

@Configuration
public class RabbitConfig {

    @Value("${spring.rabbitmq.host}")
    private String address;

    @Value("${spring.rabbitmq.port}")
    private String port;

    @Value("${spring.rabbitmq.username}")
    private String username;

    @Value("${spring.rabbitmq.password}")
    private String password;

    @Value("${spring.rabbitmq.virtual-host}")
    private String virtualHost;

    @Resource
    private Receiver receiver;

    // 连接工厂
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(address + ":" + port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);

        // 开启确认模式
        connectionFactory.setPublisherConfirms(true);

        return connectionFactory;
    }

    // rabbitAdmin封装了对rabbitMQ的管理操作
    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory){
        return new RabbitAdmin(connectionFactory);
    }

    // 使用template
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        // 设置监听
        rabbitTemplate.setConfirmCallback(confirmCallback());
        // 另外一个监听，路由失败通知
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback(returnCallback());

        return rabbitTemplate;
    }

    // 生产者发送确认
    private RabbitTemplate.ConfirmCallback confirmCallback(){
        return new RabbitTemplate.ConfirmCallback() {
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if(ack){
                    System.out.println("确认消息发送到mq成功");
                }else {
                    System.out.println("确认消息发送到mq失败，考虑重发:" + cause);
                }
            }
        };
    }

    // 路由失败通知
    private RabbitTemplate.ReturnCallback returnCallback(){
        return new RabbitTemplate.ReturnCallback() {
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("无法路由的消息，需要考虑另行处理");
                System.out.println("returned message: " + new String(message.getBody()));
                System.out.println("returned replyCode: " + replyCode);
                System.out.println("returned replyText: " + replyText);
                System.out.println("returned exchange: " + exchange);
                System.out.println("returned routingKey: " + routingKey);
            }
        };
    }

    // 声明交换器
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("directExchange");
    }
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanoutExchange");
    }
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topicExchange");
    }

    // 声明队列
    @Bean
    public Queue queue1(){
        return new Queue("queue1");
    }
    @Bean
    public Queue queue2(){
        return new Queue("queue2");
    }

    // 绑定关系
    @Bean
    public Binding bindQueue1AndDirectExchange(Queue queue1, DirectExchange directExchange){
        return BindingBuilder.bind(queue1).to(directExchange).with("red");
    }
    @Bean
    public Binding bindQueue2AndDirectExchange(Queue queue2, DirectExchange directExchange){
        return BindingBuilder.bind(queue2).to(directExchange).with("white");
    }
    @Bean
    public Binding bindQueue1AndFanoutExchange(Queue queue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(queue1).to(fanoutExchange);
    }
    @Bean
    public Binding bindQueue2AndFanoutExchange(Queue queue2, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(queue2).to(fanoutExchange);
    }
    @Bean
    public Binding bindQueue1AndTopicExchange(Queue queue1, TopicExchange topicExchange){
        return BindingBuilder.bind(queue1).to(topicExchange).with("red.*");
    }
    @Bean
    public Binding bindQueue2AndTopicExchange(Queue queue2, TopicExchange topicExchange){
        return BindingBuilder.bind(queue2).to(topicExchange).with("white.82");
    }

    @Bean
    public SimpleMessageListenerContainer messageContainer(ConnectionFactory connectionFactory, Queue queue1, Queue queue2){
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        // 绑定队列
        container.setQueues(queue1, queue2);
        // 手动提交
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        // 消费确认方法
        container.setMessageListener(receiver);
        return container;
    }
}

5.2 完整的Receiver代码

package com.zwt.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;
import java.io.IOException;

@Component
public class Receiver implements ChannelAwareMessageListener {

    public void onMessage(Message message, Channel channel) {
        try {
            String msg = new String(message.getBody());
            System.out.println("Receiver------>接收到的信息: " + msg);
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
            System.out.println("Receiver------>消息已经消费");
        } catch (Exception e) {
            System.out.println(e.getMessage());
            try {
                channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
            } catch (IOException e1) {
                System.out.println("Receiver------>拒绝消息，要求MQ重新发送");
            }
        }
    }

    public void onMessage(Message message) {
    }
}
qq_33972550
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
消息队列-RabbitMQ
Roc的博客
07-16 1181
延迟队列是一种消息队列，它允许消息在被发送后延迟一定时间才被消费者处理。这意味着消息可以设定一个未来的时间点进行投递，直到达到指定的延迟时间后，消息才会被转移到另一个队列中供消费者消费。延迟队列常用于实现需要延时处理的任务，如定时任务、延迟通知等。优先级队列是一种支持按元素优先级顺序处理消息的队列。在这种队列中，每个消息被赋予一个优先级，高优先级的消息会先于低优先级的消息被消费处理，无论它们的到达顺序如何。优先级队列用于实现重要任务的优先处理等场景。
消息队列--RabbitMQ 学习
xu_jin_shan的博客
04-01 2282
消息队列–RabbitMQ 学习
rabbitmq-consumer-receiver:带有rabbitmq的示例弹簧靴
05-31
rabbitmq-消费者-接收者 带有rabbitmq的示例弹簧靴
RabbitMQ接收端配置及实现方法
sunshtwe的博客
01-25 1817
RabbitMQ接收端 1，application.yml的配置 #MQ消息队列 rabbitmq: # 消息确认（ACK） # publisher-confirm-type: correlated #确认消息已发送到交换机(Exchange)，会返回一个ack确认码 # publisher-returns: true #确认消息已发送到队列(Queue) listener: #加了2下面2个属性,消费消息的时候,就必须发送ack确认,不然消息永远还在队列中 d
rabbitmq使用_微服务中这样使用RabbitMQ更简单
weixin_39604045的博客
12-07 793
这篇文章的读者，假设您已经对RabbitMQ、SpringBoot和微服务有一定的理解。此文章来自于对内部技术规范指引的编辑。典型应用场景RabbitMQ典型应用场景此图展示了RabbitMQ的典型应用场景，生产者把消息发送到Exchange，消费者从Queue读取消息，消息可通过topic、header、direct、fanout四种方式由Exchange路由到Queue。在微服务中的开发过程中...
消息中间件——RabbitMQ（十一）RabbitMQ整合Spring Cloud Stream实战！（全）
Coder编程的博客
08-28 1978
前言 1. SpringCloudStream整合 Spring Cloud，这个全家桶框架在整个中小型互联网公司异常的火爆，那么相对应的Spring Cloud Stream 就渐渐的被大家所重视起来，这一节课主要来介绍Spring Cloud Stream如何与RabbitMQ进行集成。 架构介绍 Destination Binder:包含自己的应用Application 左边是Ra...
RabbitMq的原理及四种常用方式（direct,fanout,topic）
qq_39380737的博客
02-26 1834
1.RabbitMQ简介 在介绍RabbitMQ之前实现要介绍一下MQ，MQ是什么？         MQ全称是Message Queue，可以理解为消息队列的意思，简单来说就是消息以管道的方式进行传递。         RabbitMQ是...
java队列源码-rabbitmq-repository:RabbitMQ消息队列学习的源码记录
05-24
rabbitmq任务队列示例 rabbitmq-java-publish-receive rabbitmq发布订阅示例 rabbitmq-java-routing rabbitmq路由示例 rabbitmq-spring-topic-exchange rabbitmq主题示例 rabbitmq-java-rpc rabbitmq PRC通信示例 ...
消息队列RabbitMQ学习-1
01-20
【RabbitMQ学习】 RabbitMQ是一种广泛使用的开源消息队列服务器，它基于Advanced Message Queuing Protocol（AMQP）标准，旨在不同应用之间共享数据。由Erlang语言开发，RabbitMQ提供了跨平台的可移植性，支持多种...
消息中间件-RabbitMQ2.zip
最新发布
01-31
**RabbitMQ 深入解析** RabbitMQ 是一个开源的消息代理和队列服务器，它基于 Advanced Message Queuing ...通过"消息中间件-RabbitMQ2"的资料，您可以深入学习RabbitMQ的各个方面，并将其成功应用于您的项目中。
RabbitMQ五种消息类型
weixin_35787722的博客
05-08 5015
大体分为两类：1和2属于点对点；3、4、5属于发布订阅模式（一对多） 点对点模式：P2P（point to point）模式包含三个角色： 消息队列（queue），发送者（sender），接收者（receiver） 每个消息发送到一个特定的队列中，接收者从中获得消息 队列中保留这些消息，直到他们被消费或超时 特点： 1. 每个消息只有一个消费者，一旦消费，消息就不在队列中了 2. 发送者和接收者之间没有依赖性，发送者发送完成，不管接收者是否运行，都不会影响 消息发送到队列中（我给你发微信，不
springboot与RabbitMQ整合消息队列，生产者发送消息确认，消费者消息确认模式
追风筝的人博客
10-12 1636
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上这些..
RabbitMQ进阶——RabbitMQ 重试机制，看这篇就够了
守夜人爱吃兔子的博客
06-30 8433
前言 消费者在处理消息的过程中可能会发生异常，那么此时此刻该如何处理这个异常的消息呢？ RabbitMQ有两个方法channel.basicNack 或 channel.basicReject能够让消息重新回到原队列中，这样子可以实现重试。但是如果第二次消费又发生了异常，一直消费一直异常。由于没有明确重试次数，会造就无限重试，这是一个致命的问题。 本文就来使用spring-rabbit中自带的retry功能来解决这个问题。 编码 依赖 starter-amqp中包含了spring-rabbit。
【微服务-消息中间件】RabbitMQ七种消息收发方式
qq_43843951的博客
08-08 1671
MQ全称为Message Queue，即消息队列。本次学习rabbit消息的收发方式
Spring Boot(八)：RabbitMQ 详解
weixin_34102807的博客
12-01 350
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。 消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将 RocketMQ 捐献给了 Apache，当然了今天的主角还是讲 RabbitMQ。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关...
RabbitMQ之（3）接收端
清风自来
01-25 912
package rabbitmq; import org.apache.log4j.LogManager; import org.apache.log4j.Logger; import com.rabbitmq.client.ConsumerCancelledException; import com.rabbitmq.client.QueueingConsumer; import com.r...
RabbitMQ学习(六)——消息确认机制(Confirm模式)
热门推荐
Anumbrella
08-04 3万+
在上一篇文章中我们讲解了RabbitMQ中的AMQP事务来保证消息发送到Broker端，同时我们可以在事务之间发送多条消息（即在channel.txSelect()和channel.txCommit()之间发送多条消息，通过使用事务来保证它们准确到达Broker），如果忘记了事务的使用，可以复习一下上一篇文章——RabbitMQ学习(五)——消息确认机制(AMQP事务)。 但是使用事务虽然可以保...
RabbitMQ消息队列入门篇（环境配置+Java实例+基础概念）
weixin_30480651的博客
01-09 1365
一、消息队列使用场景或者其好处 消息队列一般是在项目中，将一些无需即时返回且耗时的操作提取出来，进行了异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。 在项目启动之初来预测将来项目会碰到什么需求，是极其困难的。消息队列在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口。这允许你独立的扩展或修改两边的处理过...
RabbitMQ的使用
piaoslowly的专栏
08-13 7000
RabbitMQ的使用 RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。 AMQP，即Advanced Message Queuing Pr...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值