RabbitMQ 12：与springboot集成+发送方确认+失败通知+手动应答

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

生产者：发送方确认，失败通知
消费者：手动应答

1.创建一个springboot-maven工程，pom.xml引入amqp与web

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.rabbitmq</groupId>
    <artifactId>fisher</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>fisher</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
2.配置application.properties

在这里插入图片描述

spring.application.name=springboot-rabbitmq
spring.rabbitmq.host=192.168.42.111
spring.rabbitmq.port=5672
spring.rabbitmq.username=fisher
spring.rabbitmq.password=123456
spring.rabbitmq.publisher-confirms=true
spring.rabbitmq.virtual-host=fisher
3.启动类

在这里插入图片描述

package com.rabbitmq.fisher;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class FisherApplication {

    public static void main(String[] args) {
        SpringApplication.run(FisherApplication.class, args);
        System.out.println("Hello World!!!");
    }
}
4.常量类Constant

在这里插入图片描述

package com.rabbitmq.fisher;

public class Constant {
    public final static String QUEUE_HELLO = "fisher.hello";
    public final static String QUEUE_USER = "fisher.user";

    public final static String TOPIC_EMAIL = "fisher.info.email";
    public final static String TOPIC_USER = "fisher.info.user";
    public final static String TOPIC_ERROR = "errorKey";

    public final static String FANOUT_A = "fisher.fanout.a";

    public final static String EXCHANGE_TOPIC = "fisher.topic.exchange";
    public final static String EXCHANGE_FANOUT = "fisher.fanout.exchange";
}
5.定义一个配置类RabbitConfig，在connectionFactory方法中设置开启发送发确认；在rabbitTemplate方法中设置失败通知，发送方确认方法，失败回调方法；在messageContainer方法中设置消费手动应答，绑定fisher.user队列，设置消费确认方法UserReceiver

在这里插入图片描述

package com.rabbitmq.fisher.config;

import com.rabbitmq.fisher.Constant;
import com.rabbitmq.fisher.hello.UserReceiver;
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.Autowired;
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 host;
    @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;
    @Value("${spring.rabbitmq.publisher-confirms}")
    private boolean publisherConfirms;

    @Autowired
    private UserReceiver userReceiver;
    //连接工厂
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(host + ":" + port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        //开启发送方确认
        connectionFactory.setPublisherConfirms(publisherConfirms);
        return connectionFactory;
    }

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

    //使用Template
    @Bean
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        //失败通知
        template.setMandatory(true);
        //发送方确认
        template.setConfirmCallback(confirmCallback());
        //失败回调
        template.setReturnCallback(returnCallback());
        return template;
    }

    //使用Rabbit缺省的交换器（direct交换器）
    //申明队列
    @Bean
    public Queue helloQueue(){
        return new Queue(Constant.QUEUE_HELLO);
    }

    @Bean
    public Queue userQueue() {
        return new Queue(Constant.QUEUE_USER);
    }

    //topic exchange
    @Bean
    public Queue queueEmailMessage() {
        return new Queue(Constant.TOPIC_EMAIL);
    }

    @Bean
    public Queue queueUserMessage() {
        return new Queue(Constant.TOPIC_USER);
    }

    //申明topic交换器
    @Bean
    public TopicExchange exchange() {
        return new TopicExchange(Constant.EXCHANGE_TOPIC);
    }

    //绑定
    @Bean
    public Binding bindingEmailMessage() {
        return BindingBuilder.bind(queueEmailMessage()).to(exchange()).with("fisher.*.email");
    }
    @Bean
    public Binding bindingUserMessage() {
        return BindingBuilder.bind(queueUserMessage()).to(exchange()).with("fisher.*.user");
    }

    //fanout exchange
    //申明队列
    @Bean
    public Queue AMessage() {
        return new Queue(Constant.FANOUT_A);
    }

    //申明fanout交换器
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(Constant.EXCHANGE_FANOUT);
    }

    //绑定
    @Bean
    public Binding bindingAMessage() {
        return BindingBuilder.bind(AMessage()).to(fanoutExchange());
    }

    //生产者发送确认
    @Bean
    public RabbitTemplate.ConfirmCallback confirmCallback(){
        return new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (ack) {
                    System.out.println("发送者确认发送给mq成功！");
                }else {
                    System.out.println("发送者确认发送给mq失败，考虑重新发送：" + cause);
                }
            }
        };
    }
    //失败通知回调
    @Bean
    public RabbitTemplate.ReturnCallback returnCallback(){
        return new RabbitTemplate.ReturnCallback(){
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routeKey) {
                System.out.println("无法路由的消息，需要另行处理。");
                System.out.println("Return replyText:" + replyText);
                System.out.println("Return exchange:" + exchange);
                System.out.println("Return routeKey:" + routeKey);
                String msg = new String(message.getBody());
                System.out.println("Return message:" + msg);
            }
        };
    }

    //消费者确认
    @Bean
    public SimpleMessageListenerContainer messageContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
        //绑定fisher.user队列
        container.setQueues(userQueue());
        //手动提交
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        //消费确认方法，设置监听
        container.setMessageListener(userReceiver);
        return container;
    }
}
6.创建direct交换器生产者DefaultSender，分别向自动应答队列fisher.hello与手动应答队列fisher.user发送消息

