SpringBoot 集成 RabbitMQ

已于 2024-02-28 08:33:39 修改
阅读量9.6k 收藏 60
点赞数 12
分类专栏： RabbitMQ SpringBoot整合 文章标签： java-rabbitmq rabbitmq spring boot
于 2023-03-04 14:47:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44981526/article/details/129334375
版权
本文详细介绍了如何在SpringBoot应用中集成RabbitMQ，包括配置依赖、YAML配置、创建队列、消息发送和接收。接着，通过广播模式、路由模式、主题模式和头部模式四个例子展示了RabbitMQ的不同消息处理方式，以及在Java代码中的实现。
摘要由CSDN通过智能技术生成

SpringBoot 集成 RabbitMQ

1.应用实例

  • 需求说明/图解

image-20230302221224596

-P : 消息的发送者/生产者
-C : 消息的接受者/消费者

-中间表示队列

image-20230302222158980

  • 完成步骤
  1. 添加依赖
<!--rabbitmq-需要的 AMQP 依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  1. 修改yaml配置
spring:
  #rabbitmq 配置
  rabbitmq:
    host: 192.168.79.202
    username: guest
    password: guest
    #虚拟主机
    virtual-host: /
    #端口
    port: 5672
    listener:
      simple:
        #消费者最小数量
        concurrency: 10
        #消费者最大数量
        max-concurrency: 10
        #限制消费者，每次只能处理一条消息，处理完才能继续下一条消息
        prefetch: 1
        #启动时是否默认启动容器，默认为 true
        auto-startup: true
        #被拒绝时重新进入队列的
        default-requeue-rejected: true
    template:
      retry:
        #启用消息重试机制，默认为 false
        enabled: true
        #初始重试间隔时间
        initial-interval: 1000ms
        #重试最大次数，默认为 3 次
        max-attempts: 3
        #重试最大时间间隔，默认 10000ms
        max-interval: 10000ms
        #重试的间隔乘数，
        #配置 2 的话，第一次等 1s，第二次等 2s，第三次等 4s
        multiplier: 1

        #在 RabbitMQ 中，initial-interval 和 max-interval 是用于指定消息重试机制的两个参数，
        #它们的区别如下：
        #1. initial-interval（初始间隔时间）：表示第一次重试的时间间隔，也就是在消息第一次处
        #理失败后，等待多长时间再尝试重新发送消息。这个参数的默认值是 1 秒。
        #2.max-interval（最大间隔时间）：表示重试过程中的最大时间间隔，也就是每次重试时，
        #最长等待多长时间再尝试重新发送消息。这个参数的默认值是 10 秒。
  1. 在RabbitMQ配置类中创建队列
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 RabbitMQConfig {

    //定义队列名
    private static final String QUEUE = "queue";

	//创建队列
    /**
     * 1. 配置队列
     * 2. 队列名为 queue
     * 3. true 表示: 持久化 (不填，默认为true,默认持久化)
     * durable： 队列是否持久化。 队列默认是存放到内存中的，rabbitmq 重启则丢失，
     * 若想重启之后还存在则队列要持久化，
     * 保存到 Erlang 自带的 Mnesia 数据库中，当 rabbitmq 重启之后会读取该数据库
     * @return
     */
    @Bean
    public Queue queue(){
        return new Queue(QUEUE,true);
    }
    
}
  1. 创建消息发送者
/**
 * 消息发送者
 */
@Slf4j
@Service
public class MQSender {

    @Resource
    private RabbitTemplate rabbitTemplate;

    //方法：发送消息
    public void send(Object msg){
        log.info("发送消息-" + msg);
        //没有指定交换机会走默认的交换机，AMQP default
        //AMQP default是一个direct路由模式的交换机
        rabbitTemplate.convertAndSend("queue",msg);
    }

}
  1. 创建消息接收者
/**
 * 消息接收者
 */
@Service
@Slf4j
public class MQReceiver {

    //方法：接收消息
    @RabbitListener(queues = "queue")
    public void receive(Object msg) {
        log.info("接收到消息--" + msg);
    }

}
  1. 创建controller进行测试
