RabbitMq实战之（二）springboot整合RabbitMQ

最新推荐文章于 2024-03-14 14:39:14 发布
最新推荐文章于 2024-03-14 14:39:14 发布
阅读量238 收藏
点赞数
分类专栏： rabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42324034/article/details/108395079
版权

RabbitMQ

相关组件

生产者：用于发送消息
消费者：用于监听、接收、消费和处理消息
消息：可以看做是实际数据，在底层架构中是通过二进制的数据进行保存的
队列：指的是消息的暂存区和存储区，可以看做是一个中转站，消息经过这个中转站，便到了消费者手中。
交换机：同样也是消息的中转站，用于首次接收和分发消息，其中包括Fanout,Direct和Topic,Headers
路由：相当于秘钥，地址或者第三者，一般不单独使用，而是与交换机绑定在一起，将消息路由分支到指定队列
在这里插入图片描述

SpringBoot整合RabbitMQ

<!—RabbitMQ的起步依赖-->
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-amqp</artifactId>
 <version>1.3.3.RELEASE</version>
</dependency>

#RabbitMQ配置
spring.rabbitmq.virtual-host=/
#RabbitMQ服务器所在的Host，在这里连接本地即可
spring.rabbitmq.host=127.0.0.1
#5672为RabbitMQ提供服务时的端口号
spring.rabbitmq.port=5672
#guest和guest为连接到RabbitMQ服务器的用户名和密码
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
#这是自定义变量，表示本地开发环境
mq.env=local

自定义配置Bean相关组件

package com.learn.boot.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/** zlx
 *   RabbitMQ自定义注入配置Bean相关组件
 */
@Configuration
public class RabbitmqConfig {
    private static final Logger log= LoggerFactory.getLogger(RabbitmqConfig.class);

    //自动设置RabbitMQ的连接工厂实例
    @Autowired
    private CachingConnectionFactory connectionFactory;
    //自动设置消息监听器所在的容器工厂配置类实例
    @Autowired
    private SimpleRabbitListenerContainerFactoryConfigurer factoryConfigurer;


    /**
     * 下面为单一消费者实例的配置
     * @return
     */
    @Bean(name = "singleListenerContainer")
    public SimpleRabbitListenerContainerFactory listenerContainer(){
        //定义消息监听器所在的容器工厂
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        //设置容器工厂所用的实例
        factory.setConnectionFactory(connectionFactory);
        //设置消息在传输中的格式，在这里采用JSON的格式进行传输
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        //设置并发消费者实例的初始数量，在这里为1个
        factory.setConcurrentConsumers(1);
        //设置并发消费者实例的最大数量，在这里为1个
        factory.setMaxConcurrentConsumers(1);
        //设置并发消费者实例中每个实例拉取的消息数量，在这里为1个
        factory.setPrefetchCount(1);
        return factory;
    }

    /**
     *下面为多个消费者实例的配置，主要是针对高并发业务场景的配置
     * @return
     */
    @Bean(name = "multiListenerContainer")
    public SimpleRabbitListenerContainerFactory multiListenerContainer(){
        //定义消息监听器所在的容器工厂
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        //设置容器工厂所用的实例
        factoryConfigurer.configure(factory,connectionFactory);
        //设置消息在传输中的格式，在这里采用JSON的格式进行传输
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        //设置消息的确认消费模式，在这里为NONE，表示不需要确认消费
        factory.setAcknowledgeMode(AcknowledgeMode.NONE);
        //设置并发消费者实例的初始数量，在这里为10个
        factory.setConcurrentConsumers(10);
        //设置并发消费者实例的最大数量，在这里为15个
        factory.setMaxConcurrentConsumers(15);
        //设置并发消费者实例中每个实例拉取的消息数量，在这里为10个
        factory.setPrefetchCount(10);
        return factory;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(){
        //设置“发送消息后返回确认信息”
        connectionFactory.setPublisherReturns(true);
        //构造发送消息组件实例对象
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
          // 这里是为了消息确认和手动ACK
        rabbitTemplate.setMandatory(true);
        // 设置消息在传输中的格式，在这里采用JSON的格式进行传输
        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
        // 发送消息后，如果发送成功，则输出“消息发送成功”的反馈信息
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                log.info("消息发送成功:correlationData({}),ack({}), cause({})", correlationData,ack,cause);
            }
        });
        //发送消息后，如果发送失败，则输出“消息丢失”的反馈信息
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                log.info("消息丢失:exchange({}),route({}),replyCode ({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,
                message);
            }
        });
        //最终返回RabbitMQ的操作组件实例RabbitTemplate
        return rabbitTemplate;
    }
}

