一篇文章你了解不了RabbitMQ

已于 2022-06-16 15:48:28 修改
阅读量236 收藏 1
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq 中间件 java
于 2022-06-13 18:57:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46550964/article/details/125265487
版权

一篇文章你了解不了RabbitMQ

前言

本文意在让大家了解RabbitMQ, 本来想写多一些, 但是感觉一篇文章写不下, 所以这篇文章就带大家了解RabbitMQ的作用, 和几种工作模式, 及SpringBoot整合RabbitMQ的示例;

rabbitmq介绍

rabbitmq是一种用于上下游传递消息的分布式消息中间件, 由于其可靠性, 并发性, 可用性 在众多中间件中表现出色所以深受互联网公司喜爱;

rabbitmq官网：https://www.rabbitmq.com/getstarted.html

说到rabbitmq的作用其实就是所有消息中间件的作用, 说白了就是引入消息中间件来解决什么:

  1. 异步
  2. 解耦
  3. 削峰

RabbitMQ 提供了 5 种工作模式：

  1. 简单模式
  2. work 模式
  3. Publish/Subscribe 发布与订阅模式
  4. Routing 路由模式
  5. Topics 主题模式

那么我们来看看这, 三种作用, 五种工作模式 都是什么高考题

请添加图片描述

异步处理

场景说明：用户注册后，需要发注册邮件和注册短信, 传统的做法有两种 1.串行的方式 2.并行的方式

  1. 串行方式: 将注册信息写入数据库后, 发送注册邮件, 再发送注册短信, 以上三个任务全部完成后才返回给客户端。

请添加图片描述

  1. 并行方式: 将注册信息写入数据库后, 发送邮件的同时发送短信以上三个任务完成后, 返回给客户端。

请添加图片描述

上面两种方式有一个问题邮件, 短信他们成功响应对于系统来说并不是必须的, 它们只是一个通知, 而这种做法会让客户端等待没有必要等待的东西; 下面来看看MQ如何解决该问题

  1. 消息队列(异步处理)

请添加图片描述

引入消息队列后, 把发送邮件, 短信不是必须返回结果的业务逻辑异步处理, 由此可以看出, 引入消息队列后，用户的 响应时间 = 写入数据库的时间 + 写入消息队列的时间;

应用解耦

场景说明：双11是购物狂节, 用户下单后, 订单系统需要通知库存系统, 传统的做法就是订单系统调用库存系统的接口, 库存处理成功时返回结果, 这时订单系统收到库存的响应, 用户才会下单成功;

请添加图片描述

这种做法有一个缺点: 当库存系统出现故障时, 订单就会失败, 订单系统和库存系统高耦合;

引入消息队列解耦应用:

请添加图片描述

订单系统: 用户下单后, 订单系统完成持久化处理, 将消息写入消息队列, 返回用户订单下单成功。

库存系统: 订阅下单的消息, 获取下单消息, 进行库操作。 就算库存系统出现故障, 消息队列也能保证消息的可靠投递, 不会导致消息丢失。

削峰填谷

场景说明：秒杀活动, 一般会因为流量过大, 导致应用挂掉, 而活动结束后流量又恢复稳定, 传统的做法就是购买临时服务器, 增加抗压性, 还有就是在应用前端加入消息队列。

请添加图片描述

作用:

  1. 控制活动人数，超过此一定阀值的订单直接丢弃(适用于秒杀);
  2. 缓解短时间的高流量压垮应用, 流量高峰时可以将用户下单信息存储到队列中, 流量低时慢慢处理;

介绍工作模式前, 我们先安装Rabbitmq 并集成到Springboot项目中;

安装Rabbitmq

Rabbitmq下载地址

请添加图片描述

rabbitmq是由Erlang语言编写的, 所以想运行, 必须要安装Erlang环境;

Erlang依赖下载地址

请添加图片描述

Erlang安装步骤:

  1. 下载安装包
  2. 以管理员方式运行
  3. 安装位置选择默认(记下安装地址)
  4. 将Erlang添加到Path环境变量中