在这里插入图片描述

package com.rabbitmq.fisher.hello;

import com.rabbitmq.fisher.Constant;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class DefaultSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(String msg) {
        String sendMsg = msg + "======" + System.currentTimeMillis();
        System.out.println("SendMsg:" + sendMsg);
        //普通消息处理，自动ack
        rabbitTemplate.convertAndSend(Constant.QUEUE_HELLO, sendMsg);
        //消费者处理时，有手动应答
        rabbitTemplate.convertAndSend(Constant.QUEUE_USER, sendMsg);
    }

}
7.创建自动应答消费者HelloReceiver，添加@RabbitListener(queues = “fisher.hello”)监听队列fisher.hello

在这里插入图片描述

package com.rabbitmq.fisher.hello;

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

@Component
@RabbitListener(queues = "fisher.hello")
public class HelloReceiver {
    @RabbitHandler
    public void process(String hello) {
        System.out.println("HelloReceiver:" + hello);
    }
}
8.创建手动应答消费者UserReceiver，实现接口ChannelAwareMessageListener，重写onMessage方法；因为在RabbitConfig中，通过container.setMessageListener(userReceiver)设置了监听，所以此处不需要加@RabbitListener(queues = “fisher.user”)

在这里插入图片描述

package com.rabbitmq.fisher.hello;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;
/**
 * 在RabbitConfig中设置了监听，所以此处不需要加@RabbitListener(queues = "fisher.user")
 **/
@Component
public class UserReceiver implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        String msg = new String(message.getBody());
        System.out.println("UserReceiver>>>接收到的消息：" + msg);
        try {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
            System.out.println("UserReceiver>>>消息已消费");
        } catch (Exception e) {
            System.out.println(e.getMessage());
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
            System.out.println("UserReceiver>>>消息已拒绝，要求MQ重新发送");
        }
    }
}
9.创建fanout交换器生产者FanoutSender，路由键可以不填

在这里插入图片描述

package com.rabbitmq.fisher.fanout;

import com.rabbitmq.fisher.Constant;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class FanoutSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(String msg) {
        String sendMsg = msg + "==============" + System.currentTimeMillis();
        System.out.println("FanoutSender:" + sendMsg);
        rabbitTemplate.convertAndSend(Constant.EXCHANGE_FANOUT, "", sendMsg);
    }
}
10.创建fanout消费者FanoutReceiver，监听队列fisher.fanout.a

在这里插入图片描述

package com.rabbitmq.fisher.fanout;

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

@Component
@RabbitListener(queues = "fisher.fanout.a")
public class FanoutReceiver {
    @RabbitHandler
    public void process(String hello) {
        System.out.println("FanoutReceiver:" + hello);
    }
}
11.创建topic交换器生产者TopicSender，分别向队列fisher.info.email与队列fisher.info.user中发送消息，因为没有定义队列errorKey，所以rabbitTemplate.convertAndSend(Constant.EXCHANGE_TOPIC, Constant.TOPIC_ERROR, error)会因为无法路由，产生失败通知

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

package com.rabbitmq.fisher.topic;

import com.rabbitmq.fisher.Constant;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class TopicSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(){
        String email = "I am email msg############";
        System.out.println("TopicSender email:" + email);
        rabbitTemplate.convertAndSend(Constant.EXCHANGE_TOPIC, Constant.TOPIC_EMAIL, email);
        String user = "I am user msg############";
        System.out.println("TopicSender user:" + user);
        rabbitTemplate.convertAndSend(Constant.EXCHANGE_TOPIC, Constant.TOPIC_USER, user);
        String error = "I am error msg############";
        System.out.println("TopicSender error:" + error);
        rabbitTemplate.convertAndSend(Constant.EXCHANGE_TOPIC, Constant.TOPIC_ERROR, error);
    }
}
12.创建topic消费者TopicEmailMessageReceiver，监听队列fisher.info.email

在这里插入图片描述

package com.rabbitmq.fisher.topic;

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

@Component
@RabbitListener(queues = "fisher.info.email")
public class TopicEmailMessageReceiver {
    @RabbitHandler
    public void process(String email) {
        System.out.println("TopicEmailMessageReceiver:" + email);
    }
}
13.创建topic消费者TopicUserMessageReceiver，监听队列fisher.info.user

在这里插入图片描述