@Controller
public class RabbitMQHandler {

    //装配MQSender
    @Resource
    private MQSender mqSender;

    //方法：调用消息生产者，发送消息
    @RequestMapping("/mq")
    @ResponseBody
    public void mq(){
        mqSender.send("hello llp");
    }
}

2.完成测试

  1. 配置 RabbitMQ 所在的 Linux, 开放 5672 端口, 因为 Java 访问 RabbitMQ, 走的是 5672测试前，将 Mysql, Redis,RabbitMQ 启动。
  • 防火墙开启端口访问
firewall-cmd --zone=public --add-port=5672/tcp --permanent
  • 开启后需要重启防火墙才生效
firewall-cmd --reload
  • 执行 firewall-cmd --list-ports 查看端口
  1. 启动项目, 再观察 RabbitMQ 管控台

image-20230303212547071

image-20230303212600198

image-20230303212611028

image-20230303212619416

image-20230303212629191

观察后端输出

image-20230303212258586

image-20230303212716747

image-20230303212727482

当前案例, 走的是默认交换机 (AMQP Default)

image-20230303212811691

RabbitMQ 使用模式

1. Fanout-广播模式

Fanout简介

  1. fanout 就是广播模式, 就是把交换机(Exchange)里的消息发送给所有绑定该交换机的
    队列，忽略 routingKey(也就是路由)。

  2. 示意图

image-20230303202028717

解读上图：

  • 生产者把消息发送给指定的交换机
  • 再把交换机的消息发送给所有绑定该交换机的队列, 忽略 routingKey/路由
  1. 官方文档: https://www.rabbitmq.com/tutorials/tutorial-three-java.html

image-20230303202159064

应用实例

  • 需求说明/图解

image-20230303202229580

  • 执行效果

image-20230303210901823

​

代码实现

添加队列和交换机，绑定队列和交换机

@Configuration
public class RabbitMQConfig {
    
    private static final String QUEUE1 = "queue_fanout01";
    private static final String QUEUE2 = "queue_fanout02";
    private static final String EXCHANGE = "fanoutExchange";

     //--------fanout广播模式---------
   /**
     * 1. 配置队列
     * 2. 队列名为 queue
     * 3. true 表示: 持久化 (不填，默认为true,默认持久化)
     * durable： 队列是否持久化。 队列默认是存放到内存中的，rabbitmq 重启则丢失，
     * 若想重启之后还存在则队列要持久化，
     * 保存到 Erlang 自带的 Mnesia 数据库中，当 rabbitmq 重启之后会读取该数据库
     * @return
     */
    @Bean
    public Queue queue1(){
        return new Queue(QUEUE1);
    }
    
    
    @Bean
    public Queue queue2(){
        return new Queue(QUEUE2);
    }

    //创建交换机
    @Bean
    public FanoutExchange exchange(){
        return new FanoutExchange(EXCHANGE);
    }

    //将队列和交换机进行绑定
    @Bean
    public Binding binding01(){
        //将队列queue1和交换机进行绑定
        return BindingBuilder.bind(queue1()).to(exchange());
    }

    @Bean
    public Binding binding02(){
        //将队列queue1和交换机进行绑定
        return BindingBuilder.bind(queue2()).to(exchange());
    }
}

消息发送者

/**
 * 消息发送者
 */
@Slf4j
@Service
public class MQSender {

    @Resource
    private RabbitTemplate rabbitTemplate;

    //fanout广播模式发送消息
    public void sendFanout(Object msg){
        log.info("发送消息-" + msg);
        //因为是fanout广播模式，不需要指定路由，这里路由赋空值处理
        rabbitTemplate.convertAndSend("fanoutExchange","",msg);
    }

}

消息接收者

/**
 * 消息接收者
 */
@Service
@Slf4j
public class MQReceiver {
	
    //queues对应接收消息的队列
    @RabbitListener	(queues = "queue_fanout01")
    public void receive1(Object msg) {
        log.info("从 queue_fanout01 接收消息-" + msg);
    }

    @RabbitListener(queues = "queue_fanout02")
    public void receive2(Object msg){
        log.info("从 queue_fanout02 接收消息-" + msg);
    }

}

