SpringAMQP消息队列（SpringBoot集成RabbitMQ）

已于 2023-06-14 10:08:03 修改
阅读量6.5k 收藏 24
点赞数 5
文章标签： spring boot java spring Powered by 金山文档
于 2023-02-18 21:51:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55127182/article/details/129102657
版权

一、初始配置

1、导入maven坐标

<!--rabbitmq-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>

2、yml配置

spring:
    rabbitmq:
        host: 你的rabbitmq的ip
        port: 5672
        username: guest
        password: guest

二、基本消息队列

1、创建队列

访问接口：http://localhost:15672，账号密码都为guest

进入后左下角有Add queue添加队列，我已添加队列为MqTest1

2、发布消息

@SpringBootTest
class RabbitMQDemoPublishApplicationTests {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void contextLoads() {
        String queue="MqTest1";
        String message="message1";
        rabbitTemplate.convertAndSend(queue,message);
    }

}

此时可以看到队列有一个消息

3、接受消息

package com.rabbitmqdemoconsumer.rabbitmq;

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

@Component
public class SpringRabbitLeistener {

    @RabbitListener(queues = "MqTest1")
    public void listenSimpleQueueMessage(String msg){
        System.out.println("接收到的消息："+msg);
    }
}

此时控制台输出接收到的消息

三、工作消息队列（Work Queue）

可以提高消息处理速度，避免队列消息堆积

1、发布消息

@SpringBootTest
class RabbitMQDemoPublishApplicationTests {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void contextLoads() {
        String queue="MqTest1";
        String message="message1";
        for (int i=0;i<10;i++){
            rabbitTemplate.convertAndSend(queue,message);
        }
    }

}

此时队列有10条消息

2、接受消息

package com.rabbitmqdemoconsumer.rabbitmq;

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

@Component
public class SpringRabbitLeistener {

    @RabbitListener(queues = "MqTest1")
    public void listenSimpleQueueMessage1(String msg){
        System.out.println("consume1接收到的消息："+msg);
    }
    @RabbitListener(queues = "MqTest1")
    public void listenSimpleQueueMessage2(String msg){
        System.out.println("consume2接收到的消息："+msg);
    }
}

3、控制台输出结果

consume1接收到的消息：message1
consume2接收到的消息：message1
consume1接收到的消息：message1
consume2接收到的消息：message1
consume1接收到的消息：message1
consume2接收到的消息：message1
consume1接收到的消息：message1
consume2接收到的消息：message1
consume1接收到的消息：message1
consume2接收到的消息：message1

4、消息预取问题

但是此时有一个问题就是消息预取，比如队列有10条消息，两个消费者各自直接先预取5个消息，如果一个消费者接受消息的速度慢，一个快，就会导致一个消费者已经完成工作，另一个还在慢慢处理，会造成消息堆积消费者身上，要解决这个问题需要在yml文件配置相关配置

  rabbitmq:
    host: 43.140.244.236
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    listener:
      simple:
        prefetch: 1 #每次只能取一个，处理完才能取下一个消息

这样可以避免消息预取导致堆积

四、发布订阅模式

exchange是交换机，负责消息路由，但不存储消息，路由失败则消息丢失

五、发布订阅模式之广播模式（Fanout）

1、Fanout配置类（@Bean声明）

package com.rabbitmqdemoconsumer.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;

@Configuration
public class FanountConfig {
    //交换机声明
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("FanountExchange");
    }
    //声明队列1
    @Bean
    public Queue Fanount_Qeueue1(){
        return new Queue("Fanount_Qeueue1");
    }
    //声明队列2
    @Bean
    public Queue Fanount_Qeueue2(){
        return new Queue("Fanount_Qeueue2");
    }
    //绑定交换机和队列
    @Bean
    public Binding bindingFanount_Qeueue1(Queue Fanount_Qeueue1,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(Fanount_Qeueue1).to(fanoutExchange);
    }
    @Bean
    public Binding bindingFanount_Qeueue2(Queue Fanount_Qeueue2,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(Fanount_Qeueue2).to(fanoutExchange);
    }
}

可以看到声明的队列

已经声明的交换机（第一个）

绑定关系

2、发送消息

首先发送10条消息，经过交换机转发到队列

@SpringBootTest
class RabbitMQDemoPublishApplicationTests {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void contextLoads2() {
        String exchange="FanountExchange";
        String message="message";
        for (int i=0;i<10;i++){
            rabbitTemplate.convertAndSend(exchange,"",message);
        }
    }

}

此时可以看到两个队列各自有十条消息

