RabbitMQ——实战篇4（SpringBoot集成）

最新推荐文章于 2023-06-09 14:49:11 发布
最新推荐文章于 2023-06-09 14:49:11 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： 架构师-分布式框架 文章标签： java rabbitmq mq 队列 交换机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouhengzhe/article/details/113616890
版权

文章目录

其他文章地址

1、RabbitMQ——单机版安装（3.6.5）
2、RabbitMQ——入门篇
3、RabbitMQ——实战篇1（原生API）
4、RabbitMQ——实战篇2（Spring集成）
5、RabbitMQ——实战篇3（Spring集成高级特性：死信队列，消息丢失，延迟队列）
6、RabbitMQ——实战篇4（SpringBoot集成）

项目地址：https://gitee.com/zhouzhz/rabbitmq

1、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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zhz</groupId>
    <artifactId>boot_mq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>boot_mq</name>
    <description>boot集成mq</description>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <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>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>springboot_rabbitmq</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

</project>

2、配置文件

application.yml

#端口配置
server:
  port: 8080

#集成配置
spring:
  rabbitmq:
    port: 5672
    addresses: 192.168.0.66
    username: zhzmq
    password: zhzmq
    virtual-host: /zhztest

#集群地址配置
#spring.rabbitmq.addresses=172.16.48.10:5672,172.16.48.11:5672,172.16.48.12:5672

日志配置

#Set everything to be logged to the console
#log4j.rootCategory=INFO, console, D
log4j.rootCategory=INFO, console,

log4j.appender.console=org.apache.log4j.ConsoleAppender
#log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yyyyMMdd HH:mm:ss} %p %c{1}:%L - %m%n

log4j.additivity.com.hisun.swordrisk = false  
log4j.logger.org.apache.hadoop.ipc.Server = WARN

log4j.appender.D=org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File= logs/task.log
log4j.appender.D.Append=true
log4j.appender.D.Threshold=DEBUG
log4j.appender.D.layout=org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern=%d{yyyyMMdd HH:mm:ss} %p %c{1} %m%n

3、Swagger配置

package com.zhz.swagger;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class Swagger2 {
	   // http://127.0.0.1:8080/swagger-ui.html
	   @Bean
	    public Docket createRestApi() {
	        return new Docket(DocumentationType.SWAGGER_2)
	                .apiInfo(apiInfo())
	                .select()
	                .apis(RequestHandlerSelectors.basePackage("com.zhz"))
	                .paths(PathSelectors.any())
	                .build();
	    }
	    private ApiInfo apiInfo() {
	        return new ApiInfoBuilder()
	                .title("springboot集成rabbitmq")
	                .description("springboot集成rabbitmq的5种工作模式")
	                .termsOfServiceUrl("https://editor.csdn.net/md?articleId=113616890")
	                .contact("zhz")
	                .version("1.0")
	                .build();
	    }
}

4、5种工作模式的配置类

4.1、HelloWorld（简单）

package com.zhz.config;

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

/**
 * @author ：zhz
 * @date ：Created in 2021/02/07
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description:
 **/
@Configuration
public class HelloWorldConfig {
    //队列
    @Bean
    public Queue setQueue(){
        return new Queue("helloWorldQueue");
    }

}

4.2、WorkQueue（工作队列）

package com.zhz.config;

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

/**
 * @author ：zhz
 * @date ：Created in 2021/02/07
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description:
 **/
@Configuration
public class WorkConfig {
    //队列
    //声明队列
    @Bean
    public Queue workQ1() {
        return new Queue("work_sb_mq_q");
    }
}

4.3、Fanout（广播）

package com.zhz.config;

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;

/**
 * @author ：zhz
 * @date ：Created in 2021/02/07
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: Fanout模式需要声明exchange，并绑定queue，由exchange负责转发到queue上。
 *              广播模式 交换机类型设置为：fanout
 **/
@Configuration
public class FanoutConfig {
    //队列
    @Bean
    public Queue fanoutQ1(){
        return new Queue("fanout.q1");
    }
    @Bean
    public Queue fanoutQ2(){
        return new Queue("fanout.q2");
    }
    //交换机
    @Bean
    public FanoutExchange setFanoutExchange(){
        return new FanoutExchange("fanoutExchange");
    }

    //绑定交换机和队列
    @Bean
    public Binding bindQ1(){
        return BindingBuilder.bind(fanoutQ1()).to(setFanoutExchange());
    }
    @Bean
    public Binding bindQ2(){
        return BindingBuilder.bind(fanoutQ2()).to(setFanoutExchange());
    }

}