RabbitMQ发送消息和接收消息

在RabbitmqConfig 这个类添加交换机、队列、绑定key

    // 创建队列
    @Bean(name = "basicQueue")
    public Queue basicQueue() {
    /*
        // durable :是否持久化（宕机以后重新发布）
        // exclusive : 是否排外，当前队列只能被一个消费者消费
        // autoDelete 如果这个队列没有消费者，队列是否被删除
        // arguments 指定当前队列的其他信息
        */
        return new Queue("basicQueue",true,false,false,null);
    }

    @Bean
    public DirectExchange basicExchange(){
        // 跟创建队列一样
        return new DirectExchange("basicExchange",true,false);
    }

    @Bean
    public Binding basicBinding(DirectExchange directExchange,Queue queue) {
        // 绑定路由key
        return BindingBuilder.bind(queue).to(directExchange).with("basicExchange-basicQueue-key");

    }

package com.learn.boot.controller;

import com.learn.boot.resultVo.ResultVo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;


/**
 * author: zlx
 * date: 2020-1-1 17:17
 * desc:
 **/
@RestController
@RequestMapping("/rabbit")
public class RabbitMQController {
    //定义日志
    private static final Logger log= LoggerFactory.getLogger (RabbitMQController.class);
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RequestMapping("/rabbitTest")
    public ResultVo rabbitMQTest(@RequestParam String name) {
        rabbitTemplate.convertAndSend("basicExchange", "basicExchange-basicQueue-key", name);

        return ResultVo.success("生产者发送信息成功");
    }

    @RabbitListener(queues = "basicQueue",containerFactory = "singleListenerContainer")
    public void consumeMsg(Object msg){
        try {
            log.info("基本消息模型-消费者-监听消费消息：{} ",msg.toString());
        }catch (Exception e){
            log.error("基本消息模型-消费者-发生异常：",e.fillInStackTrace());
        }
    }
}

在这里插入图片描述

其他发送和接收消息方式实战

下面用一个实体对象进行传输

package com.learn.boot.model;

import lombok.Data;
import lombok.ToString;
import org.springframework.format.annotation.DateTimeFormat;

import java.io.Serializable;

@Data
@ToString
public class User implements Serializable {
    private int age;

    private String name;
}

    @RequestMapping("/rabbitTestObject")
    public ResultVo rabbitTestObject(@RequestBody User user) {
        // 该方法通过MessagePostProcessor实现类直接指定待发送消息的 类型，如上述代码中指定消息为Person类型。
//        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
        rabbitTemplate.convertAndSend("basicExchange", "basicExchange-basicQueue-key", user, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //获取消息的属性
                MessageProperties messageProperties = message.getMessageProperties();
                //设置消息的持久化模式
                messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                //设置消息的类型（在这里指定消息类型为Person类型）
                messageProperties.setHeader(AbstractJavaTypeMapper.DEFAULT_CONTENT_CLASSID_FIELD_NAME,User.class);
                //返回消息实例
                return message;
            }
        });
        log.info("生产者发送对象消息{}",user);
        return ResultVo.success("生产者发送信息成功");
    }


    @RabbitListener(queues = "basicQueue",containerFactory = "singleListenerContainer")
    public void consumeMsg(@Payload User user){
        try {
            log.info("基本消息模型-消费者-监听消费消息：{} ",user);
        }catch (Exception e){
            log.error("基本消息模型-消费者-发生异常：",e.fillInStackTrace());
        }
    }

在这里插入图片描述

