消息队列-RabbitMQ各种消息使用

最新推荐文章于 2024-05-13 21:10:57 发布
最新推荐文章于 2024-05-13 21:10:57 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： 分布式学习 文章标签： rabbitmq java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44044929/article/details/124977961
版权

实现公平队列

公平队列：也就是能力强的消费者处理的消息多一点，能者多劳。也叫工作队列。

如何实现公平消费：使用手动 ack 模式，也就是消费者手动发送消息告诉 mq 服务器端，消息消费完成，可以从队列删除该消息。

主动拉去：消费者和MQ服务器端第一次建立连接的时候。
主动推送：消费者已经和MQ服务器端保持长连接了，只要生产者投递消息，MQ服务端会立即将消息转发给消费者。

公平队列实现原理：MQ服务端没次只会给消费者发送一条消息，如果消费者没有返回ack，就不会继续发消息。

实现代码：
生产者：

public class Product {
    private static final String QUEUE_NAME = "kaico";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        // 1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        // 2.设置通道
        Channel channel = connection.createChannel();
        //开启消息确认机制
        channel.confirmSelect();
        // 3.设置消息
        String msg = "kaico开始学习RabbitMQ了111";
        System.out.println("msg:" + msg);
        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());

        //判断生产者投递消息是否成功
        if (channel.waitForConfirms()) {
            System.out.println("发送消息成功");
        } else {
            System.out.println("发送消息失败");
        }
        channel.close();
        connection.close();
    }
}

消费者

public class Consumer {
    private static final String QUEUE_NAME = "kaico";
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        // 2.设置通道
        final Channel channel = connection.createChannel();
        //MQ每次只会给消费者发送一条消息，消费者必须返回ack之后才会继续发送消息给消费者。
        channel.basicQos(1);//一次性处理消息的数量
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("消费者获取消息:" + msg);
                //手动发送消息告诉 mq 服务器端，从队列删除该消息
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 3.监听队列
        channel.basicConsume(QUEUE_NAME, false, defaultConsumer); //第二个参数是否开启自动应答模式

//        channel.close();
//        connection.close();

    }
}

保证消息不丢失

生产者：确保生产者消息投递成功到MQ成功；消息确认机制。
消费者：确保消费者消费消息成功，采用 ack 确认。
MQ服务器：需要将数据持久化到硬盘。

其他情况：硬盘坏了、持久化的过程断电了、或者其他情况投递消息失败的情况。
解决办法：通过表记录每次生产者投递消息，如果长期没有被消费，手动的补偿消费。

生产者投递消息失败的情况？
1、MQ服务器挂了
2、MQ拒绝接收消息（队列满了）

生产者和消费者的确认机制见上面的代码案例。
MQ持久化设置：
第一步、创建队列是设置成可持久化的
这种方式是把队列持久化
在这里插入图片描述1、durable是否持久化： durable为持久化、 Transient 不持久化
2、autoDelete 是否自动删除，当最后一个消费者断开连接之后队列是否自动被删除，可以通过RabbitMQ Management，查看某个队列的消费者数量，当consumers = 0时队列就会自动删除

第二步、代码设置
设置交换器的持久化

// 三个参数分别为 交换器名、交换器类型、是否持久化
channel.exchangeDeclare(EXCHANGE_NAME, "topic", true);

设置队列的持久化

// 参数1 queue ：队列名  
// 参数2 durable ：是否持久化  
// 参数3 exclusive ：仅创建者可以使用的私有队列，断开后自动删除  
// 参数4 autoDelete : 当所有消费客户端连接断开后，是否自动删除队列  
// 参数5 arguments  
channel.queueDeclare(QUEUE_NAME, true, false, false, null);

设置消息的持久化

// 参数1 exchange ：交换器  
// 参数2 routingKey ： 路由键  
// 参数3 props ： 消息的其他参数,其中 MessageProperties.PERSISTENT_TEXT_PLAIN 表示持久化  
// 参数4 body ： 消息体  
channel.basicPublish("", queue_name, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());

七种类型的消息

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

