rabbitmq基础

最新推荐文章于 2024-04-24 16:36:04 发布
最新推荐文章于 2024-04-24 16:36:04 发布
阅读量537 收藏
点赞数
文章标签： rabbitmq java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49708063/article/details/124669984
版权

安装和配置的过程省略。
简单的使用：
1.创建配置类（消费者和生产者都需要）：

/*
* 队列和交换机在消费者还是生产者创建都无所谓 主要是 要等两个都创建好过后才能够发消息
*
* */
@Configuration
public class RabbitMqConfig {
    public static final String BUSINESS_EXCHANGE_NAME = "dead.letter.demo.simple.business.exchange";
    public static final String BUSINESS_QUEUEA_NAME = "dead.letter.demo.simple.business.queuea";
    public static final String BUSINESS_QUEUEB_NAME = "dead.letter.demo.simple.business.queueb";
    public static final String DEAD_LETTER_EXCHANGE = "dead.letter.demo.simple.deadletter.exchange";
    public static final String DEAD_LETTER_QUEUEA_ROUTING_KEY = "dead.letter.demo.simple.deadletter.queuea.routingkey";
    public static final String DEAD_LETTER_QUEUEB_ROUTING_KEY = "dead.letter.demo.simple.deadletter.queueb.routingkey";
    public static final String DEAD_LETTER_QUEUEA_NAME = "dead.letter.demo.simple.deadletter.queuea";
    public static final String DEAD_LETTER_QUEUEB_NAME = "dead.letter.demo.simple.deadletter.queueb";

    //创建业务交换机
    @Bean("businessExchange")
    public FanoutExchange businessExchange(){
        return new FanoutExchange(BUSINESS_EXCHANGE_NAME);//扇出交换机 发布订阅
    }

    //创建死信交换机
    @Bean("deadExchange")
    public DirectExchange deadExchange(){
        return new DirectExchange(DEAD_LETTER_EXCHANGE);//直接相连的交换机 只有 routerKey相同才会通信
    }

    //创建业务队列A
    @Bean("businessQueueA")
    public Queue businessQueueA(){
        Map<String,Object> map=new HashMap<>();
        map.put("x-dead-letter-exchange",DEAD_LETTER_EXCHANGE);
        map.put("x-dead-letter-routing-key",DEAD_LETTER_QUEUEA_ROUTING_KEY);//表明死信交换机那个routerKey 是我要发送没用消息的队列
        /*return QueueBuilder.durable(BUSINESS_QUEUEA_NAME).withArguments(map).build();*/
        return QueueBuilder.durable(BUSINESS_QUEUEA_NAME)
                .deadLetterExchange(DEAD_LETTER_EXCHANGE)
                .deadLetterRoutingKey(DEAD_LETTER_QUEUEA_ROUTING_KEY)/*.withArguments(map)*/.build();
    }

    //创建业务队列A
    @Bean("businessQueueB")
    public Queue businessQueueB(){
        Map<String,Object> map=new HashMap<>();
        map.put("x-dead-letter-exchange",DEAD_LETTER_EXCHANGE);//绑定要发送死信到哪个交换机
        map.put("x-dead-letter-routing-key",DEAD_LETTER_QUEUEB_ROUTING_KEY);//表明死信交换机那个routerKey 是我要发送没用消息的队列
        /*return QueueBuilder.durable(BUSINESS_QUEUEB_NAME).withArguments(map).build();*/
        return QueueBuilder.durable(BUSINESS_QUEUEB_NAME)
                .deadLetterExchange(DEAD_LETTER_EXCHANGE)
                .deadLetterRoutingKey(DEAD_LETTER_QUEUEB_ROUTING_KEY)/*.withArguments(map)*/.build();
    }

    //创建死信队列A
    @Bean("deadQueueA")
    public Queue deadQueueA(){
        return QueueBuilder.durable(DEAD_LETTER_QUEUEA_NAME).build();
    }

    //创建死信队列B
    @Bean("deadQueueB")
    public Queue deadQueueB(){
        return QueueBuilder.durable(DEAD_LETTER_QUEUEB_NAME).build();
    }

    //绑定业务交换机和队列 发布订阅模式不需要routerkey
    @Bean
    public Binding businessBindingA(@Qualifier("businessExchange") FanoutExchange exchange,
                                    @Qualifier("businessQueueA") Queue queueA){
        return BindingBuilder.bind(queueA).to(exchange);
    }

