RabbitMQ与SpringBoot整合(JavaBean方式)

最新推荐文章于 2023-08-21 10:59:28 发布
最新推荐文章于 2023-08-21 10:59:28 发布
阅读量737 收藏 1
点赞数
分类专栏： RabbitMQ 文章标签： spring boot rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57806252/article/details/122411730
版权

        本次的学习是基于Gradle 来进行项目管理的，话不多少，直接上干货

引入依赖

        只选择显示了所需要引入的包，版本自行选择

// 引入SpringBoot依赖
compile('org.springframework.boot:spring-boot-starter-web')
// 引入rabbitMQ的依赖
compile('org.springframework.boot:spring-boot-starter-amqp')
testImplementation(libraries.'spring-rabbit-test')

公共配置

package com.any.common;

/**
 * ExchangeEnum
 *
 * @author 15821
 * @date 21:13 2022/1/7
 */
public enum RabbitMQEnum {
    /** 发布/订阅模式 (Publish/Subscribe) **/
    FANOUT_EXCHANGE_NAME("fanout_order_exchange"),

    QUEUE_FANOUT_WECHAT("fanout.wechat.queue"),

    QUEUE_FANOUT_SMS("fanout.sms.queue"),

    QUEUE_FANOUT_EMAIL("fanout.email.queue"),

    /** 路由模式模式 （Routing） **/
    DIRECT_EXCHANGE_NAME("direct_order_exchange"),

    QUEUE_DIRECT_WECHAT("direct.wechat.queue"),

    QUEUE_DIRECT_SMS("direct.sms.queue"),

    QUEUE_DIRECT_EMAIL("direct.email.queue"),

    ROUTINGKEY_SMS("SMS"),

    ROUTINGKEY_EMAIL("Email"),

    ROUTINGKEY_WECHAT("WeChat"),

    /** 主题模式  (Topics) **/
    TOPICS_EXCHANGE_NAME("topics_order_exchange"),

    QUEUE_TOPICS_WECHAT("topics.wechat.queue"),

    QUEUE_TOPICS_SMS("topics.sms.queue"),

    QUEUE_TOPICS_EMAIL("topics.email.queue"),

    TOPICS_ROUTINGKEY_SMS("#.sms.#"),

    TOPICS_ROUTINGKEY_EMAIL("*.email.#"),

    TOPICS_ROUTINGKEY_WECHAT("#.wechat.*"),

    /** 路由模式模式 （Routing） **/
    DIRECT_TTL_EXCHANGE_NAME("direct_ttl_order_exchange"),
    QUEUE_TTL_DIRECT_SMS("direct.ttl.sms.queue"),
    QUEUE_TTL_MESSAGE_DIRECT_SMS("direct.ttl.message.sms.queue"),
    ROUTINGKEY_TTL_SMS("TTL_SMS"),
    ROUTINGKEY_TTL_MESSAGE_SMS("TTL_MESSAGE_SMS"),

    /** 死信队列 **/
    DIRECT_TTL_DEAD_EXCHANGE_NAME("direct_ttl_dead_order_exchange"),
    QUEUE_TTL_DEAD_DIRECT_SMS("direct.ttl.dead.sms.queue"),
    ROUTINGKEY_TTL_DEAD_SMS("ttl_dead_sms");

    private String desc;

    RabbitMQEnum(String desc) {
        this.desc = desc;
    }

    public String getDesc() {
        return desc;
    }
}

生产者

        RabbitMQ的连接配置

package com.any.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

/**
 * RabbitMQ 配置类
 *
 */
@Configuration
@Slf4j
public class RabbitMQConfig {

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

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

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

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

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory(host,port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setPublisherConfirms(true);
        return connectionFactory;
    }

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) // 此注解必须加
    public RabbitTemplate rabbitTemplate(){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory());
        return rabbitTemplate;
    }

}

        发布/订阅（Publish/Subscribe）模式

package com.any.config;

import com.any.common.RabbitMQEnum;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 发布订阅模式
 * Fanout
 *
 */
@Configuration
public class FanoutRabbitMQConfiguration {

