RabbitMQ学习05--消息可靠性

消息可靠性：

1.如果消息已经到达了rabbitmq，但mq宕机了，消息并不会丢失。rabbitmq有持久化机制。

2.消费者在消费消息时，没有执行完就宕机了，消息并不会从mq清除，消费者可以使用手动ack机制。

3.生产者发送消息时由于网络问题，消息没有发送到rabbitmq，可以采用以下两种机制：事务操作，confirm操作。

 

1、RabbitMQ事务(不推荐)：

事务可以保证消息100%传递，可以通过事务的回滚，后面定时再次发送当前消息。

事务机制的缺点：效率低。加了事务要比正常速度低100倍。

 

2、Confirm确认机制：

Confirm机制是确保生产者将消息发送给了RabbitMQ的exchange。

2.1 普通Confirm方式：

package com.yas.confirm;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

public class Publisher {
    @Test
    public void publish() throws Exception {
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();
        //3.发布消息到exchange，同时指定路由规则

        //3.1 开启Confirm
        channel.confirmSelect();

        String msg = "Hello World";
        //参数1：指定exchange，使用空字符串，表示默认exchange。
        //参数2：指定路由规则，使用具体的队列名称。
        //参数3：指定传递的消息所携带的properties。
        //参数4：指定发布的具体消息，字节数组类型byte[]
        channel.basicPublish("", "HelloWorld", null, msg.getBytes());
        //注意：exchange是不会将消息持久化到本地的，Queue有持久化的功能。

        //判断消息发送是否成功
        if (channel.waitForConfirms()) {
            System.out.println("消息发送成功");
        }else{
            System.out.println("消息发送失败");
        }

        System.out.println("生产者发布消息成功");
        //4.释放资源
        channel.close();
        connection.close();
    }
}

 

2.2 批量Confirm方式：

package com.yas.confirm;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

public class Publisher2 {
    @Test
    public void publish() throws Exception {
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();
        //3.发布消息到exchange，同时指定路由规则

        //3.1 开启Confirm
        channel.confirmSelect();

        String msg = "Hello World";
        //参数1：指定exchange，使用空字符串，表示默认exchange。
        //参数2：指定路由规则，使用具体的队列名称。
        //参数3：指定传递的消息所携带的properties。
        //参数4：指定发布的具体消息，字节数组类型byte[]
        for (int i = 0; i < 1000; i++) {
            msg = msg + i;
            channel.basicPublish("", "HelloWorld", null, msg.getBytes());
        }
        //注意：exchange是不会将消息持久化到本地的，Queue有持久化的功能。

        //判断消息发送是否成功
        //当发送的消息有一个失败时，就会全部失败
        channel.waitForConfirmsOrDie();

        System.out.println("生产者发布消息成功");
        //4.释放资源
        channel.close();
        connection.close();
    }
}

 

2.3 异步Confirm方式(推荐)：

package com.yas.confirm;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmListener;
import com.rabbitmq.client.Connection;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Publisher3 {
    @Test
    public void publish() throws Exception {
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();
        //3.发布消息到exchange，同时指定路由规则

        //3.1 开启Confirm
        channel.confirmSelect();


        //参数1：指定exchange，使用空字符串，表示默认exchange。
        //参数2：指定路由规则，使用具体的队列名称。
        //参数3：指定传递的消息所携带的properties。
        //参数4：指定发布的具体消息，字节数组类型byte[]
        for (int i = 0; i < 1000; i++) {
            String msg = "Hello World";
            msg = msg + i;
            channel.basicPublish("", "HelloWorld", null, msg.getBytes());
        }
        //注意：exchange是不会将消息持久化到本地的，Queue有持久化的功能。

        //判断消息发送是否成功
        //异步发送
        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("消息发送成功，标识：" + deliveryTag + ",是否是批量：" + multiple);
            }

            @Override
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("消息发送失败，标识：" + deliveryTag + ",是否是批量：" + multiple);
            }
        });

        System.out.println("生产者发布消息成功");

        System.in.read();
        //4.释放资源
        channel.close();
        connection.close();
    }
}

 

3、Return机制：

Return机制是确保在RabbitMQ内部，exchange将消息发送给queue。

而且exchange是不能持久化消息的，queue才可以持久化，因此消息发送到queue才能保证不丢失。

采用Return机制，监听消息是否从exchange发送到了queue。

生产者代码：

package com.yas.myreturn;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Publisher {
    @Test
    public void publish() throws Exception {
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();

        //3.1 开启Confirm
        channel.confirmSelect();

        //判断消息发送是否成功
        //异步发送
        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("消息发送成功，标识：" + deliveryTag + ",是否是批量：" + multiple);
            }

            @Override
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("消息发送失败，标识：" + deliveryTag + ",是否是批量：" + multiple);
            }
        });

        //3.发布消息到exchange，同时指定路由规则

        //开启Return机制
        channel.addReturnListener(new ReturnListener() {
            //当消息没有送到queue时，才会执行
            @Override
            public void handleReturn(int replyCode, String replyText, String exchange, String routingKey, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(new String(body, "UTF-8") + "没有送到Queue中");
            }
        });

        //参数1：指定exchange，使用空字符串，表示默认exchange。
        //参数2：指定路由规则，使用具体的队列名称。
        //参数3：指定传递的消息所携带的properties。
        //参数4：指定发布的具体消息，字节数组类型byte[]
//        channel.basicPublish("", "HelloWorld", null, msg.getBytes());

        //使用带return机制的发布,mandatory:true
        for (int i = 0; i < 1000; i++) {
            String msg = "Hello World";
            msg = msg + i;
            channel.basicPublish("", "HelloWorld",true, null, msg.getBytes());
        }

        //注意：exchange是不会将消息持久化到本地的，Queue有持久化的功能。

        System.out.println("生产者发布消息成功");
        System.in.read();
        //4.释放资源
        channel.close();
        connection.close();
    }
}

 

消费者代码：

package com.yas.myreturn;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Consumer {
    @Test
    public void consume() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("HelloWorld",true,false,false,null);
        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                System.out.println("接受到消息：" + new String(body,"UTF-8"));
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
        channel.basicConsume("HelloWorld",true,consumer);
        System.out.println("消费者开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}