    /*在bind的时候一定要注意 不管是怎么做 最后的返回值一定要是Binding对象 否则无法绑定 导致绑定失败*/
    //绑定业务交换机和队列
    @Bean
    public Binding businessBindingB(@Qualifier("businessExchange") FanoutExchange exchange,
                                    @Qualifier("businessQueueB") Queue queueB){
        return BindingBuilder.bind(queueB).to(exchange);
    }

    //绑定死信队列和它的交换机
    @Bean
    public Binding deadLetterBindingA(@Qualifier("deadExchange") DirectExchange exchange,
                                      @Qualifier("deadQueueA") Queue queueA){
        return BindingBuilder.bind(queueA).to(exchange).with(DEAD_LETTER_QUEUEA_ROUTING_KEY);
    }

    //绑定死信队列和它的交换机
    @Bean
    public Binding deadLetterBindingB(@Qualifier("deadExchange") DirectExchange exchange,
                                      @Qualifier("deadQueueB") Queue queueB){
        return BindingBuilder.bind(queueB).to(exchange).with(DEAD_LETTER_QUEUEB_ROUTING_KEY);
    }
}


版本自己决定
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

生产者：

spring:
  application:
    name: nacos-consumer
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        default-requeue-rejected: false #被拒绝后是否重新入队
        acknowledge-mode: manual #手动应答

消息发送的类：

@Component
public class BusinessMessageSender {
    public static final String BUSINESS_EXCHANGE_NAME = "dead.letter.demo.simple.business.exchange";

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMsg(String msg){
        rabbitTemplate.convertSendAndReceive(BUSINESS_EXCHANGE_NAME, "", msg);
    }
}
======================================================================================
发送消息接口
@RequestMapping("rabbitmq")
@RestController
public class RabbitMqController {

    @Autowired
    private BusinessMessageSender sender;

    @RequestMapping("sendmsg")
    public String sendMsg(String msg){
        System.out.println(msg);
        sender.sendMsg(msg);
        return msg;
    }
}

消费者A：

spring:
  application:
    name: nacos-provider-9001
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        default-requeue-rejected: false #被拒绝后是否重新入队
        acknowledge-mode: manual #手动应答

配置类：

@Configuration
public class RabbitMqConfig {
    public static final String BUSINESS_EXCHANGE_NAME = "dead.letter.demo.simple.business.exchange";
    public static final String BUSINESS_QUEUEA_NAME = "dead.letter.demo.simple.business.queuea";
    public static final String DEAD_LETTER_EXCHANGE = "dead.letter.demo.simple.deadletter.exchange";
    public static final String DEAD_LETTER_QUEUEA_ROUTING_KEY = "dead.letter.demo.simple.deadletter.queuea.routingkey";
    public static final String DEAD_LETTER_QUEUEA_NAME = "dead.letter.demo.simple.deadletter.queuea";

    //创建业务交换机
    @Bean("businessExchange")
    public FanoutExchange businessExchange(){
        return new FanoutExchange(BUSINESS_EXCHANGE_NAME);//扇出交换机 发布订阅
    }

    //创建死信交换机
    @Bean("deadExchange")
    public DirectExchange deadExchange(){
        return new DirectExchange(DEAD_LETTER_EXCHANGE);//直接相连的交换机 只有 routerKey相同才会通信
    }

    //创建业务队列A
    @Bean("businessQueueA")
    public Queue businessQueueA(){
        Map<String,Object> map=new HashMap<>();
        map.put("x-dead-letter-exchange",DEAD_LETTER_EXCHANGE);
        map.put("x-dead-letter-routing-key",DEAD_LETTER_QUEUEA_ROUTING_KEY);//表明死信交换机那个routerKey对应的队列 是我要发送没用消息的队列
        /*return QueueBuilder.durable(BUSINESS_QUEUEA_NAME).withArguments(map).build();*/
        return QueueBuilder.durable(BUSINESS_QUEUEA_NAME)
                .deadLetterExchange(DEAD_LETTER_EXCHANGE)
                .deadLetterRoutingKey(DEAD_LETTER_QUEUEA_ROUTING_KEY).build();
    }

