RabbitMQ学习笔记（四、RabbitMQ队列）

目录：

• 消息路由失败了会怎样
• 备份交换器
• TTL与DLX
• 如何实现延迟队列
• RabbitMQ的RPC实现
• 持久化
• 事务
• 发送方确认机制

消息路由失败了会怎样：

在RabbitMQ中，如果消息路由失败了，一般会有两种情况。要么是把消息回退给客户端处理，要么就把消息丢弃。

处理逻辑是根据basicPublish方法的mandatory和immediate两个参数来控制。

1、mandatory：当mandatory=true时，如果交换器无法根据自身类型和路由键匹配到符合条件的队列，便会调用Basic.Return命令将消息会推给生产者；当mandatory=false时，不满足条件则丢弃此条消息。

channel.addReturnListener(new ReturnListener() {
    public void handleReturn(int replyCode, String replyText, String exchange, String routingKey,
                             AMQP.BasicProperties properties, byte[] body) throws IOException {
        // 具体处理逻辑
    }
});

2、immediate：当immediate=true时，交换器将消息路由到队列后，发现此队列上不存在任何消费者，那么这条消息将不会放入到队列中。当路由键匹配的所有队列都没有消费者时，改消息将会通过Basic.Return返回给生产者。

备份交换器：

备份交换器可以将未被路由到的消息存储在RabbitMQ中，在需要它的时候再去使用。

public class AlternateProduct {

    private static final String EXCHANGE_NAME = "alternate.exchange";
    private static final String EXCHANGE_BAK_NAME = "alternate-bak.exchange";
    
    private static final String QUEUE_NAME = "alternate.queue";
    private static final String QUEUE_BAK_NAME = "alternate-bak.queue";

    private static final String ROUTING_KEY_NAME = "alternate.routing.key";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT, false, false, false, getExchangeDeclareArgs());
        // fanout类型，放款路由限制
        channel.exchangeDeclare(EXCHANGE_BAK_NAME, BuiltinExchangeType.FANOUT, false, false, false, null);

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.queueDeclare(QUEUE_BAK_NAME, false, false, false, null);

        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ROUTING_KEY_NAME);
        // 因为交换器QUEUE_BAK_NAME设置fanout类型，所以可以不必关心路由键，故随便写可能将消息路由到对应的队列中
        channel.queueBind(QUEUE_BAK_NAME, EXCHANGE_BAK_NAME, "123");

        // 发消息时路由键设置一个不存在的""，让其路由不到，从而把消息发到备份队列中
        channel.basicPublish(EXCHANGE_NAME, "", MessageProperties.PERSISTENT_TEXT_PLAIN,
                "alternate".getBytes());

        RabbitMqUtils.close(connection, channel);
    }

    private static Map<String, Object> getExchangeDeclareArgs() {
        Map<String, Object> result = new HashMap<String, Object>(1);
        result.put("alternate-exchange", EXCHANGE_BAK_NAME);
        return result;
    }
}

关于备份交换器的注意点：

1、如果备份交换器不存在，客户端和RabbitMQ客户端都不会出现异常，但是消息会丢失。

2、如果备份交换器没有绑定任何队列，客户端和RabbitMQ客户端都不会出现异常，但是消息会丢失。

3、如果备份交换器没有匹配到任何队列，客户端和RabbitMQ客户端都不会出现异常，但是消息会丢失。

4、如果备份交换器和mandatory一起使用，且备份交换器有效，此时mandatory将无效。

TTL与DLX：

1、TTL：过期时间，有队列过期时间和消息过期时间。

）队列过期时间：

通过设置队列的过期时间，来使队列中所以的消息都具有过期时间。

）消息过期时间：

设置消息的BasicProperties props属性值来控制消息的过期时间。

AMQP.BasicProperties.Builder publishBuilder = new AMQP.BasicProperties.Builder();
// expiration单位ms
publishBuilder.expiration("10000");

channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY_NAME, publishBuilder.build(),
        "ttl".getBytes());

对于第一种TTL来说，队列一但过期就会删除调；但对于第二种TTL来说，队列过期不会马上删除，而是等队列要被消费时再判断是否要删除。

那为什么会不一样呢，我们都知道mq对性能的要求是非常高的，如果第二种ddl的方式也要及时删除的话势必要扫描整个队列，这样的话，若队列长度较大是性能便会非常的差。

