SpringBoot2.x学习之路(五)RabbitMQ的使用

最新推荐文章于 2024-04-20 12:42:27 发布
最新推荐文章于 2024-04-20 12:42:27 发布
阅读量396 收藏 3
点赞数 2
分类专栏： Spring Boot 消息队列 文章标签： spring boot rabbitmq 队列 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiyongkang520/article/details/105460303
版权

今天小七给大家介绍一下在Spring Boot项目中如何使用RabbitMQ，下面直入正题吧。

（一）RabbitMQ的安装以及介绍

之前的博文，小七有介绍过RabbitMQ以及如何安装，这里就不再赘述了，请查看下面的博文地址：
https://blog.csdn.net/qiyongkang520/category_6751853.html

（二）RabbitMQ的依赖引入

pom.xml中添加如下依赖即可：

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

（三）RabbitMQ的文件配置

.yml文件中添加如下配置：

spring:
  rabbitmq:
    host: 172.16.3.108
    port: 5672
    username: admin
    password: admin123
    virtualHost: cn

这里virtualHost可以不配置，就表示所有的交换机和队列都在/下创建。

（四）交换机的简单说明

目前RabbitMQ提供了direct、topic、headers、fanout四种交换机类型，每种类型都有自己的特点，大家可以根据具体的业务需求来选择使用，下面小七先简单介绍一下。
首先大家都知道，咱们应用系统给RabbitMQ发消息，不是直接发给队列，而是发给交换机，然后交换机根据自己的规则（路由key、键值对属性等）来分发到相应的队列上，也就是说交换机和队列之间是有绑定关系的，分别对应如下：

  • direct：交换机和队列是通过路由Key来匹配，并且是完全匹配；
  • topic：交换机和队列是通过路由Key来匹配，但是支持通配符匹配，也就是说给此类型交换机发消息时指定的路由Key如果满足多个路由的通配符匹配，那么这些队列都可以收到消息；
  • headers：交换机和队列是通过键值对来任一匹配或者完全匹配
  • fanout：交换机和队列只要绑定了即可，不需要指定任何规则，这些队列都可以收到消息

下面小七会一一介绍并截图，就容易理解多了。

（五）Direct交换机的使用

在Spring Boot怎么创建交换机、队列以及绑定呢，其实很简单，这里小七介绍两种方式，一是在配置类中创建，二是在接收消息监听类中创建。
这里小七先统一使用第二种方式，后面会介绍第一种方式。
小七，先一次性贴出监听类的所有代码MQReceiver.java:

package org.qyk.springboot.rabbitmq;

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

/**
 * <Change to the actual description of this class>
 *
 * @version 1.0
 * <pre>
 * Author       Date            Changes
 * yongkang.qi   2020年04月08日   Created
 *
 * </pre>
 * @since 1.7
 */

@Component
public class MQReceiver {
    private Logger logger = LoggerFactory.getLogger(MQReceiver.class);
    // EXCHANGE
    final static String EXCHANGE_DIRECT_EXCHANGE = "QYK_DIRECT_EXCHANGE";
    final static String EXCHANGE_TOPIC_EXCHANGE = "QYK_TOPIC_EXCHANGE";
    final static String EXCHANGE_HEADER_EXCHANGE = "QYK_HEADER_EXCHANGE";
    final static String EXCHANGE_FANOUT_EXCHANGE = "QYK_FANOUT_EXCHANGE";

    final static String EXCHANGE_SEND_TOPIC_EXCHANGE = "QYK_SEND_TOPIC_EXCHANGE";
    final static String EXCHANGE_RECEIVE_DIRECT_EXCHANGE = "QYK_RECEIVE_DIRECT_EXCHANGE";

    // QUEUE
    final static String QUEUE_DIRECT_MESSAGE1_APP1 = "QYK_DIRECT_MESSAGE1.APP1";
    final static String QUEUE_DIRECT_MESSAGE2_APP1 = "QYK_DIRECT_MESSAGE2.APP1";
    final static String QUEUE_DIRECT_MESSAGE3_APP1 = "QYK_DIRECT_MESSAGE3.APP1.AUR";
    final static String QUEUE_DIRECT_MESSAGE4_APP1 = "QYK_DIRECT_MESSAGE4.APP1.AUR";