package com.rabbitmq.fisher.topic;

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

@Component
@RabbitListener(queues = "fisher.info.user")
public class TopicUserMessageReceiver {
    @RabbitHandler
    public void process(String user) {
        System.out.println("TopicUserMessageReceiver:" + user);
    }
}
14.创建一个测试类RabbitTest

在这里插入图片描述

package com.rabbitmq.fisher.controller;

import com.rabbitmq.fisher.fanout.FanoutSender;
import com.rabbitmq.fisher.hello.DefaultSender;
import com.rabbitmq.fisher.topic.TopicSender;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/rabbit")
public class RabbitTest {
    @Autowired
    private DefaultSender defaultSender;
    @Autowired
    private FanoutSender fanoutSender;
    @Autowired
    private TopicSender topicSender;

    //普通类型测试
    @RequestMapping("/hello")
    public void hello() {
        defaultSender.send("hellomsg!");
    }

    //fanout测试
    @RequestMapping("/fanout")
    public void fanout() {
        fanoutSender.send("hellomsg!");
    }

    //topic测试
    @RequestMapping("/topic")
    public void topic() {
        topicSender.send();
    }
}
15.启动项目，请求http://localhost:8080/rabbit/hello，查看打印

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

SendMsg:hellomsg!======1589467774678
HelloReceiver:hellomsg!======1589467774678
UserReceiver>>>接收到的消息：hellomsg!======1589467774678
UserReceiver>>>消息已消费
发送者确认发送给mq成功！
发送者确认发送给mq成功！
16.请求http://localhost:8080/rabbit/fanout，查看打印

在这里插入图片描述

FanoutSender:hellomsg!==============1589468091019
FanoutReceiver:hellomsg!==============1589468091019
发送者确认发送给mq成功！
17.请求http://localhost:8080/rabbit/topic，查看打印

在这里插入图片描述

