RabbitMQ之消息模式

目的：　　

消息如何保证100%的投递

幂等性概念

Confirm确认消息

Return返回消息

自定义消费者

前言：

　　想必知道消息中间件RabbitMQ的小伙伴，对于引入中间件的好处可以起到抗高并发，削峰，业务解耦的作用并不陌生。

　　康康简单流程图了解一下。详情了解RabbitMQ可移步：https://www.cnblogs.com/huangting/p/11989597.html

注意：一般MQ中间件为了提高系统的吞吐量会把消息保存在内存中，如果不作其他处理，MQ服务器一旦宕机，消息将全部丢失；

　　这样会造成巨大影响，在业务流程上是不可以的。

以下就是我们去解决所使用的方法

消息如何保证100%的投递

　　什么是生产端的可靠性投递？

保障消息的成功发出
保障MQ节点的成功接收
发送端收到MQ节点（Broker）确认应答
完善的消息进行补偿机制（如网络问题没有返回确认应答）

　　BAT/TMD互联网大厂的解决方案：

消息落库，对消息状态进行打标
消息的延迟投递，做二次确认，回调检查

幂等性概念

　　首先，我们了解一下什么叫幂等：

　　　　　　在分布式应用中，幂等是非常重要的，也就是相同条件下对一个业务的操作，不管操作多少次，结果都是一样。

　　　其次，为什么要有幂等这种场景？

　　　　　　基本上在逻辑涉及范围比较大系统里边，都有部署分布式，就如同下面其中订单和库存可以说是两种独立的个体。

　　　　正因为是分布式，那么很有可能订单服务在调用库存时因为网络差等外因导致调用失败，但是库存服务其实是调用成功的只是在返回结果集时发生了异常，其实按照一般思维就会在调用一次库存不就可以了吗？恰恰是这样问题就出现了，订单没有接收到返回结果，但库存已经减去一个对应物品数量，如果在调用一次又减去一次，那么很明显业务上是错误的。

所以这个时候就要用到幂等性，无论库存服务在相同条件下调用几次，处理结果都一样。这样才能保证业务的紧密。

　业界主流的幂等性操作

乐观锁方案

　　比如我们执行一条更新库存的SQL语句

 Update t_repository set count = count -,version = version +  where version =

　　根据version版本，也就是在操作库存前先获取当前商品的version版本号，然后操作的时候带上此version号。

　我们梳理下，我们第一次操作库存时，得到version为1，调用库存服务version变成了；

　但返回给订单服务出现了问题，订单服务又一次发起调用库存服务，当订单服务传如的version还是1，再执行上面的sql语句时，就不会执行；

　因为version已经变为2了，where条件就不成立。这样就保证了不管调用几次，只会真正的处理一次

唯一ID+指纹码机制，利用数据库主键去重

　　　　原理就是利用数据库主键去重，业务完成后插入主键标识

Select count() from T_order where ID=唯一ID+指纹码

唯一ID就是业务表的唯一的主键，如商品ID
指纹码就是为了区别每次正常操作的码，每次操作时生成指纹码；可以用时间戳+业务编号的方式。

好处：实现简单

坏处：高并发下数据库瓶颈

解决方案：根据ID进行分库分表进行算法路由

利用Redis的原子性去实现

我们是否需要把业务结果进行数据落库，如果落库，关键解决的问题时数据库和redis操作如何做到原子性？

　　　　　　　　意思就是库存减1了，但redis进行操作完成标记时，失败了怎么办？也就是一定要保证落库和redis 要么一起成功，要么一起失败　　

如果不进行落库，那么都存储到缓存中，如何设置定时同步策略？

　　　　　　意思就是库存减1，不落库，直接先操作redis操作完成标记，然后由另外的同步服务进行库存落库，这个就是增加了系统复杂性，而且同步策略如何设置

Confirm确认消息

　　　　Confirm消息确认机制含义：

消息的确认，是指订单服务投递消息后，如果物流服务收到消息，则会给我们订单服务一个应答。

中间件进行接收应答，用来确定这条消息是否正常的发送到物流服务，这种方式也是消息的可靠性投递的核心保障

如何实现Confirm确认消息？

