目的：

　　RabbitMQ之消息模式（上）：https://www.cnblogs.com/huangting/p/11994539.html

　　消费端限流

　　消息的ACK与重回队列

　　TTL消息

　　死信队列

消费端限流

什么是消费端的限流？　

假设一个场景，首先，我们RabbitMQ服务器有上万条未处理的消息，我们随便打开一个消费者客户端，会出现下面情况：

巨量的消息瞬间全部推送过来，但是我们单个客户端无法同时处理这么多数据

消费端限流RabbitMQ提供的解决方案

RabbitMQ提供了一种qos（服务质量保证）功能，即在非自动确认消息的前提下，如果一定数目的消息（通过基于Consumer或者Channel设置Qos的值）未被确认前，不进行消费新的消息

Void BasicQos(uint prefetchSize, ushort prefetchCount, bool global);

prefetchSize：0 不限制消息大小

prefetchSize：会告诉RabbitMQ不要同时给一个消费者推送多于N个消息，即一旦有N个消息还没有ack，则该Consumer将block（阻塞）掉，直到有消息ack

Global：true\false是否将上面设置应用于Channel；简单来说，就是上面限制是Channel级别的还是Consumer级别

注意：

prefetchSize和global这两项，RabbitMQ没有实现，暂且不研究；

prefetch_count在no_ask=false的情况下生效，即在自动应答的情况下，这两个值是不生效的

首先启动虚拟机打开centos启动rabbitmq镜像

　　不然后期在idea中运行项目绝对报错

自定义消费端代码

package com.javaxh.rabbitmqapi.limit;

import com.rabbitmq.client.AMQP;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.DefaultConsumer;

import com.rabbitmq.client.Envelope;

import java.io.IOException;

public class MyConsumer extends DefaultConsumer {

    private Channel channel ;

    public MyConsumer(Channel channel) {

        super(channel);

        this.channel = channel;

    }

    @Override

    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

        System.err.println("-----------consume message----------");

        System.err.println("consumerTag: " + consumerTag);

        System.err.println("envelope: " + envelope);

        System.err.println("properties: " + properties);

        System.err.println("body: " + new String(body));

        channel.basicAck(envelope.getDeliveryTag(), false);

    }

}

消费端代码：

package com.javaxh.rabbitmqapi.limit;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class Consumer {

    public static void main(String[] args) throws Exception {

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.239.131");

        connectionFactory.setPort(5672);

        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();

        Channel channel = connection.createChannel();

        String exchangeName = "test_qos_exchange";

        String queueName = "test_qos_queue";

        String routingKey = "qos.#";

        channel.exchangeDeclare(exchangeName, "topic", true, false, null);

        channel.queueDeclare(queueName, true, false, false, null);

        channel.queueBind(queueName, exchangeName, routingKey);

        //1 限流方式  第一件事就是 autoAck设置为 false

        channel.basicQos(0, 1, false);

        channel.basicConsume(queueName, false, new MyConsumer(channel));

    }

}

生产端代码：

package com.javaxh.rabbitmqapi.limit;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class Producer {

    public static void main(String[] args) throws Exception {

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.239.131");

        connectionFactory.setPort(5672);

        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();

        Channel channel = connection.createChannel();

        String exchange = "test_qos_exchange";

        String routingKey = "qos.save";

        String msg = "Hello RabbitMQ QOS Message";

        for(int i =0; i<5; i ++){

            channel.basicPublish(exchange, routingKey, true, null, msg.getBytes());

        }

    }

}

先运行消费端在运行生产端：

消息的ACK与重回队列

消费端手工ACK与NACK

消费端进行消费的时候，如果由于业务异常我们可以进行日志的记录，然后进行补偿

如果由于服务器宕机等严重问题，那么我们就需要手工进行ACK，保障消费端消费成功

消费端的重回队列

　　自定义消费者代码

package com.javaxh.rabbitmqapi.ack;

import com.rabbitmq.client.AMQP;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.DefaultConsumer;

import com.rabbitmq.client.Envelope;

import java.io.IOException;

public class MyConsumer extends DefaultConsumer {

    private Channel channel ;

    public MyConsumer(Channel channel) {

        super(channel);

        this.channel = channel;

    }

    @Override

    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

        System.err.println("-----------consume message----------");

        System.err.println("body: " + new String(body));