TopicSender email:I am email msg############
TopicSender user:I am user msg############
TopicSender error:I am error msg############
TopicEmailMessageReceiver:I am email msg############
TopicUserMessageReceiver:I am user msg############
无法路由的消息，需要另行处理。
Return replyText:NO_ROUTE
Return exchange:fisher.topic.exchange
Return routeKey:errorKey
Return message:I am error msg############
发送者确认发送给mq成功！
发送者确认发送给mq成功！
发送者确认发送给mq成功！
Fisher3652
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot Rabbitmq 消息发送手动确认demo
10-30
SpringBoot Rabbitmq 消息发送手动确认demo,通过实现RabbitTemplate.ConfirmCallback 的confirm方法来手动确认
Seckill:基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统
03-11
基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统 开发工具 想法2017.2 开发环境 JDK 玛文 MySQL的 弹簧靴 Redis 兔子MQ 1.8 3.2.2 5.7 1.5.10发布 3.2 4倍 项目启动说明 1，启动前，请配置application....
浅谈对Rabbitmq失败通知和生产者确认的理解
majinan3456的博客
06-18 548
Rabbitmq的失败通知和生产者确认机制，对于初学者来说总是不那么好理解，咱们先看一下消息发布时候的权衡 从图中可以看出投递速度由快到慢，消息安全由低到高的权衡，我们可以看到失败通知和生产者确认在其中的位置，先总的了解下，接下来我们通过代码来理解下什么是失败通知，什么是生产者确认。 1.先创建配置类 import com.controller.MyAckReceiver; import org.springframework.amqp.core.*; import org.springf.
消息中间件之RabbitMQ专题三：spring boot 整合rabbitmq 消息发送，失败回调，发送确认
严老板的技术梦想博客
02-10 2546
文章目录一、引入spring boot -AMQP的依赖：二、配置连接,创建交换机，队列三、如何确保消息一定发送到Rabbitmq了？（一）失败回调（二）发送方确认模式四、完整案例 一、引入spring boot -AMQP的依赖： <dependency> <groupId>org.springframework.boot</...
Spring Boot整合RabbitMQ （手动应答模式）
weixin_44096325的博客
03-10 2857
手动应答模式 第1步，编写application.properties spring.rabbitmq.host = 127.0.0.1 spring.rabbitmq.port = 5672 spring.rabbitmq.password = test spring.rabbitmq.username = test spring.rabbitmq.virtual-host = /test ...
RabbitMQ 4：原生Java客户端+失败通知
Fisher3652的博客
05-04 305
mandatory设置为true，当消息不可路由时，交换器发送失败通知，此过程都发生在生产者端 1.创建生产者ProducerMandatory，发送消息时设置mandatory标志为true package com.rabbit.fisher.mandatory; import com.rabbitmq.client.*; import java.io.IOException; imp...
seckill:基于SpringBoot+Reds+RabbitMQ实现的分布式秒杀系统
04-14
seckill基于SpringBoot+Reds+RabbitMQ实现的分布式秒杀系统整体流程前端页面采用隐藏秒杀地址和使用随机秒杀地址来防止用户恶意刷接口，点击秒杀时会让用户输入数字计算验证码，输入正确后进入后端业务逻辑。...
springbootj集成canal+mysql+rabbitmq
10-11
mysql需开启binlog 查看是否开启binlog ...3.3 rabbitmq配置 在virtualHost：/ 下新增Exchanges： canal.exchange 新增队列：test.queue, 绑定canal.queue， RoutingKey：canal.routing.key canal下载及配置 ...
springboot-seckill:基于SpringBoot + MySQL + Redis + RabbitMQ + Guava开发的高并发商品限时秒杀系统
03-11
初步技术：SpringBoot + MyBatis + MySQL 中间件技术：德鲁伊+雷迪斯+ RabbitMQ +番石榴 秒杀优化方向 将请求阻止拦截在系统上游：传统秒杀系统之所以挂，请求都压倒了串行数据层，数据读写锁冲突严重，几乎所有请求...
基于SpringBoot+Mybatis+Redis+RabbitMQ的商品秒杀系统源码+数据库.zip
12-17
基于SpringBoot+Mybatis+Redis+RabbitMQ的商品秒杀系统源码+数据库.zip基于SpringBoot+Mybatis+Redis+RabbitMQ的商品秒杀系统源码+数据库.zip基于SpringBoot+Mybatis+Redis+RabbitMQ的商品秒杀系统源码+数据库.zip...
springboot+rabbitmq
03-21
通过controller类访问，写了queue模式，topic模式和广播模式的例子，可直接运行，有生产者和消费者，仅供学习之用。
SpringBoot整合RabbitMQ实现消息确认和失败消息重发
weixin_42654295的博客
10-11 3578
准备工作 安装在安装完rabbitMq后，输入http://ip:15672/ ，是可以看到一个简单后台管理界面的。 RabbitMq简介 常用的交换机有以下三种，因为消费者是从队列获取信息的，队列是绑定交换机的（一般），所以对应的消息推送/接收模式也会有以下几种： 1)Direct Exchange 直连型交换机，根据消息携带的路由键将消息投递给对应队列。 大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key 。然后当一个消息携带着路由值为X，这个消息通过生产者..
springboot中使用rabbitt
最新发布
u010480873的博客
05-21 324
在上述代码中，我们使用了MANUAL（手动确认）模式，并在消息处理成功后使用channel.basicAck()方法显式地确认消息。在RabbitMQ中，消息确认模式有两种：自动确认和手动确认。自动确认是指当消息被成功接收时，RabbitMQ会自动确认消息。手动确认是指当消费者成功处理消息后，显式地向RabbitMQ发送确认消息。希望这个示例能够帮助您了解如何在Spring Boot中使用RabbitMQ，并使用不同的交换机和队列类型以及消息确认模式。
spring boot + rabbit
a631258447的博客
01-29 310
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关心谁在生产消息，从而达到解耦的目的。在分布式的系统中，消息队列也会被用在很多其它的方面，比如：分布式事务的支持，RPC的调用等等。 RabbitMQ介绍 通常我们谈到
SpringBoot 集成 RabbitMQ
爱笑的boy的博客
03-04 9279
SpringBoot 集成 RabbitMQ
RabbitMQ——SpringBoot集成RabbitMQ
★★光亭★★
06-30 8358
RabbitMQ——SpringBoot集成RabbitMQ
springBoot集成rabbitMq
weixin_46237429的博客
05-23 1006
springBoot集成rabbitMq1.创建虚拟主机2.给用户授权虚拟机3.创建对列4.创建交换机5.交换机和对列绑定6.创建父工程rabbitmq-providerpom依赖application启动类无法启动rabbitmq-consumerpom依赖application启动类7.五种工作模式7.1简单模式 Hello Worldprovider生产者发生消息consumer消费者接受消息7.2工作队列模式 Work queuesprovider生产者发生消息consumer消费者接受消息01co
SpringBoot 集成 RabbitMQ（上）
sco5282的博客
09-26 1932
接下来使用 SpringBoot 来集成 RabbitMQ 1. 简单模式
spring boot集成Rabbit MQ
花非花雾非雾物语人生
03-23 604
1. pom.xml&lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-amqp&lt;/artifactId&gt; &lt;/dependency&gt;2. application.propertiesspring....
RabbitMQ详解：SpringBoot集成与应用实践
"SpringBoot 使用MQ，RabbitMQ介绍，应用场景，异步处理" 在IT行业中，消息队列（MQ）作为应用程序间...其强大的功能、丰富的社区支持和与SpringBoot的良好集成，都使得RabbitMQ成为现代企业级应用不可或缺的一部分。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值