请添加图片描述

请添加图片描述

安装了erlang环境后, 我们在来安装rabbitmq, 以管理员运行安装程序, 没有其他操作 正常安装即可;

默认情况安装成功后会自动创建RabbitMQ服务并且启动，所以无需任何操作，但是为了方便在浏览器端管理RabbitMQ，需要安装管理软件，进入到安装目录的sbin目录下使用命令行程序：

运行:

rabbitmq-plugins.bat enable rabbitmq_management

请添加图片描述

如图所示就是安装成功了;

浏览器输入：http://localhost:15672/
初始账号密码：guest/guest

请添加图片描述

到此我们rabbitmq就安装成功了, 下面我们用SpringBoot 集成Rabbitmq, 并测试五种工作模式;

SpringBoot 集成Rabbitmq

我们需要创建2个springboot项目，一个 rabbitmq-provider (生产者)，一个rabbitmq-consumer(消费者);

生产者

使用Maven创建名为rabbitmq-provider 空服务

Maven依赖:

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>   
	<properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

在配置文件application.yml中添加rabbitmq的连接信息

server:
  port: 8081

spring:
  rabbitmq:
    #ip地址
    host: 127.0.0.1
    #通信端口
    port: 5672
    username: guest #用户名
    password: guest #密码
    virtual-host: / #虚拟host

初始化队列信息

package com.example.rabbitmqprovider.config;


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

@Configuration
public class RabbitMQConfig {
    /**
     * 创建hello_world队列
     *
     * @param
     * @return
     * @author Hope
     */
    @Bean
    public Queue hello() {
        return new Queue("hello_world");
    }
}

使用RabbitTemplate发送消息

package com.example.controller;

import com.example.model.User;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendMsg")
    public void sendMsg(){
        rabbitTemplate.convertAndSend("hello_world", "hello 小兔子");
    }
}

最终效果如下:

请添加图片描述

消费者

使用Maven创建名为rabbitmq-consumer 空服务

Maven依赖:

<?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 http://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.7.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>org.example</groupId>
    <artifactId>rabbitmq-consumer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

在配置文件application.yml中添加rabbitmq的连接信息

server:
  port: 8082

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /

监听信息

@Component
@RabbitListener(queues = "hello_world") //监听hello_world队列
public class ConsumerService {

    /*
        监听字符串消息
     */
    @RabbitHandler
    public void helloConsumer(String message){
        System.out.println("消费者信息： " + message);
    }
}

最终效果如下:

请添加图片描述

然后我们启动生产者服务, 访问接口, 观察rabbitmq界面, 这时队列里面出现hello_world队列, 并且队列已经就绪一条消息。

请添加图片描述

然后我们在启动消费者, 消费者打印出生产者的消息, 我们这时在查看rabbitmq界面, 可以看到生产者的消息已经被消费

请添加图片描述

请添加图片描述

以上就是rabbitmq的简单工作模式
请添加图片描述

小节:

在上图的模型中，有以下概念：

  • P：生产者，也就是要发送消息的程序
  • C：消费者：消息的接收者，会一直等待消息到来
  • queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息
  • @RabbitListener 用于指定监听的队列名称
  • @RabbitHandler 用于区分同队列不同消息体的处理

工作队列模式

请添加图片描述

Work Queues(工作队列)：与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。

应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

具体实现: Work Queues 与入门程序的简单模式的代码几乎是一样的。可以完全复制，并多复制一个消费者进行多个消费者同时对消费消息的测试。

复制rabbitmq-consumer为rabbitmq-consumer2，并修改打印信息用于区分;

项目效果如下:

请添加图片描述

然后我们启动 生产者 消费者1 消费者2, 然后我们让生产者生成10条消息, 最终效果如下:

请添加图片描述
请添加图片描述

Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，只需要有一个节点成功发送即可。

但是有一点需要注意该工作队列模式使用的是轮询模式, 这种工作队列太过于理想化，并不适合实际的开发，我们难以保证每个消费者消费信息的速度相同，难免有的快有的慢;

