linux篇】七. RabbitMQ高级属性

最新推荐文章于 2023-05-22 08:35:23 发布
最新推荐文章于 2023-05-22 08:35:23 发布
阅读量136 收藏
点赞数
分类专栏： linux 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TheNew_One/article/details/104794392
版权

RabbitMQ高级属性

中国加油，武汉加油！

篇幅较长，配合目录观看

案例准备

  1. 一个Centos7的服务器

1. 参数的含义

channel.queueDeclare(QUEUE_NAME,true,false,true,null);
第二个参数：如果是false   重启之后 队列都没有了 数据也会丢失
第三个参数：连接一旦关闭  那么就会删除这个队列
第四个参数：就是最后一个消费者 退出去之后 那么这个队列是否自动删除
第五个参数：讲ttl队列的时候要专门讲

channel.basicPublish("",QUEUE_NAME,null,"我是小波波1111".getBytes());

第一个参数 ：交换机
第二个参数：路由key
第三个参数：设置的队列的属性
第四个参数：值

2. confirm机制

场景： 放到队列中的消息成功还是失败都会进行反馈

public class Producer {
    //申明队列的名字
    private static final String QUEUE_NAME="nz1904-confirm-01";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //第一步：开启confirm消息确认机制
        channel.confirmSelect();
        //我们就要对消息的可达性实施监听
        //下面就是对消息的签收情况进行确认
        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleAck(long l, boolean b) throws IOException {
                System.out.println("发送成功的监听.....");
            }
            @Override
            public void handleNack(long l, boolean b) throws IOException {
                System.out.println("发送失败的监听.....");
            }
        });
        channel.queueDeclare(QUEUE_NAME,false,false,true,null);
        channel.basicPublish("",QUEUE_NAME,null,"我是小波波1111".getBytes());
    }
}

3. return机制-写生产者和消费者

场景：我们在发送消息的是时候、我们指定的交换机不存在或者指定的路由key不存在 这种时候我们就需要监听这种不可达的消息

channel.basicPublish(arg1, arg2, arg3, mandatory, arg5);
mandatory  如果设置为ture：就表示的是要监听不可达的消息 进行处理
如果设置为false  那么队列端会直接删除这个消息

package com.wpj.returnlistener;

import com.wpj.utils.ConnectionUtils;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ReturnListener;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Producer {

    private static final String EXCHANGE_NAME="test_return_exchange";
    //能路由的key
    private static final String ROUTING_KEY="return.save";
    //不能路由的key
    private static final String ROUTING_ERROR_KEY="abc.save";

    public static void main(String[] args) throws IOException, TimeoutException {

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //添加监听
        channel.addReturnListener(new ReturnListener() {
        	/**
             *
             * @param i：队列响应给浏览器的状态码
             * @param s：表示的是状态码对应的文本信息
             * @param s1：交换机的名字
             * @param s2：表示的是路由的key
             * @param basicProperties:表示的是消息的属性
             * @param bytes：消息体的内容
             * @throws IOException
             */
            @Override
            public void handleReturn(int i, String s, String s1, String s2, AMQP.BasicProperties basicProperties, byte[] bytes) throws IOException {
                System.out.println("监听到不可达的消息");
            }
        });
      channel.basicPublish(EXCHANGE_NAME,ROUTING_ERROR_KEY,true,null,"这里是测试Return机制".getBytes());

    }
}

package com.wpj.returnlistener;

import com.wpj.utils.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer {

    private static final String EXCHANGE_NAME="test_return_exchange1";
    //是能路由的key
    private static final String ROUTING_KEY="return.#";
    //制定绑定的队列
    private static final String QUEUE_NAME="test_return_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //申明队列
        channel.queueDeclare(QUEUE_NAME,true,false,false,null);
        //申明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");
        //绑定
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,ROUTING_KEY);
        //申明消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("收到这个消息了....");
            }
        };
        //进行消费的绑定
        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);
    }
}

4. 消费端的限流问题

场景：消费者死了 队列里面一瞬间就就积累了上万条数据、这个时候当我们打开客户端的时候、瞬间就有巨量的信息给推送过来、但是我们的客户端是没有办法同时处理这么多数据的 结果就是消费者死了…
这种场景下我们就需要对消费端进行限流