        try {

            Thread.sleep(2000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        if((Integer)properties.getHeaders().get("num") == 0) {

//            手动签收，重回队列

            channel.basicNack(envelope.getDeliveryTag(), false, true);

        } else {

            channel.basicAck(envelope.getDeliveryTag(), false);

        }

    }

}

消费端代码：

package com.javaxh.rabbitmqapi.ack;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class Consumer {

    public static void main(String[] args) throws Exception {

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.239.131");

        connectionFactory.setPort(5672);

        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();

        Channel channel = connection.createChannel();

        String exchangeName = "test_ack_exchange";

        String queueName = "test_ack_queue";

        String routingKey = "ack.#";

        channel.exchangeDeclare(exchangeName, "topic", true, false, null);

        channel.queueDeclare(queueName, true, false, false, null);

        channel.queueBind(queueName, exchangeName, routingKey);

        // 手工签收 必须要关闭 autoAck = false

        channel.basicConsume(queueName, false, new MyConsumer(channel));

    }

}

生产端代码：

package com.javaxh.rabbitmqapi.ack;

import com.rabbitmq.client.AMQP;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import java.util.HashMap;

import java.util.Map;

public class Producer {

    public static void main(String[] args) throws Exception {

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.239.131");

        connectionFactory.setPort(5672);

        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();

        Channel channel = connection.createChannel();

        String exchange = "test_ack_exchange";

        String routingKey = "ack.save";

        for(int i =0; i<5; i ++){

            Map<String, Object> headers = new HashMap<String, Object>();

            headers.put("num", i);

            AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()

                    .deliveryMode(2)

                    .contentEncoding("UTF-8")

                    .headers(headers)

                    .build();

            String msg = "Hello RabbitMQ ACK Message " + i;

            channel.basicPublish(exchange, routingKey, true, properties, msg.getBytes());

        }

    }

}

先运行消费端在运行生产端：

　　

去rabbitmq中去查看

TTL消息

TTL是Time To Live的缩写，也就是生存时间

RabbitMQ支持消息的过期时间，在消息发送时可以进行指定

RabbitMQ支持队列的过期时间，从消息入队列开始计算，只要超过了队列的超时时间配置，那么消息自动的清除

纯控制台操作（演示TTL队列消息特点）

针对队列，只要是这个队列的消息，就只有这么长的存活时间

注意：主要针对消息设置，跟交换机、队列、消费者设置毫无关系

消费端代码

package com.javaxh.rabbitmqapi.ttl;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import com.rabbitmq.client.QueueingConsumer;

import java.util.Map;

public class Consumer {

    public static void main(String[] args) throws Exception {

        //1 创建一个ConnectionFactory, 并进行配置

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.239.131");

        connectionFactory.setPort(5672);

        connectionFactory.setVirtualHost("/");

        //2 通过连接工厂创建连接

        Connection connection = connectionFactory.newConnection();

        //3 通过connection创建一个Channel

        Channel channel = connection.createChannel();

        //4 声明（创建）一个队列

        String queueName = "test001";

        channel.queueDeclare(queueName, true, false, false, null);

        //5 创建消费者

        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);

        //6 设置Channel

        channel.basicConsume(queueName, true, queueingConsumer);

        while(true){

            //7 获取消息

            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();

            String msg = new String(delivery.getBody());

            System.err.println("消费端: " + msg);

            Map<String, Object> headers = delivery.getProperties().getHeaders();

            System.err.println("headers get my1 value: " + headers.get("my1"));

            //Envelope envelope = delivery.getEnvelope();

        }

    }

}

生产端代码：

package com.javaxh.rabbitmqapi.ttl;

import com.rabbitmq.client.AMQP;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import java.util.HashMap;

import java.util.Map;

public class Procuder {

    public static void main(String[] args) throws Exception {

        //1 创建一个ConnectionFactory, 并进行配置

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.239.131");

        connectionFactory.setPort(5672);

        connectionFactory.setVirtualHost("/");

        //2 通过连接工厂创建连接

        Connection connection = connectionFactory.newConnection();

        //3 通过connection创建一个Channel

        Channel channel = connection.createChannel();

        Map<String, Object> headers = new HashMap<>();

        headers.put("my1", "111");

        headers.put("my2", "222");

        AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()

                .deliveryMode(2)

                .contentEncoding("UTF-8")

                .expiration("10000")

                .headers(headers)

                .build();

        //4 通过Channel发送数据

        for(int i=0; i < 5; i++){

            String msg = "Hello RabbitMQ!";

            //1 exchange   2 routingKey

            channel.basicPublish("", "test001", properties, msg.getBytes());

        }

        //5 记得要关闭相关的连接

        channel.close();

        connection.close();

    }

}

还是先运行消费端在运行生产端：

死信队列

死信队列：DLX，Dead-Letter-Exchange

利用DLX，当消息在一个队列中变成死信（dead message）之后，它能被重新publish到另一个Exchange，这个Exchange就是DLX