而第一种为什么可以做到及时删除呢，我们知道队列具有先进先出的特性，所以先入队的肯定要比后入队的要先过期，所以只要删除头部的就好啦。

而第二种的消息过期时间都是不固定的，考虑到MQ的性能，所以采用了上述的方式。

2、DLX：死信交换器，全称Dead Letter Exchange

变为死信队列的有以下几种情况：

• 消息被拒，且requeue=false
• 队列过期或队列达到最大长度

注意：DLX也是一个正常的交换器，和一般队列没有区别，它能在任何的队列上被指定。

如何实现延迟队列：

本模块讲述RabbitMQ，仅提供RabbitMQ的实现，大佬们有兴趣可以实现其它几种方式。

延迟队列是指将消息发送到队列后，等待一段时间后再进行消费。场景：饿了么外卖下单后，超过15分钟订单失效。

延迟队列场景的时间方式有四种：

1、DB轮询：通过job或其它逻辑将订单表的必要字段查出（如：orderId、createTime、status），当订单超过xx时间，将状态置为失效。

）优点：实现简单、无技术难点、异常恢复、支持分布式/集群环境

）缺点：影响DB性能、时效性查、效率低

2、JDK DelayQueue：java api提供的延迟队列的实现，通过poll()、take()方法获取超时任务

）优点：实现简单、性能较好

）缺点：异常恢复困难、分布式/集群实现困难（基于JVM内存）

3、Redis sortedSet：通过zset类型的score来实现

）优点：解耦、异常恢复、扩展性强、支持分布式/集群环境

）缺点：增加了redis维护成本、占用带宽

4、RabbitMQ TTL + DLX：使用RabbitMQ的过期时间和死信队列实现

 实现：delay-message

）优点：解耦、异常恢复、扩展性强、支持分布式/集群环境

）缺点：增加了RabbitMQ维护成本、占用带宽

RabbitMQ的RPC实现：

RabbitMQ也可以实现RPC，客户端发送消息，服务端接收消息。

replayTo：设置回调队列，用于客户端响应服务端的回调消息。

correlationId：RPC请求和响应的关联id。

public class RpcServer {

    private static final String QUEUE_NAME = "rpc.queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = RabbitMqUtils.getRpcConnection();
        final Channel channel = connection.createChannel();
        // 创建请求处理队列，用于服务端接收客户端RPC请求
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);

        System.out.println("等待RPC请求...");

        // 服务端监听客户端发送的RPC请求
        channel.basicConsume(QUEUE_NAME, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String correlationId = properties.getCorrelationId();
                String message = "";

                try {
                    message = new String(body);
                    System.err.println(format("service recv message:{0}, corrId:{1}", message, correlationId));
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
                            .correlationId(correlationId)
                            .build();

                    // 使用默认exchange，允许通过routingKey指定message将被发送给哪个queue
                    channel.basicPublish("", properties.getReplyTo(), props, (message + "--is done.").getBytes("UTF-8"));
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        });
    }
}

public class RpcClient {

    private static final String QUEUE_NAME = "rpc.queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        final Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();

        // 随机创建corrId
        final String collId = UUID.randomUUID().toString();
        // 客户端创建匿名队列，用于响应服务端请求
        String callbackQueueName = channel.queueDeclare().getQueue();

        // 客户端发送消息；使用默认exchange（exchange=""），允许通过routingKey指定message将被发送给哪个queue
        channel.basicPublish("", QUEUE_NAME, getBasicPublishProperties(collId, callbackQueueName),
                "hello world".getBytes());
        // 客户端接收服务端响应的消息
        channel.basicConsume(callbackQueueName, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                if (collId.equals(properties.getCorrelationId())) {
                    System.out.println(format("client recv message:{0}, corrId:{1}", new String(body), collId));
                } else {
                    System.out.println("不是本次请求的消息");
                }
            }
        });

        TimeUnit.SECONDS.sleep(1);

        RabbitMqUtils.close(connection, channel);
    }

    private static AMQP.BasicProperties getBasicPublishProperties(String corrId, String callbackQueueName) {
        return new AMQP.BasicProperties().builder()
                .correlationId(corrId)
                .replyTo(callbackQueueName).build();
    }
}