package com.wpj.limit;

import com.wpj.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Producer {

    //申明队列的名字
    private static final String QUEUE_NAME="nz1904-limit-01";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        for (int i = 0; i <100 ; i++) {
            channel.basicPublish("",QUEUE_NAME, null,("测试限流"+i).getBytes());
        }
        channel.close();
        connection.close();
    }
}

package com.wpj.limit;

import com.wpj.utils.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer {

    //申明队列的名字
    private static final String QUEUE_NAME="nz1904-limit-01";

    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //创建通道
        final Channel channel = connection.createChannel();
        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //消费者的申明
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1接受到的消息是:"+new String(body));
                //进行手动应答
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        //绑定这个消费者
        channel.basicConsume(QUEUE_NAME,false,defaultConsumer);
    }
}

package com.wpj.limit;

import com.wpj.utils.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer1 {

    //申明队列的名字
    private static final String QUEUE_NAME="nz1904-limit-01";

    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //创建通道
        final Channel channel = connection.createChannel();
        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //设置限流机制
        /**
         * 第一个参数：消息本身的大小 如果设置为0  那么表示对消息本身的大小不限制
         * 第二个参数：告诉rabbitmq不要一次性给消费者推送大于N个消息 你要推送的前提是
         * 现在这N个消息 已经手动被确认 已经完成
         * 第三个参数：true/false ：是否将上面的设置应用于整个通道  true ：表示整个通道的消费者
         * 都是这个策略  如果是false表示的是 只有当前的consumer 是这个策略
         */
        channel.basicQos(0,5,false);
        //结论：实际上如果不设置的话 分配任务的事 一开始就分配好了
        //必须手动签收
        //消费者的申明
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2接受到的消息是:"+new String(body));
                try {
                  Thread.sleep(200);
                }catch (Exception err){

                }
                //进行手动应答
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        //绑定这个消费者
        channel.basicConsume(QUEUE_NAME,false,defaultConsumer);
    }
}

5. TTL队列(Time To Live)

场景：我要下单 下单之后 在一定的时间内、我的订单如果没有被处理 那么自动失效
简单的说就是咋们的队列中的消息是有时间限制的、如果超时那么这个消息将会被队列给删除

 //我们只需要给下面的队列设置好属性 那么这个队列 就自动变成 ttl队列了
Map<String,Object> map=new HashMap<>();
map.put("x-message-ttl",5000);
channel.queueDeclare(QUEUE_NAME,false,false,false,map);

6. 死信队列

前提：

  1. 发送到队列中的消息被拒绝了
  2. 消息的ttl时间过期
  3. 队列达到了最大长度 再往里面放信息

在这里插入图片描述

package com.wpj.dlx;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.wpj.utils.ConnectionUtils;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 生产者  发送消息是发送到了 那个非死信的交换机上面的
 */
public class Producer {

    //定义的是队列(正常的交换机)  这里发送消息是在交换机上面
    private static final String EXCHANGE_NAME="ttl-dlx-exchange";
    //定义一个路由的key
    private static final String  ROUTING_KEY="dlx.#";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        for (int i = 0; i <5 ; i++) {
             channel.basicPublish(EXCHANGE_NAME,ROUTING_KEY,false,null,("死信队列测试"+i).getBytes());
        }
    }
}

package com.wpj.dlx;

import com.rabbitmq.client.*;
import com.wpj.utils.ConnectionUtils;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;

/**
 * 这个就是模拟消费者
 */
public class Consumer {

    //定义的是交换机
    private static final String EXCHANGE_NAME="ttl-dlx-exchange";
    //正常情况下的队列
    private static final String QUEUE_NAME="ttl-dlx-queue";