发布与订阅模式

请添加图片描述

在订阅模型中，多了一个 Exchange 角色，而且过程略有变化：

  • P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
  • C：消费者，消息的接收者，会一直等待消息到来
  • Queue：消息队列，接收消息、缓存消息
  • Exchange：交换机（X）。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：
    1. Fanout：广播，将消息交给所有绑定到交换机的队列
    2. Direct：定向，把消息交给符合指定routing key 的队列
    3. Topic：通配符 ，把消息交给符合routing pattern（路由模式） 的队列

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与 Exchange 绑定，或者没有符合路由规则的队列，那么消息会丢失！

Fanout广播模式

创建Maven空项目 fanout-rabbitmq子工程，

Maven依赖:

<?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 http://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.7.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    
    <groupId>org.example</groupId>
    <artifactId>fanout-rabbitmq</artifactId>
    <version>1.0-SNAPSHOT</version>


    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>
<?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 http://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.7.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    
    <groupId>org.example</groupId>
    <artifactId>fanout-rabbitmq</artifactId>
    <version>1.0-SNAPSHOT</version>


    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

在配置文件中添加rabbitmq的连接信息

server:
  port: 8084

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /

初始化队列、交换机信息

package com.example.config;

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 FanoutRabbitMQConfig {

    /*
        创建fanout.A队列
     */
    @Bean
    public Queue fanoutAQueue(){
        return new Queue("fanout.A");
    }
    /*
        创建fanout.B队列
     */
    @Bean
    public Queue fanoutBQueue(){
        return new Queue("fanout.B");
    }
    /*
        创建fanout.C队列
     */
    @Bean
    public Queue fanoutCQueue(){
        return new Queue("fanout.C");
    }

    /*
        创建交换机
    */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("my_fanoutExchange");
    }

    /*
        将fanout.A绑定到 fanoutExchange交换机
     */
    @Bean
    Binding bindingExhangeA(Queue fanoutAQueue, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutAQueue).to(fanoutExchange);
    }

    /*
       将fanout.B绑定到 fanoutExchange交换机
    */
    @Bean
    Binding bindingExhangeB(Queue fanoutBQueue, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutBQueue).to(fanoutExchange);
    }

    /*
       将fanout.C绑定到 fanoutExchange交换机
    */
    @Bean
    Binding bindingExhangeC(Queue fanoutCQueue, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutCQueue).to(fanoutExchange);
    }
}

使用RabbitTemplate发送消息

package com.example.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class FanoutController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /*
        fanout模式发送简单字符串信息
    */
    @GetMapping("/sendMsg")
    public void sendMsg() {
        for (int i = 0; i <= 30; i++) {
            rabbitTemplate
                    .convertAndSend("my_fanoutExchange", "", "hello 小兔子: " + i);
        }
    }
}

监听信息

这里使用之前的rabbitmq-consumer 服务来监听fanout.A队列

修改rabbitmq-consumer代码如下

请添加图片描述

这里我们继续使用之前的rabbitmq-consumer2 服务来监听fanout.B队列, 修改如上一样

@Component
@RabbitListener(queues = "hello_world") //监听hello_world队列
@RabbitListener(queues = "fanout.B")
public class ConsumerService {

    /*
        监听字符串消息
     */
    @RabbitHandler
    public void helloConsumer(String message) throws InterruptedException {
        Thread.sleep(3000);
        System.out.println("消费者2信息： " + message);
    }

}

然后我们启动 fanout-rabbitmq 消费者1 消费者2, 然后我们让fanout生成30条消息, 最终效果如下:
请添加图片描述

小结:

交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到，实质是一个广播消息。

发布订阅模式与工作队列模式的区别：

  • 工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机，工作队列模式底层使用的是默认的交换机
  • 发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑定到默认的交换机

请添加图片描述

Routing路由模式