    /**
     * 声明交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange(RabbitMQEnum.FANOUT_EXCHANGE_NAME.getDesc(),true,false);
    }

    /**
     * 声明队列 微信消息
     */
    @Bean
    public Queue fanoutWechatQueue(){
        return new Queue(RabbitMQEnum.QUEUE_FANOUT_WECHAT.getDesc(),true);
    }

    /**
     * 完成绑定关系(队列和交换机完成绑定关系) 微信消息
     */
    @Bean
    public Binding fanoutWechatBinding(){
        return BindingBuilder.bind(fanoutWechatQueue()).to(fanoutExchange());
    }

}

        路由（Routing）模式

package com.any.config;

import com.any.common.RabbitMQEnum;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Routing 模式
 * Direct
 */
@Configuration
public class DirectRabbitMQConfiguration {

    /**
     * 声明交换机
     */
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(RabbitMQEnum.DIRECT_EXCHANGE_NAME.getDesc(),true,false);
    }

    /**
     * 声明队列 微信消息
     */
    @Bean
    public Queue directWechatQueue(){
        return new Queue(RabbitMQEnum.QUEUE_DIRECT_WECHAT.getDesc(),true);
    }

    /**
     * 完成绑定关系(队列和交换机完成绑定关系) 微信消息
     */
    @Bean
    public Binding directWechatBinding(){
        return BindingBuilder.bind(directWechatQueue()).to(directExchange()).with(RabbitMQEnum.ROUTINGKEY_WECHAT.getDesc());
    }

}

        主题(Topics)模式

package com.any.config;

import com.any.common.RabbitMQEnum;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * TopicsRabbitMQConfiguration
 * 主题模式
 */
@Configuration
public class TopicsRabbitMQConfiguration {

    /**
     * 声明交换机
     */
    @Bean
    public TopicExchange topicsExchange(){
        return new TopicExchange(RabbitMQEnum.TOPICS_EXCHANGE_NAME.getDesc(),true,false);
    }

    /**
     * 声明队列 微信消息
     */
    @Bean
    public Queue topicsWechatQueue(){
        return new Queue(RabbitMQEnum.QUEUE_TOPICS_WECHAT.getDesc(),true);
    }
    /**
     * 声明队列 短信
     */
    @Bean
    public Queue topicsSmsQueue(){
        return new Queue(RabbitMQEnum.QUEUE_TOPICS_SMS.getDesc(),true);
    }

    /**
     * 声明队列 邮件
     */
    @Bean
    public Queue topicsEmailQueue(){
        return new Queue(RabbitMQEnum.QUEUE_TOPICS_EMAIL.getDesc(),true);
    }

    /**
     * 完成绑定关系(队列和交换机完成绑定关系) 微信消息
     */
    @Bean
    public Binding topicsWechatBinding(){
        return BindingBuilder.bind(topicsWechatQueue()).to(topicsExchange()).with(RabbitMQEnum.TOPICS_ROUTINGKEY_WECHAT.getDesc());
    }

    /**
     * 完成绑定关系(队列和交换机完成绑定关系)
     */
    @Bean
    public Binding topicsSmsBinding(){
        return BindingBuilder.bind(topicsSmsQueue()).to(topicsExchange()).with(RabbitMQEnum.TOPICS_ROUTINGKEY_SMS.getDesc());
    }
    /**
     * 完成绑定关系(队列和交换机完成绑定关系)
     */
    @Bean
    public Binding topicsEmailBinding(){
        return BindingBuilder.bind(topicsEmailQueue()).to(topicsExchange()).with(RabbitMQEnum.TOPICS_ROUTINGKEY_EMAIL.getDesc());
    }
}

        测试Service

package com.any.service.Impl;

import com.any.common.RabbitMQEnum;
import com.any.service.OrderService;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.UUID;

/**
 * OrderServiceImpl
 *
 * @author 15821
 * @date 19:21 2022/1/7
 */
