生产端可靠性投递
保证生产端可靠性投递需要以下几步：
1、保障消息端成功发出。
2、保障MQ节点的成功接收。
3、发送端收到MQ节点（Broker）确认应答。
4、完善端消息进行补偿机制。
方案一：
1、对业务数据和消息数据进行落库。
2、发送消息并监听回调，如果收到ACK，更数据库消息状态。
3、分布式定时任务查找消息状态不是成功的消息进行再次投递。
总结：这种方式需要多次访问数据库，在高并发的场景可能不是很合适。
方案二：
1、对业务数据进行存储，然后发送MQ消息。并再发送一个延迟消息
2、消费者收到消息后，发送一个新的消息。
3、需要一个Callback 服务处理消费者发送的消息，将消息入库。同时接收生产者发送的延迟消息。当延迟的消息在库中存在则代表消息成功消费，否则，Callback会向生产者发送RPC通信，生产者重新找到业务数据，重新发送。
Confirm 确认消息
Confirm消息确认机制：
- 消息的确认，是指生产者投递消息后，如果Broker收到消息，则会给我们生产者一个应答。
- 生产者进行接收应答，用来确定这条消息是否正常的发送到Broker，这种方式也是消息到可靠性投递到核心保障
生产者发送消息后，可以创建一个监听等待Broker的回调。
如何实现Confirm确认消息
第一步：在channel上开启确认模式：channel.confirmSelect()
第二步：在channel上添加监听：addConfirmListener，监听成功和失败的返回结果，根据具体的结果对消息进行重新发送、记录日志等后续处理！
代码实现：
生产者：
public class Producer {
public static void main(String[] args) throws IOException, TimeoutException {
//创建一个connectionFactory，并进行配置
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
//通过连接工厂 创建连接
Connection connection = connectionFactory.newConnection();
//通过 connection 创建一个 channel
Channel channel = connection.createChannel();
//指定我们的消息投递模式：消息的确认模式
channel.confirmSelect();
String exchangeName = "test_confirm_exchange";
String routingKey = "confirm.save";
//发送一条消息
String msg = "Hello RabbitMQ Send confirm message!";
channel.basicPublish(exchangeName, routingKey, null, msg.getBytes());
//添加一个确认监听
channel.addConfirmListener(new ConfirmListener() {
@Override
public void handleAck(long deliveryTag, boolean multiple) throws IOException {
System.err.println("---------ack!-----------");
}
@Override
public void handleNack(long deliveryTag, boolean multiple) throws IOException {
System.err.println("---------no ack!-----------");
}
});
}
}
消费者：
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
//创建一个connectionFactory，并进行配置
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
//通过连接工厂 创建连接
Connection connection = connectionFactory.newConnection();
//通过 connection 创建一个 channel
Channel channel = connection.createChannel();
String exchangeName = "test_confirm_exchange";
String routingKey = "confirm.#";
String queueName = "test_confirm_queue";
//声明交换机和队列 然后进行绑定设置 最后制定路由key
channel.exchangeDeclare(exchangeName, "topic", true);
channel.queueDeclare(queueName, true, false, false, null);
channel.queueBind(queueName, exchangeName, routingKey);
//创建消费者
QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
channel.basicConsume(queueName, true, queueingConsumer);
while (true) {
QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
String msg = new String(delivery.getBody());
System.out.println(msg);
}
}
}
Return 消息机制
Return Listener 用于处理一些不可路由的消息
我们的消息生产者，通过指定一个Exchange和Routingkey，把消息送达到某一个队列中去。然后我们的消费监听队列，进行消费处理操作。
但是在某些情况下，如果我们在发消息的时候，当前的exchange不存在或者指定的路由key路由不到，这个时候如果我们需要监听这种不可达的消息，就要使用Return Listener。
在基础API中有一个关键的配置项：Mandatory，如果为true，则监听器会接收到路由不可达的消息，然后进行后续处理，如果为false，那么broker端自动删除该消息。
代码实现：
生产者：
public class Producer {
public static void main(String[] args) throws IOException, TimeoutException {
//创建一个connectionFactory，并进行配置
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
//通过连接工厂 创建连接
Connection connection = connectionFactory.newConnection();
//通过 connection 创建一个 channel
Channel channel = connection.createChannel();
String exchangeName = "test_return_exchange";
String routingKey = "return.save";
String routingKeyError = "abc.save";
String msg = "Hello RabbitMQ Return Message";
channel.addReturnListener(new ReturnListener() {
@Override
public void handleReturn(int replyCode, String replyText, String exchange, String routingKey,
AMQP.BasicProperties basicProperties, byte[] body) throws IOException {
System.err.println("------heandle return--------");
System.err.println("replyCode: " + replyCode);
System.err.println("replyText: " + replyText);
System.err.println("exchange: " + exchange);
System.err.println("routingKey: " + routingKey);
System.err.println("properties: " + basicProperties);
System.err.println("body: " + new String(body));
}
});
//channel.basicPublish(exchangeName, routingKey, true, null, msg.getBytes());
channel.basicPublish(exchangeName, routingKeyError, true, null, msg.getBytes());
}
}
消费者：
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
//创建一个connectionFactory，并进行配置
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
//通过连接工厂 创建连接
Connection connection = connectionFactory.newConnection();
//通过 connection 创建一个 channel
Channel channel = connection.createChannel();
String exchangeName = "test_return_exchange";
String routingKey = "return.#";
String routingKeyError = "abc.save";
String queueName = "test_return_queue";
channel.exchangeDeclare(exchangeName, "topic", true, false, null);
channel.queueDeclare(queueName, true, false, false, null);
channel.queueBind(queueName, exchangeName, routingKey);
QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
channel.basicConsume(queueName, true, queueingConsumer);
while (true) {
QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
String msg = new String(delivery.getBody());
System.out.println(msg);
}
}
}
当发送的消息没有接收的队列时：
消费端自定义监听
上面我们接收消息都是使用while循环，进行consumer.nextDelivery方法进行获取下一条消息，然后进行消费处理。
但是我们使用自定义的Consumer更加的方便，解耦性更加的强，也是在实际工作中最常用的使用方式。
创建自定义消费者：
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("consuerTag:" + consumerTag);
System.err.println("envelope:" + envelope);
System.err.println("properties:" + properties);
System.err.println("body:" + new String(body));
}
}
消费端使用自定义消费者进行消费：
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
//创建一个connectionFactory，并进行配置
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
//通过连接工厂 创建连接
Connection connection = connectionFactory.newConnection();
//通过 connection 创建一个 channel
Channel channel = connection.createChannel();
String exchangeName = "test_consumer_exchange";
String routingKey = "consumer.#";
String queueName = "test_consumer_queue";
channel.exchangeDeclare(exchangeName, "topic", true, false, null);
channel.queueDeclare(queueName, true, false, false, null);
channel.queueBind(queueName, exchangeName, routingKey);
channel.basicConsume(queueName, true, new MyConsumer(channel));
}
}
消费者限流
RabbitMQ 提供了一种qos（服务质量保证）功能，即在非自动确认消息的前提下，如果一定数目的消息（通过基于consume或者channel设置Qos的值）未被确认前，不进行消息新的消息。
限流主要使用 void BasicQos(uint prefetchSize, ushort prefetchCount, bool global)
参数：
- prefetchSize: 0 消息大小限制。
- prefetchCount： 会告诉RabbitMQ不要同时给一个消费者推送多个N个消息，即一旦有N个消息没有ack，则该consumer将block掉，直到有消息ack。
- global： true\false 是否将上面设置应用于channel。简单点说，就是上面限制是channel级别的还是consumer级别。
代码实现：
消费者配置：设置限流和签收方式设置成手动提交
//设置每次只处理一条消息
channel.basicQos(0, 1, false);
//限流方式 autoAck设置为false
channel.basicConsume(queueName, false, new MyConsumer(channel));
自定义消费者：
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("consuerTag:" + consumerTag);
System.err.println("envelope:" + envelope);
System.err.println("properties:" + properties);
System.err.println("body:" + new String(body));
//ack 第二个参数 是否批量提交
channel.basicAck(envelope.getDeliveryTag(), false);
}
}
消费端ACK
消费端可以进行手工端ACK和NACK
消费端进行消费的时候，如果由于业务异常我们可以进行日志的记录，然后进行补偿。也可以通过手工NACK，让消息重新投递和消费，可以记录最大重试次数。
消费端端重回队列
消费端重回队列是为了对没有处理成功对消息，把消息重新会投递给Broker。
一般我们在实际应用中，都会关闭重回队列，也就是设置为False。
//第三个参数 true代表重回队列 false 代表不重回队列
if((Integer)properties.getHeaders().get("num") == 0) {
//第三个参数 true代表重回队列
channel.basicNack(envelope.getDeliveryTag(), false, true);
} else {
//ack 第二个参数 是否批量提交
channel.basicAck(envelope.getDeliveryTag(), false);
}
TTL队列/消息
TTL
- TTL是Time To Live的缩写，也就是生存时间。
- RabbitMQ支持消息的过期时间，在消息发送时可以进行指定。
- RabbitMQ支持队列的过期时间，从消息入队列开始计算，只要超过了队列的超时时间配置，那么消息会自动的清除。
TTL分成两种：
- 队列级别：加入队列中的所有消息都有TTL时间，在控制台上可以加。
- 消息级别：在发消息时指定
new AMQP.BasicProperties.Builder().expiration("10000").build();
死信队列
DLX Dead-Letter-Exchange
利用DLX，当消息在一个队列中变成死信(dead message)之后，它能被重新publish到另一个Exchange，这个Exchange就是DLX。
消息变成死信有以下几种情况
- 消息被拒绝且requeue=false
- 消息TTL过期
- 队列达到最大长度
DLX也是一个正常的Exchange，和一般的Exchange没有区别，它能在任何的队列上被指定，实际上就是设置某个队列的属性。
当这个队列中有死信时，RabbitMQ就会自动的将这个消息重新发布到设置的Exchange上去，进而被路由到另一个队列。
可以监听这个队列中消息做相应的处理。
设置死信队列
首先需要设置死信队列的exchange和queue，然后进行绑定：
- Exchange： dlx.exchange
- Queue： dlx.queue
- RoutingKey： #
然后我们进行正常声明交换机、队列、绑定，只不过我们需要在队列加上一个参数即可：arguments.put("x-dead-letter-exchange","dlx.exchange")
这样消息在过期、requeue、队列在达到最大长度时，消息就可以直接路由到死信队列。
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
