SpringBoot整合RabbitMQ

最新推荐文章于 2025-03-10 23:51:57 发布
最新推荐文章于 2025-03-10 23:51:57 发布
阅读量272 收藏
点赞数
分类专栏： 消息队列 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/w8827130/article/details/110008865
版权

序言

如果不知道如何使用Idea创建SpringBoot项目或者不知道如何在Windows系统中搭建RabbitMQ环境，可以参考如下博客

https://blog.youkuaiyun.com/w8827130/article/details/109934393    最简单SpringBoot项目创建

https://blog.youkuaiyun.com/w8827130/article/details/109946723    Windows安装RabbitMQ

SpringBoot项目结构

RabbitMQ

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.4.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot</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>

SpringBoot的pom.xml里新增了spring-boot-starter-amqp依赖用于引入RabbitMQ

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

application.yml

配置文件中设置项目访问端口为8081，还有rabbitmq的配置

server:
  port: 8081
spring:
  application:
    name: rabbitmq-demo
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest

RabbitConfig.java

配置RabbitMQ，声明queue、exchange、bingding

queue：hello、topic.message、topic.messages、fanout.A、fanout.B、fanout.C

exchange：topicExchange、fanoutExchange、

bingding：topic.message与topicExchange绑定（routingKey=topic.message），topic.messages与topicExchange绑定（routingKey=topic.#），fanout.A、fanout.B、fanout.C与fanoutExchange绑定

package com.example.springboot.config;

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

@Configuration
public class RabbitConfig {

    @Bean
    public Queue helloQueue() {
        return new Queue("hello");
    }

    @Bean
    public Queue userQueue() {
        return new Queue("user");
    }
    
    @Bean
    public Queue queueMessage() {
        return new Queue("topic.message");
    }

    @Bean
    public Queue queueMessages() {
        return new Queue("topic.messages");
    }

    @Bean
    public Queue AMessage() {
        return new Queue("fanout.A");
    }

    @Bean
    public Queue BMessage() {
        return new Queue("fanout.B");
    }

    @Bean
    public Queue CMessage() {
        return new Queue("fanout.C");
    }

    /**
     * 创建TopicExchange
     * @return TopicExchange
     */
    @Bean
    TopicExchange topicExchange() {
        return new TopicExchange("topicExchange");
    }

    /**
     * 创建FanoutExchange
     * @return FanoutExchange
     */
    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    /**
     * 将queueMessage队列与TopicExchange交换机绑定，使用routingKey=topic.message
     * @param queueMessage
     * @param topicExchange
     * @return Binding
     */
    @Bean
    Binding bindingExchangeMessage(Queue queueMessage, TopicExchange topicExchange) {
        return BindingBuilder.bind(queueMessage).to(topicExchange).with("topic.message");
    }

    /**
     * 将queueMessage队列与TopicExchange交换机绑定，使用routingKey=topic.#（# 匹配一个或者多个词；* 仅能匹配一个词）
     * @param queueMessages
     * @param topicExchange
     * @return Binding
     */
    @Bean
    Binding bindingExchangeMessages(Queue queueMessages, TopicExchange topicExchange) {
        return BindingBuilder.bind(queueMessages).to(topicExchange).with("topic.#");
    }

    /**
     * AMessage与fanoutExchange绑定
     * @param AMessage
     * @param fanoutExchange
     * @return Binding
     */
    @Bean
    Binding bindingExchangeA(Queue AMessage,FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(AMessage).to(fanoutExchange);
    }

    /**
     * bMessage与fanoutExchange绑定
     * @param BMessage
     * @param fanoutExchange
     * @return Binding
     */
    @Bean
    Binding bindingExchangeB(Queue BMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(BMessage).to(fanoutExchange);
    }

    /**
     * CMessage与fanoutExchange绑定
     * @param CMessage
     * @param fanoutExchange
     * @return Binding
     */
    @Bean
    Binding bindingExchangeC(Queue CMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(CMessage).to(fanoutExchange);
    }
}

发送方式

Direct

将消息直接发送给特定的queue（这种方式几乎不会被用，违背了RabbitMQ解耦的初衷）

Sender.java

package com.example.springboot.sender;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Date;

@Component
public class Sender {

    private static final Logger log = LoggerFactory.getLogger(Sender.class);

    @Autowired
    public AmqpTemplate amqpTemplate;

    public void send(){
        String context = "hello"+ new Date();
        log.info("Sender:" + context);
        this.amqpTemplate.convertAndSend( "hello",context);
    }
}

Receiver.java

package com.example.springboot.receiver;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class Receiver {

    private static final Logger log = LoggerFactory.getLogger(Receiver.class);

    //监听器监听指定的Queue
    @RabbitListener(queues = "hello")
    public void process(String hello) {
        log.info("ReceiverHello:" + hello);
    }


}