请添加图片描述

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey（路由key）
  • 消息的发送方在向 Exchange 发送消息时，也必须指定消息的 RoutingKey
  • Exchange 不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列的Routingkey 与消息的 Routing key 完全一致，才会接收到消息

图解：

  • P：生产者，向 Exchange 发送消息，发送消息时，会指定一个routing key
  • X：Exchange（交换机），接收生产者的消息，然后把消息递交给与 routing key 完全匹配的队列
  • C1：消费者，其所在队列指定了需要 routing key 为 error 的消息
  • C2：消费者，其所在队列指定了需要 routing key 为 info、warning 的消息

创建Maven空项目

routing-rabbitmq子工程，

Maven依赖, spring配置都和广播的一样, 这里就不贴了;

初始化队列、交换机

package com.example.config;

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

@Configuration
public class RoutingRabbitMQConfig {

    @Bean
    public Queue directAQueue() {
        return new Queue("direct.A");
    }

    @Bean
    public Queue directBQueue() {
        return new Queue("direct.B");
    }


    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("my_directExchange");
    }

    @Bean
    Binding bindingAQueue(Queue directAQueue, DirectExchange directExchange) {
        return BindingBuilder.bind(directAQueue).to(directExchange).with("error");
    }

    @Bean
    Binding bindingBQueueInfo(Queue directBQueue, DirectExchange directExchange) {
        return BindingBuilder.bind(directBQueue).to(directExchange).with("info");
    }

    @Bean
    Binding bindingBQueueWaring(Queue directBQueue, DirectExchange directExchange) {
        return BindingBuilder.bind(directBQueue).to(directExchange).with("waring");
    }
}

使用RabbitTemplate发送消息


@RestController
public class RoutingController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /*
        error信息 只有direct.A 可以接收并消费
    */
    @GetMapping("/sendErrorMsg")
    public void sendMsg() {
        rabbitTemplate.convertAndSend("my_directExchange", "error", "error 小兔子");
    }

    /*
        info 信息 只有direct.B 可以接收并消费
     */
    @GetMapping("/sendInfoMsg")
    public void sendUser() {
        rabbitTemplate.convertAndSend("my_directExchange", "info", "info 小兔子");
    }
}

消费者监听信息

这里我们继续使用之前的消费者来监听消息, rabbitmq-consumer和rabbitmq-consumer2;

修改如下:

请添加图片描述

小结:

Routing 模式要求队列在绑定交换机时要指定 routing key，消息会转发到符合 routing key 的队列。

Topic主题模式

请添加图片描述

  • Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型Exchange 可以让队列在绑定 Routing key 的时候使用通配符！
  • Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert
  • 通配符规则：# 匹配大于等于零个，* 匹配不多不少恰好1个词
  • 例如：item.# 能够匹配 item.insert.abc 或者 item.insert，item.* 只能匹配 item.insert
创建Maven空项目

topic-rabbitmq 子工程, 具体操作不在演示了, 上面都有;

初始化队列、交换机
/**
 * explain:RabbitMQConfig
 *
 * @author Hope
 * @date 2022/6/14
 * @see TopicRabbitMQConfig
 */
@Configuration
public class TopicRabbitMQConfig {
    @Bean
    public Queue topicAQueue() {
        return new Queue("topic.A");
    }

    @Bean
    public Queue topicBQueue() {
        return new Queue("topic.B");
    }

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

    /*
     * 匹配一个词
     */
    @Bean
    Binding bindingAQueue(Queue topicAQueue, TopicExchange topicExchange) {
        return BindingBuilder.bind(topicAQueue).to(topicExchange).with("tikie.*");
    }

    /*
        # 匹配≥零个词
     */
    @Bean
    Binding bindingBQueue(Queue topicBQueue, TopicExchange topicExchange) {
        return BindingBuilder.bind(topicBQueue).to(topicExchange).with("tikie.#");
    }
}
使用RabbitTemplate发送消息
package com.example.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TopicController {
    @Autowired
    private RabbitTemplate rabbitTemplate;


    @GetMapping("/sendTopic")
    public void sendTopic(){
        /*
            routingkey三种情况：
                1.tikie： 只有topic.B可以接收到消息
                2.tikie.heihei： topic.A 和 topic.B都可以接收到消息
                3.tikie.heihei.hehe 只有topic.B可以接收到消息
         */
        rabbitTemplate.convertAndSend("my_topicExchange", "tikie.heihei.hehe", "hello 小兔子");
    }

}
消费者监听信息

