RabbitMq入门（与springboot简单使用）

已于 2023-01-09 16:59:17 修改
阅读量1.2k 收藏
点赞数 1
分类专栏： 消息中间件 文章标签： rabbitmq spring boot docker
于 2021-12-10 11:03:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43676950/article/details/121851275
版权

RabbitMq入门（与springboot简单使用）

一、简介及AMQP协议

概述

RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在完成不同的应用之间共享数据，RabbitMQ是使用Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的。

优点

  • 开源、性能优秀，稳定性保障
  • 与SpringAMQP完美的整合、API丰富。
  • 集群模式丰富、表达式配置、HA模式、镜像队列模型
  • 保证数据不丢失的前提做到高可靠性、可用性

AMQP

AMQP全称：Advanced Message Queuing Protocol

AMQP翻译：高级消息队列协议

在这里插入图片描述

二、安装

Docker安装

docker 拉取rabbitmq（默认最新）镜像

docker pull rabbitmq

docker运行rabbitmq

docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 -v /mydata/rabbitmq/data:/var/lib/rabbitmq --hostname myRabbit -e RABBITMQ_DEFAULT_VHOST=my_vhost  -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin 586ccc4c0d63（镜像编号）

开启web控制台

# 进入rabbitmq容器
[vagrant@bogon etc]$ sudo docker exec -it rabbitmq /bin/bash
# 进入rabbitmq容器，开启web控制台
root@myRabbit:/# rabbitmq-plugins enable rabbitmq_management

遇到的问题

Management API returned status code 500

进入rabbitmq容器，执行如下命令。

cd /etc/rabbitmq/conf.d/
echo management_agent.disable_metrics_collector = false > management_agent.disable_metrics_collector.conf
exit

三、核心概念

整体架构

RabbitMQ整体结构.png

  • Server：又称为Broker，接受客户端的连接，实现AMQP实体服务
  • Connection：连接，应用程序与Broker的网络连接
  • Channel：网络信道，几乎所有的操作都在Channel中进行，Channel是进行消息读写的通道。客户端可建立多个channel，每个Channel代表一个会话任务。
  • Message：消息。服务器和应用程序之间传送的数据，由Properties和Body组成。Properties可以对消息进行修饰，比如消息的优先级，延迟等高级特性；Body则是消息体内容。
  • Virtual host：虚拟地址，用于进行逻辑隔离，最上层的消息路由。一个Virtual Host里面可以有若干个Exchange和Queue，同一个Virtual Host里面不能有相同名称的Exchange或queue
  • Exchange：交换机，接收消息，根据路由键转发消息到绑定的队列。
  • Binding: Exchange 和Queue之间的虚拟连接，binding中可含有routing key。
  • Routing key: 一个路由规则，虚拟机可用它来确定如何路由一个特定消息。
  • Queue: 也称为Message Queue，消息队列，保持消息并将他们转发给消费者。

消息如何流转

在这里插入图片描述

  1. 生成者指定发送的Exchange和routing key，并发送信息到Exchange
  2. Exchange根据routing key ，把消息放到对应的Message Queue
  3. 消费者根据监听的Message Queue，来进行消费。

Exchange Type

概述

在rabbitMq中，Exchange有四个类型：direct，topic，fanout，header，详见

direct

direct类型的exchange，只有当routing key完全相等时，才能路由到对应的Queue

topic

topic类型的direct差不多，只是topic可以设置“*”和“#”通配符。

fanout

俗称广播，此路由直接将消息路由到所有绑定队列中，无须对消息的routingkey进行匹配。

Header

Headr类型的exchange是根据header来判断，用的比较少

四、简单使用

此节简单介绍一下，springboot如何使用rabbitmq，在此之前，我们需要两个springboot工程（生产者和消费者），他们的包名结构一定要相同，因为这涉及到消费者接收消息时，如果两个工程的消息类结构和包名不一样会接收不到。来看一下我的包结构，依次是生产者，消费者
生成者
消费者

依赖文件

<?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.6.1</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.study.rabbitmq</groupId>
	<artifactId>RApusic-consumer</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>RApusic-consumer</name>
	<description>study for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<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>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.amqp</groupId>
			<artifactId>spring-rabbit-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
		</dependency>
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>2.6</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.78</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<excludes>
						<exclude>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</exclude>
					</excludes>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

生产者

yml配置

spring:
  http:
    encoding:
      charset: UTF-8
  datasource:
      url: jdbc:mysql://localhost:3306/ml?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=GMT%2B8
      username: root
      password: root
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
    default-property-inclusion: NON_NULL
  rabbitmq:
    addresses: 192.168.137.20:5672  #rabbitmq地址
    username: admin 
    password: admin
    virtual-host: / #虚拟主机，一般最新版好像没有这个虚拟主机，需要你去rabbitmq的web控制台创建一下。
    connection-timeout: 15000