持久化：

在RabbitMQ中交换器、队列、消息都设置为持久化就能保持消息不丢失了嘛？

当然不，情况如下：

1、当autoAck设置为true的时候，消费者接收到消息后还没来得及处理就宕机了。

解决：autoAck设为false，消费者处理完消息后再通知服务端删除消息。

2、再RabbitMQ持久化到磁盘中的这段时间，RabbitMQ服务器宕机了。

解决：服务端确认机制、镜像队列（后面章节会描述）。

事务：

1、开启事务：channel.txSelect()

2、提交事务：channel.txCommit()

3、回滚事务：channel.txRollback()

事务和db的事务很相似，不细说。

发送方确认机制：

AMQP协议提供了事务机制来保证消息能真正成功的到达RabbitMQ，但事务机制会严重的影响到RabbitMQ的吞吐量，所以RabbitMQ引入了一种轻量的方式，发送方确认机制。

客户端使用方式：

1、将信道设置发送方确认方式：channel.confirmSelect()。

2、确认消息是否发送成功：

）boolean waitForConfirms() throws InterruptedException;

）boolean waitForConfirms(long timeout) throws InterruptedException, TimeoutException;

）void waitForConfirmsOrDie() throws IOException, InterruptedException;

）void waitForConfirmsOrDie(long timeout) throws IOException, InterruptedException, TimeoutException;

发送方确认消息成功的三种方式：

public class PublisherConfirmProduct {

    private static final String EXCHANGE_NAME = "demo.exchange";
    private static final String ROUTING_KEY = "demo.routingkey";
    private static final String QUEUE_NAME = "demo.queue";
    private static final String MESSAGE = "Hello World！";

    /**
     * 单条确认
     */
    public static void commonConfirm() throws Exception {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = initChannel(connection);

        channel.confirmSelect();
        for (int i = 0; i < 100; i++) {
            channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, MessageProperties.PERSISTENT_TEXT_PLAIN, MESSAGE.getBytes());
            if (channel.waitForConfirms()) {
                // 逐条确认是否发送成功
                System.out.println("send success!");
            }
        }

        RabbitMqUtils.close(connection, channel);
    }

    /**
     * 批量确认
     */
    public static void batchConfirm() throws Exception {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = initChannel(connection);

        channel.confirmSelect();
        for (int i = 0; i < 100; i++) {
            channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, MessageProperties.PERSISTENT_TEXT_PLAIN, MESSAGE.getBytes());
        }

        // 批量确认是否发送成功，如果某一次确认失败这一批都要重新发送
        if (channel.waitForConfirms()) {
            System.out.println("send success!");
        }

        RabbitMqUtils.close(connection, channel);
    }

    /**
     * 异步确认
     */
    public static void asyncConfirm() throws Exception {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = initChannel(connection);
        channel.basicQos(1);

        channel.confirmSelect();

        // 定义一个未确认消息集合
        final SortedSet<Long> unConfirmSet = Collections.synchronizedNavigableSet(new TreeSet<>());
        for (int i = 0; i < 100; i++) {
            channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, MessageProperties.PERSISTENT_TEXT_PLAIN, MESSAGE.getBytes());
            unConfirmSet.add(channel.getNextPublishSeqNo());
        }

        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                System.err.println(format("拒绝消息 deliveryTag:{0}, multiple:{1}", deliveryTag, multiple));
            }

            @Override
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                System.err.println(format("确认消息 deliveryTag:{0}, multiple:{1}", deliveryTag, multiple));
                if (multiple) {
                    // multiple为true，则deliveryTag之前的所有消息全部被确认
                    unConfirmSet.headSet(deliveryTag + 1).clear();
                } else {
                    // 否则只确认一条消息
                    unConfirmSet.remove(deliveryTag);
                }
            }
        });

        TimeUnit.SECONDS.sleep(5);
        System.out.println(unConfirmSet.size());

        RabbitMqUtils.close(connection, channel);
    }

    private static Channel initChannel(Connection connection) throws IOException {
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT, true, false, null);
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ROUTING_KEY);
        return channel;
    }

    public static void main(String[] args) throws Exception {
//        commonConfirm();
//        batchConfirm();
        asyncConfirm();
    }
}