controller层测试类

@Controller
public class RabbitMQHandler {

    //装配MQSender
    @Resource
    private MQSender mqSender;

    //调用消息生产者，发送消息到交换机
    @RequestMapping("/mq/fanout")
    @ResponseBody
    public void fanout(){
        mqSender.sendFanout("hello fanout~");
    }

}

完成测试

image-20230303213503564

  • 点击交换机 fanoutExchange, 查看绑定情况

image-20230303213716620

image-20230303213802275

image-20230303213816463

观察后台输出

image-20230303213840168

点击队列名,查看队列情况

image-20230303213847891

image-20230303213901556

image-20230303213941410

2.Direct-路由模式

Direct简介

  1. direct 就是路由模式, 路由模式是在使用交换机的同时，生产者指定路由发送数据，
    消费者绑定路由接受数据。
  2. 与广播模式不同的是，广播模式只要是绑定了交换机的队列都会收到生产者向交换
    机推送过来的数据。而路由模式下加了一个路由设置，生产者向交换机发送数据时，会
    声明发送给交换机下的哪个路由，并且只有当消费者的队列绑定了交换机并且声明了路
    由，才会收到数据
  3. 示意图

image-20230303214433190

  • P：消息的生产者
  • X：交换机
  • 红色：队列
  • C1，C2：消息消费者
  • error，info，warning：路由
  1. 官方文档: https://www.rabbitmq.com/tutorials/tutorial-four-java.html

image-20230303214550619

应用实例

  • 需求说明/图解

image-20230303214622009

  • 执行效果

image-20230304102154461

代码实现

声明队列、交换机、路由

@Configuration
public class RabbitMQConfig {

    //direct
    private static final String QUEUE_DIRECT1 = "queue_direct01";
    private static final String QUEUE_DIRECT2 = "queue_direct02";
    private static final String EXCHANGE_DIRECT = "directExchange";
    //路由
    private static final String routing_key01 = "queue.red";
    private static final String routing_key02 = "queue.green";


    //--------direct路由模式---------
    @Bean
    public Queue queue_direct1() {
        return new Queue(QUEUE_DIRECT1);
    }

    @Bean
    public Queue queue_direct2() {
        return new Queue(QUEUE_DIRECT2);
    }

    @Bean
    public DirectExchange exchange_direct() {
        return new DirectExchange(EXCHANGE_DIRECT);
    }

    @Bean
    public Binding binding_direct1() {
        //将队列queue_direct1和交换机进行绑定，并给队列绑定路由
        return BindingBuilder.bind(queue_direct1()).to(exchange_direct()).with(routing_key01);
    }

    @Bean
    public Binding binding_direct2() {
        //将队列queue_direct2和交换机进行绑定，并给队列绑定路由
        return BindingBuilder.bind(queue_direct2()).to(exchange_direct()).with(routing_key02);
    }

}

消息发送者

/**
 * 消息发送者
 */
@Slf4j
@Service
public class MQSender {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void sendDirect1(Object msg){
        log.info("发送消息-" + msg);
        rabbitTemplate.convertAndSend("directExchange","queue.red",msg);
    }

    public void sendDirect2(Object msg){
        log.info("发送消息-" + msg);
        rabbitTemplate.convertAndSend("directExchange","queue.green",msg);
    }
    
}

消息接收者

/**
 * 消息接收者
 */
@Service
@Slf4j
public class MQReceiver {
    @RabbitListener(queues = "queue_direct01")
    public void queue_direct1(Object msg){
        log.info("从 queue_direct1 接收消息-" + msg);
    }

    @RabbitListener(queues = "queue_direct02")
    public void queue_direct2(Object msg){
        log.info("从 queue_direct2 接收消息-" + msg);
    }

}

controller测试

@Controller
public class RabbitMQHandler {

    //装配MQSender
    @Resource
    private MQSender mqSender;

    //direct 模式
    @GetMapping("/mq/direct01")
    @ResponseBody
    public void direct01() {
        mqSender.sendDirect1("hello aimee");
    }

