SpringBoot集成RabiitMQ 安装 简单入门5种案例

最新推荐文章于 2022-11-22 16:20:39 发布
最新推荐文章于 2022-11-22 16:20:39 发布
阅读量191 收藏
点赞数 1
分类专栏： RabbitMQ 文章标签： rabbitmq java 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MYYRR/article/details/106926538
版权

RabbitMQ 最简单入门

1. 搭建

1.1 下载rabbitMq

RabbitMQ官网下载址：http://www.rabbitmq.com/install-windows.html
Erlang官网下载地址：http://www.erlang.org/downloads

直接官网下载、安装
RabbitMQ用Erlang编程语言开发的，需要安装Erlang语言开发包

1.2 环境变量

在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在命令窗口中切换到此次MQ的安装目录下的sbin，运行命令：rabbitmq-plugins enable rabbitmq_management，这样就可以添加可视化插件了。
在这里插入图片描述
在这里插入图片描述
启动rabbitmq，浏览器输入 http://127.0.0.1:15672/ 就可以访问了

1.3 添加用户

超级管理员(administrator)
　 可登陆管理控制台(启用management plugin的情况下)，可查看所有的信息，并且可以对用户，策略(policy)进行操作。
监控者(monitoring)
　　可登陆管理控制台(启用management plugin的情况下)，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)
策略制定者(policymaker)
　　可登陆管理控制台(启用management plugin的情况下), 同时可以对policy进行管理。
普通管理者(management)
　　仅可登陆管理控制台(启用management plugin的情况下)，无法看到节点信息，也无法对策略进行管理。
无角色
　　无法登陆管理控制台，通常就是普通的生产者和消费者。
在这里插入图片描述
新建一个virtual host
在这里插入图片描述
点击name 下 .*

在这里插入图片描述
给用户添加操作权限
在这里插入图片描述
检查 用户 virtual-host相互绑定
在这里插入图片描述
virtual-host 虚拟机就检查有没有绑定账号
在这里插入图片描述

2. 简单5种模式demo

.properties 文件

spring.application.name=spirng-boot-rabbitmq
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin

.pom 文件

<?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>

	<groupId>com</groupId>
	<artifactId>demo_1</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.4.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<name>demo_1</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<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-test</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.1 简单队列

confing

package com.demo.easy;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class RabbitConfigEasy {

    @Bean
    public Queue queue(){
        return new Queue("q_hello",true);
    }
}

生产者

package com.demo.easy;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;


@Component
public class RabbitSendEasy {

    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send(){
        String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("Sender Time: " + date);
        this.rabbitTemplate.convertAndSend("rabbitEasy",date);
    }
}

消费者 使用注解声明队列

package com.demo.easy;

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


@Component
@RabbitListener(queuesToDeclare = @Queue("rabbitEasy"))
public class RabbitRecevier {

    @RabbitHandler
    public void process(String data){
        System.out.println("Recevier1  消费消息 :"+data);
    }
}

测试

package com.demo.easy;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;


@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitTestEasy {

    @Autowired
    private RabbitSendEasy rabbitSendEasy;

    @Test
    public void sendEasy(){
        rabbitSendEasy.send();
    }
}

2.2 Work模式

confing

生产者 增加方法

package com.demo.easy;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

@Component
public class RabbitSendEasy {

    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send(){
        String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("Sender Time: " + date);
        this.rabbitTemplate.convertAndSend("q_hello",date);
    }
    public void send(int i){
        String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("index:"+i+" Sender Time: " + date);
        this.rabbitTemplate.convertAndSend("q_hello",String.valueOf(i));
    }
}

新建一个消费者

package com.demo.easy;

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


@Component
@RabbitListener(queues = "q_hello")
public class RabbitRecevierEasy2 {

    @RabbitHandler
    public void process(String data){
        System.out.println("Recevier2  消费消息  第:" + data + "条");
    }
}

测试

package com.demo.easy;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;



@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitTestEasy {

    @Autowired
    private RabbitSendEasy rabbitSendEasy;

    @Test
    public void sendEasy(){
        rabbitSendEasy.send();
    }
    @Test
    public void sendWork(){
        for (int i = 0; i < 100; i++) {
            rabbitSendEasy.send(i);
        }
    }
}

在这里插入图片描述

2.3 发布/订阅者模式

confing

package com.demo.Publish;


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;

@Configuration
public class RabbitConfigPublish {

    @Bean
    public Queue aMessage() {
        return new Queue("rabbit_publish_a");
    }

    @Bean
    public Queue bMessage() {
        return new Queue("rabbit_publish_b");
    }

    @Bean
    public Queue cMessage() {
        return new Queue("rabbit_publish_c");
    }

