Web | RabbitMQ | 整合Spring & Springboot

最新推荐文章于 2022-08-26 23:26:16 发布
最新推荐文章于 2022-08-26 23:26:16 发布
阅读量535 收藏
点赞数
文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43354104/article/details/106318447
版权

Web-RabbitMQ-整合Spring & Springboot目录

RabbitMq 参数配置详解

除了 连接MQ代理、建立交换机和队列、发送消息，还需要 发送方确认消息发送成功、接收方消费后反馈
这里发送消息等不再是Channel而是RabbitTemplate

一、Spring整合RabbitMQ

生产方

1. 依赖

<dependency>
	<groupId>org.springframework.amqp</groupId>
	<artifactId>spring-rabbit</artifactId>
	<version>2.1.8.RELEASE</version>
</dependency>

2. properties配置文件

rabbitmq.host=192.168.12.135
rabbitmq.port=5672
rabbitmq.username=host
rabbitmq.password=host
rabbitmq.virtual-host=/test
rabbitmq.publisher-confirms=true //是否开启confirm模式，默认为false
rabbitmq.publisher-returns=true //是否开启return模式，默认为false

3. spring-rabbitmq.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:properties/rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" 
    						   host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"
                               publisher-confirms="${rabbitmq.publisher-confirms}"
                               publisher-returns="${rabbitmq.publisher-returns}" />
    <!--定义管理交换机、队列-->
    <rabbit:admin connection-factory="connectionFactory"/>

    <!--
    auto-declare：不存在则自动创建；不绑定到交换机则绑定到默认交换机
    -->
    <rabbit:queue id="spring_queue" name="spring_queue" auto-declare="true"/>

    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~广播；所有队列都能收到消息 start~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_fanout_queue_1" name="spring_fanout_queue_1" auto-declare="true"/>

    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_fanout_queue_2" name="spring_fanout_queue_2" auto-declare="true"/>

    <!--定义广播类型交换机；并绑定上述两个队列-->
    <rabbit:fanout-exchange id="spring_fanout_exchange" name="spring_fanout_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding queue="spring_fanout_queue_1"/>
            <rabbit:binding queue="spring_fanout_queue_2"/>
        </rabbit:bindings>
    </rabbit:fanout-exchange>
    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~广播；所有队列都能收到消息 end~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->

    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~通配符；*匹配一个单词，#匹配多个单词 start~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_star" name="spring_topic_queue_star" auto-declare="true"/>
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_well" name="spring_topic_queue_well" auto-declare="true"/>
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_well2" name="spring_topic_queue_well2" auto-declare="true"/>
	<!--创建主题交换机，绑定队列-->
    <rabbit:topic-exchange id="spring_topic_exchange" name="spring_topic_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="heima.*" queue="spring_topic_queue_star"/>
            <rabbit:binding pattern="heima.#" queue="spring_topic_queue_well"/>
            <rabbit:binding pattern="itcast.#" queue="spring_topic_queue_well2"/>
        </rabbit:bindings>
    </rabbit:topic-exchange>
     <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~通配符；*匹配一个单词，#匹配多个单词 end~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->

    <!--定义rabbitTemplate对象操作可以在代码中方便发送消息，这里需要指定connectionFactory-->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>
</beans>

4. 发送消息

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring-rabbitmq.xml")
public class ProducerTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