在Channel上开启确认模式：channel.confirmSelect()
在channel上添加监听：addConfirmListener，监听成功和失败的返回结果，根据具体的结果对消息进行重新发送、或记录日志等后续处理！

　　消费端代码

package com.javaxh.rabbitmqapi.confirm;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import com.rabbitmq.client.QueueingConsumer;

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();

        connectionFactory.setVirtualHost("/");

        //2 获取C    onnection

        Connection connection = connectionFactory.newConnection();

        //3 通过Connection创建一个新的Channel

        Channel channel = connection.createChannel();

        String exchangeName = "test_confirm_exchange";

        String routingKey = "confirm.#";

        String queueName = "test_confirm_queue";

        //4 声明交换机和队列 然后进行绑定设置, 最后制定路由Key

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

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

        channel.queueBind(queueName, exchangeName, routingKey);

        //5 创建消费者

        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);

        channel.basicConsume(queueName, true, queueingConsumer);

        while(true){

            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();

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

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

        }

    }

}

服务提供方代码

package com.javaxh.rabbitmqapi.confirm;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.ConfirmListener;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;

public class Producer {

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

        //1 创建ConnectionFactory

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.239.131");

        connectionFactory.setPort();

        connectionFactory.setVirtualHost("/");

        //2 获取C    onnection

        Connection connection = connectionFactory.newConnection();

        //3 通过Connection创建一个新的Channel

        Channel channel = connection.createChannel();

        //4 指定我们的消息投递模式: 消息的确认模式

        channel.confirmSelect();

        String exchangeName = "test_confirm_exchange";

        String routingKey = "confirm.save";

        //5 发送一条消息

        String msg = "Hello RabbitMQ Send confirm message!";

        channel.basicPublish(exchangeName, routingKey, null, msg.getBytes());

        //6 添加一个确认监听

        channel.addConfirmListener(new ConfirmListener() {

            @Override

            public void handleNack(long deliveryTag, boolean multiple) throws IOException {

                System.err.println("-------no ack!-----------");

            }

            @Override

            public void handleAck(long deliveryTag, boolean multiple) throws IOException {

                System.err.println("-------ack!-----------");

            }

        });

    }

}

运行结果：

消费端：

服务提供方：

Return返回消息

　　Return Listener用于处理一些不可路由的消息。

正常情况：我们的消息生产者，通过指定一个Exchange和RoutingKey，把消息送达到某一个队列中去，然后我们的消费者监听队列，进行消费处理操作！

异常情况：在某些情况下，如果我们在发送消息的时候，当前的Exchange不存在或者指定的路由key路由不到，这个时候如果我们需要监听这种不可达的消息，就需要使用Return Listener！

在基础API中有一个关键的配置项

Mandatory：如果为true，则监听器会接收到路由不可达的消息，然后进行后续处理，如果为false，那么Broker端自动删除该消息！

消费端代码

package com.javaxh.rabbitmqapi.returnlistener;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import com.rabbitmq.client.QueueingConsumer;

public class Consumer {

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

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.239.131");

        connectionFactory.setPort();

        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();

        Channel channel = connection.createChannel();

        String exchangeName = "test_return_exchange";

        String routingKey = "return.#";

        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.err.println("消费者: " + msg);

        }

    }

}

生产端代码：

package com.javaxh.rabbitmqapi.returnlistener;

import com.rabbitmq.client.*;

import java.io.IOException;

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_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 properties, byte[] body) throws IOException {

                System.err.println("---------handle  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: " + properties);

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

            }

        });

        //消息投递成功，会被消费者所消费

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

        //消息不可达，将触发ReturnListener

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

    }

}

效果:

自定义消费者

我们一般就是在代码中编写while循环，进行consumer.nextDelivery方法进行获取下一条消息，然后进行消费处理！

但是我们使用自定义的Consumer更加的方便，解耦性更加的强，也是实际工作中最常用的使用方式！

自定义消费端代码

package com.javaxh.rabbitmqapi.consumer;

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.consumer;

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_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));

    }

}

生产端调用：

package com.javaxh.rabbitmqapi.consumer;

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_consumer_exchange";

        String routingKey = "consumer.save";

        String msg = "Hello RabbitMQ Consumer Message";

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

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

        }

    }

}

效果：

谢谢观看！！！