实体类的传输

User.java

package com.example.springboot.pojo;

import java.io.Serializable;

public class User implements Serializable {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

UserSender.java

package com.example.springboot.sender;

import com.example.springboot.pojo.User;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserSender {

    @Autowired
    private AmqpTemplate amqpTemplate;

    public void send(){
        User user = new User();
        user.setName("daimouren");
        amqpTemplate.convertAndSend("user",user);
    }
}

UserReceiver.java

package com.example.springboot.receiver;

import com.example.springboot.pojo.User;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;

@Component
@RabbitListener(queues = "user")
public class UserReceiver {

    private static final Logger log = LoggerFactory.getLogger(Receiver.class);

    @RabbitHandler
    public void process(User user){
        log.info("listener user：{}",user.getName());
    }
}

Topic

TopicSender.java

package com.example.springboot.sender;

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

@Component
public class TopicSender {

    private static final Logger log = LoggerFactory.getLogger(TopicSender.class);

    @Autowired
    public AmqpTemplate amqpTemplate;

    public void sendTopic(){
        amqpTemplate.convertAndSend("topicExchange","topic.message","Topic-message1");

        amqpTemplate.convertAndSend("topicExchange","topic.messages","Topic-message2");

        amqpTemplate.convertAndSend("topicExchange","topic.test3.tes2","Topic-message3");
    }

}

TopicReceiver.java

package com.example.springboot.receiver;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class TopicReceiver {

    private static final Logger log = LoggerFactory.getLogger(TopicReceiver.class);

    @RabbitListener(queues = "topic.message")
    public void process1(String msg){
        log.info("TopicReceiver1："+msg);
    }
    
    @RabbitListener(queues = "topic.messages")
    public void process2(String msg){
        log.info("TopicReceiver2："+msg);
    }
}

Fanout

FanoutSender.java

package com.example.springboot.sender;

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

import java.util.Date;

@Component
public class FanoutSender {

    private static final Logger log = LoggerFactory.getLogger(FanoutSender.class);

    @Autowired
    public AmqpTemplate amqpTemplate;

