RabbitMQ消息队列

已于 2024-02-03 14:30:49 修改
阅读量921 收藏 26
点赞数 21
文章标签： rabbitmq 分布式 java
于 2024-01-09 18:18:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73505556/article/details/135486923
版权

目录

BasicQueue简单队列模型

WorkQueue工作队列

能者多劳

Fanout广播

Direct

Topic

消息转换器

BasicQueue简单队列模型

引入依赖

在父工程mq-demo中引入依赖

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

添加配置(消息发送)

配置MQ地址，在publisher服务的application.yml中添加配置

spring:
  rabbitmq:
    host: 192.168.150.101 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

消息发送

在publisher服务中编写测试类XXXAmqpTest，利用RabbitTemplate实现消息发送

package cn.itcast.mq.spring;

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

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, spring amqp!";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

============================================

添加配置(消息接收)

配置MQ地址，在consumer服务的application.yml中添加配置

spring:
  rabbitmq:
    host: 192.168.150.101 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

消息接收

在consumer服务的cn.itcast.mq.listener包中新建一个类XXXListener

package cn.itcast.mq.listener;

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

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
}

WorkQueue工作队列

Work queues，也被称为（Task queues），任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息。

引入依赖

在父工程mq-demo中引入依赖

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

添加配置(消息发送)

配置MQ地址，在publisher服务的application.yml中添加配置

spring:
  rabbitmq:
    host: 192.168.150.101 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

声明消息队列

在consumer服务的cn.itcast.mq.config包中新建一个类用于声明消息队列

package cn.itcast.mq.config;

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

@Configuration
public class WorkConfig {

    @Bean
    public Queue workGiaoOne(){
        return new Queue("simple.queue");
    }

}

编写测试类(消息发送)

在publisher服务中的XXXAmqpTest类中添加一个测试方法，循环发送，模拟大量消息堆积现象。

/**
     * workQueue
     * 向队列中不停发送消息，模拟消息堆积。
     */
@Test
public void testWorkQueue() throws InterruptedException {
    // 队列名称
    String queueName = "simple.queue";
    // 消息
    String message = "hello, message_";
    for (int i = 0; i < 50; i++) {
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message + i);
        Thread.sleep(20);
    }
}

============================================

添加配置(消息接收)

配置MQ地址，在consumer服务的application.yml中添加配置

spring:
  rabbitmq:
    host: 192.168.150.101 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

消息接收

在consumer服务的cn.itcast.mq.listener包中新建一个类XXXListener

@Component
public class SpringRabbitListener {

	@RabbitListener(queues = "simple.queue")
	public void listenWorkQueue1(String msg) throws InterruptedException {
	    System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
	    Thread.sleep(20);
	}
	
	@RabbitListener(queues = "simple.queue")
	public void listenWorkQueue2(String msg) throws InterruptedException {
	    System.err.println("消费者2........接收到消息：【" + msg + "】" + LocalTime.now());
	    Thread.sleep(200);
	}
    
}

测试

可以看到消费者1很快完成了自己的25条消息。消费者2却在缓慢的处理自己的25条消息。

也就是说消息是平均分配给每个消费者，并没有考虑到消费者的处理能力。这样显然是有问题的。

能者多劳

在spring中有一个简单的配置，可以解决这个问题。修改consumer服务的application.yml文件，添加配置

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

Fanout广播

在广播模式下，消息发送流程是这样的：

1） 可以有多个队列

2） 每个队列都要绑定到Exchange（交换机）

3） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定

4） 交换机把消息发送给绑定过的所有队列

5） 订阅队列的消费者都能拿到消息

引入依赖

在父工程mq-demo中引入依赖

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

声明队列和交换机

Spring提供了一个接口Exchange，来表示所有不同类型的交换机

在consumer中创建一个类，声明交换机

package cn.itcast.mq.config;

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 FanoutConfig {
    /**
     * 声明交换机
     * @return Fanout类型交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }
}

声明队列1

/**
 * 第1个队列
 */
@Bean
public Queue fanoutQueue1(){
    return new Queue("fanout.queue1");
}
/**
 * 绑定队列和交换机
 */
@Bean
public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
    return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
}

声明队列2

/**
 * 第2个队列
 */
@Bean
public Queue fanoutQueue2(){
    return new Queue("fanout.queue2");
}

/**
 * 绑定队列和交换机
 */
@Bean
public Binding bindingQueue2(){
    return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange());
}

添加配置(消息发送)

配置MQ地址，在publisher服务的application.yml中添加配置

spring:
  rabbitmq:
    host: 192.168.150.101 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

消息发送

在publisher服务的XXXAmqpTest类中添加测试方法

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
	@Test
	public void testFanoutExchange() {
	    // 交换机名称
	    String exchangeName = "itcast.fanout";
	    // 消息
	    String message = "hello, everyone!";
	    rabbitTemplate.convertAndSend(exchangeName, "", message);
	}
}

添加配置(消息接收)