    @Bean
    FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanoutExchangePublish");
    }

    @Bean
    Binding bindingExchangeA(Queue aMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(aMessage).to(fanoutExchange);
    }

    @Bean
    Binding bindingExchangeB(Queue bMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(bMessage).to(fanoutExchange);
    }

    @Bean
    Binding bindingExchangeC(Queue cMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(cMessage).to(fanoutExchange);
    }
}

生产者

package com.demo.Publish;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RabbitSendPublish {

    @Autowired
    private AmqpTemplate amqpTemplate;

    public void send(Integer i){

        System.out.println("发布 Sender : " + i);
        amqpTemplate.convertAndSend("fanoutExchangePublish","",i);
    }
}

建立三个消费者   
	修改监听队列名称 @RabbitListener(queues = "rabbit_publish_a") 
	修改控制台日志方面观看 System.out.println("A:订阅 消息:"+i);
	其余代码相同

消费者

package com.demo.Publish;

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

@Component
@RabbitListener(queues = "rabbit_publish_a")
public class RabbitRecevier1Publish {

    @RabbitHandler
    public void recevier(Integer i){
        System.out.println("A:订阅 消息:"+i);
    }
}

测试

package com.demo.Publish;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RabblitTestPublish {

    @Autowired
    private RabbitSendPublish rabbitSendPublish;

    @Test
    public void send1(){
        rabbitSendPublish.send(15672);
    }
}

在这里插入图片描述

2.4 路由模式

confing

package com.demo.routing;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabiitConfigRouting {

    @Bean
    TopicExchange topicExchange() {
        return new TopicExchange("routingTopicExchange");
    }

    @Bean
    public Queue messageA(){
        return new Queue("rabbit_routing_a");
    }

    @Bean
    public Queue messageB(){
        return new Queue("rabbit_routing_b");
    }

    @Bean
    public Queue messageC(){
        return new Queue("rabbit_routing_c");
    }

    @Bean
    Binding bindingExchangeMessageA(Queue messageA, TopicExchange topicExchange) {
        return BindingBuilder.bind(messageA).to(topicExchange).with("rabbitRouting.A");
    }

    @Bean
    Binding bindingExchangeMessageB(Queue messageB, TopicExchange topicExchange) {
        return BindingBuilder.bind(messageB).to(topicExchange).with("rabbitRouting.A");
    }

    @Bean
    Binding bindingExchangeMessageC(Queue messageC, TopicExchange topicExchange) {
        return BindingBuilder.bind(messageC).to(topicExchange).with("rabbitRouting.C");
    }

}

生产者

package com.demo.routing;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RabbitSendRouting {

    @Autowired
    private AmqpTemplate amqpTemplate;

    public void send(Integer i){
        System.out.println("Send   key : rabbitRoutingA  i;"+i);
        amqpTemplate.convertAndSend("routingTopicExchange","rabbitRouting.A",i);
    }

    public void send2(Integer i){
        System.out.println("Send   key : rabbitRoutingB  i;"+i);
        amqpTemplate.convertAndSend("routingTopicExchange","rabbitRouting.B",i);
    }

    public void send3(Integer i){
        System.out.println("Send   key : rabbitRoutingC  i;"+i);
        amqpTemplate.convertAndSend("routingTopicExchange","rabbitRouting.C",i);
    }
}

创建三个消费者
修改 @RabbitListener(queues = “rabbit_routing_a”)
@RabbitListener(queues = “rabbit_routing_b”)
@RabbitListener(queues = “rabbit_routing_c”)
修改 System.out.println(“Recevier1/2/3 消费消息 i:”+i);

package com.demo.routing;

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

@Component
@RabbitListener(queues = "rabbit_routing_a")
public class RabbitRecevier1Routing {

    @RabbitHandler
    public void recevier(Integer i){
        System.out.println("Recevier1  消费消息   i:"+i);
    }
}

测试

package com.demo.routing;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitTestRouting {

    @Autowired
    private RabbitSendRouting rabbitSendRouting;

    @Test
    public void send1(){
        rabbitSendRouting.send(15672);
    }

    @Test
    public void send2(){
        rabbitSendRouting.send2(15672);
    }

    @Test
    public void send3(){
        rabbitSendRouting.send3(15672);
    }
}

test 1
在这里插入图片描述
test3
在这里插入图片描述

2.5 通配符模式

confing