    public void sendFanout(){
        String context = "fanoutExchange："+ new Date();
        log.info("Sender:" + context);
        this.amqpTemplate.convertAndSend("fanoutExchange","abcd.ee",context);
    }
}

FanoutReceiver.java

package com.example.springboot.receiver;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class FanoutReceiver {

    private static final Logger log = LoggerFactory.getLogger(FanoutReceiver.class);

    //监听器监听指定的Queue
    @RabbitListener(queues = "fanout.A")
    public void processfanoutA(String message) {
        log.info("ReceiverfanoutA:" + message);
    }

    //监听器监听指定的Queue
    @RabbitListener(queues = "fanout.B")
    public void processfanoutB(String message) {
        log.info("ReceiverfanoutB:" + message);
    }

    //监听器监听指定的Queue
    @RabbitListener(queues = "fanout.C")
    public void processfanoutC1(String message) {
        log.info("ReceiverfanoutC1:" + message);
    }
}

RabbitmqController.java

创建Controller接口，对各种场景的mq发送的测试

package com.example.springboot.controller;

import com.example.springboot.sender.FanoutSender;
import com.example.springboot.sender.Sender;
import com.example.springboot.sender.TopicSender;
import com.example.springboot.sender.UserSender;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RabbitmqController {

    @Autowired
    private Sender sender;

    @Autowired
    private UserSender userSender;

    @Autowired
    private TopicSender topicSender;

    @Autowired
    private FanoutSender fanoutSender;

    @RequestMapping("sendhello")
    public String sendhello() {
        sender.send();
        return "send success!";
    }

    @RequestMapping("sendfanout")
    public String sendfanout() {
        fanoutSender.sendFanout();
        return "send success!";
    }

    @RequestMapping("senduser")
    public String senduser() {
        userSender.send();
        return "send success!";
    }

    @RequestMapping("sendtopic")
    public String sendtopic() {
        topicSender.sendTopic();
        return "send success!";
    }
}

 

参考文章

https://blog.youkuaiyun.com/typ1805/article/details/82835318

Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 50万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
springboot整合RabbitMQ
weixin_45671337的博客
07-19 945
介绍 MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。 MQ特点： MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取或者订阅队列
Spring Boot ： Spring Boot 整合 RabbitMQ
CHIKA2333的博客
08-09 635
RabbitMQ 是一个消息队列，说到消息队列，大家可能多多少少有听过，它主要的功能是用来实现应用服务的异步与解耦，同时也能起到削峰填谷、消息分发的作用。消息队列在比较主要的一个作用是用来做应用服务的解耦，消息从消息的生产者传递到消息队列，消费者从消息队列中获取消息并进行消费，生产者不需要管是谁在消费消息，消费者也无需关注消息是由谁来生产的。在分布式的系统中，消息队列也会被用在其他地方，比如分布式事务的支持，代表如阿里开源的 RocketMQ。当然，我们本篇文章的主角还是 RabbitMQ。
SpringBoot中整合RabbitMQ（测试+部署上线 最完整）
最新发布
web15285868498的博客
03-10 1640
RabbitMQ服务端是由并发式语言Erlang编写的，所以安装RabbitMQ的之前需要安装Erlang，保证所需要的环境。注意：这里没有下载的版本，下载需要与自己的版本一致，如果发现启动不了RabbitMQ，请看后面的启动RabbitMQ。由于目前是测试阶段，这里我使用之前学习的时候的版本。
# SpringBoot 集成 RabbitMQ
不积跬步，无以至千里；不积小流，无以成江海
01-13 231
RabbitMQ是实现AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ主要是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时，消费者无法快速消费，那么需要一个中间层。保存这个数据。...
springboot 集成rabbitmq
qq_34135615的博客
02-01 986
springboot集成rabbitmq
springboot整合rabbitmq
weixin_43790613的博客
10-07 1470
文章目录自己创建连接对象 导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 自己创建连接对象 连接对象的工具类 import com.rabbitmq.client.Channel; import com.rabbitm
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
springboot整合rabbitmq，开启手工确认。保证消息100%投递
09-16
在Spring Boot应用中整合RabbitMQ，以确保消息100%投递，是一个关键的实践，特别是对于那些需要高可靠性和数据一致性的系统。RabbitMQ是一个流行的开源消息代理，它遵循Advanced Message Queuing Protocol (AMQP)...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包
07-02
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包 整合4种常用模式+高级特性死信队列 暂未整合TTL队列 博客地址:...
Springboot 整合RabbitMq
GSON的博客
08-21 4917
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
Spring boot整合RabbitMQ
一个还在上学的程序缘
11-30 3915
目录： 一、RabbitMQ简介   RabbitMQ安装不必我多说，linux和windows环境下都可以安装，我是在windows环境下进行安装的，安装RabbitMQ之前需要先安装Erlang，因为Rabbit MQ 是建立在Erlang OTP平台上，而且安装Erlang 时要注意安装的RabbityMQ 所依赖的Erlang版本。   RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而且支持跨平台。
Spring Boot整合RabbitMQ
哟，你又在偷偷写bug！
03-03 2273
// 创建队列 @Bean public Queue queue() {/*** @param name 队列名字* @param durable 声明一个持久队列(该队列将在服务器重启后继续存在)，则为true} // 创建交换机（Direct类型） @Bean public DirectExchange exchange() {} // 绑定队列到交换机 @Bean public Binding binding() {} }
springboot整合RabbitMq
wwwzhouzy的专栏
06-26 434
一、RabbitMq的介绍 RabbitMQ是消息中间件的一种,消息中间件即分布式系统中完成消息的发送和接收的基础软件.这些软件有很多,包括ActiveMQ(apache公司的),RocketMQ(阿里巴巴公司的,现已经转让给apache). 消息中间件的工作过程可以用生产者消费者模型来表示.即,生产者不断的向消息队列发送信息,而消费者从消息队列中消费信息.具体过程如下: 从上图可看出,对于消息队列来说,生产者,消息队列,消费者是最重要的三个概念,生产者发消息到消息队列中去,消费者监听指定的消
springboot整合rabbitMQ
weixin_41018853的博客
07-01 88
SSS
spring-boot 集成 rabbitmq
qq_40074764的博客
06-07 774
本文转载自:https://blog.youkuaiyun.com/zl18310999566/article/details/54341057之前说了集成的ActiveMQ，那就再说说集成另一个很火的MQ，兔子。本文示例主要参看官方的演示https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples/spring-...
springboot 整合rabbitmq
09-07
Spring Boot框架可以很容易地与RabbitMQ进行集成。为了实现这个目标，你需要在项目的依赖项中添加两个关键的依赖项。首先，你需要添加spring-boot-starter-amqp依赖项，它提供了与RabbitMQ进行通信的必要类和方法。其次，你还需要添加spring-boot-starter-web依赖项，以便在项目中使用Web功能。 在你的项目中创建两个Spring Boot应用程序，一个是RabbitMQ的生产者，另一个是消费者。通过这两个应用程序，你可以实现消息的发送和接收。生产者应用程序负责将消息发送到RabbitMQ的消息队列，而消费者应用程序则负责从队列中接收并处理消息。这样，你就可以实现基于RabbitMQ的消息传递系统。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [SpringBoot整合RabbitMQ](https://blog.youkuaiyun.com/K_kzj_K/article/details/106642250)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [Springboot 整合RabbitMq ，用心看完这一篇就够了](https://blog.youkuaiyun.com/qq_35387940/article/details/100514134)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [undefined](undefined)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值