RabbitMq教程

RabbitMq教程

什么是RabbitMq

RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。RabbitMQ官方地址：http://www.rabbitmq.com

准备工作

创建一个Maven项目导入依赖

<dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.14.2</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.11.0</version>
        </dependency>

连接rabbitmq

/**
 * 创建工厂
 * */

public static Channel getChannel() throws Exception {
    //创建一个工厂
    ConnectionFactory factory = new ConnectionFactory();
    //工厂ip 连接RabbitMq队列 
    //如果是本地的话127.0.0.1或者localhost 没有更改rabbitmq端口的话不用设置Port
    factory.setHost("xx.xx.xx.xx");
    //使用rabbitmq连接后台管理的插件时虚拟机开放的是15672端口 而在java远程连接的时候用到的是5672端口
    factory.setPort(5672);
    //用户名
    factory.setUsername("xxx");
    //密码
    factory.setPassword("xxx");

    //创建连接
    Connection connection = factory.newConnection();
    //获取信道
    return connection.createChannel();
}

发送消息

try {
    Channel channel = RabbitMqConnectionFactory.getChannel();
    /**
     * 生成一个队列
     * 参数说明:
     * 1.队列名称
     * 2.该队列是否持久化(该队列用完是否删除)
     * 3.该队列是否只供一个消费者消费,是否进行消息共享,true表示可以只有一个消费者消费，false表示多个
     * 4.是否自动删除 最后一个消费者断开连接之后,该队是否自动删除
     * 5.其他参数
     * */
    channel.queueDeclare(RabbitMqConnectionFactory.QUEUE_NAME,false,false,false,null);
    String message = "hello rabbitMq2";
    /**
     * 发送一个消息
     * 参数说明：
     * 1.发送到哪个交换机
     * 2.路由的key值是哪个  (队列的名称)
     * 3.其他参数信息
     * 4.发送消息的消息体
     * */
    channel.basicPublish("","hello",null,message.getBytes());
    System.out.println("发送成功");
} catch (Exception e) {
    e.printStackTrace();
}

接收消息

try {
    Channel channel = RabbitMqConnectionFactory.getChannel();
    //声明 接受消息
    DeliverCallback deliverCallback = (consumerTag,message) ->{
        System.out.println(new String(message.getBody()));
    };

    //取消消息时回调
    CancelCallback cancelCallback = consumerTag ->{
        System.out.println("消息消费被中断");
    };

    /**
     * 消费者消费消息
     * 参数说明:
     * 1.消费哪个队列
     * 2.消费成功之后是否需要自动应答 ture表示自动应答 false 表示手动应答
     * 3.消费者未成功消费回调
     * 4.消费者取录消费回调
     * */
    channel.basicConsume("hello",true,deliverCallback,cancelCallback);
} catch (Exception e) {
    e.printStackTrace();
}

多个接受者消费消息

如果有多个消费者接受消息 rabbitMq会使用轮询的方式分发给不同的消费者消息

**例如：**如果有 a，b，c，d ，有a1，a2两个消费者

​ 那么a1如果先获取到a消息 a2就获取到b消息，然后a1获取 到c消息，最后a2获取到d消息

如果手动接受消息 a1接收到消息还未应答就断开了 消息会回到队列中 a2收到消息

用多线程模拟多个消费者获取消息和手动应答消息

创建线程类MyThread

public class MyThread extends Thread{

    private String name;
    private Channel channel;
    private Long millis;