    //定义死信队列的交换机的名字
    private static final  String DLX_EXCHANGE_NAME="dlx-exchange";
    //死信队列的定义
    private static final  String DLX_QUEUE_NAME="dlx-queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        final Channel channel = connection.createChannel();
        //创建交换机和队列进行绑定
        channel.exchangeDeclare(EXCHANGE_NAME,"topic",true);
        //队列的申明
        //我们要申明成死信队列
        Map<String,Object> map=new HashMap<String,Object>();
        map.put("x-message-ttl",5000);
        //添加一个死信的属性  //后面这个名字就是死信队列交换机的名字
        map.put("x-dead-letter-exchange",DLX_EXCHANGE_NAME);
        channel.queueDeclare(QUEUE_NAME,true,false,false,map);
        //进行队列和交换机进行绑定
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"dlx.#");
        //上面是正常的队列的申明
        //下面就是死信队列的申明
        channel.exchangeDeclare(DLX_EXCHANGE_NAME,"topic");
        //申明队列
        channel.queueDeclare(DLX_QUEUE_NAME,true,false,false,null);
        //绑定这个死信队列
        channel.queueBind(DLX_QUEUE_NAME,DLX_EXCHANGE_NAME,"#");
        //直接性的来调用这个
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("获取到数据了:"+new String(body));
            }
        };
        //绑定消费者
        channel.basicConsume(DLX_QUEUE_NAME,true,defaultConsumer);
        //现在有这个问题呀?
    }
}

7. 消费者端手动签收和消息的重回队列

@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    System.out.println("接受到的消息是:"+new String(body));
    /**第一个参数：当前消息的标记
     * 第二个参数：是否批量进行应答
     * 下面是签收
     */
    //channel.basicAck(envelope.getDeliveryTag(),false);
    //下面也可以拒绝签收
    /**
     * 第三个参数：表示决绝签收之后这个消息是否要重回队列?
     */
    channel.basicNack(envelope.getDeliveryTag(),false,true);
}

8. 消息的延迟投递来解决传递的可靠性

在这里插入图片描述

9. 日志消息表实现可靠消息的传输

在这里插入图片描述