//定义confirm和callback的回调函数
	@Before
	public void callback(){
	//1. 设置confirmCallBack
		rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
		            /**
		             * 发送消息后此方法就会被执行
		             * @param correlationData ：消息相关配置信息
		             * @param b ：交换机是否接收到消息
		             * @param s ：失败原因，成功为null
		             */
		            @Override
		            public void confirm(CorrelationData correlationData, boolean b, String s) {
		                if(b){
		                    System.out.println("confirm方法被执行，消息发送成功");
		                }else {
		                    System.out.println("confirm方法被执行，消息发送失败");
		                    System.out.println("错误信息: "+s);
		                    //可以自己定义一些逻辑，让消息再次发送，具体怎么搞没研究过
		                }
		            }
		        });

		rabbitTemplate.setMandatory(true);

        //2.设置ReturnCallBack,
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             *
             * @param message   消息对象
             * @param replyCode 错误码
             * @param replyText 错误信息
             * @param exchange  交换机
             * @param routingKey 路由键
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("return 执行了....");

                System.out.println(message);
                System.out.println(replyCode);
                System.out.println(replyText);
                System.out.println(exchange);
                System.out.println(routingKey);

                //处理，会让交换机将消息给其它队列
            }
        });
        
	}
	
    /**
     * 只发队列消息
     * 默认交换机类型为 direct
     * 交换机的名称为空，路由键为队列的名称
     */
    @Test
    public void queueTest(){
        //路由键与队列同名
        rabbitTemplate.convertAndSend("spring_queue", "只发队列spring_queue的消息。");
    }

    /**
     * 发送广播
     * 交换机类型为 fanout
     * 绑定到该交换机的所有队列都能够收到消息
     */
    @Test
    public void fanoutTest(){
        /**
         * 参数1：交换机名称
         * 参数2：路由键名（广播设置为空）
         * 参数3：发送的消息内容
         */
        rabbitTemplate.convertAndSend("spring_fanout_exchange", "", "发送到spring_fanout_exchange交换机的广播消息");
    }

    /**
     * 通配符
     * 交换机类型为 topic
     * 匹配路由键的通配符，*表示一个单词，#表示多个单词
     * 绑定到该交换机的匹配队列能够收到对应消息
     */
    @Test
    public void topicTest(){
        /**
         * 参数1：交换机名称
         * 参数2：路由键名
         * 参数3：发送的消息内容
         */
        rabbitTemplate.convertAndSend("spring_topic_exchange", "heima.bj", "发送到spring_topic_exchange交换机heima.bj的消息");
        rabbitTemplate.convertAndSend("spring_topic_exchange", "heima.bj.1", "发送到spring_topic_exchange交换机heima.bj.1的消息");
        rabbitTemplate.convertAndSend("spring_topic_exchange", "heima.bj.2", "发送到spring_topic_exchange交换机heima.bj.2的消息");
        rabbitTemplate.convertAndSend("spring_topic_exchange", "itcast.cn", "发送到spring_topic_exchange交换机itcast.cn的消息");
    }
}

消费方

1. 依赖

<dependency>
	<groupId>org.springframework.amqp</groupId>
	<artifactId>spring-rabbit</artifactId>
	<version>2.1.8.RELEASE</version>
</dependency>

2. properties配置文件

rabbitmq.host=192.168.12.135
rabbitmq.port=5672
rabbitmq.username=host
rabbitmq.password=host
rabbitmq.virtual-host=/test
rabbitmq.publisher-confirms=true //是否开启confirm模式，默认为false
rabbitmq.publisher-returns=true //是否开启return模式，默认为false

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:properties/rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>
	<!--右边为自定义的监听器，在3中致谢了第一个可以类比于`channel.basicConsume()`的参数（callback）`DefaultConsumer类`**-->
    <bean id="springQueueListener" class="com.rabbitmq.listener.SpringQueueListener"/>
    <bean id="fanoutListener1" class="com.rabbitmq.listener.FanoutListener1"/>
    <bean id="fanoutListener2" class="com.rabbitmq.listener.FanoutListener2"/>
    <bean id="topicListenerStar" class="com.rabbitmq.listener.TopicListenerStar"/>
    <bean id="topicListenerWell" class="com.rabbitmq.listener.TopicListenerWell"/>
    <bean id="topicListenerWell2" class="com.rabbitmq.listener.TopicListenerWell2"/>

<!-- 自动确认，在这里才指定监听从哪个队列出来的消息 -->
    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
        <rabbit:listener ref="springQueueListener" queue-names="spring_queue"/>
        <rabbit:listener ref="fanoutListener1" queue-names="spring_fanout_queue_1"/>
        <rabbit:listener ref="fanoutListener2" queue-names="spring_fanout_queue_2"/>
        <rabbit:listener ref="topicListenerStar" queue-names="spring_topic_queue_star"/>
        <rabbit:listener ref="topicListenerWell" queue-names="spring_topic_queue_well"/>
        <rabbit:listener ref="topicListenerWell2" queue-names="spring_topic_queue_well2"/>
    </rabbit:listener-container>
</beans>

3. 定义监听器

不管是自动还是手动确认，都会执行监听类，其实与其说是监听类可以说是消费逻辑，监听器是负责接收消息对消息消费的，设置手动确认时会在里面自定义一些确认的逻辑。

实现MessageListener，重写onMessage方法即可，其它监听器一样，这里不赘述。这个可以类比 channel.basicConsume()的参数（callback）DefaultConsumer类

public class SpringQueueListener implements MessageListener {
//Message类中封装了消息的相关信息，这个监听器类会在接收消息后自动执行
	@Override
    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(), "utf-8");

            System.out.printf("接收路由名称为：%s，路由键为：%s，队列名为：%s的消息：%s \n",
                    message.getMessageProperties().getReceivedExchange(),
                    message.getMessageProperties().getReceivedRoutingKey(),
                    message.getMessageProperties().getConsumerQueue(),
                    msg);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

消费端测试代码

拦截器会自动执行消费消息，这里只是保证消费端处于启动状态，加载spring-rabbitmq-consumer.xml配置文件

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-consumer.xml")
public class ConsumerTest {