3、接受消息

 //监听交换机Fanount_Qeueue1
    @RabbitListener(queues = "Fanount_Qeueue1")
    public void listenFanountQeueue1(String msg){
        System.out.println("Fanount_Qeueue1接收到的消息："+msg);
    }
    //监听交换机Fanount_Qeueue2
    @RabbitListener(queues = "Fanount_Qeueue2")
    public void listenFanountQeueue2(String msg){
        System.out.println("Fanount_Qeueue2接收到的消息："+msg);
    }

控制台结果如下（共发送20条，每个队列10条）

Fanount_Qeueue1接收到的消息：message
Fanount_Qeueue1接收到的消息：message
Fanount_Qeueue1接收到的消息：message
Fanount_Qeueue1接收到的消息：message
Fanount_Qeueue2接收到的消息：message
Fanount_Qeueue1接收到的消息：message
Fanount_Qeueue2接收到的消息：message
Fanount_Qeueue1接收到的消息：message
Fanount_Qeueue2接收到的消息：message
Fanount_Qeueue1接收到的消息：message
Fanount_Qeueue2接收到的消息：message
Fanount_Qeueue1接收到的消息：message
Fanount_Qeueue2接收到的消息：message
Fanount_Qeueue1接收到的消息：message
Fanount_Qeueue2接收到的消息：message
Fanount_Qeueue2接收到的消息：message
Fanount_Qeueue2接收到的消息：message
Fanount_Qeueue2接收到的消息：message

六、发布订阅模式之路由模式（Direct）

会将消息根据规则路由到指定的队列

1、声明（基于@RabbitListener声明）

package com.rabbitmqdemoconsumer.rabbitmq;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class SpringRabbitLeistener {

    /**
     * 绑定交换机和队列，并为key赋值
     * @param msg
     */
    @RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "DirectQueue1"),
        exchange = @Exchange(name = "DirectExchange",type = ExchangeTypes.DIRECT),
        key = {"red","blue"}
    ))
    public void listenDirectQueue1(String msg){
        System.out.println("listenDirectQueue1接收到的消息："+msg);
    }


    @RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "DirectQueue2"),
        exchange = @Exchange(name = "DirectExchange",type = ExchangeTypes.DIRECT),
        key = {"red","yellow"}
    ))
    public void listenDirectQueue2(String msg){
        System.out.println("listenDirectQueue2接收到的消息："+msg);
    }
}

此时可以看到声明的队列

声明的交换机（第一个）

绑定关系

2、发送给blue

发送消息


@SpringBootTest
class RabbitMQDemoPublishApplicationTests {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void contextLoads2() {
        String exchange="DirectExchange";
        String message="HelloWorld";
        for (int i=0;i<10;i++){
            rabbitTemplate.convertAndSend(exchange,"blue",message);
        }
    }

}

接收消息

listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld

3、发送给red

发送消息

@SpringBootTest
class RabbitMQDemoPublishApplicationTests {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void contextLoads2() {
        String exchange="DirectExchange";
        String message="HelloWorld";
        for (int i=0;i<10;i++){
            rabbitTemplate.convertAndSend(exchange,"blue",message);
        }
    }

}

接收消息

listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue2(red,yellow)接收到的消息：HelloWorld
listenDirectQueue2(red,yellow)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue2(red,yellow)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue2(red,yellow)接收到的消息：HelloWorld
listenDirectQueue2(red,yellow)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue2(red,yellow)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue2(red,yellow)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue2(red,yellow)接收到的消息：HelloWorld
listenDirectQueue2(red,yellow)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld
listenDirectQueue2(red,yellow)接收到的消息：HelloWorld
listenDirectQueue1(red,blue)接收到的消息：HelloWorld

七、发布订阅模式之广播模式（Topic）

Queue与Exchange指定BindingKey可以使用通配符：

#：代指0个或多个单词

*：代指一个单词

比如：

bindingkey: china.# ->中国的所有消息

bindingkey: #.weather ->所以国家的天气

1、声明

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "TopicQueue1"),
        exchange = @Exchange(name = "TopicExchange",type = ExchangeTypes.TOPIC),
        key = {"china.#"}
    ))
public void listenTopicQueue1(String msg){
    System.out.println("listenTopicQueue1接收到的消息："+msg);
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "TopicQueue2"),
    exchange = @Exchange(name = "TopicExchange",type = ExchangeTypes.TOPIC),
    key = {"#.news"}
))
public void listenTopicQueue2(String msg){
    System.out.println("listenTopicQueue2接收到的消息："+msg);
}