    //name 用于辨别知道那个消费者线程接收 millis用于设置线程睡眠时间
    public MyThread(String name,Long millis) {
        this.name = name;
        try {
            this.channel = RabbitMqConnectionFactory.getChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        this.millis = millis;
    }

    @Override
    public void run() {
        System.out.println(name + "线程已启动");
        /**
         * 消费者消费消息
         * 参数说明:
         * 1.消费哪个队列
         * 2.消费成功之后是否需要自动应答 ture表示自动应答 false 表示手动应答
         * 3.消费者未成功消费回调
         * 4.消费者取录消费回调
         * */
        try {
            this.channel.basicConsume(ThredCousumer.Queue_NAME,false, (consumerTag,message) ->{
                try {
                    //睡眠
                    Thread.sleep(this.millis);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(this.name + "收到消息:" + new String(message.getBody()));
                /**
                 * 收到消息处理后应答消息
                 *
                 * 1.消息标记tag
                 * 2.是否批量应答未应答消息
                 * */
                this.channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
                System.out.println(this.name + "应答消息成功->处理消息:" + new String(message.getBody()));
            }, CancelCallback ->{
                System.out.println("消费消息被中断回调");
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

发送者发送消息

/**
 *
 * 发送消息
 * */
public class pulishTest {

    private static final String Queue_NAME = "test";
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqConnectionFactory.getChannel();
        //创建队列
        channel.queueDeclare(Queue_NAME,false,false,false,null);

        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()){
            channel.basicPublish("",Queue_NAME,null,scanner.next().getBytes(StandardCharsets.UTF_8));
            System.out.println("发送消息成功:"+ scanner.next());
        }

    }
}

接收者手动接受消息

/**
 * 手动接受消息
 * */
public class ThredCousumer {

    public static final String Queue_NAME = "test";

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

        MyThread myThread1 = new MyThread("一号",1000L);
        MyThread myThread2 = new MyThread("二号",5000L);
        MyThread myThread3 = new MyThread("三号",10000L);
        myThread1.start();
        myThread2.start();
        myThread3.start();
    }
}

rabbitMq持久化

概念

如何保证处理任务不丢失的情况，但是如何保障当rabbitMq服务停掉以后消息生产者发送过来的消息不丢失。默认情况下RabbitMq退出或由于某种原因崩溃时，它忽略队列和消息，除非告知它不要这样做。确保消息不会丢失需要做两件事情：我们需要将队列和消息都标记为持久化

队列如何实现持久化

之前我们创建的队列都是非持久化的，rabbitmq如果重启的话，改队列就会被删除掉，如果要将队列实现持久化 需要在声明队列的时候把**durable**参数设置为持久化

//durable设置为ture 持久化操作
boolean durable = true;
channel.queueDeclare(Queue_NAME,durable,false,false,null);

如果原先存在队列，设置持久化状态需要先删除原先的队列，不然会报错

未设置持久化前

设置持久化后

这个时候重启rabbitmq队列也依然存在

消息实现持久化

要想让消息实现持久化（保存在磁盘上，原先不持久化是保存在内存中）需要在消息生产者修改代码，添加MessageProperties.PERSISTENT_TEXT_PLAIN这个属性

不公平分发

最开始的时候RabbitMq分发消息采用的是轮询分发，但是在某种场景下这种策略不是很好，比如有两个消费者在处理消息，其中消费者一处理任务速度比较快，消费者二处理任务速度却很慢，这个时候采用轮询分发的话到这处理速度快的这个消费者很大一部分时间处于空闲状态，而处理慢的消费者一直在干活，这种分配方式在这种情况就不大好，但是rabbitMq并不知道这种情况，它依然很公平的进行分发

为了避免这种情况，我们可以设置channel.basicQos();参数

相当于谁消费快，预取区没有满，就多放点，相当于原来是轮询的现在还是轮询只不过满的跳过的实现方式

//同一时刻服务器只会发送一条消息给消费者
int prefetchCount = 1; //消息可以存储的未应答消息数
this.channel.basicQos(prefetchCount);

发布确认

概念

当发布者发布消息的时候，为了保证消息不丢失且如果rabbitMq将消息保存在磁盘的过程中如果出现宕机这种情况的情况下，消息不会丢失，首先我们需要满足3个条件

1. 队列必须设置持久化

2. 消息必须持久化

3. rabbitMq完消息后确认（发布确认）

   意思是消息已经保存在磁盘后，rabbitMq告诉发布者消息已经保存在磁盘，发布者进行确认

开启发布确认

confirmSelect()

三种发布确认

单个发布确认

​ 这是一种简单的确认方式，它是一种同步确认发布的方式，也就是发布一个消息之后只有它被确认发布，后续的消息才能继续发布, waitForConfirmsOrDie(long)这个方法只有在消息被确认的时候才返回，如果在指定时间范围内这个消息没有被确认那么它将抛出异常。这种确认方式有一个最大的缺点就是:发布速度特别的慢，因为如果没有确认发布的消息就会阻塞所有后续消息的发布，这种方式最多提供每秒不超过数百条发布消息的吞吐量。当然对于某些应用程序来说这可能已经足够了。

批量发布确认

​ 单个发布那种方式非常慢，与单个等待确认消息相比，先发布一批消息然后一起确认可以极大地提高吞吐量，当然这种方式的缺点就是:当发生故障导致发布出现问题时，不知道是哪个消息出现问题了，我们必须将整个批处理保存在内存中，以记录重要的信息而后重新发布消息。当然这种方案仍然是同步的，也一样阻塞消息的发布。

异步发布确认

​ 异步确认虽然编程逻辑比上两个要复杂，但是性价比最高，无论是可靠性还是效率都比较好，他是利用回调函数来达到消息可靠性传递的，这个中间件也是通过函数回调来保证是否投递成功

三种发布确认代码

//定义一个次数常量
private static final int COUNT = 100;

public static void main(String[] args) throws Exception {
    Channel channel = RabbitMqConnectionFactory.getChannel();
    channel.confirmSelect();

    //创建队列
    //durable设置为ture 持久化操作
    boolean durable = true;
    channel.queueDeclare("serial",durable,false,false,null);

    long start = System.currentTimeMillis();

    //选择哪一种确认方法代码
    //Serial(channel);//单个确认
    //Batch(channel);//批量确认
    //Asynchronous(channel);//异步确认
    
    long end = System.currentTimeMillis();
    System.out.println("time:"+ (end - start));

}

//单个确认
public static void Serial(Channel channel) throws Exception {
    for (int i = 0; i < COUNT; i++) {
        String test = i + "test";
        channel.basicPublish("","serial", MessageProperties.PERSISTENT_TEXT_PLAIN,test.getBytes(StandardCharsets.UTF_8));
        boolean waitForConfirms = channel.waitForConfirms();
        if (waitForConfirms) {
            System.out.println("成功");
        }
    }
}

//批量确认
public static void Batch(Channel channel) throws Exception {
    for (int i = 0; i < COUNT; i++) {
        String test = i + "test";
        channel.basicPublish("","serial", MessageProperties.PERSISTENT_TEXT_PLAIN,test.getBytes(StandardCharsets.UTF_8));
        if (i % COUNT == 0) {
            boolean waitForConfirms = channel.waitForConfirms();
            if (waitForConfirms) {
                System.out.println("成功");
            }
        }
    }
}

//异步确认
public static void Asynchronous(Channel channel) throws Exception{
    //线程安全有序的一个map，适用于高并发
    ConcurrentSkipListMap<Long, String> outstandingConfirm = new ConcurrentSkipListMap<>();

    /**
     * 1.消息的标记
     * 2.是否为批量确认
     * */
    //消息接收成功 回调函数
    ConfirmCallback ackCallback = ((deliveryTag, multiple) -> {
        //2.删除掉已经确认的消息  剩下的就是未确认的消息
        //是否是批量
        if(multiple){
            ConcurrentNavigableMap<Long, String> longStringConcurrentNavigableMap =
                    outstandingConfirm.headMap(deliveryTag);
            longStringConcurrentNavigableMap.clear();
        }else {
            outstandingConfirm.remove(deliveryTag);
        }

        System.out.println("确认的消息：" + deliveryTag);
    });
    //消息接收失败 回调函数
    ConfirmCallback nackCallBack = (deliveryTag, multiple) -> {
        //3.打印一下未确认的消息都有哪些
        String message = outstandingConfirm.get(deliveryTag);
        System.out.println("未确认标记:"+ deliveryTag + "--->未确认的消息:" + message);
    };
    //准备消息的监听器 监听那些消息成功了  那些消息失败了
    /**
     * 1.监听消息接收成功
     * 2.监听消息接收失败
     * */
    channel.addConfirmListener(ackCallback, nackCallBack);
    for (int i = 0; i < COUNT; i++) {
        String test = i + "test";
        channel.basicPublish("","serial", MessageProperties.PERSISTENT_TEXT_PLAIN,test.getBytes(StandardCharsets.UTF_8));
        /**
         * 1.getNextPublishSeqNo调取下一次发布的序号
         * 2.消息
         * */
        outstandingConfirm.put(channel.getNextPublishSeqNo(), test);
    }
}

测试结果

因为我是用阿里云测试的 所以时间可能比本地要长

单个确认时间

批量确认时间

异步确认时间

比较三种发布确认

1. 单独发布消息

   同步等待确认，简单，但吞吐量非常有限。

2. 批量发布消息

   批量同步等待确认，简单，合理的吞吐量，一旦出现问题但很难推断出是那条消息出现了问题。

3. 异步发布消息

   最佳性能和资源使用，在出现错误的情况下可以很好地控制，但是实现起来稍微难些

交换机

介绍

在RabbitMQ中，生产者发送信息不会直接将消息投递到队列中，而是将消息投递到交换机中，再由交换机转发到具体的队列中，队列再将消息以推送或者拉取方式给消费进行消费

1. 路由键(RoutingKey)

   生产者将消息发送给交换机的时候，会指定RoutingKey指定路由规则

2. 绑定键(BindingKey)

   通过绑定键将交换机与队列关联起来，这样RabbitMq就知道如何正确地将消息路由到队列

3. 两者中的关系

   生产者将消息发送给哪个Exchange是需要由RoutingKey决定的，生产者需要将Exchange与哪个队列绑定时需要由BindingKey决定的

交换机类型

1. 直连交换机(Direct Exchange)
2. 主题交换机(Topic Exchange)
3. 扇形交换机(Fanout Exchange)
4. 首部交换机(Headers Exchange)
5. 死信交换机(Dead Letter Exchange)
6. 默认交换机

扇形交换机(Fanout Exchange)

扇形交换机是最基本的交换机类型，它能做的事情就是简单的广播消息，扇形交换机会把能接受到的消息全部发送给绑定自己身上的队列。因为广播不需要思考，所以扇形交换机处理消息的速度也是所有交换机类型里面最快的

创建交换机线程类

public class ExchangeThread extends Thread{

    //线程名称
    private String name;
    //交换机名称
    private String ExchangeName;
    //信道
    private Channel channel;
    //交换机类型
    private BuiltinExchangeType type;
    //线程停止时间
    private Long millis;
    //路由键
    private String[] RoutingKey;


    public ExchangeThread(String name,String ExchangeName, Long millis,BuiltinExchangeType type,String[] RoutingKey) {
        this.RoutingKey = RoutingKey;
        this.ExchangeName = ExchangeName;
        this.type = type;
        this.name = name;
        try {
            this.channel = RabbitMqConnectionFactory.getChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        this.millis = millis;
    }

    @Override
    public void run() {
        System.out.println(this.name + "线程已启动");
        try {
            //声明交换机
            /**
             * 1.交换机名称
             * 2.类型
             * */
            this.channel.exchangeDeclare(this.ExchangeName,this.type);
            //生产一个临时队列、队列名称随机
            String queueName = this.channel.queueDeclare().getQueue();

            //绑定交换机与队列
            /**
             * 1.队列名称
             * 2.交换机
             * 3.路由键
             * */
            for (String key : this.RoutingKey) {
                this.channel.queueBind(queueName, this.ExchangeName,key);
            }

            //接受消息
            this.channel.basicConsume(queueName,true,(consumerTag,message) -> {
                try {
                    //睡眠
                    Thread.sleep(this.millis);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(this.name + "线程收到"+"message:"+ new String(message.getBody()));
            }, CancelCallback->{
                System.out.println("消息消费被中断");
            });
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

---

消费者类

/**
 *
 * 扇形交换机接受消息
 * */
public class FanoutExchangeCousumer {

    public static final String EXCHANGE_NAME = "fanoutExchange";
    public static void main(String[] args) throws Exception{

         ExchangeThread thread = new ExchangeThread("一号", EXCHANGE_NAME,0L, BuiltinExchangeType.FANOUT,new String[]{""});
        ExchangeThread thread1 = new ExchangeThread("二号",EXCHANGE_NAME,2000L,BuiltinExchangeType.FANOUT,new String[]{""});
        ExchangeThread thread2 = new ExchangeThread("三号",EXCHANGE_NAME,5000L,BuiltinExchangeType.FANOUT,new String[]{""});
        thread.start();
        thread1.start();
        thread2.start();
    }
}

---

发布者类

/**
 * 发布者
 * */
public class FanoutExchangePulish {

    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqConnectionFactory.getChannel();

        //声明一个交换机
        /**
         *     public DeclareOk exchangeDeclare(String exchange, String type) throws IOException
         *     1.交换机名称
         *     2.类型
         * */
        channel.exchangeDeclare(FanoutExchangeCousumer.EXCHANGE_NAME,BuiltinExchangeType.FANOUT);

        //发送消息
        Scanner scanner = new Scanner(System.in);
        System.out.println("请发送消息:\n");
        while (scanner.hasNext()){
            String message = scanner.next();
            /**
             *     public void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException
             * */
            channel.basicPublish(FanoutExchangeCousumer.EXCHANGE_NAME,"",null,message.getBytes(StandardCharsets.UTF_8));
            System.out.println("message发送成功:" + message);
        }
    }
}

---

测试结果

发布者发布消息

消费者接受消息

直连交换机(Direct Exchange)

直连交换机：将消息推送到bindingKey与该消息的routingKey相同的队列

创建消费者类

public class DirectExchangeCousumer {
    public static final String EXCHANGE_NAME = "directExchange";
    public static void main(String[] args) {
        ExchangeThread thread = new ExchangeThread("一号", EXCHANGE_NAME,0L, BuiltinExchangeType.DIRECT, new String[]{"info", "warning"});
        ExchangeThread thread1 = new ExchangeThread("二号", EXCHANGE_NAME,0L, BuiltinExchangeType.DIRECT, new String[]{"error"});
        thread.start();
        thread1.start();
    }
}

创建发布者类

public class DirectExchangePulish {
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqConnectionFactory.getChannel();

        //发布消息
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入消息:\n");
        while (scanner.hasNext()){
            String message =  scanner.next();
            System.out.println("请输入路由key 1:info 2:warning 3:error");
            boolean nextInt = scanner.hasNextInt();
            if (nextInt){
                int i = scanner.nextInt();
                switch (i){
                    case 1:channel.basicPublish(DirectExchangeCousumer.EXCHANGE_NAME,"info",null,message.getBytes(StandardCharsets.UTF_8));
                        System.out.println("成功发送消息:" + message + "--->路由key:info");
                        break;
                    case 2:channel.basicPublish(DirectExchangeCousumer.EXCHANGE_NAME,"warning",null,message.getBytes(StandardCharsets.UTF_8));
                        System.out.println("成功发送消息:" + message + "--->路由key:warning");
                        break;
                    case 3:channel.basicPublish(DirectExchangeCousumer.EXCHANGE_NAME,"error",null,message.getBytes(StandardCharsets.UTF_8));
                        System.out.println("成功发送消息:" + message + "--->路由key:error");
                        break;
                    default:
                        System.out.println("发送失败，请选择正确类型");
                }
            }else {
                System.out.println("发送失败，请选择数字");
            }
        }
    }
}

测试结果

主题交换机（Topic Exchange）

发送到类型是topic交换机的消息的routing_ key 不能随意写,必须满足一定的要求, 它必须是一个单词列表，以点号分隔开。这些单词可以是任意单词，比如说: “stock.usd.nyse”, “nyse.vmw”,“quick.orange.rabbit”.这种类型的。当然这个单词列表最多不能超过255个字节。

*(星号)可以代替一个单词

#(井号)可以替代零个或多个单词

当一个队列的绑定键是"#"，它将会接收所有的消息，而不再考虑所接收消息的路由键

当一个队列的绑定键没有用到"#"和*时，它又像direct交换一样工作。

消费者代码

public class TopicExchangeCousumer {

    public static final String EXCHANGE_NAME = "topicExchange";

    public static void main(String[] args){
        ExchangeThread q1 = new ExchangeThread("Q1", EXCHANGE_NAME, 0L, BuiltinExchangeType.TOPIC, new String[]{"*.orange.*"});
        ExchangeThread q2 = new ExchangeThread("Q2", EXCHANGE_NAME, 0L, BuiltinExchangeType.TOPIC, new String[]{"*.*.rabbit","lazy.#"});
        q1.start();
        q2.start();
    }
}

生产者代码

public class TopicExchangePulish {
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqConnectionFactory.getChannel();
        //发送消息
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入消息\n");
        while (scanner.hasNext()){
            String message = scanner.next();
            System.out.println("请输入routingKey:\n");
            boolean hasNext = scanner.hasNext();
            if (hasNext){
                String routingKey = scanner.next();
                channel.basicPublish(TopicExchangeCousumer.EXCHANGE_NAME,routingKey,null,message.getBytes(StandardCharsets.UTF_8));
                System.out.println("成功发送消息,routingkey:"+routingKey + "---->message:" + message);
            }else {
                System.out.println("发送失败");
            }
        }
    }
}

测试结果

死信队列

​ 死信，就是无法被消费的消息，字面意思可以这样理解, 一般来说, producer 将消息投递到broker或者直接到queue里了, consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信,有死信自然就有了死信队列。

​ 应用场景:为了保证订单业务的消息数据不丢失，需要使用到RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中.还有比如说:用户在商城下单成功并点击去支付后在指定时间未支付时自动失效

---

为什么会死信

1. 消息TTL过期

2. 队列达到最大长度(队列满了，无法再添加数据到mq中)

3. 消息被拒绝(basic.reject或basic.nack)并且requeue=false.

消息TTL过期

线程类

public class DealLetterThread extends Thread {
    //线程名称
    private String name;
    //信道
    private Channel channel;
    //死信交换机
    public static final String DEAD_LETTER_EXCHANGE = "dead_letter_exchange";
    //普通交换机
    public static final String ORDINARY_EXCHANGE = "ordinary_exchange";
    //死信队列名称
    public static final String DEAD_LETTER_NAME = "dead_letter_name";

    //路由键
    private String[] RoutingKey;
    //是否是死信队列
    private boolean isDealLetter;

    public DealLetterThread(String name, String[] routingKey,boolean isDealLetter) {
        this.name = name;
        try {
            this.channel = RabbitMqConnectionFactory.getChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        this.isDealLetter = isDealLetter;
        RoutingKey = routingKey;
    }

    @Override
    public void run() {
        if(isDealLetter){
            System.out.println(this.name + "线程启动,该线程队列是死信队列");
            try {
                //开始接收死信队列的消息 手动应答 如果想自动应答的第二个参数改为true
                this.channel.basicConsume(DEAD_LETTER_NAME,false,(consumerTag,message)->{
                    System.out.println(this.name + "线程接受到的死信队列消息:"+ new String(message.getBody()));
                    //不批量应答消息
                    this.channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
                    System.out.println(this.name+"线程死信消息:"+new String(message.getBody())+"应答成功");
                },CancelCallback->{
                    System.out.println("消息消费被中断");
                });
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else{
            System.out.println(this.name + "线程启动,该线程是普通队列");
            try {
                //声明交换机
                this.channel.exchangeDeclare(ORDINARY_EXCHANGE,BuiltinExchangeType.TOPIC);
                this.channel.exchangeDeclare(DEAD_LETTER_EXCHANGE,BuiltinExchangeType.DIRECT);
                //将死信消息路由
                Map<String,Object> arguments = new HashMap<String, Object>();
                //过期时间 arguments.put("x-message-ttl",10000);
                //正常队列设置死信交换机
                arguments.put("x-dead-letter-exchange",DEAD_LETTER_EXCHANGE);
                //正常时间设置死信routingKey
                arguments.put("x-dead-letter-routing-key","deadletter");
                //声明普通队列
                String queue = this.channel.queueDeclare(UUID.randomUUID().toString(), true, false, false, arguments).getQueue();
                //声明死信队列
                this.channel.queueDeclare(DEAD_LETTER_NAME,true,false,false,null);

                //绑定交换机和队列
                for (String key : this.RoutingKey) {
                    this.channel.queueBind(queue,ORDINARY_EXCHANGE,key);
                }
                this.channel.queueBind(DEAD_LETTER_NAME,DEAD_LETTER_EXCHANGE,"deadletter");

                //获取消息回调
                DeliverCallback deliverCallback = (consumerTag,message) ->{
                    System.out.println(this.name + "线程取到未过期消息:"+new String(message.getBody()));
                    this.channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
                    System.out.println(this.name +"线程未过期消息:"+new String(message.getBody())+"应答成功");
                };
                //取消消息回调
                CancelCallback cancelCallback = consumerTag ->{
                    System.out.println("消息消费被中断");
                };
                //获取未过期的消息
                this.channel.basicConsume(queue,false,deliverCallback,cancelCallback);
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

发布者

Channel channel = RabbitMqConnectionFactory.getChannel();
//开启发布确认
channel.confirmSelect();

//死信消息 设置TTL时间 10s
AMQP.BasicProperties basicProperties = new AMQP.BasicProperties().builder().expiration("10000").build();

ConcurrentSkipListMap<Long, String> outstandingConfirm = new ConcurrentSkipListMap<>();

ConfirmCallback ackCallback = (deliveryTag, multiple) ->{
    if(multiple){
        ConcurrentNavigableMap<Long, String> longStringConcurrentNavigableMap =
                outstandingConfirm.headMap(deliveryTag);
        longStringConcurrentNavigableMap.clear();
    }else {
        outstandingConfirm.remove(deliveryTag);
    }
    System.out.println("已确认的标记：" + deliveryTag);
};
ConfirmCallback nackCallback = (deliveryTag, multiple)->{
    System.out.println("未确认标记:"+ deliveryTag);
};
channel.addConfirmListener(ackCallback,nackCallback);
//发送消息
Scanner scanner = new Scanner(System.in);
System.out.println("请输入消息\n");
while (scanner.hasNext()){
    String message = scanner.next();
    System.out.println("请输入routingKey:\n");
    boolean hasNext = scanner.hasNext();
    if (hasNext){
        String routingKey = scanner.next();
        channel.basicPublish(DealLetterThread.ORDINARY_EXCHANGE,routingKey,basicProperties,message.getBytes(StandardCharsets.UTF_8));
        System.out.println("成功发送消息,routingkey:"+routingKey + "---->message:" + message);
        //异步确认
        outstandingConfirm.put(channel.getNextPublishSeqNo(), message);
    }else {
        System.out.println("发送失败");
    }
}

消费者

DealLetterThread thread = new DealLetterThread("a1", new String[]{"*.a1.*","*.*.a1"}, false);
DealLetterThread thread1 = new DealLetterThread("a2", new String[]{"a2.#"}, false);
DealLetterThread thread2 = new DealLetterThread("a3", new String[]{""}, true);
DealLetterThread thread3 = new DealLetterThread("a4", new String[]{""}, true);
thread.start();
thread1.start();
thread2.start();
thread3.start();

测试结果

这时候我们再打开线程，可以看到a1和a2消息已经过期 放到了死信的队列去了

重新运行 获取到死信队列的消息

队列达到最大长度

当消息的未过期数量超过队列长度 超出的消息将直接进入到死信队列

//设置正常队列的长度限制 10个
arguments.put("x-max-length",10);

测试结果

消息被拒绝

这个时候要将队列设置为手动应答 在获取消息回调的方法里面设置basicReject即可拒绝消息 消息被拒绝将进入到死信队列中

//获取消息回调
DeliverCallback deliverCallback = (consumerTag,message) ->{
    if(new String(message.getBody()).equals("拒绝消息")){
        System.out.println(this.name + "线程取到未过期消息:"+new String(message.getBody()));
        this.channel.basicReject(message.getEnvelope().getDeliveryTag(),false);
        System.out.println(this.name +"线程未过期消息:"+new String(message.getBody())+"拒绝消息成功");
    }else {
        System.out.println(this.name + "线程取到未过期消息:"+new String(message.getBody()));
        this.channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        System.out.println(this.name +"线程未过期消息:"+new String(message.getBody())+"应答成功");
    }
 }

测试结果

a1拒绝后进入了死信队列

然后启动死信队列就能获取到消息

延迟队列

什么是延迟队列

延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上,延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说,延时队列就是用来存放需要在指定时间被处理的元素的队列。

使用场景

1. 订单在十分钟之内未支付则自动取消
2. 新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。
3. 用户注册成功后,如果三天内没有登陆则进行短信提醒。
4. 用户发起退款,如果三天内没有得到处理则通知相关运营人员。
5. 预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议

---

​ 这些场景都有一个特点，需要在某个事件发生之后或者之前的指定时间点完成某一项任务, 如:发生订单生成事件,在十分钟之后检查该订单支付状态，然后将未支付的订单进行关闭;看起来似乎使用定时任务，一直轮询数据,每秒查一次, 取出需要被处理的数据，然后处理不就完事了吗?如果数据量比较少,确实可以这样做，比如:对于“如果账单一周内未支付则进行自动结算”这样的需求，如果对于时间不是严格限制，而是宽松意义上的一周，那么每天晚上跑个定时任务检查一下所有未支付的账单，确实也是一个可行的方案。但对于数据量比较大，并且时效性较强的场景,如: “订单十分钟内未支付则关闭”, 短期内未支付的订单数据可能会有很多,活动期间甚至会达到百万甚至千万级别，对这么庞大的数据量仍旧使用轮询的方式显然是不可取的，很可能在一秒内无法完成所有订单的检查，同时会给数据库带来很大压力，无法满足业务要求而且性能低下。

整合SpringBoot

导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>2.0.7</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <!--   RabbitMq依赖     -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <!--    RabbitMq测试依赖    -->
    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit-test</artifactId>
    </dependency>
    <!--   swagger     -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>3.0.0</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>3.0.0</version>
    </dependency>

</dependencies>

修改配置文件

spring:
  rabbitmq:
    host: "xx.xx.xx.xx"
    port: 5672
    username: "xxxxx"
    password: "xxxxx"

创建TTLConfig

@Configuration
public class QueueTTLConfig {

    //普通交换机名称
    private static final String GENERAL_EXCHANGE = "general_exchange";
    //死信交换机名称
    private static final String DEAL_LETTER_EXCHANGE = "deal_letter_exchange";
    //普通队列名称
    private static final String GENERAL_QUEUE = "general_queue";
    //死信队列名称
    private static final String DEAL_LETTER_QUEUE = "deal_letter_queue";

    //声明普通交换机
    @Bean("GENERAL_EXCHANGE")
    public DirectExchange generalExchangeBean(){
        return new DirectExchange(GENERAL_EXCHANGE);
    }

    //声明死信交换机
    @Bean("DEAL_LETTER_EXCHANGE")
    public DirectExchange dealLetterExchangeBean(){
        return new DirectExchange(DEAL_LETTER_EXCHANGE);
    }

    //声明普通队列TTL 为20s
    @Bean("GENERAL_QUEUE")
    public Queue generalQueueBean(){
        Map<String, Object> arguments = new HashMap<>();
        //设置TTL过期时间
        arguments.put("x-message-ttl",20000);
        //设置死信交换机
        arguments.put("x-dead-letter-exchange",DEAL_LETTER_EXCHANGE);
        //设置死信routingKey
        arguments.put("x-dead-letter-routing-key","deal_letter_key");
        return QueueBuilder.durable(GENERAL_QUEUE).withArguments(arguments).build();
    }

    //声明死信队列
    @Bean("DEAL_LETTER_QUEUE")
    public Queue dealLetterQueueBean(){
        return QueueBuilder.durable(DEAL_LETTER_QUEUE).build();
    }
    //绑定
    @Bean
    public Binding generalBindingExchange(@Qualifier("GENERAL_EXCHANGE") DirectExchange generalExchange,
                                          @Qualifier("GENERAL_QUEUE") Queue generalQueue){
        return BindingBuilder.bind(generalQueue).to(generalExchange).with("general_queue_key");
    }

    @Bean
    public Binding dealLetterBindingExchange(@Qualifier("DEAL_LETTER_EXCHANGE")DirectExchange dealLetterExchange,
                                             @Qualifier("DEAL_LETTER_QUEUE")Queue dealLetterQueue){
        return BindingBuilder.bind(dealLetterQueue).to(dealLetterExchange).with("deal_letter_key");
    }

}

创建控制器用于发布消息

@Slf4j
@Controller
@RequestMapping("/send")
public class SendController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/ttlsend/{message}/{ttltime}")
    public void ttlsend(@PathVariable String message,@PathVariable String ttltime){
        rabbitTemplate.convertAndSend("general_exchange","general_queue_key",message,mes->{
            mes.getMessageProperties().setExpiration(ttltime);
            return mes;
        });
        log.info("当前时间:{},成功发送一条{}毫秒消息发送到general_queue,消息是:{}",new Date().toString(),ttltime,message);
    }
}

接收消息

@Slf4j
@Component
public class DealLetterQueueCousument {

    @RabbitListener(queues = "deal_letter_queue")
    public void receiveQueue(Message message, Channel channel){
        String msg = new String(message.getBody());
        log.info("当前时间:{},成功收到一条死信队列消息消息是:{}",new Date().toString(),msg);
    }

}

测试结果

如果使用在消息属性上设置TTL的方式,消息可能并不会按时“死亡",因为RabbitMQ只会检查第一个消息是否过期，如果过期则丢到死信队列,如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。

安装延迟队列插件解决问题

下载插件地址

下载插件后放在rabbitMq安装目录下lib/rabbitmq_server-x.x.x/plugins目录下

安装命令: rabbitmq-plugins enable rabbitmq_delayed_message_exchange

安装完成后 如果是3.8.x以上版本的不用重启就可以看到交换机Type多了一个x-delayed-message这样就安装成功了

使用延迟插件解决延迟问题

​ 自定义的交换机中，这是一种新的交换类型, 该类型消息支持延迟投递机制消息传递后并不会立即投递到目标队列中，而是存储在mnesia(一个分布式数据系统)表中，当达到投递时间时，才投递到目标队列中。

延迟队列配置类

@Configuration
public class DelayedQueueConfig {

    //延迟交换机
    public static final String DELAYED_EXCHANGE = "delayed.exchange";
    //延迟队列
    public static final String DELAYED_QUEUE = "delayed.queue";
    //routingKey
    public static final String DELAYED_ROUTINGKEY = "delayed.routingkey";

    @Bean("delayedExchange")
    public CustomExchange delayedExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", "direct");
        return new CustomExchange(DELAYED_EXCHANGE,"x-delayed-message",true,false,arguments);
    }

    @Bean("delayedQueue")
    public Queue delayedQueue(){
        return new Queue(DELAYED_QUEUE,true);
    }

    //绑定
    @Bean
    public Binding delayedExchangeBindingQueue(@Qualifier("delayedQueue") Queue delayedQueue,
                                               @Qualifier("delayedExchange") CustomExchange delayedExchange){
        return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(DELAYED_ROUTINGKEY).noargs();
    }
}

发送消息

@GetMapping("/ttlsenddalayed/{message}/{ttltime}")
public void ttlsenddalayed(@PathVariable String message,@PathVariable Integer ttltime){
    rabbitTemplate.convertAndSend(DelayedQueueConfig.DELAYED_EXCHANGE,DelayedQueueConfig.DELAYED_ROUTINGKEY,message, mes->{
        mes.getMessageProperties().setDelay(ttltime);//单位还是ms
        return mes;
    });
    log.info("当前时间:{},成功发送一条{}毫秒消息发送到延迟队列,消息是:{}",new Date().toString(),ttltime,message);
}

接收消息

//基于延迟插件获取消息
@RabbitListener(queues = DelayedQueueConfig.DELAYED_QUEUE)
public void delayedQueue(Message message, Channel channel){
    String msg = new String(message.getBody());
    log.info("当前时间:{},成功收到一条死信队列消息消息是:{}",new Date().toString(),msg);
}

测试结果

高级发布确认

​ 在生产环境中由于一些不明原因,导致rabbitmq重启,在RabbitMQ重启期间生产者消息投递失败,导致消息丢失,需要手动处理和恢复。于是就要开始思考,如何才能进行RabbitMQ的消息可靠投递呢?特别是在这样比较极端的情况，RabbitMQ 集群不可用的时候，无法投递的消息该如何处理呢

配置文件

spring.rabbitmq.publisher-confirm-type= correlated

1. **NONE:**禁用发布确认模式，（默认值）

2. **CORRELATED:**发布消息成功到交换机后会触发回调方法

3. SIMPLE

   有两种效果,第一种效果和CORRELATED值一样会触发回调方法，第二种在发布消息成功后使用rabbitTemplate调用waitForConfirms或waitForConfirmsOrDie方法等待broker节点返回发送结果，根据返回结果来判定下一步的逻辑， 要注意的是waitForConfirmsOrDie方法如果返回false则会关闭channel,则接下来无法发送消息到broker

配置类

@Configuration
public class ConfirmConfig {

    //交换机
    public static final String CONFIRM_EXCHANGE = "confirm_exchange";
    //队列名称
    public static final String CONFIRM_QUEUE = "confirm_queue";
    //routingkey
    public static final String CONFIRM_ROUTING_KEY = "confirm_routing_key";

    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){
        return new DirectExchange(CONFIRM_EXCHANGE);
    }

    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE).build();
    }

    @Bean
    public Binding confirmQueueBindingExchange(@Qualifier("confirmExchange") DirectExchange confirmExchange,
                                               @Qualifier("confirmQueue") Queue confirmQueue){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_ROUTING_KEY);
    }

}

回调接口

@Slf4j
@Component
public class MyCallback implements RabbitTemplate.ConfirmCallback {

    //注入
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(this);
    }

    /**
     * 交换机确认回调方法
     * 1.保存回调消息的id和相关信息
     * 2.交换机接受到消息true  接收不到false
     * 3.cause接收到消息为null 接收不到消息为失败的原因
     * */

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String id = correlationData!=null ? correlationData.getId() : "";
        if (ack){
            log.info("交换机收到消息id:{}",id);
        }else {
            log.info("交换机收不到消息id:{},失败原因:{}",id,cause);
        }
    }
}

测试

controller

@GetMapping("/send/{message}")
public void Send(@PathVariable String message){
    CorrelationData correlationData = new CorrelationData();
    correlationData.setId(UUID.randomUUID().toString());
    rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE,ConfirmConfig.CONFIRM_ROUTING_KEY,message,correlationData);
    log.info("发送消息成功:{},id:{}",message,correlationData.getId());
}

测试输入不存在的交换机名字

消息退回

如果交换机已经接收到消息 但是队列没有接受到就要将消息退回给生产者

配置文件

spring.rabbitmq.publisher-returns=true

同样还要实现ReturnsCallback接口并且注入

@Slf4j
@Component
public class MyCallback implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnsCallback {

    //注入
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }

    /**
     * 交换机确认回调方法
     * 1.保存回调消息的id和相关信息
     * 2.交换机接受到消息true  接收不到false
     * 3.cause接收到消息为null 接收不到消息为失败的原因
     * */

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String id = correlationData!=null ? correlationData.getId() : "";
        if (ack){
            log.info("交换机收到消息id:{}",id);
        }else {
            log.info("交换机收不到消息id:{},失败原因:{}",id,cause);
        }
    }

    /**
    *
    *回退接口
    */
    @Override
    public void returnedMessage(ReturnedMessage returnedMessage) {
          log.info("退回消息:{},code:{},被交换机退回:{},退回原因:{},key:{}",new String(returnedMessage.getMessage().getBody()),returnedMessage.getReplyCode(),returnedMessage.getExchange(),returnedMessage.getReplyText(),returnedMessage.getRoutingKey());
    }
}

public class ReturnedMessage {
	//失败消息
    private final Message message;
    //失败的code
    private final int replyCode;
    //失败原因
    private final String replyText;
    //失败的交换机
    private final String exchange;
    //失败的路由key
    private final String routingKey;

备份交换机

配置类添加备份交换机队列

@Configuration
public class ConfirmConfig {

    //交换机
    public static final String CONFIRM_EXCHANGE = "confirm_exchange";
    //队列名称
    public static final String CONFIRM_QUEUE = "confirm_queue";
    //routingkey
    public static final String CONFIRM_ROUTING_KEY = "confirm_routing_key";
    //备份交换机
    public static final String BACKUP_EXCHANGE = "backup_exchange";
    //备份队列
    public static final String BACKUP_QUEUE = "backup_queue";
    //报警队列
    public static final String WARNING_QUEUE = "warning_queue";


    //交换机指向备份交换机
    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){
        return ExchangeBuilder.directExchange(CONFIRM_EXCHANGE).durable(true).withArgument("alternate-exchange",BACKUP_EXCHANGE).build();
    }

    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE).build();
    }