4.4、Direct（路由）

package com.zhz.config;

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

/**
 * @author ：zhz
 * @date ：Created in 2021/02/07
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 路由模式|Routing模式   交换机类型：direct  ==>需要交换机
 **/
@Configuration
public class DirectConfig {
    //声明队列
    @Bean
    public Queue directQ1(){
        return new Queue("direct_sb_mq_q1");
    }
    @Bean
    public Queue directQ2(){
        return new Queue("direct_sb_mq_q2");
    }
    //声明交换机exchange
    @Bean
    public DirectExchange setDirectExchange(){
        return new DirectExchange("directExchange");
    }
    //绑定交换机和队列
    @Bean
    public Binding bindDirectBinding1(){
        return BindingBuilder.bind(directQ1()).to(setDirectExchange()).with("china.changsha");
    }
    @Bean
    public Binding bindDirectBinding2(){
        return BindingBuilder.bind(directQ2()).to(setDirectExchange()).with("china.beijing");
    }
}

4.5、Topic（通配符）

package com.zhz.config;

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

/**
 * @author ：zhz
 * @date ：Created in 2021/02/07
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description:
 **/
@Configuration
public class TopicConfig {
    //队列
    @Bean
    public Queue topicQ1(){
        return new Queue("topic_sb_mq_q1");
    }
    @Bean
    public Queue topicQ2(){
        return new Queue("topic_sb_mq_q2");
    }
    //交换机
    @Bean
    public TopicExchange setTopicExchange(){
        return new TopicExchange("topicExchange");
    }

    //绑定交换机和队列,声明binding，需要声明一个routingKey
    @Bean
    public Binding bindTopic1(){
        return BindingBuilder.bind(topicQ1()).to(setTopicExchange()).with("changsha.*");
    }
    @Bean
    public Binding bindQ2(){
        return BindingBuilder.bind(topicQ2()).to(setTopicExchange()).with("#.beijing");
    }
}

5、生产者

package com.zhz.controller;

import io.swagger.annotations.ApiOperation;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.UnsupportedEncodingException;

/**
 * @author ：zhz
 * @date ：Created in 2021/02/07
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description:
 **/
@RestController
public class ProducerController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //helloWord直连
    @ApiOperation(value = "helloWorld发送接口", notes = "直接发送到队列")
    @GetMapping(value = "/helloWorldSend")
    public Object helloWorldSend(String message) throws AmqpException, UnsupportedEncodingException {
        //设置部分请求参数
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
        //发消息
        rabbitTemplate.send("helloWorldQueue", new Message(message.getBytes("UTF-8"), messageProperties));
        return "message send: " + message;
    }

    //工作队列模式
    @ApiOperation(value = "workQueue发送接口", notes = "发送到所有监听该队列的消费")
    @GetMapping(value = "/workQueueSend")
    public Object workQueueSend(String message) throws AmqpException, UnsupportedEncodingException {
        //设置部分请求参数
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
        //制造多个消息进行发送操作
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.send("work_sb_mq_q", new Message(message.getBytes("UTF-8"), messageProperties));
        }
        return "message send: " + message;
    }

    // pub/sub 发布订阅模式   交换机类型 fanout
    @ApiOperation(value = "fanout发送接口", notes = "发送到fanoutExchange。消息将往该exchange下的所有queue转发")
    @GetMapping(value = "/fanoutSend")
    public Object fanoutSend(String message) throws AmqpException, UnsupportedEncodingException {
        //设置部分请求参数
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
        //fanout模式只往exchange里发送消息。分发到exchange下的所有queue
        rabbitTemplate.send("fanoutExchange", "", new Message(message.getBytes("UTF-8"), messageProperties));
        return "message send: " + message;
    }

    //routing路由工作模式  交换机类型 direct
    @ApiOperation(value = "direct发送接口", notes = "发送到directExchange。exchange转发消息时，会往routingKey匹配的queue发送")
    @GetMapping(value = "/directSend")
    public Object routingSend(String routingKey, String message) throws AmqpException, UnsupportedEncodingException {
        if (routingKey == null) {
            routingKey = "china.changsha";
        }
        //设置部分请求参数
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
        rabbitTemplate.send("directExchange", routingKey, new Message(message.getBytes("UTF-8"), messageProperties));
        return "message send : routingKey >" + routingKey + ";message > " + message;
    }

    //topic 工作模式   交换机类型 topic
    @ApiOperation(value = "topic发送接口", notes = "发送到topicExchange。exchange转发消息时，会往routingKey匹配的queue发送，*代表一个单词，#代表0个或多个单词。")
    @GetMapping(value = "/topicSend")
    public Object topicSend(String routingKey, String message) throws AmqpException, UnsupportedEncodingException {
        if (routingKey == null) {
            routingKey = "changsha.kf";
        }
        //设置部分请求参数
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
        rabbitTemplate.send("topicExchange", routingKey, new Message(message.getBytes("UTF-8"), messageProperties));
        return "message send : routingKey >" + routingKey + ";message > " + message;
    }
}