交换机类型

  1. Direct exchange（直连交换机）：根据生产者投递不同的路由键，再由交换机发送到队列实现匹配路由键。
  2. Fanout exchange（扇型交换机）：只要绑定了队列，就会把消息发送到队列。
  3. Topic exchange（主题交换机）：
  4. Headers exchange（头交换机）

交换机核心作用：分发路由消息、中转。
队列：容器存放多个不同的消息，遵循先进先出的原则。
消息：传递的参数
路由键：交换机根据路由键的值，发送到不同的队列中。
扇形交换机主要的特征：只要队列绑定同一个交换机，生产者将消息投递到交换机中，交换机会将消息发送给所有绑定的队列进行存放消息。

点对点队列

这个没有交换机，这个其实是默认的交换机（直连交换机），我们需要提供一个生产者一个队列以及一个消费者。

工作队列

一个生产者，一个默认的交换机（DirectExchange），一个队列，两或多个消费者。

一个队列对应了多个消费者，默认情况下，由队列对消息进行平均分配，消息会被分到不同的消费者手中。消费者可以配置各自的并发能力，进而提高消息的消费能力，也可以配置手动 ack，来决定是否要消费某一条消息。

发布订阅模式

一个生产者，多个消费者，每一个消费者都有自己的一个队列，生产者没有将消息直接发送到队列，而是发送到了交换机，每个队列绑定交换机，生产者发送的消息经过交换机，到达队列，实现一个消息被多个消费者获取的目的。需要注意的是，如果将消息发送到一个没有队列绑定的 Exchange上面，那么该消息将会丢失，这是因为在 RabbitMQ 中 Exchange 不具备存储消息的能力，只有队列具备存储消息的能力。

首先创建路由，路由类型：direct
在这里插入图片描述

生产者

public class ExProducer {
    private static final String EXCHANGE_NAME = "kaico_room19_direct";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //  创建Connection
        Connection connection = RabbitMQConnection.getConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 通道关联交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "direct", true);
        //定义路由键
        String routingKey = "kaico.sms";
        String msg = "kaico正在学习发布订阅模式消息" + routingKey;
        channel.basicPublish(EXCHANGE_NAME, routingKey, null, msg.getBytes());
        channel.close();
        connection.close();
        //如果消息没有绑定队列，消息可能会丢失。
    }
}

邮件消费者

public class EmailConsumer {
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "consumerDirect_email";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "kaico_room19_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("邮件消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 消费者将路由绑定队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);

    }
}

短信消费者

public class SmsConsumer {
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "consumerDirect_sms";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "kaico_room19_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("短信消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 消费者将路由绑定队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);

    }
}

Direct

DirectExchange 的路由策略是将消息队列绑定到一个 DirectExchange 上，当一条消息到达 DirectExchange 时会被转发到与该条消息 routing key 相同的 Queue 上，在direct 类型上增加了 routing key，如果消费者没有指定路由键的话（默认）就会接收所有的消息。可以在后台管理页面接触绑定。
在这里插入图片描述

在这里插入图片描述

Topic

TopicExchange 是比较复杂但是也比较灵活的一种路由策略，在 TopicExchange 中，Queue 通过 routingkey 绑定到 TopicExchange 上，当消息到达 TopicExchange 后，TopicExchange 根据消息的 routingkey 将消息路由到一个或者多个 Queue 上。

在这里插入图片描述

创建交换机
在这里插入图片描述匹配规则：消费者根据路由键中是否有 # 和 * 来模糊匹配，符号 “#” 匹配路由键的一个或多个词，符号 “”匹配路由键的一个词。
例如：topic..queue那么这个队列会接收topic.aaaa.queue这样格式的消息，不能接收 topic.aaaa.bbbb.queue这样格式的消息，topic.#.queue 能接收 topic.aaaa.bbbb.queue 这样格式的消息

RPC