    //创建死信队列A
    @Bean("deadQueueA")
    public Queue deadQueueA(){
        return QueueBuilder.durable(DEAD_LETTER_QUEUEA_NAME).build();
    }


    //绑定业务交换机和队列 发布订阅模式不需要routerkey
    @Bean
    public Binding businessBindingA(@Qualifier("businessExchange") FanoutExchange exchange,
                                    @Qualifier("businessQueueA") Queue queueA){
        return BindingBuilder.bind(queueA).to(exchange);
    }

    //绑定死信队列和它的交换机
    @Bean
    public Binding deadLetterBindingA(@Qualifier("deadExchange") DirectExchange exchange,
                                      @Qualifier("deadQueueA") Queue queueA){
        return BindingBuilder.bind(queueA).to(exchange).with(DEAD_LETTER_QUEUEA_ROUTING_KEY);
    }
}

业务队列A的消息接收类：

@Component
@Slf4j
public class BunsinessMessageReceive {

    @RabbitListener(queues = {RabbitMqConfig.BUSINESS_QUEUEA_NAME})
    public void ReceiveA(Message message, Channel channel) throws Exception{
        String msg=new String(message.getBody());
        log.info("接收到消息A： "+msg);
        boolean ack=true;//是否应答
        Exception exception=null;
        try {
            if (msg.contains("deadletter")){
                throw new IllegalArgumentException("dead letter exception");
            }
        }catch (Exception e){
            ack=false;//拒绝应答
            exception=e;
        }
        if(ack){
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }else {
            log.error("消息发生异常 ， error message : "+exception.getMessage());
            channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,false);//拒绝应答
        }
    }
}

业务队列A对应的死信队列A消息接收代码：

@Component
public class DeadLetterMessageReceive {

    //死信队列A消息的收到
    @RabbitListener(queues = {DEAD_LETTER_QUEUEA_NAME})
    public void receiveA(Message message, Channel channel) throws IOException {
        System.out.println("收到死信消息A：" + new String(message.getBody()));
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

消费者B：

@Configuration
public class RabbitMqConfig {
    public static final String BUSINESS_EXCHANGE_NAME = "dead.letter.demo.simple.business.exchange";
    public static final String BUSINESS_QUEUEB_NAME = "dead.letter.demo.simple.business.queueb";
    public static final String DEAD_LETTER_EXCHANGE = "dead.letter.demo.simple.deadletter.exchange";
    public static final String DEAD_LETTER_QUEUEB_ROUTING_KEY = "dead.letter.demo.simple.deadletter.queueb.routingkey";
    public static final String DEAD_LETTER_QUEUEB_NAME = "dead.letter.demo.simple.deadletter.queueb";

    //创建业务交换机
    @Bean("businessExchange")
    public FanoutExchange businessExchange(){
        return new FanoutExchange(BUSINESS_EXCHANGE_NAME);//扇出交换机 发布订阅
    }

    //创建死信交换机
    @Bean("deadExchange")
    public DirectExchange deadExchange(){
        return new DirectExchange(DEAD_LETTER_EXCHANGE);//直接相连的交换机 只有 routerKey相同才会通信
    }

    //创建业务队列B
    @Bean("businessQueueB")
    public Queue businessQueueB(){
        Map<String,Object> map=new HashMap<>();
        map.put("x-dead-letter-exchange",DEAD_LETTER_EXCHANGE);//绑定要发送死信到哪个交换机
        map.put("x-dead-letter-routing-key",DEAD_LETTER_QUEUEB_ROUTING_KEY);//表明死信交换机那个routerKey对应的队列 是我要发送没用消息的队列
        //两种方式绑定  本质上都是一样的
        /*return QueueBuilder.durable(BUSINESS_QUEUEB_NAME).withArguments(map).build();*/
        return QueueBuilder.durable(BUSINESS_QUEUEB_NAME)
                .deadLetterExchange(DEAD_LETTER_EXCHANGE)
                .deadLetterRoutingKey(DEAD_LETTER_QUEUEB_ROUTING_KEY).build();
    }

    //创建死信队列B
    @Bean("deadQueueB")
    public Queue deadQueueB(){
        return QueueBuilder.durable(DEAD_LETTER_QUEUEB_NAME).build();
    }

    //绑定业务交换机和队列
    @Bean
    public Binding businessBindingB(@Qualifier("businessExchange") FanoutExchange exchange,
                                    @Qualifier("businessQueueB") Queue queueB){
        return BindingBuilder.bind(queueB).to(exchange);
    }

    //绑定死信队列和它的交换机
    @Bean
    public Binding deadLetterBindingB(@Qualifier("deadExchange") DirectExchange exchange,
                                                                        @Qualifier("deadQueueB") Queue queueB){
        return BindingBuilder.bind(queueB).to(exchange).with(DEAD_LETTER_QUEUEB_ROUTING_KEY);
    }
}

业务队列B的消息接收类：

//接收消息
@Component
@Slf4j
public class BunsinessMessageReceive {

    @RabbitListener(queues = {RabbitMqConfig.BUSINESS_QUEUEB_NAME})
    public void ReceiveA(Message message, Channel channel) throws Exception{
        String msg=new String(message.getBody());
        log.info("接收到消息B： "+msg);
        boolean ack=true;//是否应答
        Exception exception=null;
        try {
            if (msg.contains("deadletter")){
                throw new IllegalArgumentException("dead letter exception");
            }
        }catch (Exception e){
            ack=false;//拒绝应答
            exception=e;
        }
        if(ack){
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }else {
            log.error("消息发生异常 ， error message : "+exception.getMessage());
            channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,false);//拒绝应答
        }
    }
}

业务队列A对应的死信队列A消息接收代码：


@Component
public class DeadLetterMessageReceive {