server:
  servlet:
    context-path: /
  port: 8001

代码编写

写完配置文件后，就该开始编写代码了，首先编写实体类 Order。

package com.study.rabbitmq.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Order implements Serializable {


    private static final long serialVersionUID = -837945093037776296L;
    private String id;
    private String name;
    private String messageId;//存储消息发送的唯一标识。
}

生产者发送消息的代码。由于springboot的关系，所以写的代码非常少

package com.study.rabbitmq.producer;

import com.study.rabbitmq.entity.Order;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

    public void  send(Order order){
        CorrelationData correlationData = new CorrelationData();
        correlationData.setId(order.getMessageId());
        rabbitTemplate.convertAndSend("order-exchange",//exchange
                "order.dada.123",//routingKey
                order,//消息体内容
                correlationData);//correlationData消息唯一ID
    }
}

到此生产者代码编写完毕，是不是很简单。但是完成这些代码后我们发的消息，还不能被rabbitmq接收，因为exchange和queue还没有在rabbit中创建。所以下一节的内容，聪明的你应该猜到了。

RabbitMQ相关配置

访问rabbitmq的控制台

在这里插入图片描述

输入用户密码登录控制台。

创建Virtual Host

在这里插入图片描述

  1. 选项卡切换到admin，右侧选中Virtual Host，键入Name。点击添加完成操作。

创建exchange

在这里插入图片描述

  1. 选择exchange的选项卡。
  2. 图中红框区域键入exchange的name：order-exchange。type选为topic
  3. 点击add exchange按钮，完成exchange的创建。

创建queues

  1. 点击exchange选项卡，点击add a new queue在这里插入图片描述

  2. 点开后，键入name（order-queue），点击Add queue在这里插入图片描述

exchange 与queue的bind

  1. 点exchange选项卡，点击创建好的order-exchange在这里插入图片描述

  2. 键入图中内容，点击bind按钮，完成绑定。在这里插入图片描述

测试

到此rabbitmq的exchange和queue设置完毕。我们可以测试一下，是否可以使用（ps：如果控制台点击遇到Management API returned status code 500的错误，请看安装那节遇到问题篇）。

在生产者中编写测试用例并启动。

package com.study.rabbitmq.RApusic;

import com.study.rabbitmq.entity.Order;
import com.study.rabbitmq.producer.OrderSender;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.UUID;

@SpringBootTest
class RApusicApplicationTests {

	@Test
	void contextLoads() {
		System.out.printf("111");
	}

	@Autowired
	private OrderSender orderSender;

	@Test
	public void testSend(){
		Order order = new Order();
		order.setId("2021120900000001");
		order.setName("测试订单1");
		order.setMessageId(System.currentTimeMillis()+"$"+ UUID.randomUUID().toString());
		orderSender.send(order);
	}

}

查看web控制台，可见消息已经发送到了rabbitmq中。
在这里插入图片描述

消费者

生产者生产的消息，需要消费者消费。

yml配置

spring:
  http:
    encoding:
      charset: UTF-8
  datasource:
      url: jdbc:mysql://localhost:3306/ml?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=GMT%2B8
      username: root
      password: root
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
    default-property-inclusion: NON_NULL
  rabbitmq:
    #基本配置
    addresses: 192.168.137.20:5672
    username: admin
    password: admin
    virtual-host: /
    connection-timeout: 15000
    #消费端配置
    listener:
      simple:
        concurrency: 5 #并发数
        max-concurrency: 15 #最大并发数
        acknowledge-mode: manual #签收模式 manual（手动）or AUTO（自动）
        prefetch: 1 #限流
server:
  servlet:
    context-path: /
  port: 8002

编写代码

消费者也需要entity来接收发送来的消息。

package com.study.rabbitmq.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Order implements Serializable {
    private static final long serialVersionUID = -837945093037776296L;
    private String id;
    private String name;
    private String messageId;//存储消息发送的唯一标识。
}

编写监听

package com.study.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import com.study.rabbitmq.entity.Order;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Map;

@Component
public class OrderReceiver {

    @RabbitListener(bindings = @QueueBinding(value = @Queue(value = "order-queue",declare = "true"),
    exchange = @Exchange(name = "order-exchange",durable = "true",type ="topic" ),
            key = "order.#"
    ))
    @RabbitHandler
    public void onOrderMessage(@Payload Order order, @Headers Map<String,Object> headers, Channel channel) throws IOException {
        //消息者操作
        System.out.println("-----收到消息------");
        System.out.println("订单ID"+order.getId());
        //获取heads中的DELIVERY_TAG
        Long deliveryTag =(Long) headers.get(AmqpHeaders.DELIVERY_TAG);
        //手工签收,basicAck（DELIVERY_TAG，是否支持批量）；
        channel.basicAck(deliveryTag,false);
    }
}