    @Test
    public void test1(){
        boolean flag = true;
        while (true){

        }
    }
}

二、Spring Boot整合RabbitMQ

生产者

1. 依赖

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

2. application.yml配置文件

RabbitMQ相关参数配置见：Springboot-RabbitMq 参数配置详解

spring:
  rabbitmq:
    host: localhost
    port: 5672
    virtual-host: /itcast
    username: heima
    password: heima
    
spring.rabbitmq.publisher-confirms: 是否启用【发布确认】，默认false
spring.rabbitmq.publisher-returns: 是否启用【发布返回】，默认false

3. 配置类

定义交换机和队列

@Configuration
public class RabbitMQConfig {

    public static final String EXCHANGE_NAME = "boot_topic_exchange";
    public static final String QUEUE_NAME = "boot_queue";

    //1.交换机
    @Bean("bootExchange")
    public Exchange bootExchange(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }


    //2.Queue 队列
    @Bean("bootQueue")
    public Queue bootQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }

    //3. 队列和交互机绑定关系 Binding
    /*
        1. 知道哪个队列
        2. 知道哪个交换机
        3. routing key
        4. @Qualifier指定了名称，而Queue指定了类型，相当于和@Authoud的组合
     */
    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue, @Qualifier("bootExchange") Exchange exchange){
    //需要指定参数就and()不需要就noargs()；
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }


}

4. 发送消息

通过RabbitTemplate来完成

import com.itheima.rabbitmq.config.RabbitMQConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitMQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

//发送消息
    @Test
    public void test(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE, "item.insert", "商品新增，routing key 为item.insert");
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE, "item.update", "商品修改，routing key 为item.update");
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE, "item.delete", "商品删除，routing key 为item.delete");
    }

消费者

1. 依赖

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

2. application.yml配置文件

RabbitMQ相关参数配置见：Springboot-RabbitMq 参数配置详解

spring:
  rabbitmq:
    host: localhost
    port: 5672
    virtual-host: /itcast
    username: heima
    password: heima
    
spring.rabbitmq.listener.simple.acknowledge-mode: manual --设置为手动
spring.rabbitmq.listener.direct.acknowledge-mode: manual

3. 定义监听器

Springboot整合RabbitMQ 消费者消息接收确认

消费消息

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

@Component
public class MyListener {