队列

交换机（第四个）

绑定关系

2、发送消息（测试1）

package com.rabbitmqdemo;

import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class RabbitMQDemoPublishApplicationTests {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void contextLoads2() {
        String exchange="TopicExchange";
        String message="HelloWorld";
        for (int i=0;i<10;i++){
            rabbitTemplate.convertAndSend(exchange,"china.news",message);
        }
    }

}

接收消息

TopicQueue2接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue2接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue2接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue2接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue2接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue2接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue2接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue2接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue2接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue2接收到的消息：HelloWorld

3、发送消息（测试2）

发送消息

package com.rabbitmqdemo;

import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class RabbitMQDemoPublishApplicationTests {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void contextLoads2() {
        String exchange="TopicExchange";
        String message="HelloWorld";
        for (int i=0;i<10;i++){
            rabbitTemplate.convertAndSend(exchange,"china.weather",message);
        }
    }

}

接收消息

TopicQueue1接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld
TopicQueue1接收到的消息：HelloWorld

梁山教父
关注
  • 5
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Spring Boot异步消息之AMQP讲解及实战（附源码）
showswoller的博客
10-29 2395
Spring Boot异步消息之AMQP讲解及实战（附源码） 通过一个发布者订阅者实例讲解
Springboot 集成 RabbitMQ (spring-boot-starter-amqp)
一生一世一双人的博客
06-29 7307
Springboot 集成RabbitMQmaven依赖application.yml配置RabbitMQ配置一般队列配置死信队列配置消息发送消费者 maven依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version&
从0到1全面讲解RabbitMq消息队列搭建以及SpringBoot配置详解
最新发布
八戒的博客
05-28 1076
按提示安装即可，注意安装路径不要带中文。按win+r,输入cmd进入命令窗口，然后cd到Mq的sbin路径下，输入如下命令进行安装验证是否安装成功Erlang安装下载安装即可RabbitMq界面RabbitMq配置完成之后，默认打开地址默认用户名：guest 密码：guest。
Spring boot集成RabbitMq
初心魏的博客
06-20 3811
一、搭建RabbitMq 1.1 参考 RabbitMQ教程 二、使用教程 2.1 打开服务端 cmd 打开 C:\Program Files\RabbitMQ Server\rabbitmq_server-3.8.0\sbin， 输入：rabbitmq-plugins enable rabbitmq_management 出现: The following plugins have been...
Spring整合RabbitMQ
Mr_yu_shao的博客
08-31 3190
超简单！入门级SpringBoot整合RabbitMQ，一看就会！
RabbitMQ（二）Springboot整合及使用
fox_bert的博客
09-26 3383
一、RabbitMQ的重要概念 RabbitMQ是一种基于amq协议的消息队列，本文主要记录一下使用spring-boot-starter-amqp操作 rabbitmq。 a) 虚拟主机(vhost) 虚拟主机：一个虚拟主机持有一组交换机、队列和绑定。虚拟主机的作用在于进行权限管控，rabbitmq默认有一个虚拟主机"/"。可以使用rabbitmqctl add_vhost命令添加虚...
SpringCloud微服务-SpringAMQP（RabbitMQ）
m0_63144319的博客
03-06 2175
Spring AMQP是Spring框架对AMQP（Advanced Message Queuing Protocol）的支持库，用于简化在Java应用程序中使用消息队列的开发。通过Spring AMQP，开发人员可以更轻松地与消息代理进行交互，发送和接收消息，以实现异步通信和解耦应用程序组件。Spring AMQP提供了一组丰富的功能和API，使得在使用AMQP消息队列时更加便捷和高效。SpringAmqp的官方地址：https://spring.io/projects/spring-amqp。
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
SpringBoot集成RabbitMQ的方法是指使用SpringBoot框架集成RabbitMQ消息队列的方法，RabbitMQ是一种基于AMQP协议的开源消息队列软件。该方法可以实现消息的异步处理，提高系统的可扩展性和可靠性。 在SpringBoot中...
SpringBoot集成Rabbitmq简单案例
03-15
在本文中，我们将深入探讨如何将Spring Boot与RabbitMQ集成，实现一个简单的消息队列应用。Spring Boot是Spring框架的轻量级实现，旨在简化Java应用的开发过程，而RabbitMQ则是一个广泛使用的开源消息代理，它遵循...
SpringBoot集成RabbitMQ实现用户注册的示例代码
08-25
本文主要介绍了使用SpringBoot集成RabbitMQ实现用户注册的示例代码，通过详细的示例代码，帮助读者学习和工作。该示例代码介绍了如何使用RabbitMQ实现用户注册功能，提供了详细的实现步骤和代码示例。 SpringBoot...
springboot集成rabbitMQ之对象传输的方法
08-28
Spring Boot 集成 RabbitMQ 之对象传输的方法 本文将详细介绍 Spring Boot 集成 RabbitMQ 之对象传输的方法，从 RabbitMQ 的安装、依赖配置、生产者配置、消费者配置等方面进行讲解，并结合实例代码进行说明。 一...
rabbitmq基础+springboot集成rabbitmq
10-14
**SpringBoot集成RabbitMQ** Spring Boot提供了方便的RabbitMQ支持，简化了配置和操作。集成RabbitMQ需要以下步骤： 1. 添加依赖：在`pom.xml`中引入`spring-boot-starter-amqp`依赖。 2. 配置：在`application....
JSD-2204-(业务逻辑开发)-续消息队列-Kafka-RabbitMQ-Day15
TheNewSystrm的博客
09-07 869
JSD-2204-(业务逻辑开发)-续消息队列-Kafka-RabbitMQ-Day15
Spring AMQP 概述
qq_44113347的博客
04-16 1041
Spring AMQP 是一个基于 AMQP 协议的消息队列框架，它提供了 Exchange、Queue 和 Binding 等核心概念，并提供了一系列基于注解的监听器和消息模板类，方便发送和接收消息。在 Spring Cloud 中，可以通过 YML 配置文件来配置 Spring AMQP，并可以在 Maven 中添加依赖来引入 Spring AMQP。
SpringBoot整合AMQP
lwd2307997664的博客
05-03 1238
SpringBoot整合AMQP 文章目录SpringBoot整合AMQP前言一、JMS、AMQP概念以及区别二、RabbitMQ简介三、互联网大厂为什么选择RabbitMQ四、RabbitMQ的一些核心概念五、RabbitMQ的部署安装 前言 消息队列（Message Queue）是一种进程间或者线程间的异步通信方式。使用消息队列，消息生产者会将消息保存在消息队列中，知道消息消费者来取走它。实现服务的解耦合，并提高系统的可靠性和扩展性。 目前常用的开源消息队列有很多，RabbitMQ、ActiveMQ、
记一次测试rabiitmq ‘org.springframework.amqp.core.AmqpAdmin‘ that could not be found. 解决
weixin_50232070的博客
04-25 807
rabiitmq ‘org.springframework.amqp.core.AmqpAdmin‘ that could not be found
Spring AMQP，以及各种模式的使用
scanf_GL的博客
02-21 613
简单使用
Spring中使用RabbitMQ
fxtxz2的专栏
07-20 1688
rabbitMQ使用
SpringBoot集成RabbitMQ
DFT_CaiNiao的博客
11-27 1082
1.添加依赖： <!-- AMQP依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2.修改配置文件： # RabbitMQ rabbitmq: # 服务器 host: 1
Consider defining a bean of type 'org.springframework.amqp.rabbit.connection.ConnectionFactory' in your configuration.
08-25
To define a bean of type 'org.springframework.amqp.rabbit.connection.ConnectionFactory' in your Spring configuration, you can use the following steps: 1. Make sure you have the necessary dependencies in your project's build file. For example, if you're using Maven, include the following dependency in your pom.xml file: ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. Open your configuration class and annotate it with `@Configuration` to indicate that it is a configuration class. 3. Define a method within the class and annotate it with `@Bean`. This method will create and configure the bean. 4. Inside the method, instantiate an object of type `org.springframework.amqp.rabbit.connection.ConnectionFactory`. You can use any implementation of this interface, such as `org.springframework.amqp.rabbit.connection.CachingConnectionFactory`. 5. Configure the connection factory according to your needs. For example, you can set the host, port, username, password, etc. using appropriate setters or through application properties. Here's an example of how the code might look like: ```java import org.springframework.amqp.rabbit.connection.ConnectionFactory; import org.springframework.amqp.rabbit.connection.CachingConnectionFactory; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class RabbitMQConfig { @Bean public ConnectionFactory connectionFactory() { CachingConnectionFactory connectionFactory = new CachingConnectionFactory(); connectionFactory.setHost("localhost"); connectionFactory.setPort(5672); connectionFactory.setUsername("guest"); connectionFactory.setPassword("guest"); // Configure other properties as needed return connectionFactory; } } ``` Make sure to adjust the connection details based on your RabbitMQ setup. I hope this helps! Let me know if you have any further questions.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值