    final static String QUEUE_TOPIC_MESSAGE1_APP1 = "QYK_TOPIC_MESSAGE1.APP1";
    final static String QUEUE_TOPIC_MESSAGE2_APP1 = "QYK_TOPIC_MESSAGE2.APP1";
    final static String QUEUE_TOPIC_MESSAGE3_APP1 = "QYK_TOPIC_MESSAGE3.APP1";

    final static String QUEUE_HEADER_MESSAGE1_APP1 = "QYK_HEADER_MESSAGE1.APP1";
    final static String QUEUE_HEADER_MESSAGE2_APP1 = "QYK_HEADER_MESSAGE2.APP1";

    final static String QUEUE_FANOUT_MESSAGE1_APP1 = "QYK_FANOUT_MESSAGE1.APP1";
    final static String QUEUE_FANOUT_MESSAGE2_APP1 = "QYK_FANOUT_MESSAGE2.APP1";

    // ROUTE KEY
    final static String ROUTE_KEY_CNR = "#.CNR";
    final static String ROUTE_KEY_USR = "#.USR";
    final static String ROUTE_KEY_EUR = "#.EUR";
    final static String ROUTE_KEY_AUR = "#.AUR";

    // DIRECT： Exchange、Queue、QueueBinding
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(QUEUE_DIRECT_MESSAGE1_APP1),
            exchange = @Exchange(value = EXCHANGE_DIRECT_EXCHANGE),
            key = QUEUE_DIRECT_MESSAGE1_APP1
    ))
    public void process1(String message) {
        logger.error("MqReceiver [QYK_DIRECT_MESSAGE1.APP1]: {}", message);
    }

    // DIRECT： Exchange、Queue、QueueBinding
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(QUEUE_DIRECT_MESSAGE2_APP1),
            exchange = @Exchange(value = EXCHANGE_DIRECT_EXCHANGE),
            key = QUEUE_DIRECT_MESSAGE2_APP1
    ))
    public void process2(String message) {
        logger.error("MqReceiver [QYK_DIRECT_MESSAGE2.APP1]: {}", message);
    }


    // TOPIC： Exchange、Queue、QueueBinding
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(QUEUE_TOPIC_MESSAGE1_APP1),
            exchange = @Exchange(value = EXCHANGE_TOPIC_EXCHANGE, type ="topic"),
            key = {ROUTE_KEY_CNR}
    ))
    public void process3(String message) {
        logger.error("MqReceiver [QUEUE_TOPIC_MESSAGE1_APP1]: {}", message);
    }

    // TOPIC： Exchange、Queue、QueueBinding
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(QUEUE_TOPIC_MESSAGE2_APP1),
            exchange = @Exchange(value = EXCHANGE_TOPIC_EXCHANGE, type ="topic"),
            key = {ROUTE_KEY_USR,ROUTE_KEY_EUR,ROUTE_KEY_AUR}
    ))
    public void process4(String message) {
        logger.error("MqReceiver [QUEUE_TOPIC_MESSAGE2_APP1]: {}", message);
    }

    // TOPIC： Exchange、Queue、QueueBinding
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(QUEUE_TOPIC_MESSAGE3_APP1),
            exchange = @Exchange(value = EXCHANGE_TOPIC_EXCHANGE, type ="topic"),
            key = {ROUTE_KEY_CNR,ROUTE_KEY_USR}
    ))
    public void process5(String message) {
        logger.error("MqReceiver [QUEUE_TOPIC_MESSAGE3_APP1]: {}", message);
    }

    // Headers：
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(QUEUE_HEADER_MESSAGE1_APP1),
            exchange = @Exchange(value = EXCHANGE_HEADER_EXCHANGE, type ="headers"),
            arguments = {@Argument(name = "One",value = "A"), @Argument(name = "Two",value = "B"), @Argument(name = "x-match",value = "any")}
    ))
    public void process6(String message) {
        logger.error("MqReceiver [QUEUE_HEADER_MESSAGE1_APP1]: {}", message);
    }

    // Headers：
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(QUEUE_HEADER_MESSAGE2_APP1),
            exchange = @Exchange(value = EXCHANGE_HEADER_EXCHANGE, type ="headers"),
            arguments = {@Argument(name = "One",value = "A"), @Argument(name = "Two",value = "B"), @Argument(name = "x-match",value = "all")}
    ))
    public void process7(String message) {
        logger.error("MqReceiver [QUEUE_HEADER_MESSAGE2_APP1]: {}", message);
    }

    // Fanout：
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(QUEUE_FANOUT_MESSAGE1_APP1),
            exchange = @Exchange(value = EXCHANGE_FANOUT_EXCHANGE, type ="fanout")
    ))
    public void process8(String message) {
        logger.error("MqReceiver [QUEUE_FANOUT_MESSAGE1_APP1]: {}", message);
    }

    // Fanout：
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(QUEUE_FANOUT_MESSAGE2_APP1),
            exchange = @Exchange(value = EXCHANGE_FANOUT_EXCHANGE, type ="fanout")
    ))
    public void process9(String message) {
        logger.error("MqReceiver [QUEUE_FANOUT_MESSAGE2_APP1]: {}", message);
    }



    // 交换机绑定交换机
    @RabbitListener(queues = QUEUE_DIRECT_MESSAGE3_APP1)
    public void process10(String message) {
        logger.error("MqReceiver [QYK_DIRECT_MESSAGE3_APP1]: {}", message);
    }

    // 交换机绑定交换机
    @RabbitListener(queues = QUEUE_DIRECT_MESSAGE4_APP1)
    public void process11(String message) {
        logger.error("MqReceiver [QYK_DIRECT_MESSAGE4_APP1]: {}", message);
    }
}