消息变成死信有以下几种情况

    • 消息被拒绝（basic.reject/basic.nack）并且requeue=false
    • 消息TTL过期
    • 队列达到最大长度

死信队列的特点

DLX也是一个正常的Exchange，和一般的Exchange没有区别，它能在任何的队列上被指定，实际上就是设置某个队列的属性；

当这个队列中有死信时，RabbitMQ就会自动的将这个消息重新发布到设置的Exchange上去，进而被路由到另一个队列；

可以监听这个队列中消息做相应的处理，这个特性可以弥补RabbitMQ3.0以前支持的immediate参数的功能

死信队列设置

  • 首先需要设置死信队列的Exchange和Queue，然后进行绑定：

Exchange：dlx.exchange

Queue：dlx.queue

RoutingKey：#

  • 然后我们进行正常声明交换机、队列、绑定，只不过我们需要在队列加上一个参数即可：

Arguments.put(“x-dead-letter-exchange”,”dlx.exchange”)；

这样消息在过期、requeue、队列在达到最大长度时，消息就可以直接路由到死信队列

自定义消费端

package com.javaxh.rabbitmqapi.dlx;

import com.rabbitmq.client.AMQP;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.DefaultConsumer;

import com.rabbitmq.client.Envelope;

import java.io.IOException;

public class MyConsumer extends DefaultConsumer {

    public MyConsumer(Channel channel) {

        super(channel);

    }

    @Override

    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

        System.err.println("-----------consume message----------");

        System.err.println("consumerTag: " + consumerTag);

        System.err.println("envelope: " + envelope);

        System.err.println("properties: " + properties);

        System.err.println("body: " + new String(body));

    }

}

消费端：

package com.javaxh.rabbitmqapi.dlx;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import java.util.HashMap;

import java.util.Map;

public class Consumer {

    public static void main(String[] args) throws Exception {

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.239.131");

        connectionFactory.setPort(5672);

        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();

        Channel channel = connection.createChannel();

        // 这就是一个普通的交换机 和 队列 以及路由

        String exchangeName = "test_dlx_exchange";

        String routingKey = "dlx.#";

        String queueName = "test_dlx_queue";

        channel.exchangeDeclare(exchangeName, "topic", true, false, null);

        Map<String, Object> agruments = new HashMap<String, Object>();

        agruments.put("x-dead-letter-exchange", "dlx.exchange");

        //这个agruments属性，要设置到声明队列上

        channel.queueDeclare(queueName, true, false, false, agruments);

        channel.queueBind(queueName, exchangeName, routingKey);

        //要进行死信队列的声明:

        channel.exchangeDeclare("dlx.exchange", "topic", true, false, null);

        channel.queueDeclare("dlx.queue", true, false, false, null);

        channel.queueBind("dlx.queue", "dlx.exchange", "#");

        channel.basicConsume(queueName, true, new MyConsumer(channel));

    }

}

生产端代码：

package com.javaxh.rabbitmqapi.dlx;

import com.rabbitmq.client.AMQP;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class Producer {

    public static void main(String[] args) throws Exception {

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.239.131");

        connectionFactory.setPort(5672);

        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();

        Channel channel = connection.createChannel();

        String exchange = "test_dlx_exchange";

        String routingKey = "dlx.save";

        String msg = "Hello RabbitMQ DLX Message";

        for(int i =0; i<1; i ++){

            AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()

                    .deliveryMode(2)

                    .contentEncoding("UTF-8")

                    .expiration("10000")

                    .build();

            channel.basicPublish(exchange, routingKey, true, properties, msg.getBytes());

        }

    }

}

谢谢观看！！！