6、消费者

package com.zhz.controller;

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

/**
 * @author ：zhz
 * @date ：Created in 2021/02/07
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 监听
 **/
@Component
public class ConsumerReceiver {
    //直连模式的多个消费者，会分到其中一个消费者进行消费。类似task模式
    //通过注入RabbitContainerFactory对象，来设置一些属性，相当于task里的channel.basicQos
    @RabbitListener(queues = "helloWorldQueue")
    public void helloWorldReceive(String message){
        System.out.println("hello world："+message);
    }
    //工作队列模式
    @RabbitListener(queues = "work_sb_mq_q")
    public void wordQueueReceiveQ1(String message){
        System.out.println("工作队列模式1："+message);
    }
    @RabbitListener(queues = "work_sb_mq_q")
    public void wordQueueReceiveQ2(String message){
        System.out.println("工作队列模式2："+message);
    }
    //pub/sub模式进行消息监听
    @RabbitListener(queues = "fanout.q1")
    public void fanoutReceiveQ1(String message){
        System.out.println("发布订阅模式1："+message);
    }
    @RabbitListener(queues = "fanout.q2")
    public void fanoutReceiveQ2(String message){
        System.out.println("发布订阅模式1："+message);
    }

    //Routing路由模式
    @RabbitListener(queues="direct_sb_mq_q1")
    public void routingReceiveQ1(String message) {

        System.out.println("Routing路由模式1: " +message);
    }

    @RabbitListener(queues="direct_sb_mq_q2")
    public void routingReceiveQ2(String message) {

        System.out.println("Routing路由模式2: " +message);
    }
    //topic 模式
    //注意这个模式会有优先匹配原则。例如发送routingKey=guangzhou.IT,那匹配到guangzhou.*(guangzhou.IT,guangzhou.eco),之后就不会再去匹配*.ITd
    @RabbitListener(queues="topic_sb_mq_q1")
    public void topicReceiveQ1(String message) {
        System.out.println("Topic模式1: " +message);
    }

    @RabbitListener(queues="topic_sb_mq_q2")
    public void topicReceiveQ2(String message) {
        System.out.println("Topic模式2: " +message);
    }

}

7、启动类

package com.zhz;

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

@SpringBootApplication
public class BootMqApplication {

    public static void main(String[] args) {
        SpringApplication.run(BootMqApplication.class, args);
    }

}

我是小白弟弟，一个在互联网行业的小白，立志成为一名架构师
https://blog.csdn.net/zhouhengzhe?t=1