目前只需要关注process1和process2。
下面，咱们再来创建一下个单元测试类，代码如下：

package org.qyk.springboot.rabbitmq;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;


/**
 * <Change to the actual description of this class>
 *
 * @version 1.0
 * <pre>
 * Author       Date            Changes
 * yongkang.qi   2020年04月08日   Created
 *
 * </pre>
 * @since 1.7
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class RabbitMQTest {

    @Autowired
    private AmqpTemplate rabbitTemplate;

    @Test
    public void testCreateQueueAndExchange() {
        System.out.println("***********");
        System.out.println("***********");
    }

    @Test
    public void testSendDirectMessage() throws InterruptedException {
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_DIRECT_EXCHANGE,
                MQReceiver.QUEUE_DIRECT_MESSAGE1_APP1, "hello");
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_DIRECT_EXCHANGE,
                MQReceiver.QUEUE_DIRECT_MESSAGE2_APP1, "hello");

        Thread.sleep(5000);
    }

    @Test
    public void testSendTopicMessage() throws InterruptedException {
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_TOPIC_EXCHANGE,
                "TOPIC.MESSAGE.CNR", "hello");

        Thread.sleep(3000);
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_TOPIC_EXCHANGE,
                "USR.TOPIC.MESSAGE", "hello");

        Thread.sleep(3000);
        System.out.println("***********");
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_TOPIC_EXCHANGE,
                "TOPIC.MESSAGE.EUR", "hello");

        Thread.sleep(5000);
    }

    @Test
    public void testSendHeadersMessage() throws InterruptedException {
        String msg = "hello";
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setHeader("One", "A");
        Message message = new Message(msg.getBytes(), messageProperties);
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_HEADER_EXCHANGE, null, message);
        Thread.sleep(3000);
        messageProperties = new MessageProperties();
        messageProperties.setHeader("One", "A");
        messageProperties.setHeader("Two", "B");
        message = new Message(msg.getBytes(), messageProperties);
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_HEADER_EXCHANGE, null, message);
        Thread.sleep(5000);
    }

    @Test
    public void testSendFanoutMessage() throws InterruptedException {
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_FANOUT_EXCHANGE, null, "hello");
        Thread.sleep(5000);
    }

    @Test
    public void testSendExchangeExchange() throws InterruptedException {
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_SEND_TOPIC_EXCHANGE, "TEST.CNR", "hello");
        Thread.sleep(3000);
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_SEND_TOPIC_EXCHANGE, "TEST.USR", "hello");
        Thread.sleep(3000);
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_SEND_TOPIC_EXCHANGE, MQReceiver.QUEUE_DIRECT_MESSAGE3_APP1, "hello");
        Thread.sleep(3000);
        rabbitTemplate.convertAndSend(MQReceiver.EXCHANGE_SEND_TOPIC_EXCHANGE, MQReceiver.QUEUE_DIRECT_MESSAGE4_APP1, "hello");
        Thread.sleep(5000);
    }
}

这里只需要关注testCreateQueueAndExchange和testSendDirectMessage两个单元测试方法。
首先，咱们来运行testCreateQueueAndExchange，然后看下RabbitMQ管理后台的页面，首先是交换机，截图如下：
在这里插入图片描述
然后，再来看下队列，如下图：
在这里插入图片描述
接下来，再点进去看一下和队列的绑定关系，截图如下：
在这里插入图片描述
这个相信大家能看懂，消息发送到此交互机后，是通过发消息时指定的Routing key和上面的路由规则完全匹配来决定发送到哪个队列的。
下面，咱们再来运行一下testSendDirectMessage，运行日志如下：
在这里插入图片描述
就是按咱们说的规则来的，大家可以把QUEUE_DIRECT_MESSAGE1_APP1和QUEUE_DIRECT_MESSAGE2_APP1这两个队列的路由key指定成一样的，然后再运行testSendDirectMessage，就会发现当路由匹配上时，这两个队列都会收到此条消息。

（六）Topic交换机的使用

这里只需要关注接收类的process3、process4以及process5，下面直接先运行testCreateQueueAndExchange，来看下控制台交换机的效果，截图如下：
在这里插入图片描述
通配符的含义，简单说一下：

  • *（星号）仅代表一个单词
  • #（井号）代表任意个单词
    也就是说只要发送消息给此交互机时，如果指定的路由key能匹配到以上的通配符路由规则，那么对应的队列就可以收到此条消息。
    下面，大家可以运行testSendTopicMessage测试看看，这里小七就不演示了。

（七）Headers交换机的使用

这里，只需要关注消息接收类的process6和process7，咱们可以直接运行testCreateQueueAndExchange，先来看下控制台交换机的样子，如下：
在这里插入图片描述
这里先说明一下x-match的作用：

  • any：发送消息给交换机时指定的键值对，只要有一对键值匹配上，此队列就可以收到消息
  • all：发送消息给交换机时指定的键值对，所有的键值对都必须匹配上，此队列才能收到消息。
    大家可以运行testSendHeadersMessage看一下效果，小七也不演示啦。

（八）Fanout交换机的使用

这里大家只需要关注process8和process9，这个交换机类型比较简单，就像订阅模式一下，只要订阅了就会收到消息。下面直接截图：
在这里插入图片描述
大家可以运行testSendFanoutMessage来看一下效果。

（九）交换机绑定交换机

上面咱们介绍的都是队列如何与交换机绑定的，其实，交换机也可以与交互机绑定，下面咱们来一起看看，这里小七通过配置的方式来创建交换机、队列以及绑定关系，配置类如下：

package org.qyk.springboot.rabbitmq;

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

/**
 * <Change to the actual description of this class>
 *
 * @version 1.0
 * <pre>
 * Author       Date            Changes
 * yongkang.qi   2020年04月08日   Created
 *
 * </pre>
 * @since 1.7
 */