在这里插入图片描述

  1. 首先 Client 发送一条消息，和普通的消息相比，这条消息多了两个关键内容：一个是 correlation_id，这个表示这条消息的唯一 id，还有一个内容是 reply_to，这个表示消息回复队列的名字。
  2. Server 从消息发送队列获取消息并处理相应的业务逻辑，处理完成后，将处理结果发送到 reply_to 指定的回调队列中。
  3. Client 从回调队列中读取消息，就可以知道消息的执行情况是什么样子了。

这种情况其实非常适合处理异步调用。

代码案例暂无。

Publisher Confirms

publisher confirms是一个RabbitMQ的插件用于实现可靠的发布。当publisher confirms在channel上启用时，broker将异步确认客户端发送的信息，意味着服务端接收到了消息。
生产者

public class Producer {
    private static final String QUEUE_NAME = "kaico_room19_ceshi";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        System.out.println("生产者启动。。。");
        // 1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        // 2.设置通道
        Channel channel = connection.createChannel();
        // 生产者调用confirmSelect将channel设置为confirm模式注意
        channel.confirmSelect();
        // 3.设置消息
        String msg = "kaico学习rabbitmq的工作队列" + LocalDateTime.now().toString();
        System.out.println("msg:" + msg);
        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        //确认消息发送到mq成功【确认机制】
        if (channel.waitForConfirms()) {
            System.out.println("发送消息成功");
        } else {
            System.out.println("发送消息失败");
        }
        channel.close();
        connection.close();
    }
}

Springboot整合RabbitMQ

springboot 只需要配置转换机和队列的信息就会帮我们自动创建对应的信息。

maven依赖

  <!-- 添加springboot对amqp的支持 -->
        <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>

yml配置

spring:
  rabbitmq:
    ####连接地址
    host: www.kaicostudy.com
    ####端口号
    port: 5672
    ####账号
    username: kaico
    ####密码
    password: kaico
    ### 地址
    virtual-host: /kaicoStudy

编写配置类：也就是交换机和队列的信息，spring会自动创建对应的队列和交换机

@Configuration
public class OrderRabbitMQConfig {
    /**
     * 派单队列
     */
    public static final String ORDER_DIC_QUEUE = "order_dic_queue";
  
    /**
     * 派单交换机
     */
    public static final String ORDER_EXCHANGE_NAME = "order_exchange_name";

    /**
     * 定义派单队列
     *
     * @return
     */
    @Bean
    public Queue directOrderDicQueue() {
        return new Queue(ORDER_DIC_QUEUE);
    }


    /**
     * 定义订单交换机
     *
     * @return
     */
    @Bean
    DirectExchange directOrderExchange() {
        return new DirectExchange(ORDER_EXCHANGE_NAME);
    }

    /**
     * 派单队列与交换机绑定
     *
     * @return
     */
    @Bean
    Binding bindingExchangeOrderDicQueue() {
        return BindingBuilder.bind(directOrderDicQueue()).to(directOrderExchange()).with("orderRoutingKey");
    }
 
}

消费者

@Component
@RabbitListener(bindings = @QueueBinding(
        exchange = @Exchange(value = "order_exchange_name", type = ExchangeTypes.DIRECT), // 交换机(直连)
        key = "testRouting",                // 路由key
        value = @Queue("order_dic_queue"))) // 派单队列
public class MailMsgConsumer {

    @RabbitHandler
    public void process(String msg){

        System.out.println("邮件消费者消费消息：" + msg);
    }
}

生产者发送消息