RabbitMQ之消息模式（下）的更多相关文章

  1. RabbitMQ之消息模式简单易懂，超详细分享~~~

    前言 上一篇对RabbitMQ的流程和相关的理论进行初步的概述,如果小伙伴之前对消息队列不是很了解,那么在看理论时会有些困惑,这里以消息模式为切入点,结合理论细节和代码实践的方式一起来学习. 正文 常 ...

  2. RabbitMQ之消息模式2

    消费端限流 什么是消费端的限流? 假设一个场景,首先,我们RabbitMQ服务器有上万条未处理的消息,我们随便打开一个消费者客户端,会出现下面情况: 巨量的消息瞬间全部推送过来,但是我们单个客户端无法 ...

  3. RabbitMQ之消息模式

    目的: 消息如何保证100%的投递 幂等性概念 Confirm确认消息 Return返回消息 自定义消费者 前言: 想必知道消息中间件RabbitMQ的小伙伴,对于引入中间件的好处可以起到抗高并发,削 ...

  4. RabbitMQ之消息模式1

    消息100%的投递 消息如何保障100%的投递成功? 什么是生产端的可靠性投递? 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点(Broker)确认应答 完善的消息进行补偿机制 BAT ...

  5. 解决spring boot在RabbitMQ堆积消息情况下无法启动问题

    最近遇到一个问题,服务站点上线之前,先去新建需要的rabbitmq并绑定关系,此时 如果发送消息方运行, 那边会造成新建的q消息部分堆积得不到及时消费 那么问题来了? 在消息堆积情况下,服务站点无法启 ...

  6. RabbitMQ入门-消息订阅模式

    消息派发 上篇<RabbitMQ入门-消息派发那些事儿>发布之后,收了不少反馈,其中问的最多的还是有关消息确认以及超时等场景的处理. 楼主,有遇到消费者后台进程不在,但consumer连接 ...

  7. simple模式下rabbitmq的代码

    simple模式代码 package RabbitMQ import ( "fmt" "github.com/streadway/amqp" "log ...

  8. [老老实实学WCF] 第十篇 消息通信模式(下) 双工

    老老实实学WCF 第十篇 消息通信模式(下) 双工 在前一篇的学习中,我们了解了单向和请求/应答这两种消息通信模式.我们知道可以通过配置操作协定的IsOneWay属性来改变模式.在这一篇中我们来研究双 ...

  9. RabbitMQ分布式消息队列服务器（一、Windows下安装和部署）

    RabbitMQ消息队列服务器在Windows下的安装和部署-> 一.Erlang语言环境的搭建 RabbitMQ开源消息队列服务是使用Erlang语言开发的,因此我们要使用他就必须先进行Erl ...

随机推荐

  1. 大数定律（Law of Large Numbers）

    大数定律:每次从总体中随机抽取1个样本,这样抽取很多次后,样本的均值会趋近于总体的期望.也可以理解为:从总体中抽取容量为n的样本,样本容量n越大,样本的均值越趋近于总体的期望.当样本容量极大时,样本均 ...

  2. nginx 访问控制之 http_referer

    在rewrite时,曾经用过该变量,当时实现了防盗链功能. 其实基于该变量,我们也可以做一些特殊的需求. 示例: 背景:网站被黑挂马,搜索引擎收录的网页是有问题的,当通过搜索引擎点击到网站时,却显示一 ...

  3. Mac上安装Python3虚拟环境（VirtualEnv）教程

    如果已经安装好pip3,那么执行命令安装virtualenv环境 pip3 install virtualenv 安装完成检测版本是否安装成功 virtualenv --version 创建新目录 M ...

  4. ZooKeeper入门实战教程（一）-介绍与核心概念

    1.ZooKeeper介绍与核心概念1.1 简介ZooKeeper最为主要的使用场景,是作为分布式系统的分布式协同服务.在学习zookeeper之前,先要对分布式系统的概念有所了解,否则你将完全不知道 ...

  5. MySQL中IS NULL、IS NOT NULL、!=不能用索引？胡扯！

    转:https://mp.weixin.qq.com/s/CEJFsDBizdl0SvugGX7UmQ 不知道从什么时候开始,网上流传着这么一个说法: MySQL的WHERE子句中包含 IS NULL ...

  6. [技术博客]微信小程序开发中遇到的两个问题的解决

    IDE介绍 微信web开发者工具 前端语言 微信小程序使用的语言为wxml和wss,使用JSON以及js逻辑进行页面之间的交互.与网页的html和css略有不同,微信小程序在此基础上添加了自己的改进, ...

  7. 批量kill掉包含某个关键字的进程

    需要把 linux 下符合某一项条件的所有进程 kill 掉,又不能用 killall 直接杀掉某一进程名称包含的所有运行中进程(我们可能只需要杀掉其中的某一类或运行指定参数命令的进程),这个时候我们 ...

  8. zookeeper生产最广泛使用java客户端curator介绍及其它客户端比较

    关于zookeeper的原理解析,可以参见zookeeper核心原理详解,本文所述大多数实践基于对zookeeper原理的首先理解. Curator是Netflix公司开源的一个Zookeeper客户 ...

  9. 【C++】C++中重载运算符和类型转换

    输入输出运算符 输入输出运算符 输入输出运算符 算术和关系运算符 相等运算符 关系运算符 赋值运算符 复合赋值运算符 下标运算符 递增和递减运算符 成员访问运算符 函数调用运算符 lambda是函数对 ...

  10. Python 多进程爬虫实例

    Python  多进程爬虫实例 import json import re import time from multiprocessing import Pool import requests f ...