zhz小白
关注
专栏目录
Spring Boot进阶(75)：从容应对HTTP请求——Spring Boot与OkHttp完美结合
**My Coding Family**
06-29 1854
本文将介绍如何在Spring Boot应用程序中使用OkHttp来发起HTTP请求。我们将演示如何使用OkHttp的核心API来发送GET和POST请求，并使用Spring Boot的特性来扩展和定制请求。我们还将介绍如何使用Spring Boot和OkHttp来处理HTTP响应，并提供一些代码示例和测试用例来帮助读者更好地理解如何使用这些工具构建可靠的HTTP请求功能。
RabbitMQ 实战（二）Spring Boot 整合 RabbitMQ
皂白
02-04 7339
这篇文章主要讲基本的整合。先把代码跑起来，再说什么高级特性。 RabbitMQ 中的一些术语 如果你打开 RabbitMQ web 控制台，你会发现其中有一个 Exhanges 不好理解。下面简单说明一下。 交换器（Exchange） 交换器就像路由器，我们先是把消息发到交换器，然后交换器再根据路由键（routingKey）把消息投递到对应的队列。（明白这个概念很重要，后面的代
RabbitMQ整合SpringBoot
qwq1518346864的博客
06-18 224
RabbitMQ整合SpringBoot 一.RabbitMQ整合SpringBoot（手动ack） 1.创建SpringBoot工程 2.导入依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp&l...
RabbitMQ整合Springboot
本人拙笔，记录一些开发、面试中的笔记，希望能帮到你。
01-31 136
代码已上传GitHub 引入依赖 <!--集成RabbitMQ 需要使用到的依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency>
RabbitMQ集成SpringBoot
my_air的博客
08-21 325
RabbitMQ基本使用基本概念集成SpringBootDirect 直流交换机Fanout: 扇形交换机Topic: 主题交换机发送消息convertSendAndReceive方法与convertAndSend方法的区别 基本概念 了解rabbitmq之前先要了解3个基本概念：生产者、消费者、代理（队列）。 rabbitmq在生产者和代理中间做了一层抽象。这样消息生产者和队列就没有直接联系，在中间加入了一层交换器（Exchange）。这样消息生产者把消息交给交换器，交换器根据路由策略再把消息转发给对应队
SpringBoot集成kafka全面实战
热门推荐
Felix
03-28 20万+
本文是SpringBoot+Kafka的实战讲解，如果对kafka的架构原理还不了解的读者，建议先看一下《大白话kafka架构原理》、《秒懂kafka HA（高可用）》两篇文章。 一、生产者实践 普通生产者 带回调的生产者 自定义分区器 kafka事务提交 二、消费者实践 简单消费 指定topic、partition、offset消费 ...
springboot中rabbitmq集成——单项目
坤哥的博客
04-08 1209
这两天看了下activemq和rabbitmq，现在跟大家分享下rabbitmq在springboot中的集成及使用。 依赖 dependency> groupId>org.springframework.bootgroupId> artifactId>spring-boot-starter-amqpartifactId> dependency> 具体代码： @Spri
springboot中rabbitmq集成——多项目
坤哥的博客
04-08 4469
这里以两个项目为例，一个消息的生产者，一个消息的消费者，接着上篇单项目的讲。目录结构： rabbitmq作为消息生产者，发送消息。rabbitmqreceiver消息的接收者，消费消息。 发送字符串的时候在两个项目之间是没问题的，大家可以自己测试。发送端代码： public void run(String... args) throws Exception { User us
《Spring Boot 实战派》--12.集成RabbitMQ,实现系统间的 数据交换
tumu6889的博客
05-28 3311
第12章集成RabbitMQ,实现系统间的数据交换 RabbitMQ是近年来使用非常广泛的消息中间件。 本章首先介绍它的原理、概念、6种工作模式、常用的注解； 然后用实例讲解在Spring Boot 中如何使用AmqpTemplate接口实现消息的发送和监听。 12.1认识RabbitMQ 12.1.1介绍RabbitMQ RabbitMQ 是开源的高级消息队列协议(Advanced Message Queueing Protocol, AMQP) 的实现，用Erlang语言编写，...
Rabbitmq集成springboot
huangchong0107的博客
05-14 451
一：provider端 1.项目里添加pom <!--rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> <dependency> <groupId>org.spri
2021-09-02 消息中间件RabbitMQ（整合SpringBoot）_02
Young的博客
09-04 472
环境 JDK13 maven3.8.1 一、RabbitMQ整合SpringBoot 建立一个SpringBoot工程，引入依赖 <dependencies> <!--启动器--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifac
RabbitMQ (四) --------- SpringBoot 集成 RabbitMQ
在森林里麋了鹿
04-22 3020
目录一、创建消息生产者工程二、创建消息接收者工程三、Direct 模式消息发送和接收1. 编写 Direct 模式的消息发送2. 编写 Direct 模式的消息接收 一、创建消息生产者工程 创建模块 rabbitmq-springboot-send 配置模块 rabbitmq-springboot-send 的 application.properties 文件添加对 RabbitMQ 的集成 #配置RabbitMQ链接信息 #配置RabbitMQ服务器的IP地址 spring.rabbitmq.ho
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4720
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
spring boot-整合RabbitMq（RabbitMq基础）
西京刀客
11-23 847
文章目录RabbitMq基础Springboot 整合RabbitMq参考 RabbitMq基础 Springboot 整合RabbitMq 参考 SpringBoot集成rabbitmq（一） 参考URL: https://www.cnblogs.com/sword-successful/p/10295561.html
springboot集成rabbitmq
初念初恋的博客
06-09 5493
RabbitMQ 是实现 AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ 主要是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时，消费者无法快速消费，那么需要一个中间层。保存这个数据。AMQP，即 Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。
springboot rabbitmq使用 springboot rabbitmq使用 springboot集成rabbitmq一对多
最新发布
07-09
Spring Boot集成RabbitMQ可以通过以下步骤完成： 1. 添加Maven依赖：在pom.xml文件中添加RabbitMQ的Spring Boot Starter依赖。 ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zhz小白

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

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

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

打赏作者

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

抵扣说明：

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

余额充值