@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private RabbitTemplate rabbitTemplate;


    @Override
    public void fanoutMakeOrder(String userId, String productId, int num) {
        // 1、根据商品Id 查询库存是否充足
        // 2、保存订单
        String orderId = UUID.randomUUID().toString();
        System.out.println("订单生成成功：" + orderId);
        // 3、通过MQ 来完成消息的分发
        // 参数1:交换机  参数2：路由key/queue队列名称 参数3：消息内容
        String routingKey = "";
        rabbitTemplate.convertAndSend(RabbitMQEnum.FANOUT_EXCHANGE_NAME.getDesc(), routingKey, orderId);
    }

    @Override
    public void diRectMakeOrder(String userId, String productId, int num) {
        // 1、根据商品Id 查询库存是否充足
        // 2、保存订单
        String orderId = UUID.randomUUID().toString();
        System.out.println("订单生成成功：" + orderId);
        // 3、通过MQ 来完成消息的分发
        // 参数1:交换机  参数2：路由key/queue队列名称 参数3：消息内容
        // 发送SMS
        rabbitTemplate.convertAndSend(
                RabbitMQEnum.DIRECT_EXCHANGE_NAME.getDesc(), RabbitMQEnum.ROUTINGKEY_SMS.getDesc(), orderId);

        // 发送Email
        rabbitTemplate.convertAndSend(
                RabbitMQEnum.DIRECT_EXCHANGE_NAME.getDesc(), RabbitMQEnum.ROUTINGKEY_EMAIL.getDesc(), orderId);
    }

    @Override
    public void topicsMakeOrder(String userId, String productId, int num) {
        // 1、根据商品Id 查询库存是否充足
        // 2、保存订单
        String orderId = UUID.randomUUID().toString();
        System.out.println("订单生成成功：" + orderId);

        String routingKey = "wechat.email.sms";
        // 3、通过MQ 来完成消息的分发
        // 参数1:交换机  参数2：路由key/queue队列名称 参数3：消息内容
        // 发送SMS

        //TOPICS_ROUTINGKEY_SMS("#.sms.#"),
        //
        //        TOPICS_ROUTINGKEY_EMAIL("*.email.#"),
        //
        //        TOPICS_ROUTINGKEY_WECHAT("#.wechat.*");
        rabbitTemplate.convertAndSend(RabbitMQEnum.TOPICS_EXCHANGE_NAME.getDesc(), routingKey, orderId);
    }

    @Override
    public void directTTLMakeOrder(String userId, String productId, int num) {
        // 1、根据商品Id 查询库存是否充足
        // 2、保存订单
        String orderId = UUID.randomUUID().toString();
        System.out.println("订单生成成功：" + orderId);
        // 3、通过MQ 来完成消息的分发
        // 参数1:交换机  参数2：路由key/queue队列名称 参数3：消息内容
        // 发送SMS
        System.out.println(RabbitMQEnum.ROUTINGKEY_TTL_SMS.getDesc());

        for (int i = 1; i < 11; i++) {
            rabbitTemplate.convertAndSend(RabbitMQEnum.DIRECT_TTL_EXCHANGE_NAME.getDesc()
                    , RabbitMQEnum.ROUTINGKEY_TTL_SMS.getDesc(), orderId+"-size:"+i);
        }

    }

    @Override
    public void directTTLMessageMakeOrder(String userId, String productId, int num) {
        // 1、根据商品Id 查询库存是否充足
        // 2、保存订单
        String orderId = UUID.randomUUID().toString();
        System.out.println("订单生成成功：" + orderId);
        // 3.给消息设置过期时间
        MessagePostProcessor postProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setExpiration("5000");
                message.getMessageProperties().setContentEncoding("UTF-8");
                return message;
            }
        };
        // 3、通过MQ 来完成消息的分发
        // 参数1:交换机  参数2：路由key/queue队列名称 参数3：消息内容
        // 发送SMS
        System.out.println(RabbitMQEnum.ROUTINGKEY_TTL_MESSAGE_SMS.getDesc());
        rabbitTemplate.convertAndSend(RabbitMQEnum.DIRECT_TTL_EXCHANGE_NAME.getDesc()
                , RabbitMQEnum.ROUTINGKEY_TTL_MESSAGE_SMS.getDesc(), orderId,postProcessor);
    }
}