这里我们继续使用之前的消费者来监听消息, rabbitmq-consumer和rabbitmq-consumer2;

rabbitmq-consumer2代码


@Component
@RabbitListener(queues = "hello_world") //监听hello_world队列
@RabbitListener(queues = "fanout.B")
@RabbitListener(queues = "direct.B")
@RabbitListener(queues = "topic.B")
public class ConsumerService {

    /*
        监听字符串消息
     */
    @RabbitHandler
    public void helloConsumer(String message) throws InterruptedException {
        Thread.sleep(3000);
        System.out.println("消费者2信息： " + message);
    }

}

小结

  • Topic 主题模式可以实现 Pub/Sub 发布与订阅模式和 Routing 路由模式的功能，只是 Topic 在配置routing key 的时候可以使用通配符，显得更加灵活。

工作模式总结

  1. 简单模式 HelloWorld：

    • 一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）。

  2. 工作队列模式 Work Queue

    • 一个生产者、多个消费者（轮询），不需要设置交换机（使用默认的交换机）。

  3. 发布订阅模式 Publish/subscribe(fanout广播模式)

    • 需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列。

  4. 路由模式 Routing(direct模式)

    • 需要设置类型为 direct 的交换机，交换机和队列进行绑定，并且指定 routing key，当发送消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。

  5. 通配符模式 Topic

    • 需要设置类型为 topic 的交换机，交换机和队列进行绑定，并且指定通配符方式的 routing key，当发送消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。