    //direct 模式
    @GetMapping("/mq/direct02")
    @ResponseBody
    public void direct02() {
        mqSender.sendDirect2("hello llp");
    }
}

完成测试

  1. 启动项目, 再观察 RabbitMQ 管控台

    image-20230304102219589

    点击交换机 directExchange, 查看绑定情况

image-20230304102255218

image-20230304102303323

image-20230304102330002

image-20230304102335880

查看控制台数据情况

image-20230304102351213

点击相应的队列, 观察队列已经有了消息变化, (提示：发送消息后就观察, 因为是实时刷新
的)

image-20230304102522115

image-20230304102530547

image-20230304102537236

3.Topic主题模式

Topic 介绍

  1. direct 模式会造成路由 RoutingKey 太多, 而实际开发中往往是按照某个规则来进行路
    由匹配的, RabbitMQ 提供了 Topic 模式/主题模式来适应这种需求.
  2. Topic 模式是 direct 模式上的一种扩展/叠加, 扩展/叠加了模糊路由 RoutingKey 的模
    式, 可以理解为是模糊的路由匹配模式

  • *（星号）：可以（只能）匹配一个单词

  • #（井号）：可以匹配多个单词（或者零个）

示意图:

image-20230304102751872

  1. 官方文档: https://www.rabbitmq.com/tutorials/tutorial-five-java.html

image-20230304102839581

应用实例

  • 需求说明/图解

image-20230304102911668

  • 执行效果

代码实现

配置队列、交换机、路由

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

@Configuration
public class RabbitMQTopicConfig {

    //topic主题模式
    private static final String QUEUE_TOPIC1 = "queue_topic01";
    private static final String QUEUE_TOPIC2 = "queue_topic02";
    private static final String EXCHANGE_TOPIC = "topicExchange";
    //路由
    private static final String routing_key01 = "#.queue.#";
    private static final String routing_key02 = "*.queue.#";


    @Bean
    public Queue queue_topic01() {
        return new Queue(QUEUE_TOPIC1);
    }

    @Bean
    public Queue queue_topic02() {
        return new Queue(QUEUE_TOPIC2);
    }

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(EXCHANGE_TOPIC);
    }

    @Bean
    public Binding binding_topic1() {
        //将队列queue1和交换机进行绑定
        return BindingBuilder.bind(queue_topic01()).to(topicExchange()).with(routing_key01);
    }

    @Bean
    public Binding binding_topic2() {
        //将队列queue1和交换机进行绑定
        return BindingBuilder.bind(queue_topic02()).to(topicExchange()).with(routing_key02);
    }

}

消息发送者

/**
 * 消息发送者
 */
@Slf4j
@Service
public class MQSender {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void sendTopic1(Object msg) {
        log.info("发送消息-" + msg);
        rabbitTemplate.convertAndSend("topicExchange", "queue.red.message", msg);
    }

    public void sendTopic2(Object msg) {
        log.info("发送消息-" + msg);
        rabbitTemplate.convertAndSend("topicExchange", "green.queue.green.message", msg);
    }

}

消息接收者

/**
 * 消息接收者
 */
@Service
@Slf4j
public class MQReceiver {
-
    @RabbitListener(queues = "queue_topic01")
    public void queue_topic1(Object msg) {
        log.info("从 queue_topic01 接收消息-" + msg);
    }

    @RabbitListener(queues = "queue_topic02")
    public void queue_topic2(Object msg) {
        log.info("从 queue_topic02 接收消息-" + msg);
    }
}

编写controller层测试方法

@Controller
public class RabbitMQHandler {

    //装配MQSender
    @Resource
    private MQSender mqSender;

    //topic 模式
    @GetMapping("/mq/topic01")
    @ResponseBody
    public void topic01() {
        mqSender.sendTopic1("hello aimee topic");
    }

    //topic 模式
    @GetMapping("/mq/topic02")
    @ResponseBody
    public void topic02() {
        mqSender.sendTopic2("hello llp topic");
    }

}

完成测试

  1. 启动项目, 再观察 RabbitMQ 管控台

image-20230304112241248

点击交换机 topicExchange, 查看绑定情况