@Configuration
public class RabbitMQConfig {

    @Bean(name = "directQueue1")
    public Queue directQueue1() {
        return new Queue(MQReceiver.QUEUE_DIRECT_MESSAGE1_APP1);
    }

    @Bean(name = "directQueue2")
    public Queue directQueue2() {
        return new Queue(MQReceiver.QUEUE_DIRECT_MESSAGE2_APP1);
    }

    @Bean(name = "directQueue3")
    public Queue directQueue3() {
        return new Queue(MQReceiver.QUEUE_DIRECT_MESSAGE3_APP1);
    }

    @Bean(name = "directQueue4")
    public Queue directQueue4() {
        return new Queue(MQReceiver.QUEUE_DIRECT_MESSAGE4_APP1);
    }

    @Bean(name = "sendTopicExchange")
    public TopicExchange sendTopicExchange() {
        return new TopicExchange(MQReceiver.EXCHANGE_SEND_TOPIC_EXCHANGE);
    }

    @Bean(name = "receiveDirectExchange")
    public DirectExchange receiveDirectExchange() {
        return new DirectExchange(MQReceiver.EXCHANGE_RECEIVE_DIRECT_EXCHANGE);
    }

    @Bean
    Binding bindingExchangeQueue1(@Qualifier("directQueue1") Queue queue, TopicExchange sendTopicExchange) {
        return BindingBuilder.bind(queue).to(sendTopicExchange).with(MQReceiver.ROUTE_KEY_CNR);
    }

