SpringBoot整合RabbitMQ

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

序言

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

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

https://blog.csdn.net/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.csdn.net/typ1805/article/details/82835318

呆某人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot解析pom文件及解析自动配置
m0_49935332的博客
04-22 1159
解析pom文件 父项目 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.4.0</version> <relativePath/> <!-- lookup parent from r..
SpringBoot-RabbitMQ：RabbitMQ为异步消息处理提出了一个很好的解决方案，它是一个非常好用的消息中间件，主要用于中间件的解压缩，同时，Spring Boot为RabbitMQ提供了支持，Spring Boot为兔子准备了spring-boot-starter-amqp，spring-rabbit支持AMQP（即高级消息队列协议，高级消息协议，是应用层协议的一个开放标准），并且为兔子模板和兔子MQ提供了自动配置选项
01-29
SpringBoot-RabbitMQ消息层次 这个指南将引导你建立一个RabbitMQ AMQP服务器发布和订阅消息的过程。 声明 可以使用本人阿里云安装好的RabbitMQ服务器 host:http://120.27.114.229 username:root password:root port:5672 web management: http://120.27.114.229:15672 建立 你会使用Spring AMQP的RabbitTemplate内置应用系统来发布消息和使用一个MessageListenerAdapter POJO来订阅消息 git克隆 gradle bootRun 需要 大约几十分钟 一款文本编辑器或者IDE 你也可以从这个项目中入门代码或者可以在入门 （个人非常喜欢的一件eclipse的IDE）中查看 RabbitMQ服务器 如何完成 像许多的Spring 项目，你可以从头开始并完成每一步，或者你可以绕过你已经熟悉的一些步骤，无论是哪种步骤，你最终可以完成代码 从头开始的话，请去看内置 如果要绕过你熟悉的，按照以下合并： 并解压得到源代码或者从
SpringBoot AMQP
大漠知秋的加油站
07-07 7386
SpringBoot 已经提供了对 AMQP 协议完全支持的 依赖，引入此依赖即可快速方便的在 SpringBoot 中使用 RabbitMQ。参考：Spring AMQP。 声明式实现（推荐） 注意，以上配置再启动 SpringBoot 并不会立马创建交换机、队列、绑定，SpringBoot AMQP 有懒加载，需要等到使用 时才会创建。什么是使用 呢？ 再比如监听了队列 死信队列机制 死信队列需要在创建 Queue 时指定对应属性： RabbitTemplate 是 SpringBoo
从0到1全面讲解RabbitMq消息队列搭建以及SpringBoot配置详解
最新发布
八戒的博客
05-28 1080
按提示安装即可，注意安装路径不要带中文。按win+r,输入cmd进入命令窗口，然后cd到Mq的sbin路径下，输入如下命令进行安装验证是否安装成功Erlang安装下载安装即可RabbitMq界面RabbitMq配置完成之后，默认打开地址默认用户名：guest 密码：guest。
SpringBoot所有的Starter以及常用依赖
A_java_c的博客
08-10 1611
官网 官网 列表 spring-boot-starter Core starter, including auto-configuration support, logging and YAML spring-boot-starter-activemq Starter for JMS messaging using Apache ActiveMQ spring-boot-starter-amqp Starter for using Spring AMQP and Rabbit MQ
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最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
Springboot整合RabbitMQ简单demo
01-22
本文将详细讲解如何在Spring Boot项目中整合RabbitMQ，并通过一个简单的示例来展示其实现过程。 首先，我们需要了解RabbitMQ的基本概念。RabbitMQ是一个开源的消息代理和队列服务器，遵循AMQP（Advanced Message ...
springboot整合rabbitmq
09-14
SpringBoot整合RabbitMQ是将高可用的消息中间件RabbitMQ与SpringBoot框架结合，以实现应用程序间的异步通信和解耦。RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）协议的消息队列，而SpringBoot则为...
springboot整合RabbitMQ
11-04
springboot整合RabbitMQ,测试实现Queue队列使用，Exchange交换器的基本使用。
springboot整合rabbitmq项目
01-30
SpringBoot整合RabbitMQ项目是将流行的Spring Boot框架与企业级消息中间件RabbitMQ结合，以实现高效、可靠的异步通信和解耦。在这个项目中，我们将探讨如何配置Spring Boot应用来使用RabbitMQ，以及相关的核心概念和...
Springboot整合RabbitMq学习
01-05
SpringBoot整合RabbitMQ的学习是一个重要的主题，尤其对于那些希望在Java环境中构建高效、可扩展的消息传递系统的开发者来说。RabbitMQ是一个开源的消息代理和队列服务器，它使用AMQP（Advanced Message Queuing ...
SpringBoot整合rabbitMQ,spring-boot-starter-amqp 的使用
weixin_43343423的博客
11-26 3566
在springBoot项目中使用rabbitMQ是很方便的,spring提供了spring-boot-starter-amqp依赖,只需要简单的配置即可与spring无缝整合 本文不介绍rabbitMQ理论知识,主要介绍在spring中如何使用rabbirMQ 依赖与配置 maven <dependencies> <dependency> ...
如何在Spring Boot中集成RabbitMQ
weixin_43866043的博客
12-07 1134
在Spring Boot集成的RabbitMQ应用中，通常会在消费者处理消息时发生异常的情况下，明确地将消息发送到死信队列。如果点进来，没有显示这个绑定队列，就说明配置的不对，后续也无法消费，点进队列后，就会显示队列中的消息了。避免消息丢失：死信队列确保无法处理的消息不会被丢失，而是存储在一个特定的地方，供进一步的检查和处理。队列达到最大长度：如果队列设置了最大长度并达到这个限制，最老的消息可能会被移动到死信队列。在这个例子中，如果在处理消息的过程中发生异常，消息会被明确地拒绝，并发送到配置的死信队列。
RabbitMQ 浅析
Darklovy
06-05 554
转载自：https://www.cnblogs.com/ityouknow/p/6120544.html RabbitMQ 是一个由 Erlang 语言开发的 AMQP（高级消息队列协议） 的开源实现。它主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲、消息分发的作用。 AMQP AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是...
springboot 整合rabbitmq
09-07
- *1* [SpringBoot整合RabbitMQ](https://blog.csdn.net/K_kzj_K/article/details/106642250)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值