配置MQ地址，在consumer服务的application.yml中添加配置

spring:
  rabbitmq:
    host: 192.168.150.101 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

消息接收

在consumer服务的cn.itcast.mq.listener包中新建一个类XXXListener

@Component
public class SpringRabbitListener {

	@RabbitListener(queues = "fanout.queue1")
	public void listenFanoutQueue1(String msg) {
	    System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
	}
	
	@RabbitListener(queues = "fanout.queue2")
	public void listenFanoutQueue2(String msg) {
	    System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
	}
    
}

Direct

在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

在Direct模型下：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）

  • 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。

  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

基于注解声明队列和交换机

在consumer的XXXListener中添加两个消费者，同时基于注解来声明队列和交换机

package cn.itcast.mq.listener;

@Component
public class DirectListener {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","blue"}
    ))
    public void directQueue1(String msg){
        System.out.println("消息队列1的消费者1，msg：" + msg);
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
    ))
    public void directQueue2(String msg){
        System.out.println("消息队列2的消费者1，msg：" + msg);
    }
}

消息发送

package cn.itcast.mq.helloworld;

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

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendDirectExchange() {
        // 交换机名称
        String exchangeName = "itcast.direct";
        // 消息
        String message = "奥里给";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "yellow", message);
    }
}

Topic

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符

  • Queue1：绑定的是china.# ，因此凡是以 china.开头的routing key 都会被匹配到。包括china.news和china.weather

  • Queue2：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配。包括china.news和japan.news

消息发送

在publisher服务的XXXAmqpTest类中添加测试方法

/**
     * topicExchange
     */
@Test
public void testSendTopicExchange() {
    // 交换机名称
    String exchangeName = "itcast.topic";
    // 消息
    String message = "喜报！孙悟空大战哥斯拉，胜!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
}

消息接收

在consumer服务的XXXListener中添加方法

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue1"),
    exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
    key = "china.#"
))
public void listenTopicQueue1(String msg){
    System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue2"),
    exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
    key = "#.news"
))
public void listenTopicQueue2(String msg){
    System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
}

消息转换器

测试默认转换器

@Test
public void testSendMap() throws InterruptedException {
    // 准备消息
    Map<String,Object> msg = new HashMap<>();
    msg.put("name", "Jack");
    msg.put("age", 21);
    // 发送消息
    rabbitTemplate.convertAndSend("simple.queue", msg);
}

发送消息后查看控制台

配置JSON转换器

在publisher和consumer两个服务中都引入依赖：

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

在启动类中添加一个Bean

每个工程启动类均增加

@Bean
public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
}