@RestController
public class OrderController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RequestMapping("/sendEasyMsg")
    public String sendEasyMsg() {
        String msg = "kaico学习Springboot整合Rabbitmq,时间：" + LocalDateTime.now().toString();
        rabbitTemplate.convertAndSend("order_exchange_name", "testRouting", msg);

        return "成功";
    }
}
kaico2018
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何使用rabbitmq的管理界面查看队列的消息内容和人工发送消息内容
qq_34004088的博客
12-21 3万+
1、获取队列中的消息 点击queues，Get Message(s),Payload里的内容就是 2、人工往队列里发消息 Headers 设置contentType application/json Payload里填上发送内容，点击Publish message 就可以
消息中间件RabbitMQ系列，直连模式，实现利用代码从队列里面取出数据（四）
一天不写代码难受的博客
10-20 571
之前已经利用代码，将一些数据放到了队列里面，现在我们要实现利用代码从队列里面拿出数据。 public class Customer { public static void main(String[] args) throws IOException, TimeoutException { // 创建连接mq的连接工厂对象，这个是依赖里面的类，我们只需要拿过来创建对象就可以了 ConnectionFactory connectionFactory
Rabbitmq元数据导入导出
bennybi的博客
01-29 2551
操作前需要先下载rabbitmqadmin工具 rabbitmqadmin工具依赖rabbitmq_management插件 安装rabbitmq_management插件 rabbitmq-plugins enable rabbitmq_management 下载工具http://{hostname}:15672/cli/rabbitmqadmin http://{hostname}:15672/cli/rabbitmqadmin] 类似UNIX的操作系统用户需要将Rabbitmqadmi
RabbitMQ
weixin_38702618的博客
07-18 520
来源 RabbitMQ是用Erlang实现的一个高并发高可靠AMQP消息队列服务器。 支持消息的持久化、事务、拥塞控制、负载均衡等特性，使得RabbitMQ拥有更加广泛的应用场景。 RabbitMQ跟Erlang和AMQP有关。下面简单介绍一下Erlang和AMQP。 Erlang是一门动态类型的函数式编程语言，它也是一门解释型语言，由Erlang虚拟机解释执行。从语言模型上说，Erlang是...
SpringBoot + RabbitMQ从延时队列中删除指定的值【RabbitMQ中的basicAck和basicNack的区别以及basicReject又是什么？】
番茄Salad
04-15 3264
业务需求是，就是我本来是有一个order-queue队列绑定到了死信队列交换机order-dead-direct-exchange上，然后我的业务是，现在有一个用户下单但是没有付款，order-queue队列写入该条信息并计时24小时后如果用户还是未付款状态则移除到死信队列order-dead-queue中。问题来了，如果在这个24小时内，用户取消订单，这时候就要从order-queue队列中移除该条信息。怎么操作呢？
RabbitMQ队列迁移
domain.5忘初心
10-24 2253
RabbitMQ把某个队列从一个集群迁移到另一个集群的操作方法 比如，把队列 dhgate_translate_priority 由酒仙桥读写jxq_mq_group_e集群的172.19.224.22、172.19.224.25节点分别迁移至酒仙桥读写jxq_mq_group_g集群的172.19.40.71、172.19.40.72节点。 step1、在dhmq管理平台（http://172.19.40.57:8080/login）上查看dhgate_translate_priority队列信息和所属集
RabbitMQ之工作队列 ( Work Queues )
JAVA开发区的博客
05-09 1429
工作队列（又称任务队列）的主要思想是避免立即执行资源密集型任务，而不得不等待它完成。相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。
108、AMQP消息队列-RabbitMQ1
08-04
当前我们的容器已经启动了，我们可以在浏览器中来访问消息队列的管理端，输localhost:15672。执完数据库的更改之后，运symfony console d
Spring-rabbitMQ整合消息队列RabbitMQ
11-15
Spring boot整合消息队列RabbitMQ
贝岭的matlab的代码-belling-spring-rabbitmq:Spring项目集成了消息队列-RabbitMQ，实现了普通消息订阅
06-16
贝岭的matlab的代码 ...rabbitmq-server-3.6.12.exe rabbitmq_delayed_message_exchange-0.0.1.ez （延时消息插件-必备） 注意事项 RabbitMQ本身是不支持延迟消息发送，需要下载rabbitmq_delayed_mess
消息队列RabbitMQ示例6种模式
01-22
简单模式：生产者与消费者 Work模式：发布者与3个订阅者 Topic交换机：生产者与3个消费者 Fanout交换机：生产者与2个消费者 Direct交换机：产生者与两个消费者 RPC远程回调：客户端与服务端
flask-rabbitmq：带RabbitMQ代理的烧瓶
02-05
烧瓶应用生产者将消息推送到正确的队列使用从RabbitMQ服务器推送消息的工作程序。要求Python 3和需求文件依赖性RabbitMQ经纪人正在安装使用pip安装和更新： 创建一个virtualenv $ python -m venv venv
Spring Boot笔记-接收RabbitMQ队列中的消息
web15536243458的博客
08-24 562
这里指的是目前并发为5个，最大并发数为10个，监听确认为手动，也就是接收了数据，要给RabbitMQ给一个反馈信息。首先有个关键：此处实验接收的数据类型为Order，这里要求发送和接收要一模一样。这里如果没有对应的交换机和队列，那么此处就会自动新建。这里有2个注解，是简单使用RabbitMQ的关键！这里，包名和类都一模一样否则接收端监听会失败！发送端不停的发送消息！下面是productorDemo。如下，consumerDemo。
RabbitMQ介绍及使用
chontue_ren的博客
07-25 389
RabbitMQ 是一个开源的AMQP实现、服务器端用Erlang语言编写，支持多种客户端。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。
初识RabbitMQ
loveme888的专栏
08-15 1218
RabbitMQ是一套开源（MPL）的消息队列服务软件，是由 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现，由以高性能、健壮以及可伸缩性出名的 Erlang 写成.
RabbitMQ—队列
王萌萌
06-04 744
消息代理     在保证消息传输过程安全的前提下，为应用提供通用的消息发送和接收平台。     专有名词     生产（Producing），即发送     发送消息的程序就是开发者（producer），用“P”表示          队列（queue），邮箱的名称     无限缓冲，可接受多个生产者（producers）的消息，也可以给多个消费者（consumers
RabbitMQ消息中间件快速入门
欢迎来到编程小栈
07-19 2178
文章目录一、同步和异步通讯1. 同步通讯2. 异步通讯二、RabbitMQ1. MessageQueue对比2. RabbitMQ快速入门【1】安装与启动【2】基本结构3. 五种消息模型介绍【1】入门案例1）publisher实现2）consumer实现4. SpringAMQP实现【1】Basic Queue 基本消息队列1）消息发送2）消息接收3）测试【2】WorkQueue工作消息队列1）消息发送2）消息接收3）测试4）prefetch提前获取【3】发布订阅三种模式1）Fanout[1] 声明队列和交
抓取rabbitmq的queues列表
偶爱喝可乐
08-19 3093
查看详细步骤请移步2017/09/11更新 Python request get 更简单抓取#!/usr/bin/python3 # -*- coding: utf-8 -*- # author=Heimport json import subprocess from log import log_base from config import mq class Queues: def __
RabbitMQ（四种使用模式）
最新发布
Sun的个人博客
05-13 1983
/ 定义一个交换机，两个队列的名称// 创建两个队列和一个交换机// 创建队列1@Bean// 创建队列2@Bean// 创建交换机@Bean// 将队列一和交换机绑定@Bean// 将队列二和交换机绑定@Bean// ----------------- Direct模式 -----------------// 定义一个交换机，两个队列的名称// 定义两个路由分别为red和green// 创建两个队列和一个交换机// 创建队列1@Bean。
消息队列-RabbitMQ
09-14
RabbitMQ是一个开源的消息队列系统，它实现了高效的消息传递机制。它使用AMQP（Advanced Message Queuing Protocol）作为通信协议，并提供了可靠的消息传递、灵活的路由方式和强大的消息模式支持。 通过RabbitMQ，应用程序可以在不同的组件之间异步地发送和接收消息。它可以处理大量的消息，并确保它们按照指定的规则进行路由、持久化和传递。 RabbitMQ的核心概念是生产者、消费者和队列。生产者负责发送消息到队列，消费者从队列中接收消息并进行处理。队列是消息的缓冲区，它存储了等待被消费的消息。 RabbitMQ还支持各种高级特性，如消息确认、持久化、事务、优先级队列等。它可以与各种编程语言和平台进行集成，并广泛应用于分布式系统、微服务架构、异步任务处理等场景中。 总之，RabbitMQ是一个功能强大、可靠性高的消息队列系统，可以帮助应用程序实现解耦、提高性能和可扩展性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值