    @Bean
    public Binding confirmQueueBindingExchange(@Qualifier("confirmExchange") DirectExchange confirmExchange,
                                               @Qualifier("confirmQueue") Queue confirmQueue){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_ROUTING_KEY);
    }

    @Bean("backupExchange")
    public FanoutExchange backupExchange(){
        return new FanoutExchange(BACKUP_EXCHANGE);
    }

    @Bean("backupQueue")
    public Queue backupQueue(){
        return QueueBuilder.durable(BACKUP_QUEUE).build();
    }

    @Bean("warningQueue")
    public Queue warningQueue(){
        return QueueBuilder.durable(WARNING_QUEUE).build();
    }

    //绑定
    @Bean
    public Binding backupQueueBindingExchange(@Qualifier("backupQueue")Queue backupQueue,
                                              @Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(backupQueue).to(backupExchange);
    }

    @Bean
    public Binding warningQueueBindingExchange(@Qualifier("warningQueue")Queue warningQueue,
                                              @Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(warningQueue).to(backupExchange);
    }

}

添加报警队列消费者

//报警队列
@RabbitListener(queues = ConfirmConfig.WARNING_QUEUE)
public void warningQueue(Message message){
    String msg = new String(message.getBody());
    log.error( "当前时间:{},成功收到一条报警队列消息消息是:{}",new Date().toString(),msg);
}

测试结果

测试发送2条消息到交换机 其中有一个路由是错误的

发送路由错了 消息发送到备用交换机报警队列

成功接收到一条错误的消息