    @Bean
    Binding bindingExchangeQueue2(@Qualifier("directQueue2") Queue queue, TopicExchange sendTopicExchange) {
        return BindingBuilder.bind(queue).to(sendTopicExchange).with(MQReceiver.ROUTE_KEY_USR);
    }

    @Bean
    Binding bindingExchangeExchange(DirectExchange receiveDirectExchange, TopicExchange sendTopicExchange) {
        return BindingBuilder.bind(receiveDirectExchange).to(sendTopicExchange).with(MQReceiver.ROUTE_KEY_AUR);
    }

    @Bean
    Binding bindingExchangeQueue3(@Qualifier("directQueue3") Queue queue, DirectExchange receiveDirectExchange) {
        return BindingBuilder.bind(queue).to(receiveDirectExchange).with(MQReceiver.QUEUE_DIRECT_MESSAGE3_APP1);
    }

    @Bean
    Binding bindingExchangeQueue4(@Qualifier("directQueue4") Queue queue, DirectExchange receiveDirectExchange) {
        return BindingBuilder.bind(queue).to(receiveDirectExchange).with(MQReceiver.QUEUE_DIRECT_MESSAGE4_APP1);
    }

}

咱们再来看下QYK_SEND_TOPIC_EXCHANGE交换机的绑定关系，如下图：
在这里插入图片描述
QYK_RECEIVE_DIRECT_EXCHANGE的，小七也截图出来，如下：
在这里插入图片描述
看到没有，QYK_RECEIVE_DIRECT_EXCHANGE不是队列，是交换机。那么当客户端发消息到QYK_SEND_TOPIC_EXCHANGE交换机时，如果指定的路由如果能匹配到QYK_RECEIVE_DIRECT_EXCHANGE上，之后是怎么处理的呢。其实很简单，再把此路由放到QYK_RECEIVE_DIRECT_EXCHANGE上继续路由匹配就行了。
大家可以运行testSendExchangeExchange来看一下效果，小七就不演示了。

（十）结语

上面，小七没有介绍如何给RabbitMQ发消息，首先引入按下面方式引入客户端即可：

@Autowired
    private AmqpTemplate rabbitTemplate;

然后，发现消息的时候，指定交换机、路由、键值对以及消息等即可。
好了，如果有不明白的童鞋，一定要亲自动手试试，就能明白啦。