image-20230304112257946

image-20230304112310949

image-20230304112323341

观察后台输出

queue.red.message
green.queue.green.message
#.queue.#
*.queue.#
调用topic1, queue.red.message匹配到的路由是#.queue.#
调用topic2, green.queue.green.message匹配到的路由是*.queue.#和#.queue.#
* 有且仅有一个 
# 可以有多个也可以没有

image-20230304112228196

4.Headers模式

Headers 介绍

  1. headers 模式/headers 头路由模式 使用比较少
  2. headers 交换机是一种比较复杂且少见的交换机，不同于 direct 和 topic，它不关心路由 key 是否匹配，而只关心 header 中的 key-value 对是否匹配(这里的匹配为精确匹配，包含键和值都必须匹配)， 有点类似于 http 中的请求头。
  3. headers 头路由模型中，消息是根据 prop 即请求头中 key-value 来匹配的。
  4. 绑定的队列(也可以理解成消费方) 指定的 headers 中必须包含一个"x-match"的键
  5. 键"x-match"的值有 2 个：all 和 any。
    all：表示绑定的队列/消费方 指定的所有 key-value 都必须在消息 header 中出现并匹配
    any：表示绑定的队列/消费方 指定的 key-value 至少有一个在消息 header 中出现并匹配即可

应用实例

  • 需求说明/图解
  1. 给 headers 交换机发送消息 hello ABC, 让 QUEUE01 和 QUEUE02 两个队列都接收
  2. 给 headers 交换机发送消息 hello llp, 让 QUEUE01 队列都接收
  3. 适应 headers 模式完成

代码实现

创建队列、交换机

@Configuration
public class RabbitMQHeadersConfig {

    private static final String QUEUE01 = "queue_header01";
    private static final String QUEUE02 = "queue_header02";
    private static final String EXCHANGE = "headersExchange";


    @Bean
    public Queue queue_header01() {
        return new Queue(QUEUE01);
    }

    @Bean
    public Queue queue_header02() {
        return new Queue(QUEUE02);
    }

    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange(EXCHANGE);
    }

    @Bean
    public Binding binding_header01() {
        Map<String,Object> map = new HashMap<>();
        map.put("color","red");
        map.put("speed","low");
        System.out.println("yy=" + headersExchange().hashCode());
        //whereAny(map): 只要发送的消息的属性 MessageProperties 有任意一个k-v匹配就 OK
        return BindingBuilder.bind(queue_header01()).to(headersExchange()).whereAny(map).match();
    }

    @Bean
    public Binding binding_header02() {
        Map<String, Object> map = new HashMap<>();
        map.put("color", "red");
        map.put("speed", "fast");
        System.out.println("xx=" + headersExchange().hashCode());
        //whereAll(map): 发送的消息的属性 MessageProperties 要全部匹配才 OK
        return BindingBuilder.bind(queue_header02()).to(headersExchange()).whereAll(map).match();
    }

}

消息发送者

@Slf4j
@Service
public class MQSender {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void sendHeader1(String msg) {
        MessageProperties properties = new MessageProperties();
        properties.setHeader("color", "red");
        properties.setHeader("speed", "fast");
        Message message = new Message(msg.getBytes(), properties);
        rabbitTemplate.convertAndSend("headersExchange","",message);
    }

    public void sendHeader2(String msg) {
        MessageProperties properties = new MessageProperties();
        properties.setHeader("color", "red");
        properties.setHeader("speed", "normal");
        Message message = new Message(msg.getBytes(), properties);
        rabbitTemplate.convertAndSend("headersExchange","",message);
    }

}

消息接收者

/**
 * 消息接收者
 */
@Service
@Slf4j
public class MQReceiver {

    @RabbitListener(queues = "queue_header01")
    public void queue_header1(Message message) {
        log.info("queue_header01 接收消息 message 对象" + message);
        log.info("queue_header01 接收消息" + new String(message.getBody()));
    }

    @RabbitListener(queues = "queue_header02")
    public void queue_header2(Message message) {
        log.info("queue_header2 接收消息 message 对象" + message);
        log.info("queue_header2 接收消息" + new String(message.getBody()));
    }
}