    /**
     * 监听某个队列的消息，会自动执行。
     * @param message 接收到的消息
     */
    @RabbitListener(queues = "item_queue")
    public void myListener1(String message){
        System.out.println("消费者接收到的消息为：" + message);
    }
}
红掌波清波
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
springboot | Rabbitmq 实现RPC方式 远程同步调用
洛阳泰山的博客
01-06 1911
RabbitMQ是一个开源的消息代理软件，它实现了高级消息队列协议（AMQP），用于在应用程序之间进行异步通信和消息传递。RabbitMQ提供了可靠的消息传递机制，具有高吞吐量、低延迟和可扩展性等特点，被广泛应用于分布式系统、微服务架构和消息驱动的应用程序中。
RabbitMQ整合springboot
qq_54605990的博客
04-20 250
RabbitMQ整合springboot（一个例子） 1. 创建一个spring boot项目 web想加就加，第二个必选 2. 创建以下的目录结构 3. 父工程引入相关依赖 <?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:
RabbitMQ概念及环境搭建（五）与web的整合
刀刀的专栏
12-12 1万+
#################################### rabbitmq_web_stomp #################################### 处于试验阶段，同伙WebSocket兼容层SockJS时 Web Browser与RabbitMQ(rabbitmq-stomp)实时通讯,可用于实时的WEB应用 安装 sudo rabbitmq-plu
web项目中spring如何整合RabbitMQ？
it_0101的博客
08-29 4760
如何在Windows下安装rabbitMQ？这个问题已在我的上一篇文章中讲解清楚，不清楚的同学可以看看我的上一篇文章。  Windows下安装及配置RabbitMQ？ 接下来讲解如何在web项目中配合spring来使用rabbitMQ？ 一、若是maven工程，在pom.xml文件中添加依赖： 若不是maven工程，需自己找jar包加入
手写快速Web开发框架--集成RabbitMQ
u011546032的博客
09-22 431
#最近难得有空，然后试着集成了下RabbitMQ ###完整代码在这里 https://github.com/zhangjunapk/WinterBatis 先看下效果,访问这个路径能发送消息，然后消费者能消费消息       ##首先定义注解 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) publi...
RabbitMQ整合SpringBoot(web)
cristianoxm的博客
06-27 193
一、index.html <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <a href="/testFanout">testFanout</a> <a href="/testHello">testHello&lt
RabbitMQ入门到进阶(Spring整合RabbitMQ&SpringBoot整合RabbitMQ)
lyl54545的博客
03-30 2548
1.MQ简介 MQ 全称为 Message Queue，是在消息的传输过程中保存消息的容器。多用于分布式系统 之间进行通信。 ​ 编辑切换为居中 添加图片注释，不超过 140 字（可选） 2.为什么要用 MQ 1.流量消峰 没使用MQ ​ 编辑切换为居中 添加图片注释，不超过 140 字（可选） 使用了MQ ​ 编辑切换为居中 添加图片注释，不超过 140 字（可选） 2.应用解耦 ​ 编辑切换为居中 添加图片注释，不超过 140..
springboot整合rabbitmq、elasticsearch
09-21
标题中的“springboot整合rabbitmq、elasticsearch”指的是在Spring Boot项目中集成RabbitMQ（一个消息队列系统）和Elasticsearch（一个分布式搜索引擎）。这两个技术在IT领域中广泛应用于构建可扩展、高可用性的...
RabbitMQ安装与springboot整合RabbitMQ
01-07
进入tag标签下，找到带有management的，这个是带有web管理界面的。 下载较慢可以是用加速。 docker pull registry.docker-cn.com/library/rabbitmq:3-management docker images检查镜像 docker run -d -p 5672:5672 ...
RabbitMQ 相关整合实战项目（完结）
HUJIAXIN的博客
09-17 958
RabbitMQ 整合 PD 商城实战项目流程总结 一、订单流量削峰（解耦） 简单模式，若多添加几个消费者则用工作模式。 导入商城项目 将 step5 课前资料里面 /elasticsearch/pd商城.zip 解压。 第二层目录下 pd-web 文件夹解压到 rabbitmq 工程目录下面。 修改 pom.xml 文件中的 SpringBoot 版本为 2.3.2.RELEASE（可拖拽至 idea 内更改）。 在 rabbitmq 工程中导入模块（若之前在 idea 内更改则可以直接
Web模式使用RabbitMQ
李白
08-26 576
启动rabbitmq服务后，登陆网址：http://localhost:156721、进入交换机tab，点击默认交换机（AMQP default）进入2、消息发送成功弹框显示，点击关闭1、获取消息2、详细内容截图3、消息应答模式选择注意方式一：在交换机处选择队列绑定输入需绑定的队列信息查看交换机已绑定的队列，可进行解绑操作方式二：在队列处选择交换机绑定进行绑定或者解绑已绑定的交换机...
web网页发送mq到服务器,websocket整合rabbitMQ——实现消息推送
weixin_39606799的博客
08-13 967
一、实现功能：当前页面点击请求后，另一个页面立即收到一条消息，用springboot+websocket+rabbitMQ实现。二、java代码：1、先在pom里导入需要的坐标org.springframework.bootspring-boot-starter-amqp2.1.4.RELEASEorg.springframework.bootspring-boot-starter-websock...
关于WebSocket+RabbitMQ整合实现消息实时推送的案例
开发能力提升中。。。。
07-02 3万+
WebSocket+RabbitMQ基于Spring boot实现 1.配置 maven导包 SpringBoot 与webSocket的关联 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.springframework.boot&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;spring-b
RabbitMQ集成Webflux消费消息
指尖凉的博客
06-08 1474
RabbitMQ集成Webflux来消费消息
RabbitMQ系列之四 Spring RabbitMQ整合
程序猿的博客
11-15 1854
本文将会详细介绍Spring和RabbitMQ整合，
springboot之web项目整合rabbitmq
weixin_44390164的博客
09-22 378
1. 导入依赖 <!--AMQP依赖，包含RabbitMQ--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> springAMQP依赖里面包含了RabbitMQ依赖 springAMQP（Advanced
Web端连接RabbitMQ
Astian的博客
11-13 3761
参考文档： 基于 RabbitMQ 的实时消息推送 【js学习】js连接RabbitMQ达到实时消息推送 一、背景 最近项目需要在Web端中后台应用中作为消费者连接RabbitMQ，以动态接收业务系统生成的最新数据。 RabbitMQ官方有nodejs库（http://www.rabbitmq.com/tutorials/tutorial-one-javascript.html），但经测试该库...
SpringMvc整合websocket、rabbitMq详解
热门推荐
fangzg811107320的博客
07-25 13万+
源码在:https://download.csdn.net/download/fangzg811107320/10535726
SpringBoot整合RabbitMQ实现死信队列详解
"本文介绍了SpringBoot如何集成RabbitMQ并实现死信队列功能，通过具体的示例代码展示了配置和使用过程。" 在SpringBoot应用中集成RabbitMQ，可以利用其强大的消息中间件能力，提高系统的可靠性和可扩展性。死信队列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值