杰KaMi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PAcee1#myNote#04.RabbitMQ高级-消息100%投递成功方案1
07-25
1.消息入库，比如订单场景，当我们创建一条订单，需要发送消息给优惠券模块，来减少用户使用的优惠券 2.如果消息在第一步成功入库 3.MQ收到消息后返回结果响应
rabbitmq-linux-3.7.19.zip
07-19
rabbitmq的linux操作系统安装文件
RabbitMQ高级特性整理
weixin_44399827的博客
03-01 1723
RabbitMQ的高级特性整理如下： 参考：朱忠华老师的著作：Rabbit实战指南 channel参数mandatory设置为true，当消息没有找到任何队列的时候，可以返回给客户端。 备份交换机（AE）的设置、避免消息丢失。AE和mandatory同时存在的时候、只有AE生效 DLX （dead-letter-exchange）死信交换器，死信队列 进入条件：消息被拒绝（basic.reject/basic.Nack）并且设置request参数为false 消息过期 ...
3.RabbitMQ讲义--高级
无
10-26 871
3.RabbitMQ讲义--高级 7. RbbitMQ 高级 7.1. 过期时间TTL 7.1.1. 设置队列TTL 7.1.2. 设置消息TTL 7.2. 死信队列 7.2.1. 定义死信交换机 7.2.2. 队列设置死信交换机 7.2.3. 消息过期的死信队列测试 1）发送消息代码 2）在rabbitMQ管理界面中结果 3）流程 7.2.4. 消息过长的死信队列测试 1）发送消息代码 2）在rabbitMQ管理界面中结果 3）消费者接收死信队列消息 4）流程 7.3. 延迟队列 7.4. 消息确认机制
RabbitMQ详解（一）：Linux安装
weixin_45181611的博客
05-10 1577
RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件
Linux消息中间件-RabbitMQ
yyf0430的博客
12-10 1042
Linux消息中间件-RabbitMQ
026. RabbitMQ 入门及消息分发机制
山海散客
06-28 139
1. RabbitMQ 简介 RabbitMQ 是一个开源的 AMQP 实现，服务器端用 Erlang 语言编写，支持多种客户端。用于在分布式系统中存储转...
1.RabbitMQ消息队列介绍
相互学习 共同进步
05-22 195
MQ（Message Queue，消息队列），消息队列是应用程序和应用程序之间的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。 RabbitMQ是一个开源的，实现了高级消息队列协议（AMQP）的开源消息代理软件（面向消息的中间件），在AMQP基础上完善的，可复用的企业消息系统、支持主流的操作统、Linux、Windows、MacOX等，提供多种开发语言支持，Java、Python、Ruby、.NET、PHP、C/C++、node.js等。用于在分布式系统中
Rabbitmq安装以及入门
ifspirt的博客
04-02 3034
rabbitmq安装以及入门
RabbitMQ高级特性
qq_40432598的博客
03-11 582
RabbitMQ高级特性
RabbitMQ的高级特性
weixin_58473601的博客
06-24 340
RabbitMQ的高级特性
Nlog.RabbitMQ:流行的Nlog日志记录工具的目标
05-25
Nlog.RabbitMQ.Target 流行的NLog日志记录工具的RabbitMQ目标 最低推荐配置 <? xml version = " 1.0 " encoding = " utf-8 " ?> < target name = " RabbitMQTarget " xsi :
rabbitmq-linux安装教程.rar
07-31
linux环境搭建rabbitmq，简洁明了，比目前网上大多数的文档都行之有效，包含安装包及文档说明，相信你能够搭建成功。
liunx篇】 十四. elasticsearch单机部署
TheNew_One的博客
07-17 1494
elasticsearch单机部署案例准备单机部署ElasticSreach1. 安装java2. 修改linux的线程内存和文件3. 配置系统允许的软件运行内存4. 解压es相关配置文件5. 修改es的启动host地址6. 配置es的虚拟机内存7. 创建用户8. 关闭防火墙9. 访问页面 案例准备 一台Centos7的虚拟机 jdk-8u221-linux-x64.tar.gz elasticsearch-6.3.1.tar.gz 单机部署ElasticSreach 1. 安装java 配置java
linux篇】十. Docker安装FastDFS和Solr
TheNew_One的博客
03-27 410
Docker安装FastDFS**中国加油，武汉加油！**篇幅较长，配合目录观看案例准备1. Docker安装FastDFS 中国加油，武汉加油！ 篇幅较长，配合目录观看 案例准备 一台Centos7的服务器或虚拟机 安装了Docker 本案例基于linux篇】九. Docker安装 1. Docker安装FastDFS docker search fastdfs docker pull yg...
linux篇】六. RabbitMQ的使用
TheNew_One的博客
03-10 326
RabbitMQ的使用篇幅较长，配合右边目录观看项目准备1. MQ是什么2. MQ的作用2.1 流量消峰（解决高并发）2.2 模块之间的异步通信3. 消息队列中消息中间件4. RabbitMQ安装4.1 安装之前需要的环境4.2 下载rpm文件4.3 下载完成需要安装4.4 设置开机启动4.5 启动这个服务4.6 查看服务的状态4.7 停止这个服务4.8 查看当前所有的用户 中国加油，武汉加油！ ...
liunx篇】 十二. Redis发布订阅和超时指令 四
TheNew_One的博客
03-31 294
Redis发布订阅**中国加油，武汉加油！**篇幅较长，配合目录观看案例准备1. Redis发布订阅 中国加油，武汉加油！ 篇幅较长，配合目录观看 案例准备 本案例基于liunx篇】 十二. Redis事务 三 1. Redis发布订阅 ...
spring.rabbitmq.listener.simple.auto-startup
最新发布
09-16
spring.rabbitmq.listener.simple.auto-startup是Spring Boot中配置RabbitMQ简单消息监听器是否自动启动的属性。该属性的值为true或false，默认为true。 当该属性值为true时，Spring Boot启动时会自动创建RabbitMQ的简单消息监听器，并开始监听消息。而当该属性值为false时，Spring Boot会忽略RabbitMQ的简单消息监听器，不会自动创建和启动。 可以根据项目需求来决定是否启用自动创建和启动RabbitMQ的简单消息监听器。如果不需要使用消息监听器，可以将该属性值设置为false，这样可以避免不必要的资源浪费。 若需要在Spring Boot启动时自动创建并启动RabbitMQ的简单消息监听器，可以将该属性值保持为默认的true即可。这样可以方便地在应用程序启动后即可开始监听RabbitMQ的消息，实现消息的消费处理。 总之，spring.rabbitmq.listener.simple.auto-startup是一个控制RabbitMQ简单消息监听器是否自动启动的属性，根据项目需求可以选择启用或禁用该功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值