package com.demo.routing;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabiitConfigRouting {

    @Bean
    TopicExchange topicExchange() {
        return new TopicExchange("routingTopicExchange");
    }

    @Bean
    public Queue messageA(){
        return new Queue("rabbit_routing_a");
    }

    @Bean
    public Queue messageB(){
        return new Queue("rabbit_routing_b");
    }

    @Bean
    public Queue messageC(){
        return new Queue("rabbit_routing_c");
    }

    @Bean
    Binding bindingExchangeMessageA(Queue messageA, TopicExchange topicExchange) {
        return BindingBuilder.bind(messageA).to(topicExchange).with("rabbitRouting.*");
    }

    @Bean
    Binding bindingExchangeMessageB(Queue messageB, TopicExchange topicExchange) {
        return BindingBuilder.bind(messageB).to(topicExchange).with("rabbitRouting.#");
    }

    @Bean
    Binding bindingExchangeMessageC(Queue messageC, TopicExchange topicExchange) {
        return BindingBuilder.bind(messageC).to(topicExchange).with("rabbitRouting.C");
    }

}

修改路由模式 Configuration
test1
在这里插入图片描述
test2
在这里插入图片描述
test3
在这里插入图片描述
#：匹配一个或多个单词 每个词以.分隔
*：只能匹配一个词

2.6 总结

简单模式： 1对1
work模式： 1对多 每一个消息必须只能一个消费者消费
发布订阅： 生产者绑定交换机 交换机将消息发到队列 多个消费者的消息是一样的
路由模式： 生产者发送消息(带routingkey)到交换机交换机根据routingkey发送到相应队列
通配符模式：routingkey 增加通配符 #/*
在这里插入图片描述

常见问题

Execution of Rabbit message listener failed.

去RabbitMQ客户端上的队列消息先删除，那些队列消息还是原先的错误的消息。

Caused by: java.io.EOFException: null

at java.io.DataInputStream.readUnsignedByte
检查端口号/http端口号

java.net.SocketException: Socket Closed oSounhMonMethod

用户角色缺少权限 查看角色是否有足够权限。

rabbitmq SocketException: Socket Closed

确认用户是否有权限 不要用guest用户

.. . . ..
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot进阶(68)：如何用SpringBoot轻松实现定时任务？集成Quartz来帮你！(附源码)
**My Coding Family**
09-05 2270
Quartz是一个非常流行的开源调度框架，它提供了许多强大的功能，如定时任务调度、作业管理、任务持久化等。而SpringBoot是目前Java开发中非常流行的框架之一，其对各种开源框架集成非常方便。本篇文章将介绍如何在SpringBoot中集成Quartz，以便于更好的管理和调度定时任务。
rabbitmq一些实例应用
weixin_39039786的博客
01-15 636
rabbitmq特点 * 异步处理 * 应用解耦：只关心消息，不关心参数 * 流量控制（削锋）：把流量请求放到队列，实现流量控制 消息队列主要的两种形式目的地 * 队列（queue）：点对点（point to point）信息通信 * 点对点式： * 消息发送者发送消息，消息代理将其放入一个队列中，消息接收者从队列中获取消息内容，消息读取后被移出队列 * 消息只有唯一的发送者和接收者，但并不是说只有一个接收者 * 主题（topic）：发布（public）/订阅（subcribe）消息通信 *
rabbitmq完整例子
08-13
rabbitmq完整例子，包含客户端、服务端例子。里面集中了各种案例详解
rabbitMQ开发案例
12-17
RabbitMQ消息中间件
【详细步骤】Springboot整合RabiitMQ
咖啡程序员
12-10 2200
文章目录前言一、首先我们需要引入RabiitMQ的依赖二、然后进行配置1.在application.yml配置文件中进行RabbitMQ的配置2.创建配置类3.封装发送消息和接收消息的类三、测试1.随便在一个Contoller类中写一个测试方法2.启动项目 进行测试 前言 提示：Springboot整合RabiitMQ： 前面我们安装好了RabiitMQ并成功启动后，接下来我们就来学习如何将RabiitMQ整合到Springboot上，并且进行实战使用。springboot的项目创建这里就不进行说明了。
springboot整合rabbitmq（一）
qq_36090537的博客
11-22 805
RabbitMQ简单来说就是一个消息队列中间件,用来保存消息和传递消息的一个容器。在此过程中充当一个中间人的作用。 是一种程序对程序的通信方法，其服务器也是以高性能、健壮以及可伸缩性出名的Erlang语言编写而成。
RabbitMQ 基本api使用 以及和spring、springboot整合
qqxhb 资源共享
06-02 1871
1 RabbitMQ介绍 1.1 RabbitMQ简介及使用场景 MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP（Advanced MessageQueue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。RabbitMQ官网 消息队列应用场景： 任务异步处理。 将不需要同...
RabbitMQ入门6：Spring Boot整合RabbitMQ；（入门级演示）
小枯林的博客
05-11 626
说明： （1） 一：创建两个Spring Boot项目，分别充当Producer和Consumer； 关于Spring Boot项目的创建，可以参考【Spring Boot入门三：创建Spring Boot项目；（包括【Spring 官网start.spring.io】方式，【IDEA集成的Spring Initializr】方式）】或者【Spring Boot电商项目8：数据库设计与项目初始化三：创建Spring Boot项目；】； 1.创建【spring-boot-rabbitmq-pro
springboot从入门到精通
08-08
本资源包"springboot从入门到精通"旨在帮助初学者和进阶者全面掌握SpringBoot的核心概念和技术。 一、SpringBoot基础 SpringBoot的基础部分涵盖了如何创建第一个SpringBoot项目，通过起步依赖（Starters）简化Maven...
springboot-learn：:rose:springboot通用框架集成示例，涉及多种网站监控，数据缓存，网络通信，持久层，权限管理，常用工具等
02-05
弹簧靴 支持作者就star一下，谢谢 :party_popper: :party_popper: springboot-learn这个工程为IDEA创建的Empty Project工程...SpringBoot入门案例Hello World SpringBoot配置Thymeleaf模板引擎 SpringBoot构造异常异常
springboot+rabbitmq搭建实现mqtt协议订阅发布
qq_36090537的博客
11-18 2437
springboot+rabbitmq搭建实现mqtt协议订阅发布
springboot 如何优雅的使用 alibaba rocketmq 消息队列
Long-Tai
12-12 5580
文章保证，一路执行下去不会报错，报错你找我。如果觉得有用，希望屏幕前的大佬，点赞➕关注 只有想到的方面多时，才能在够实际运用中发现更多的问题，这也是作者给读者最好的礼物 使用这篇文章 docker 安装 rocketmq，肯定没问题 新建 springboot 项目 新建一个 springboot 项目，pom 文件如下，rocketmq 使用 apache 封装的 jar <?xml version="1.0" encoding="UTF-8"?> <project xmlns..
Springboot集成RabbitMQ一个完整案例
星空
11-26 1142
springboot 集成 RabbitMQ 非常简单，如果只是简单的使用配置非常少，springboot 提供了 spring-boot-starter-amqp 对消息各种支持。 1、配置pom文件，主要是添加spring-boot-starter-amqp的支持 <dependency> <groupId>org.springframework.boot<...
JMS、AMQP实例讲解
Stay Hungry, Stay Foolish
03-14 338
  使用Git从GitHub上将samples代码拷贝到本机，然后导入到IDE中 git clone git://github.com/stephansun/samples.git samples包含7个模块，分别为 samples-jms-plain：使用JMS原生API; samples-jms-spring：使用Spring对JMS原生API封装后的spring-...