启动springboot，

在这里插入图片描述

至此springboot整合rabbitmq完毕。如果您发现文章中有错误，请及时告诉我，万分感谢。

IT小学僧
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQSpringBootGetStart:RabbitMQ SpringBoot入门
04-30
RabbitMQ SpringBoot入门 基本网址： : 兔子MQ 安装并启动服务器 使用命令“ rabbitmq-server”启动服务器，然后使用来宾/来宾启动 或添加用户 使用Spring Boot 了解AMQP结构 在/ config中 queue（）方法创建一个AMQP队列。 exchange（）方法创建一个主题交换。 binding（）方法将这两者绑定在一起，定义了RabbitTemplate发布到交易所时发生的行为。 这与绑定有什么关系？ 标准标头之一称为路由密钥，代理使用此标头将消息与队列匹配。 每个队列都指定一个“绑定键”，如果该键与路由键头的值匹配，则该队列会接收到该消息。 消息侦听器容器和接收者Bean就是您侦听消息所需的全部。 要发送消息，您还需要一个Rabbit模板。 在listenerAdapter（）方法中定义的bean在conta
springboot-rabbitmq：springboot-rabbitmq学习与实践项目
02-14
项目须知 项目包括springboot集成rabbitmq入门和实战，stater包下是入门代码，practice1下面是实战代码 starter内包括的是基本的springboot集合rabbitMq的使用 练习内包含： 秒杀场景兔MQ 死信量子兔MQ
SpringBoot使用RabbitMQ
最新发布
Turing158的博客
01-29 824
RabbitMQ是用Erlang实现的一个高并发高可靠AMQP消息队列服务器。支持消息的持久化、事务、拥塞控制、负载均衡等特性，主要是为了实现系统之间的双向解耦。
springboot+整合rabbitmq的全套代码
09-15
reabbitmq的完整学习 >rabbitMq软件上传到liunx服务器 >RabbitMQ入门 >RabbitMQ的工作模式 >Springboot整合RabbitMQ >SpringBoot整合RabbitMQ(交换机与多个队列绑定) >RabbitMQ-集群搭建>负载均衡-HAProxy 完整链接地址: https://blog.csdn.net/qq_39505065/article/details/126880533?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22126880533%22%2C%22source%22%3A%22qq_39505065%22%7D
RabbitMQ创建生产者和消费者
master_zhao的博客
07-25 693
在pom.xml文件中引入如下依赖。
Springboot初步使用RabbitMQ
热门推荐
Ron_的博客
01-29 1万+
RabbitMQ消息队列 1.2.消息队列（MQ） 1.2.1.什么是消息队列 解耦、削峰填谷、异步 消息队列，即MQ，Message Queue。 消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。 结合前面所说的问题： 商品服务对商品增删改以后，无需去操作索引库或静态页面，只是发送一条消息，也不关心消息被谁接收。 搜索服务服务接收消息，去处
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4306
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
RabbitMQ 浅析
Darklovy
06-05 537
转载自：https://www.cnblogs.com/ityouknow/p/6120544.html RabbitMQ 是一个由 Erlang 语言开发的 AMQP（高级消息队列协议） 的开源实现。它主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲、消息分发的作用。 AMQP AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是...
RabbitMQ实战教程
09-02
本课程适用于RabbitMQ实战者以及SpringBoot整合RabbitMQ实战需求者。课程将首先带领大家拜读RabbitMQ官网的技术开发手册，之后会将学到的知识深入的实战到实际的各种应用场景中，从而加深知识点的理解，其中包括如何实现单一队列多个消费者监听消费、业务服务模块解耦通信、抢单高并发方案的解决、登录成功异步写日志、异步发送邮件、死信队列实战以及实现用户下单超时未支付自动失效等等。
【SpringBoot高级篇】SpringBoot集成RabbitMQ消息队列
输入技术、输出想法
04-29 4936
SpringBoot整合rabbitMQSpringBoot与消息概述应用场景异步应用解耦流量削峰JMS与AMQP比较RabbitMQ简介核心概念MessagePublisherExchangeQueueBindingConnectionChannelConsumerVirtual HostBrokerRabbitMQ运行机制Exchange 类型Direct EXchangeFanout EXchangeTopic EXchangeSpringBoot RabbitMQ整合docker安装RabbitMQ
springboot集成rabbitmq
初念初恋的博客
06-09 5243
RabbitMQ 是实现 AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ 主要是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时，消费者无法快速消费，那么需要一个中间层。保存这个数据。AMQP，即 Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。
RabbitMQ入门到进阶(Spring整合RabbitMQ&SpringBoot整合RabbitMQ).doc
07-08
RabbitMQ入门到进阶(Spring整合RabbitMQ&SpringBoot整合RabbitMQ).doc
rabbitmq-springboot
04-19
入门 docker run -d --hostname my-rabbit --name rabbit -p 15672：15672 -p 5672：5672 rabbitmq：3-management 参考文件 有关更多参考，请考虑以下部分： 导游 Abrir o console没有docker do Rabbitmq docker ...
消息中间件——RabbitMQ（五）快速入门生产者与消费者，SpringBoot整合RabbitMQ！
vc33569的专栏
11-23 507
本章我们来一次快速入门RabbitMQ——生产者与消费者。需要构建一个生产端与消费端的模型。什么意思呢？我们的生产者发送一条消息，投递到RabbitMQ集群也就是Broker。我们的消费端进行监听RabbitMQ，当发现队列中有消息后，就进行消费。
SpringBoot 集成 RabbitMQ
爱笑的boy的博客
03-04 5083
SpringBoot 集成 RabbitMQ
消息队列——RabbitMQ基本概念+容器化部署和简单工作模式程序
测试
07-15 2944
容器化部署rabbitMQ
rabbitmq生产者和消费者入门
kingloneye的博客
03-18 207
1、生产者 pom.xml <dependencies> <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <versi...
【RabbitMQ】Spring整合RabbitMQ、Spring实现RabbitMQ五大工作模式（万字长文）
qq_61903414的博客
04-15 2282
订阅模式与前两种不同，订阅模式需要使用到fanout类型的交换机，并且将队列与之绑定，他的生产者在xml文件里需要去创建两个队列与fanout类型的交换机并绑定，在发送消息时指定交换机名称即可，而消费者则与前者相同，只是需要修改指定监听的队列名。此处由于创建的交换机类型是fanout广播类型不需要去配置路由，如果创建的direct交换机不止需要配置队列名属性，还需要配置路由属性，如果是topic交换机则需要配置通配符。同样在消费者创建的xml文件里我们路创建队列监听器容器来将不同队列的消息映射到不同的类。
SpringAMQP消息队列（SpringBoot集成RabbitMQ）
JackMa的博客
02-18 6080
但是此时有一个问题就是消息预取，比如队列有10条消息，两个消费者各自直接先预取5个消息，如果一个消费者接受消息的速度慢，一个快，就会导致一个消费者已经完成工作，另一个还在慢慢处理，会造成消息堆积消费者身上，要解决这个问题需要在yml文件配置相关配置。exchange是交换机，负责消息路由，但不存储消息，路由失败则消息丢失。控制台结果如下（共发送20条，每个队列10条）六、发布订阅模式之路由模式（Direct）三、工作消息队列（Work Queue）可以提高消息处理速度，避免队列消息堆积。
springboot rabbitmq使用 springboot rabbitmq使用 springboot集成rabbitmq一对多
07-09
Spring Boot集成RabbitMQ可以通过以下步骤完成： 1. 添加Maven依赖：在pom.xml文件中添加RabbitMQ的Spring Boot Starter依赖。 ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. 配置RabbitMQ连接信息：在application.properties（或application.yml）文件中配置RabbitMQ的连接信息。 ```properties spring.rabbitmq.host=your_rabbitmq_host spring.rabbitmq.port=your_rabbitmq_port spring.rabbitmq.username=your_rabbitmq_username spring.rabbitmq.password=your_rabbitmq_password ``` 3. 创建RabbitMQ发送者：创建一个发送消息的类，使用`RabbitTemplate`发送消息到指定的交换机和队列。 ```java import org.springframework.amqp.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class RabbitMQSender { @Autowired private RabbitTemplate rabbitTemplate; public void sendMessage(String exchange, String routingKey, Object message) { rabbitTemplate.convertAndSend(exchange, routingKey, message); } } ``` 4. 创建RabbitMQ接收者：创建一个接收消息的类，使用`@RabbitListener`注解监听指定的队列，处理接收到的消息。 ```java import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component public class RabbitMQReceiver { @RabbitListener(queues = "your_queue_name") public void receiveMessage(Object message) { // 处理接收到的消息 System.out.println("Received message: " + message.toString()); } } ``` 5. 发送和接收消息：在需要发送或接收消息的地方调用对应的方法。 ```java @Autowired private RabbitMQSender rabbitMQSender; public void sendMessage() { rabbitMQSender.sendMessage("your_exchange_name", "your_routing_key", "Hello, RabbitMQ!"); } ``` 以上是基本的使用方式，你可以根据实际需求进行扩展和配置。注意，你还需要安装并启动RabbitMQ服务。 希望对你有所帮助！如果有任何疑问，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值