香辣奥利奥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
中间件RabbitMQ之运维篇
01-27
RabbitMQ的rabbitMQ是一个在AMQP协议标准基础上完整的，可服用的企业消息系统。他遵循MozilaPublic License开源协议。采用Erlang实现的工业级的消息队列(MQ)服务器。AMQP(高级消息队列协议)是一个异步消息传递所使用...
springboot整合rabbitmq（一）
qq_36090537的博客
11-22 764
RabbitMQ简单来说就是一个消息队列中间件,用来保存消息和传递消息的一个容器。在此过程中充当一个中间人的作用。 是一种程序对程序的通信方法，其服务器也是以高性能、健壮以及可伸缩性出名的Erlang语言编写而成。
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4373
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
rabbitMQProvider
03-02
rabbitMQProvider
RabbitMQ 大神系列课程代码--provider
12-24
provider 端代码完整demo 工具：idea 工程：Maven 语言： Java 需要平台： 数据库（MySQL等） consumer端代码： https://download.csdn.net/download/jwq1220/10872749
rabbitmq-c:RabbitMQ C客户端
05-10
RabbitMQ C AMQP客户端库 介绍 这是C语言AMQP客户端库，可与代理的v2.0 +一起使用。 有关该库的公告会定期在rabbitmq-c用户上发布，并交叉发布到rabbitmq-users。 最新稳定版 可以在以下位置找到rabbitmq-c的最新...
Java使用RabbitMq的一个简单demo
06-21
Java使用RabbitMq的一个简单demo，自留。
面试官：RabbitMQ本身不支持延迟队列，那你给我实现一个？.zip
最新发布
03-02
面试官：RabbitMQ本身不支持延迟队列，那你给我实现一个？.zip面试官：RabbitMQ本身不支持延迟队列，那你给我实现一个？.zip面试官：RabbitMQ本身不支持延迟队列，那你给我实现一个？.zip面试官：RabbitMQ本身不支持...
RabbitMQ常用3种交换器详解
上善若泪
02-11 1305
文章目录1 交换器1.1 Direct 交换器1.1.1 使用需求1.1.2 Consumer消费者1.1.2.1 properties配置文件1.1.2.2 消费者实体类1.1.3 Provider提供者1.1.3.1 properties配置文件1.1.3.2 生产消息实体1.1.3.3 测试类1.2 Topic 交换器1.2.1 使用需求1.2.2 Consumer消费者1.2.2.1 pr...
rabbitMQ consumer provider txSelect confirmSelect addConfirmListener
08-26
rabbitMQ consumer provider txSelect confirmSelect addConfirmListener
RabbitMQ几种模式
u014263388的专栏
05-30 9810
RabbitMQ几种模式
RabbitMQ的基本使用
qq_54936371的博客
02-25 1870
RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，RabbitMQ是使用Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的。 一、消息队列 1、MQ：Message Queue释义 服务之间最常见的通信方式是直接调用彼此来通信,消息从一端发出后立即就可以达到另一端,称为即时消息通讯(同步通信) 消息从某一端发出后,首先进入一个容器进行临时存储,当达到某种条件后,再由这个容器发送给另一端,称为延迟消息通讯(异步通信) 2、消息队列特点.
rabbitMQ模式详解
微笑流浪
03-20 1036
工作模式:    工作原理:当生成者产生消息后,保存到队列当中,c1和c2分别是监听队列的两个消费者工作模式内部采用的是轮训的机制依次执行消息发布订阅者模式    P: provider 生产者X: exchange 代表交换机C1:只间听c1的消息队列C2:只监听C2的消息队列说明:只要队列绑定了交换机,当P生产者生成消息时,这时连接交换机的全部队列都会收到这个消息,并且所有的消费者都会执行!类...
第3篇 RabbitMQ的5种模式与实例
热门推荐
u010753907的博客
06-07 1万+
3.1 简单模式Hello World 功能：一个生产者P发送消息到队列Q,一个消费者C接收 生产者实现思路： 创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，使用通道channel
第四十一章： 基于SpringBoot & RabbitMQ完成DirectExchange分布式消息消费
weixin_34378969的博客
12-03 175
消息队列目前流行的有KafKa、RabbitMQ、ActiveMQ等，它们的诞生无非不是为了解决消息的分布式消费，完成项目、服务之间的解耦动作。消息队列提供者与消费者之间完全采用异步通信方式，极力的提高了系统的响应能力，从而提高系统的网络请求吞吐量。 每一种的消息队列都有它在设计上的独一无二的优势，在实际的项目技术选型时根据项目的需求来确定。 本章目标 基于SpringBoot项目整合Rabbit...
RabbitMQ消息队列
weixin_30650859的博客
03-19 224
目录： 　　1、介绍 　　2、linux安装 　　3、工作模式 　　4、整合spring 介绍： MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。 应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。 消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如...
RabbitMQ 消息提供者和消息消费者分在两个项目
qq_42026600的博客
05-25 623
两个项目中配置相同的 rabbitmq 主机, 在application.propertes文件中配置 #rabbitmq # 配置虚拟机 spring.rabbitmq.virtual-host=/ # 开启消息确认机制 confirm 异步 spring.rabbitmq.publisher-confirm-type=correlated # 之前的旧版本 开启消息确认机制的方式 # spring.rabbitmq.publisher-confirms=true # 开启return机制 sprin
rabbitmq（一）：基本概念，channel，virtualHost, Broker，3种exchange，原生实现及springboot整合
人在江湖
10-11 1509
RabbitMQ基本概念 1-1：基本架构图 图来自于 https://www.cnblogs.com/xiaozhang666/p/13866121.html rabbitmq版本：RabbitMQ 3.9.7 maven 版本： <dependencies> <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client&
rabbitmq访问不了
10-20
如果你无法访问rabbitmq，可以尝试以下几步解决问题： 1. 以管理员身份打开命令窗口，并进入rabbitMQ文件夹下的sbin目录下，执行 rabbitmq-service.bat remove 命令。 2. 接着执行：set RABBITMQ_BASE=D:\RabbitMQ\...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

香辣奥利奥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值