消费者

        RabbitMQ的连接配置

package com.any.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

/**
 * RabbitMQ 配置类
 *
 */
@Configuration
@Slf4j
public class RabbitMQConfig {

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

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

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

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

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory(host,port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setPublisherConfirms(true);
        return connectionFactory;
    }

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) // 此注解必须加
    public RabbitTemplate rabbitTemplate(){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory());
        return rabbitTemplate;
    }

}

        消费者测试接收(其他同理)

package com.any.rabbitmq.fanout;

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

/**
 * EmailConsumer
 */
@RabbitListener(queues = {"fanout.email.queue"})
@Component
public class FanoutEmailConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("Email fanout---接收到的消息是：->"+message);
    }
}

倪家李子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springboot2.1以javabean整合rabbitmq及自动注入rabbitmqTemplate为空问题
DN金猿的博客
07-06 3486
springboot集成rabbitmq之前也写过，这次再来个总结，总体来讲比较简单 主要就是配置属性文件，将属性以javabean的形式注入，配置工厂，对象等原来以xml<bean>形式注入的对象。 代码如下properties属性 #rabbitMQ配置 rabbit.config.host=192.168.135.129 rabbit.config.port=5672 rabbit.config.userName=guest rabbit.config.password=guest
java rabbitmq 工具类_spring boot rabbitmq传递bean（实体类）/ JSON
weixin_28815535的博客
02-24 562
spring boot使用rabbitmq传递实体类：java对象必须序列化。实现序列化有2种方式：1)bean对象实现Serializable接口发送者和接收者bean对象都必须序列化2)借助SerializationUtils工具类org.apache.commonscommons-lang33.8发送者：SerializationUtils.serialize()接收者：Serializat...
SpringBoot中使用RabbitMQ传递对象
qq_47260186的博客
06-04 1513
SpringBoot中使用RabbitMQ传递对象
javaweb、spring、springmvc和springboot有什么区别，都是做什么用的？
最新发布
GitHub质检员
08-21 3308
那这时候有些靓仔就要问了，那你既然是HTML页面，那为啥不直接给浏览器运行呢？为啥还非要Java服务器，把解析好的HTML返回给浏览器显示呢？
SpringBoot 整合 MQ
qq_33753147的博客
10-29 3769
SpringBoot 整合 MQ
RabbitMQ整合到SpringBoot
小白的记录
01-25 1687
SpringBoot整合RabbitMQ 创建SpringBoot工程的时候选择Web依赖 导入mq依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency yml配置文件配置mq五大参数,除了hostip和端口,补上用户名密码和虚
SpringBoot 集成 RabbitMQ
Listening_Wind的博客
01-28 551
SpringBoot 集成 RabbitMQ 简介 RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）协议标准开发规范的一种消息投递服务，主要应用场景 异步处理、应用解耦、流量削峰。 RabbitMQ 名词 Broker : 它提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输,。 vhost : 虚拟主机,一个broker里可以有多个vhost，用作不同用户的权限分离。 Exchange ：消息交换器,它
RabbitMQ与SpringBoot整合.docx
06-19
RabbitMQ是消息中间件的一种,消息中间件即分布式系统中完成消息的发送和接收的基础软件.这些软件有很多,包括ActiveMQ(apache公司的),RocketMQ(阿里巴巴公司的,现已经转让给apache). 消息中间件的工作过程可以用生产...
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
RabbitMQ安装与springboot整合RabbitMQ
01-07
RabbitMQ安装 docker hub进入仓库拉镜像数据，链接：https://hub.docker.com 进入tag标签下，找到带有management的，这个是带有web管理界面的。 下载较慢可以是用加速。 docker pull registry.docker-...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
RabbitMQ传递对象
02-12
RabbitMQ传递对象
rabbitmq:SpringBoot整合RabbitMQ
05-17
SpringBoot整合消息队列RabbitMQ 简介 消息对列一般分JMS和AMQP两种 JMS是基于java API，对平台的支持力度较差 AMQP是一种跨平台、跨语言的网络线级协议 RabbitMQ为本工程的消息队列练习方式
springboot整合stream使用rabbitmq作为消息中间件
12-13
当我们谈论"SpringBoot整合stream使用rabbitmq作为消息中间件"时，我们涉及的关键技术点主要包括Spring Boot的Stream模块、RabbitMQ的使用以及它们如何协同工作来实现高效的微服务通信。 Spring Boot Stream模块是...
关于SpringBoot在项目中整合RabbitMQ中间件
weixin_61492871的博客
06-09 264
我们都知道，SpringBoot为我们提供了RabbitTemplate类，来帮助我们在Java代码中直接操作我们的RabbitMQ，但是，对于官方提供的原生RabbitTemplate我们需要为我们项目具体要求进行定制化调整（如果项目中不需要，这步骤可以忽略）这里我们需要知道，SpringBoot官方已经为我们准备好了关于RabbitMQ的启动器，都作为高级消息队列，存在于spring-boot-starter-amqp依赖中。步骤⑤ 核心业务中使用RabbitMQ。步骤① 导入RabbitMQ依赖。
RabbitMq消息监听，转换问题
g3230863的博客
11-30 5771
在发送消息的时候，我们可以通过代码看到RabbitMq默认的是使用SimpleMessageConverter来进行消息转换的   SimpleMessageConverter的源码如下图   源码分析总结： 1.MessageConverter可以把java对象转换成Message对象，也可以把Message对象转换成java对象 2.MessageListenerAdapter内部...
springboot整合rabbitmq,支持消息确认机制
otherCoco的博客
09-29 1万+
springboot整合rabbitmq,支持消息确认机制  安装 推荐一篇博客 https://blog.csdn.net/zhuzhezhuzhe1/article/details/80464291 项目结构 POM.XML &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven...
springboot集成rabbitMQ实现消息的推送
热门推荐
liyingying111111的专栏
07-19 1万+
RabbitMQ消息中间件组件，目前比较流行的消息中间件有:RabbitMQ、RocketMQ、ActiveMQ、Kafka等。 我的代码中用的是RabbitMQ，先介绍几个概念：       一：消息队列的特性如下： 异步性，将耗时的同步操作通过以发送消息的方式进行了异步化处理，减少了同步等待的时间。 松耦合，消息队列减少了服务之间的耦合性，不同的服务可以通过消息队列进行通信，而不用关心...
ActiveMQ处理Message（String -javabean）
weixin_30299709的博客
08-06 101
一、ActiveMq想要实现必备的六要素（基于jms） //链接工厂。用于创建链接 private ConnectionFactory factory; //用于访问Mq的链接，由链接工厂创建 private Connection connection; //消息队列的一次持久的有状态的会话，由链接...
rabbitmq整合springboot实战
08-18
在Spring Boot中整合RabbitMQ可以使用Spring AMQP库来简化操作。下面是一个简单的RabbitMQ和Spring Boot的实战示例： 1. 添加依赖：在`pom.xml`文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. 配置RabbitMQ连接信息：在`application.properties`文件中添加RabbitMQ的连接信息，例如： ```properties spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest ``` 3. 创建消息发送者和接收者： ```java // 消息发送者 @Component public class MessageSender { private final RabbitTemplate rabbitTemplate; public MessageSender(RabbitTemplate rabbitTemplate) { this.rabbitTemplate = rabbitTemplate; } public void sendMessage(String message) { rabbitTemplate.convertAndSend("my-exchange", "my-routing-key", message); } } // 消息接收者 @Component public class MessageReceiver { @RabbitListener(queues = "my-queue") public void receiveMessage(String message) { System.out.println("Received message: " + message); } } ``` 4. 创建一个启动类： ```java @SpringBootApplication public class RabbitMQApplication { public static void main(String[] args) { SpringApplication.run(RabbitMQApplication.class, args); } } ``` 通过以上步骤，你可以在Spring Boot应用中使用RabbitMQ进行消息的发送和接收。你可以

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

倪家李子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值