    //死信队列A消息的收到
    @RabbitListener(queues = {RabbitMqConfig.DEAD_LETTER_QUEUEB_NAME})
    public void receiveA(Message message, Channel channel) throws IOException {
        System.out.println("收到死信消息B：" + new String(message.getBody()));
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

访问接口：http://localhost:8080/rabbitmq/sendmsg?msg=msg在这里插入图片描述
在这里插入图片描述

再看这个：http://localhost:8080/rabbitmq/sendmsg?msg=deadletter
死信队列也同时处理成功了
在这里插入图片描述

高某某。。
关注
RabbitMQ基础
DOVISSSS的博客
09-08 1156
RabbitMQ基础
rabbitmq基础+springboot集成rabbitmq
10-14
**RabbitMQ基础** RabbitMQ是一个开源的消息代理和队列服务器，用于在分布式系统中进行消息传递。它是基于AMQP（Advanced Message Queuing Protocol）协议实现的，提供了高可用性、可扩展性和稳定性。RabbitMQ的...
Spring Boot 2.6.x整合Swagger启动失败报错问题解决（治标还治本）
Hello World
01-04 1万+
问题 Spring Boot 2.6.x版本引入依赖 springfox-boot-starter (Swagger 3.0) 后，启动容器会报错： Failed to start bean ‘ documentationPluginsBootstrapper ‘ ; nested exception…
Caused by: java.lang.IllegalStateException: Failed to introspect Class [springfox.documentation.swag
qq_62736318的博客
07-29 2214
注意：我这里service-gateway并没有使用swagger，而是使用工具类工程导入时带入如果想看gateway整合swagger，可跳过文章gateway和以下的包都冲突：所以如果导入了web的jar包，需要注释掉gateway使用的是webflux,和web会造成冲突。
SpringBoot - 集成SWAGGER的常见问题
记录并分享
07-02 925
SWAGGER2与SWAGGER3的区别以及在实际工作中遇到的问题，如何在HEADER中设置公共参数？如何根据部署环境PROFILES来开启/关闭SWAGGER。
java.lang.IllegalStateException: Failed to introspect Class报错原因和解决办法
热门推荐
北回归线的博客
02-14 8万+
java.lang.IllegalStateException: Failed to introspect Class报错原因和解决办法
Spring源码 @Import和@Configuration注解
oldshaui的博客
06-11 1056
接着上回的分析
rabbitmq基础入门
04-01
RabbitMQ基础入门主要涵盖了MQ的基本概念、使用MQ的原因、MQ的分类以及RabbitMQ的详细知识。MQ，即Message Queue，是一种基于FIFO（先进先出）原则的消息队列服务，用于不同进程间的通信，尤其在互联网架构中，它起...
RabbitMq 基础知识.docx
05-25
以下是对RabbitMQ基础知识的详细解释： 1. **消息持久化** - 消息持久化是确保即使RabbitMQ服务重启，消息也不会丢失的关键特性。这包括交换机(exchange)、队列(queue)和消息(message)的持久化。 - 在声明交换机...
RabbitMQ基础教程
04-19
### RabbitMQ基础教程知识点详解 #### 一、RabbitMQ简介 RabbitMQ是一种开源的消息代理和队列服务器，基于AMQP（Advanced Message Queuing Protocol）标准开发，它提供了多种编程语言的API接口，能够方便地与其他...
SpringBoot整合RabbitMQ基础学习Exchange源码
03-03
在本文中，我们将深入探讨如何在SpringBoot应用中整合RabbitMQ，并重点解析Exchange的相关源码。RabbitMQ是一款开源的消息代理和队列服务器，它使用AMQP（Advanced Message Queuing Protocol）协议，广泛应用于...
RabbitMQ基础.pptx
01-10
RabbitMQ是一款广泛使用的开源消息队列系统，基于Erlang语言开发，支持多种协议，如AMQP、XMPP、SMTP和STOMP等。由于其稳定性和丰富的功能，RabbitMQ在很多场景下被选作消息中间件。 **常见MQ产品比较** 除了...
rabbitmq基础介绍.pptx
03-03
RabbitMQ是一个开源的消息代理系统，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中实现可靠的消息传递。RabbitMQ的核心功能是作为消息中间件，它允许不同应用之间通过消息进行通信，...
十、RabbitMQ高级 - 死信交换机
莫等闲 白了少年头 空悲切
05-04 683
消息超时的两种方式是？给队列设置ttl属性，进入队列后超过ttl时间的消息变为死信给消息设置ttl属性，队列接收到消息超过ttl时间后变为死信如何实现发送一个消息20秒后消费者才收到消息？给消息的目标队列指定死信交换机将消费者监听的队列绑定到死信交换机发送消息时给消息设置超时时间为20秒。
RabbitMQ之死信(延迟)队列
m0_53151031的博客
02-27 1971
目录 一、死信（延迟）队列介绍 1、死信交换机概述： 2、死信案列讲解 二、死信交换机代码编写 1、编写死信交换机配置类 2、编写死信控制类 3、运行生产者，看测试结果 一、死信（延迟）队列介绍 1、死信交换机概述： 死信交换机(DLXs)就是普通的交换机，可以是任何一种类型，也可以用普通常用的方式进行声明。 对于任何一个队列，死信交换机可以通过在客户端使用队列参数进行声明，...
rabbitMQ死信.延迟队列
m0_60402568的博客
02-26 1467
死信队列(延迟队列) 死信，在官网中对应的单词为“Dead Letter”,它是 RabbitMQ 的一种消息机制。 般来说，生产者将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，如果它一直无法消费某条数据，那么可以把这条消息放入死信队列里面。等待 条件满足了再从死信队列中取出来再次消费，从而避免消息丢失。 死信消息来源： 消息 TTL 过期 队列满了，无法再次添加数据 消息被拒绝（reject 或 nack），并且
RabbitMQ延迟队列，死信队列(8)
最新发布
weixin_45751763的博客
04-24 671
首先，定义一个死信队列（DLX），用于接收延迟消息。然后，定义一个延迟队列，将消息发送到延迟队列中，并设置消息的 TTL，使消息在一定的延迟时间后成为死信，进入死信队列。
RabbitMQ高级特性-死信队列和延迟队列
Blueeyedboy521的博客
06-19 598
如下情况的消息会成为死信：如果该队列配置了dead-letter-exchange属性，指定了一个交换机，name队列中的死信就会投递到这个交换机中，而这个交换机称为死信交换机（Dead Letter Exchange，简称DLX）队列发现消费者无法处理消息时，比如失败次数太多，队列就会根据配置的死信交换机，路由到死信队列，在之前的消费失败处理策略中RepublishMessageRecoverer（重试耗尽后，将失败消息投递到指定的交换机），是由消费者来投递到error.queue。比如下对比： TTL（
RabbitMQ基础使用与实践教程
资源摘要信息: "RabbitMQ入门教程" RabbitMQ是一个开源的消息代理软件（亦称面向消息的中间件），它是基于高级消息队列协议（AMQP）的实现，最初由LShift公司开发，后来被Pivotal收购。RabbitMQ被广泛使用在各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值