RabbitMQ使用例子
热门推荐
博客
07-12 1万+
一些概念： RabbiMQ的认知：首先要抛弃熟悉的客户端和服务器的观念。对于RabbitMQ应该认为是消息投递服务。、                               其次：从应用程序角度来看RabbitMQ的话，应用程序要先决定是个消息的发送者还是消息的接受者。                                         如果从RabbitMQ的角度来看的话...
RabbitMQ案例
涛
04-19 3731
1.Windows环境安装RabbitMQ Server：一：安装RabbitMQ需要先安装Erlang语言开发包，百度网盘地址：http://pan.baidu.com/s/1jH8S2u6。直接下载地址：http://erlang.org/download/otp_win64_18.3.exe。安装完成后需要配置环境变量：新建系统变量：变量名 ERLANG_HOME 变量值 D:\softIn...
RabbitMQ使用案例
qq_40068304的博客
12-29 3079
一.简单模式(队列-->交换机) yml配置: server: port: 8088 spring: rabbitmq: host: 127.0.0.1 port: 5672 username: guest password: guest publisher-confirm-type: correlated #消息确认方式,通过 correlated 来确认(将来的消息中才会带 correlation_id,只有通过 correlation_
RabbitMQ——七个案例
weixin_43379341的博客
06-04 1522
安装RabbitMQ 一、安装RabbitMQ需要先安装Erlang语言开发包 百度网盘链接：https://pan.baidu.com/s/1sFVkN0I7w52TFPrVXfjtxg 提取码：wrdj 直接下载地址：http://erlang.org/download/otp_win64_18.3.exe 安装完成后需要配置环境变量： 新建系统变量： 变量名 ERLANG_HOME 变量值 D:\softInstall\erl7.3（Erlang安装目录） 添加到PATH：%ERLANG_HOME%\
SpringBoot 集成rabbitmq
最新发布
07-28
SpringBoot集成RabbitMQ可以通过以下步骤实现。首先，在配置文件中添加RabbitMQ的连接信息。例如，在application.yml文件中配置RabbitMQ的主机、端口、用户名和密码等信息。\[1\]然后，引入SpringBoot整合RabbitMQ的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值