开朗觉觉
关注
  • 21
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ消息队列的工作模式
江晓龙的博客
06-26 1万+
使用Routing路由模式时，Exchange与队列也不再进行绑定了，而是通过声明一个RoutingKey，通过这个key将消息路由到特定的队列中，因此在消息发送方发消息时，就需要指定消息的RoutingKey，Routing根据消息中的RoutingKey进行判断，当消息中的RoutingKey与队列中的RoutingKey完全一致时，消息才能正常存储到队列中，最后被消费者处理。简而言之，使用Topic模式后，可以对消息数据中的RoutingKey进行通配符匹配，将满足条件的消息数据分发到特定的队列中。
RabbitMq消息队列指南.docx
07-05
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。 MQ 为Message Queue ， 消息...
RabbitMQ消息队列常见面试题总结
热门推荐
张维鹏的博客
03-23 6万+
RabbitMQ消息队列常见面试题总结； 1、什么是消息队列？消息队列的优缺点？ 2、Kafka、ActiveMQ、RabbitMQ、RocketMQ的区别？ 3、如何保证消息不被重复消费？ 4、如何保证消息不丢失，进行可靠性传输？ 5、如何保证消息的有序性？ 6、如何处理消息堆积情况? 7、如何保证消息队列的高可用？
C#RabbitMQ消息队列的使用
weixin_18649821372的博客
07-29 1843
C#RabbitMQ消息队列的使用 概念 1、消息(Message) 消息指的是两个应用之间传递的数据。其中数据的类型可以有很多的形式，可能只是包含文本字符串的一条消息，也可能时一个嵌入的对象。 2、消息队列(Meaasge Queue) 消息队列指的是在消息传递过程中保存消息的容器，我们可以把它理解成通讯中的缓存区，只不过是在缓存区当中可以存储多条消息数据，且提取的顺序是先进先出的原则。在消息队列中，通常还有两个必不可少的角色，也就是消息的发出是由谁来发，我们称之为生产者；以及这条消息被谁接受使用，我们称
消息队列——RabbitMQ消息队列集群
611 - 菜鸟运维逆袭架构师之路
06-16 1504
RabbitMQ消息队列系统消息队列/中间件前言MQ简介核心功能MQ的分类同类产品RabbitMQ详解RabbitMQ简介RabbitMQ特点 消息队列/中间件 前言 在我们秒杀抢购商品的时候，系统会提醒我们稍等排队中，而不是像几年前一样页面卡死或报错给用户 像这种排队结算就用到了消息队列机制，放入通道里面一个一个结算处理，而不是某个时间断突然涌入大批量的查询新增把数据库给搞宕机 所以RabbitMQ本质上起到的作用就是削峰填谷，为业务保驾护航。 MQ简介 MQ全称为Message Queue，消息
RabbitMQ消息队列__学习报告
weixin_70228478的博客
10-26 3485
（1）（开发者）查看所有的队列：rabbitmqctl list_queues（2）（开发者）清除所有的队列：rabbitmqctl reset（3）添加用户：rabbitmqctl add_user username password（4）分配角色：rabbitmqctl set_user_tags username administrator（5）新增虚拟主机：rabbitmqctl add_vhost vhost_name。
rabbitmq消息队列原理
一群专业码农的笔记本
08-12 3万+
一、rabbitmq架构 RabbitMQ是一个流行的开源消息队列系统，是AMQP（高级消息队列协议）标准的实现，由以高性能、健壮、可伸缩性出名的Erlang语言开发，并继承了这些优点。rabbitmq简单架构如下： 上图简单展示了rabbitmq的架构，从图中看到几个关键字：vhost、exchange、route key、queue等，后面会介绍这些概念。 下面看下rabbitmq的...
RabbitMQ消息队列创建
wxxya的博客
11-23 1万+
操作环境 centos 7.9 RabbitMQ 3.8.23 Erlang 24.1.2 局域网（内网） 本文章是通过RabbitMQ图形管理界面，进行消息创建与队列绑定 首先在RabbitMQ安装时 图形操作(15672)端口是要打开，通过地址在浏览器进行访问，如是安装在云服务器上，可在安全组中将当前端口开放，也可以通过putty工具代理到本地进行访问。 接下来可以通过RabbitMQ自带的图形管理进行队列创建、把exchange和queue按照路由规则绑定起来 首先介绍一下图形中功能的意思 .
golang实现rabbitmq消息队列
qq_38151401的博客
04-22 3121
目录 一、前期准备 二、具体实现过程 1、通用方法定义 2、Simple模式 3、工作模式 4、Publish订阅模式 5、Routine路由模式 6、Topic话题模式 三、完整代码 一、前期准备 1、安装rabbitmq（docker）：https://blog.csdn.net/qq_38151401/article/details/103327339 2、熟悉了解r...
RabbitMQ消息队列阻塞处理
weixin_44770684的博客
07-29 4097
适当增加消费端资源限制 以及增加消费端实例数来提高消费端对消息队列的消费能力，我的环境该消息队列的消费端实例数原本是一个实例，最终通过将该消费端实例数量增加到3个实例，才解决了消息队列阻塞的问题。(由于我写文档截图的时候已经把堆积的消息问题处理了，所以看的消息数值是9，消息阻塞的时候该值实际上和收到的告警的通知告警的数值是一致的)异步处理和批量处理：如果消息队列的负载过高，可以考虑将一些耗时较长的操作改为异步处理，或者批量处理多条消息，以减少消息队列的阻塞。等，来优化消息的处理和队列的性能。
rabbitmq消息队列
02-25
消息队列（Message Queue）是一种应用间的通信方式，消息发送后可以立即返回，由消息系统来确保消息的可靠传递。消息发布者只管把消息发布到 MQ 中而不用管谁来取，消息使用者只管从 MQ 中取消息而不管是谁发布的。...
rabbitMQ消息队列
11-18
rabbitMQ消息队列服务端
rabbitMQ 消息队列 Demo
10-18
rabbitMQ官方Demo，包含01HelloWorld，02WorkQueues，03PublishSubscribe，04Routing，05Topics，06RPC六个示例
使用golang实现的推送系统 结合rabbitmq消息队列 gin-web实现消息接收推送
02-18
golang 推送系统 单机 客户端通过websocket连接到服务端 ...服务端从rabbitmq接收消息，根据消息所属通过websocket推送到具体用户 服务端从http api接收消息，根据消息所属通过websocket推送到具体用户
Docker 部署RabbitMQ
天河有尽后为涯，星海无边前作岸。
05-16 405
d：设置程序后台运行。：设置服务自启动。--name：指定运行后的容器名称。-e：设置环境。这里主要设置账号密码为admin。默认账号密码为guest ，只能在 localhost访问，由于需要外网访问，所以创建admin用户进行登录。-p：设置公网IP地址的端口号对应容器内部的端口号。：安装可视化管理组件。
RabbitMQ的基本组件有哪些？
yuanlaile的博客
05-15 295
RabbitMQ的基本组件介绍，RabbitMQ不生产消息，他是消息的搬运工。
卸载RabbitMq
m0_46487331的博客
05-13 294
卸载RabbitMQ的方法取决于您最初安装它时所使用的工具和平台。
【Linux】Centos7安装RabbitMQ
最新发布
m0_72166275的博客
05-17 221
超详细的RabbitMQ的安装

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值