zglx123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
RabbitMQ 学习笔记 -- 08 RabbitTemplate 及消息序列化
yorsola的博客
08-06 4258
生产者发送消息时可以为消息指定一些参数 Delivery mode: 是否持久化，1 - Non-persistent，2 - Persistent Headers：头文件可以有任何名称。这里只能设置长字符串头。 Properties: 设置消息属性(传递模式和头信息是最常见的情况)。无效的属性将被忽略. Valid properties are: content_type ： 消息内容的类型 content_encoding： 消息内容的编码格式 priority： 消息的
SpringBoot Rabbit 多IP多 virtual host 配置
u011447403的专栏
11-11 4024
本文记录了在一个 RabbitMQ 中添加多个 virtual host（又叫vhost）时与 SpringBoot 相关的配置文件、RabbitTemplate 和 RabbitListener 的配置方法。
工具篇--4.1RabbitMq--常用配置参数详解
拽着尾巴的鱼儿的博客
06-14 8502
控制使用一个 RabbitMQ 连接创建的 channel 数量，即 RabbitMQ 连接池中缓存连接时每个连接中的 channel 的数量，缓存的目的是减少连接和销毁的开销。sring.rabbitmq.cache.channel.checkout-timeout 是 Spring Boot 集成 RabbitMQ 客户端连接工厂（ConnectionFactory）的一个属性，用于设置缓存的通道（channel）请求超时时间。如果系统的性能要求比较高，可以考虑关闭重试功能，或者调整重试参数的值。
消息中间件RabbitMQ实战解析
Mr.J
08-04 849
注：文章皆为个人纪录，可用性请以最终结果为准，若有错还请大佬们指出，谢谢！ 发送消息与消费消息流程辅助理解 你现在要去约妹，见面前会进行如下对话： 你（消息提供者）：我会给你一个惊喜，你找到我我就告诉你，接下来我告诉你我所在的位置：这块地方有很多十字路口，你先找到名叫“交换机”的十字路口，再去找到与”交换机“十字路口相连的名叫"队列"的那条套路，路上有很多人，我拿着一朵叫”RoutingKey“的 fa ，找到我后我就告诉你一个名叫”message“的惊喜 ...
工作随笔——rabbitmq消息的序列化与反序列化（springboot）
TIANQIcode
10-21 2723
一、需求 发送时需要将对象序列化为json字符串，接收时反序列化为对象。 二、方案 1、序列化 在任意配置类下提供RabbitTemplate的bean，覆盖Springboot的自动化配置。将消息转译器设置为springboot提供的Jackson转译器。 // 提供自定义RabbitTemplate,将对象序列化为json串 @Bean public RabbitTemplate jacksonRabbitTemplate(ConnectionFactory connectionFact
SpringBoot整合Rabbitmq发送接收消息实战
09-15
SpringBoot整合Rabbitmq发送接收消息实战 另外，博主发起了SpringBoot整合Rabbitmq这一系列的gitchat交流会。刚兴趣的童鞋可以进入交流：https://gitbook.cn/gitchat/activity/5b90f9214fb1bd5c9acd4338 交流QQ：...
Spring Boot整合RabbitMQ开发实战详解
08-28
Spring Boot 整合 RabbitMQ 开发实战详解 首先，需要了解 RabbitMQ 中的一些基本概念，包括交换器（Exchange）、队列（Queue）和绑定（Binding）。交换器就像路由器，把消息发到交换器，然后交换器再根据路由键...
MQ消息中间件之RabbitMQ以及整合SpringBoot2.x实战教程
01-18
整合RabbitMQ可以方便地在SpringBoot项目中使用消息队列。以下是一些核心概念： 1. **配置**: 首先，需要在`application.properties`或`application.yml`中配置RabbitMQ服务器的相关信息，如主机地址、端口、虚拟...
springboot与rabbitmq结合的实战、实例项目
04-15
3. **Spring Boot整合RabbitMQ** - **配置**: 在Spring Boot项目中，可以通过添加`spring-boot-starter-amqp`依赖来引入RabbitMQ支持。接着，在`application.properties`或`application.yml`中配置RabbitMQ服务器的...
Rabbitmq spring boot的配置参数
qq_20004115的博客
01-29 973
spring.rabbitmq.addresses= # 以逗号分隔的客户端应连接的地址列表 spring.rabbitmq.cache.channel.checkout-timeout= # 如果已达到缓存大小，则等待获取通道的持续时间 spring.rabbitmq.cache.channel.size= # 要在缓存中保留的通道数 spring.rabbitmq.cache.connection.mode=channel # 连接工厂缓存模式 spring.rabbitmq.cache.connec.
SpringBoot整合RabbitMQ重试机制及配置
m0_67402823的博客
03-28 3197
RabbitMQ自动补偿机制触发:(多用于调用第三方接口) 1.当我们的消费者在处理我们的消息的时候,程序抛出异常情况下(默认无限次数重试) 2.应该对我们的消息重试设置间隔重试时间,比如消费失败最多只能重试5次,间隔3秒(防止重复消费,幂等问题) 如果重试5次,也就是15秒内重试还是失败情况下应该如何处理 1.默认情况下,重试多次还是失败的话,会自动删除该消息(消息可能会丢失) 解决思路: A:如果重试多次还是失败的情况下,最终存放到死信队列. B:采用表日志记录,消费失败错误的日志记录 后期人工自动对消
springboot集成rabbitmq-环境搭建
luoshisiji的专栏
12-09 191
springboot集成rabbitmq环境搭建
消息队列 - Springboot2.0 + RabbitMQ3.8.5搭建、配置、集成与使用
瑶山的博客
07-18 1497
版本：Springboot2.0 + RabbitMQ3.5.8 快速搭建 最近项目可能要用到rabbitMq,就写个demo测试下，以前也没做过，所以rabbitmq-demo安装测试用的是最新包，创建虚拟主机，直连交换机Direct Exchange和主题交换机Topic Exchange两种代码实现，发布者和消费者消息确认等， --博客持续更新，宗旨CV即用
spring boot + rabbitmq 传递列表消息
qq_41939901的博客
11-01 411
rabbitmq传递列表、对象消息。自定义converter
（踩坑篇）rabbitmq不同模块序列化和反序列化
最新发布
zy11517的博客
03-14 1483
列化（Serialization）和反序列化（Deserialization）是将对象转换为字节流或将字节流转换为对象的过程。序列化是指将对象转换为字节流的过程。在序列化时，对象的状态信息（例如属性值、字段值等）被转换为一串字节，以便能够在网络上传输或者保存到磁盘上。序列化可以将对象持久化，并且使其能够在不同的环境中进行传输和恢复。序列化通常用于分布式系统、缓存、消息队列等场景。反序列化是指将字节流恢复为对象的过程。在反序列化时，字节流被解析并还原为对应的对象，使其可以在内存中重新使用。
RabbitMQ：@RabbitListener 与 @RabbitHandler 及 消息序列化
热门推荐
weixin_43343423的博客
12-04 3万+
添加 @RabbitListener 注解来指定某方法作为消息消费的方法，例如监听某 Queue 里面的消息 MessageConvert 涉及网络传输的应用序列化不可避免，发送端以某种规则将消息转成 byte 数组进行发送，接收端则以约定的规则进行 byte[] 数组的解析 RabbitMQ 的序列化是指 Message 的 body 属性，即我们真正需要传输的内容，RabbitMQ 抽象出一个...
handler机制
jackzhouyu的专栏
10-12 647
handler机制：概念 handler机制是一种异步通信机制，通常用于子线程中数据更新后，通知主线程UI更新。 handler运行框架图 从上面handler的运行框架图来看，为了完成handler整个流程，你必须按事先创建好四个东西： handler、Message、MessageQueue和Looper,也许Looper从上图来看并不是必须的，因为遍历MessageQueue只是调用了一个静
RabbitMQ消息队列的高可靠使用
博学de叫兽
12-29 964
整体解决方案   TopicExchange型交换机，会根据RouteKey将消息路由至匹配队列（推模式下，消息将被推送至消费者的监听函数处理），消息流转和路由的示意图如下。 生产端可靠性保障   为防止消息在未发送到Broker前就由于网络原因或其他情况导致丢失，生产者端需要保障消息成功送达中间件，手段一般有两种，一是使用事务机制，但这种做法是非异步的，吞吐量性能较差；另一种是确认机制，本例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值