完成测试

  1. 启动项目, 再观察 RabbitMQ 管控台

image-20230304143653007

点击交换机 headersExchange, 查看绑定情况

image-20230304143711829

image-20230304143723498

image-20230304143730141

调用header1，队列1和队列2都能接收

image-20230304143756756

image-20230304143740916

调用header2，header头并不完全匹配，因此只有队列1能够接收到消息

image-20230304144022018

llp1110
关注
专栏目录
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4791
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springboot集成RabbitMQ
最新发布
Flying_Fish_roe的博客
09-26 1654
可以通过@Bean@Bean@Bean@Bean：定义了一个Direct类型的交换器。Queue：定义了一个队列testQueue。Binding：将队列与交换器通过routingKey绑定。
SpringBoot集成RabbitMQ
abc_138的博客
07-02 2622
RabbitMQ官方提供的Java 客户端编码相对复杂，一般生产环境下我们更多会结合Spring 来使用。而Spring 的官方刚好基于RabbitMQ 提供了这样一套消息收发的模板工具SpringAMQP。
Spring Boot 集成 RabbitMQ
空明的博客
07-15 1627
Spring Boot 集成 RabbitMQ ,记录一些交换器类型、消息投递及消息确认方式的使用。
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置...
springboot集成rabbitMQ之对象传输的方法
08-28
Spring Boot 集成 RabbitMQ 之对象传输的方法 本文将详细介绍 Spring Boot 集成 RabbitMQ 之对象传输的方法，从 RabbitMQ 的安装、依赖配置、生产者配置、消费者配置等方面进行讲解，并结合实例代码进行说明。 一...
SpringBoot集成RabbitMQ实现用户注册的示例代码
08-25
本文主要介绍了使用SpringBoot集成RabbitMQ实现用户注册的示例代码，通过详细的示例代码，帮助读者学习和工作。该示例代码介绍了如何使用RabbitMQ实现用户注册功能，提供了详细的实现步骤和代码示例。 SpringBoot...
Springboot 整合RabbitMq
GSON的博客
08-21 4767
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
Springboot 整合RabbitMq ，用心看完这一篇就够了
热门推荐
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
Spring boot集成RabbitMq
初心魏的博客
06-20 4546
一、搭建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 Boot集成RabbitMQ
这河里吗l的博客
08-13 1631
RabbitMQ是一个由Erlang语言编写的消息中间件，它遵循AMQP协议，提供了稳定可靠的消息传输服务。RabbitMQ通过其独特的架构和丰富的功能，帮助开发者解决分布式系统中的消息传递问题，提高系统的可扩展性、可靠性和响应速度。
springboot整合rabbitmq
m0_52307083的博客
04-14 153
springboot整合rabbitmq其中，Sender 类使用 AmqpTemplate 发送消息，Receiver 类使用 @RabbitListener 注解监听消息队列。其中，spring.rabbitm
SpringBoot 集成rabbitmq
07-28
SpringBoot集成RabbitMQ可以通过以下步骤实现。首先，在配置文件中添加RabbitMQ的连接信息。例如，在application.yml文件中配置RabbitMQ的主机、端口、用户名和密码等信息。\[1\]然后，引入SpringBoot整合RabbitMQ的依赖，包括spring-boot-starter-amqp和spring-rabbit-test等依赖项。\[2\]接下来，可以编写代码来实现与RabbitMQ的交互，例如发送和接收消息等操作。通过使用RabbitTemplate和@RabbitListener等注解，可以方便地实现消息的发送和接收。最后，可以通过运行SpringBoot应用程序来测试RabbitMQ的集成是否成功。 #### 引用[.reference_title] - *1* [SpringBoot 集成RabbitMQ](https://blog.csdn.net/July_whj/article/details/120634833)[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^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [Springboot整合RabbitMQ](https://blog.csdn.net/weixin_49076273/article/details/124991012)[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^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [SpringBoot教程(十五) | SpringBoot集成RabbitMq](https://blog.csdn.net/lsqingfeng/article/details/123652520)[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^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值