qiyongkang520
关注
专栏目录
springboot2.X.zip
05-21
通过上述讲解，我们可以看到SpringBoot2.X简化了Spring应用的开发、测试和部署流程，极大地提高了开发效率，是现代Java开发的首选框架之一。结合提供的博客地址，你可以进一步学习和实践SpringBoot2的具体用法和实战...
Springboot2.x整合RabbitMQ
竹林幽深
02-10 299
1、RabbitMQ介绍 可参照RabbitMQ笔记 2、接入配置 pom依赖 <!--amqp依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artif...
Spring Boot整合RabbitMQ
最新发布
null
04-20 1526
当消息在一个队列中变成死信（dead message）之后，它能被重新发送到另一个交换机中，这个交换机就是DLX ，绑定DLX的队列就是死信队列。一般在生产中，先启动消费者服务，再启动生产者服务，因此我们通常把配置类放在消费者服务中，否则可能导致无队列监听而服务启动失败或报错。DLX也是一个正常的交换机，和一般的交换机没有区别，它能在任何的队列上被指定，实际上就是设置某一个队列的属性。启动测试类，执行成功，查看RabbitMQ Web页面，成功绑定，且各存在一条消息。
SpringBoot2.x整合RabbitMQ（完整版）
热门推荐
孔明的博客
03-18 4万+
本篇文章实现了 SpringBoot整合RabbitMQ，实现了 work模型，发布订阅模型，topic模型，confirm消息确认机制，return消息机制，TTL队列，死信队列等。整合方式有很多，比如使用 RabbitAdmin进行整合，本文介绍一个最简单的整合方式，只需要在 RabbitmqConfig.java 配置文件中进行简单配置，便可以方便的使用。相信你会喜欢这种方式的
SpringBoot2x整合RabbitMQ
m0_65014849的博客
01-09 261
SpringBoot2x整合RabbitMQ
Springboot2整合RabbitMQ
小猪呀的博客
07-03 596
1.RabbitMQ简介 P代表的发送的消息(Message) X代表的交换机(Exchange) 红色的代表队列(Queue) C代表着消费者(Consumer) 2.RabbitMQ发送消息的流程 Routing key:生产者在将消息发送给Exchange的时候，一般会指定一个routing key，来指定这个消息的路由规则，而这个routing key需要与Exchange Type及binding key联合使用才能最终生效。 Binding key: ...
springboot2.x书籍随书源代码.zip
06-20
2. **WebFlux**：SpringBoot 2.x 引入了对Reactive编程的支持，通过WebFlux模块，可以构建非阻塞式的Web应用，提高系统性能和可伸缩性。 3. **Actuator增强**：Actuator是用于监控和管理SpringBoot应用的组件，在2....
dbblog：基于SpringBoot2.x + Vue2.x + ElementUI + Iview + Elasticsearch + RabbitMQ + Redis + Shiro的多模块前替代分离的博客项目
02-06
你可以拿它作为前端Vue2.x学习的练手教程； 你也可以把它作为springboot2.x技术的学习项目； 你也可以拿它作为当下火热的ElasticSearch和RabbitMQ的学习Demo; 你也可以将其视为一个前分离分离的项目实践； 你还可以...
springbootexamples：个人学习SpringBoot2.x写的一些示例程序，目前正在持续更新中...。
02-05
SpringBoot2.x个人学习示例程序个人学习SpringBoot2.x写的一些示例程序，每个文件夹模块放置对应的示例程序代码。在学习前首先要确保一下你本地是否配置了JDK和Maven的基础环境。 Maven必须是3.2及以上版本， JDK...
基于SpringBoot+MyBatis+Redis+RabbitMQ 实现的秒杀系统.zip
08-18
5. **项目结构**：根据文件列表中的"ok_x"，我们可以推测项目可能包含以下部分：主程序入口、SpringBoot配置文件、MyBatis的Mapper接口与XML配置、Redis和RabbitMQ的相关配置、业务逻辑代码（包括秒杀服务、订单服务...
SpringBoot2+RabbitMQ详细教程
12-06
适用人群IT相关从业者课程概述【收获是什么？】   三部曲之单机部署：本课程属于其中的单机版本的单独授课，同步最新的RabbitMQ官网3.8.x的版本教学，互联网的前沿倡导者和实践者。 【收获是什么？】     SpringBoot2+RabbitMq的整合无论是点对点还是topic均能搞定。【RabbitMQ是什么？】      我们在双11的夜晚购物和12306抢票，当我们凌晨大量的秒杀和抢购商品或者火车票，然后去结算的时候，就会发现，界面会提醒我们，让我们稍等，以及一些友好的图片文字提醒。而不是像前几年的时代，动不动就页面卡死，报错等来呈现给用户。这就是MQ的功劳，属于高并发的必要组件，当我们在结算的时候，并不会一窝蜂一样涌入收银台，而是排队结算。这也是队列机制。对于解耦，削峰，高并发的必要学习内容.....【为什么学习？】   互联网的消息中间件必不可少，rabbitmq在消息中间中举足轻重，属于必学组件。
Spring Boot2 + Redis + RabbitMQ + Elasticsearch
03-09
让同学们快速学习Spring Boot 2.x, 同时通过本次学习，能掌握目前最流行的相关技术适用人群对从事软件开发者有很大的提升，前提需要了解Java语言及相关Web编程知识课程简介资料下载: https://pan.baidu.com/s/12IJeGXSELRACibRPkzpLww 同学们快速入门SpringBoot2.x， 并能通过本次学习掌握MyBatis、Redis、RabbitMQ、Elasticsearch及微信小程序知识，经过这次学习，能进一步提升同学们技能，本次课程，采用Java8环境，IDEA开发工具，同时采用了Linux CentOS7进行搭建Redis、RabbitMQ及Elasticsearch环境.
RabbitMQ学习笔记：springboot2 amqp集成生产者消费者
OceanSky的专栏
12-28 1520
1.引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency&...
Springboot集成rabbitMQ-2
sinat_34397278的博客
09-22 533
springboot 集成rabbitmq，配置交换机，队列，绑定路由键，以及配置消息送达回调
Spring Boot 中的 RabbitMQ 是什么，如何使用
Java徐师兄的博客
07-01 1026
本文介绍了 RabbitMQ 的基本概念，以及如何在 Spring Boot 中使用 RabbitMQ。我们还介绍了 RabbitMQ 的一些高级功能，包括消息确认、消息持久化、消息 TTL 和死信队列。通过学习本文，你应该已经有了足够的知识来开始在 Spring Boot 中使用 RabbitMQ 了。
springboot2.x整合rabbitmq
穷水叮咚的博客
09-04 9317
首先请确保你的rabbitmq服务已经打开，或者百度搜索安装   Exchange 类型 Exchange分发消息时根据类型的不同分发策略有区别，目前共四种类型：direct、fanout、topic、headers 。只说前三种模式。 1.Direct模式 消息中的路由键（routing key）如果和 Binding 中的 binding key 一致， 交换器就将消息发到对应的队列...
Spring Boot2.x-15 整合RabbitMQ 及RabbitMQ的基本使用
小工匠
04-11 1万+
文章目录概述依赖配置基本使用手工创建队列，发送消息到指定的队列自动创建队列，发送消息到指定的队列自动创建队列,Exchange和队列绑定自动创建队列,Exchange和队列绑定,接收指定key的消息 概述 以 Spring Cloud实战-06使用/actuator/bus-refresh端点手动刷新配置 + 使用Spring Cloud Bus自动更新配置中使用的几个微服务工程为基础，我们梳理下...
SpringBoot2整合RabbitMQ入门
冷兮Coding
05-09 1103
一、消息队列概述 1. 消息服务中两个重要概念： 消息代理（message broker）和 目的地（Destination） 当消息发送者发出消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。 2. 消息队列主要有两种形式的目的地 1. 队列（queue）: 点对点消息通信（point-to-point） 2. 主题（topic）: 发布（publish）/ 订阅（subscribe）消息通信 点对点式 消息发送者发送消息，消息代理将其放入一个队列中，消息接收者从队列中获取消息内容，消息读
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值