RabbitMQ笔记

四大核心概念

下载安装erlang和rabbitMQ

1.安装Erlang：
https://github.com/rabbitmq/erlang-rpm/releases/download/v23.2.6/erlang-23.2.6-1.el7.x86_64.rpm

rpm -ivh erlang-23.2.6-1.el7.x86_64.rpm

#测试
erl -version

2.安装RabbitMQ
https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.8.12/rabbitmq-server-3.8.12-1.el7.noarch.rpm

#先安装依赖socat
yum install socat -y

rpm -ivh rabbitmq-server-3.8.12-1.el7.noarch.rpm

3.命令：

添加开机启动RabbitMQ服务
chkconfig rabbitmq-server on

启动服务
/sbin/service rabbitmq-server start

查看服务状态
/sbin/service rabbitmq-server status

#停止服务
/sbin/service rabbitmq-server stop

#安装可视化管理 插件
rabbitmq-plugins enable rabbitmq_management

4.重启rabbitmq服务，然后在windows客户端进入192.168.163.128(Linux的ip地址):15672，需要开启端口号，顺利进入！

开启防火墙
firewall-cmd --permanent --add-port=15672/tcp

重启生效
firewall-cmd --reload

5.添加用户并且设置权限

创建账号
rabbitmqctl add_user admin 123

设置用户角色   
rabitmqctl set_user_tags admin administrator

设置用户权限   格式：rabitmqctl set_permissions [-p <vhostpath>] <user> <conf> <write> <read>
rabbitmqctl set_permissions -p "/" admin ".*" ".*" ".*"     #用户admin具有/vhost1这个virtual host中所有资源的配置、写、读权限

查看用户列表
rabbitmqctl list_users

HellowWorld

创建开发环境

创建maven工程rabbitmq-hello,pom.xml:

    <dependencies>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.8.0</version>
        </dependency>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>

生产者代码

注意：如果报connection error，考虑是端口号没有开放的问题。连接服务，请求的端口号是5672，而可视化工具服务，请求的是15672，因此需要开启5672跟15672两个端口，测试连接成功！

public class Producer {
   // 队列名称
   public static  final String QUEUE_NAME="hello";

   // 发消息
   public static void main(String[] args) throws IOException, TimeoutException {
       // 创建一个连接工厂
       ConnectionFactory factory = new ConnectionFactory();

       // 工厂IP连接RabbitMQ的队列
       factory.setHost("192.168.163.128");
       // 用户名
       factory.setUsername("admin");
       // 密码
       factory.setPassword("123");

       factory.setPort(5672);

       // 创建连接
       Connection connection = factory.newConnection();
       // 获取信道
       Channel channel = connection.createChannel();
       /*
           * 生成一个队列
           * 参数1：队列名称
           * 参数2：队列里面的消息是否持久化，默认情况下，消息存储在内存中
           * 参数3：该队列是否只供一个消费者进行消费，是否进行消费共享，true可以多个消费者消费，
           *        false只能一个消费者消费
           * 参数4：是否自动删除：最后一个消费者断开连接之后，该队列是否自动删除，true则自动删除，
           *        false不自动删除
           * 参数5：其他参数
       * */
       channel.queueDeclare(QUEUE_NAME,false,false,false,null);
       // 发消息
       String message = "hello world";
       /*
       * 发送一个消息
       * 参数1：发送到哪个交换机
       * 参数2：路由的key值是那个，本次是队列的名称
       * 参数3：其他参数信息
       * 参数4：发送消息的消息体
       * */
       channel.basicPublish("",QUEUE_NAME,null,message.getBytes(StandardCharsets.UTF_8));
       System.out.println("消息发送完毕！");

   }
}

消费者代码

public class Consumer {
    // 队列名称
    public static final String QUEUE_NAME = "hello";

    // 接受消息
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        factory.setHost("192.168.163.128");
        factory.setUsername("admin");
        factory.setPassword("123");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

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

        // 声明 取消消息
        CancelCallback cancelCallback = consumer -> {
            System.out.println("消息消费被中断");
        };

        /*
        * 消费者接收消息
        * 参数1：表示消费哪个UI列
        * 参数2：消费成功之后，是否需要自动应答，true表示自动应答，false表示手动应答
        * 参数3：消费者成功消费的回调
        * 参数4：消费者取消消费的回调
         */
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}

工作队列

工作队列(又称任务队列)的主要思想是避免立即执行资源密集型任务，而不得不等待它完成。相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。

实现工作队列

抽取连接工厂工具类

/*
* 此类为连接工厂创建信道的工具类
* */
public class RabbitMqUtils {
     // 得到一个连接的channel
    public static Channel getChannel() throws IOException, TimeoutException {
        // 创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.24.8");
        factory.setUsername("admin");
        factory.setPassword("123");
        Connection connection = factory.newConnection();
        com.rabbitmq.client.Channel channel = connection.createChannel();
        return channel;
    }
}

工作线程代码

public class Worker01 {

    // 队列名称
    public static final String QUEUE_NAME = "hello";

    // 接受消息
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();

        // 接受消息参数
        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println("接受到的消息："+message.getBody());
        };

        // 取消消费参数
        CancelCallback cancelCallback = consumerTag -> {
            System.out.println(consumerTag+"消费者取消消费接口回调逻辑");
        };

        // 消息的接受
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}

同时开启两个工作线程：

生产者代码

public class Task01 {

    private static final String QUEUE_NAME="hello";

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

        //声明一个队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //从控制台输入消息
        Scanner scanner=new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes(StandardCharsets.UTF_8));
            System.out.println("消息发送完成："+message);
        }

    }
}

消息应答

消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成了部分突然它挂掉了，会发生什么情况。RabbitMQ一旦向消费者传递了一条消息，便立即将该消息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息。以及后续发送给该消费这的消息，国为它无法接收到。
为了保证消息在发送过程中不丢失，RabbitMQ引入消息应答机制，消息应答就是:消费者在接收到消息并且处理该消息之后，告诉RabbitMQ它已经处理了，RabbitMQ可以把该消息删除了。

自动应答

消息发送后立即被认为已经传送成功，这种模式需要在高吞吐量和数据传输安全性方面做权衡,因为这种模式如果消息在接收到之前，消费者那边出现连接或者channel关闭，那么消息就丢失了,当然另一方面这种模式消费者那边可以传递过载的消息，没有对传递的消息数量进行限制,当然这样有可能使得消费者这边由于接收太多还来不及处理的消息，导致这些消息的积压，最终使得内存耗尽，最终这些消费者线程被操作系统杀死，所以这种模式仅适用在消费者可以高效并以某种速率能够处理这些消息的情况下使用。

手动应答（建议）

消息应答的方法

Channel.basicAck(用于肯定确认)，RabbitMQ已知道该消息并且成功处理，可以将其丢弃

Channel.basicNack(用于否定确认)

Channel.basicReject(用于否定确认)，与Channel.basicNack相比少了一个参数Multiple，不处理该消息了，直接拒绝，可以将其丢弃了。

Multiple的解释(一般为false)
手动应答的好处是可以批量应答并且减少网络拥堵

multiple的true和false是不同的意思：
true表示批量应答channel上未应答的消息，比如channel上有传送tag的消息5,6,7,8,，当前tag是8，那么此时5-8的这些还未应答的消息就会被确认收到消息应答.
false同上面相比只会应答tag=8的消息，5,6,7这三个消息依然不会被确认收到消息应答.

消息自动重新入队
如果消费者由于某些原因失去连接(其通道已关闭，连接已关闭或TCP连接丢失)，导致消息未发送ACK确认，RabbitMQ将了解到消息未完全处理，并将对其重新排队。如果此时其他消费者可以处理，它将很快将其重新分发给另一个消费者。这样，即使某个消费者偶尔死亡，也可以确保不会丢失任何消息。

生产者代码：

    /*
 * 消息在手动应答时是不丢失、放回队列中重新消费
 * */
 public class Task2 {
 
     // 队列名称
     public static final String TASK_QUEUE_NAME = "ack_queue";
 
     public static void main(String[] args) throws IOException, TimeoutException {
         Channel channel = RabbitMqUtils.getChannel();
 
         // 声明队列
         channel.queueDeclare(TASK_QUEUE_NAME,false,false,false,null);
 
         Scanner scanner = new Scanner(System.in);
         while (scanner.hasNext()){
             String message = scanner.next();
             channel.basicPublish("",TASK_QUEUE_NAME,null,message.getBytes(StandardCharsets.UTF_8));
             System.out.println("生产者发出消息："+message);
         }
 
     }
 }

消费者1代码

    /*
 * 消费者
 * */
 public class Worker02 {
     // 队列名称
     public static final String TASK_QUEUE_NAME = "ack_queue";
 
     public static void main(String[] args) throws IOException, TimeoutException {
         Channel channel = RabbitMqUtils.getChannel();
         System.out.println("C1等待接受消息处理时间较短");

     DeliverCallback deliverCallback = (consumerTag,message) -> {
         //沉睡1s
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
         System.out.println("接受到的消息是:"+new String(message.getBody()));

         //进行手动应答
         /*
         * 参数1：消息的标记  tag
         * 参数2：是否批量应答，false：不批量应答 true：批量
         * */
         channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
     };


     // 采用手动应答
     boolean autoAck = false;
     channel.basicConsume(TASK_QUEUE_NAME,autoAck,deliverCallback,(consumerTag) -> {
         System.out.println(consumerTag+"消费者取消消费接口回调逻辑");
     });
 }
}

消费者2代码

 /*
 * 消费者
 * */
 public class Worker03 {
     // 队列名称
     public static final String TASK_QUEUE_NAME = "ack_queue";
 
     public static void main(String[] args) throws IOException, TimeoutException {
         Channel channel = RabbitMqUtils.getChannel();
         System.out.println("C2等待接受消息处理时间较长");
 
         DeliverCallback deliverCallback = (consumerTag,message) -> {
            //沉睡30s
            try {
                Thread.sleep(30000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
             System.out.println("接受到的消息是:"+new String(message.getBody()));
 
             //进行手动应答
             /*
             * 参数1：消息的标记  tag
             * 参数2：是否批量应答，false：不批量应答 true：批量
             * */
             channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
         };
 
 
         // 采用手动应答
         boolean autoAck = false;
         channel.basicConsume(TASK_QUEUE_NAME,autoAck,deliverCallback,(consumerTag) -> {
             System.out.println(consumerTag+"消费者取消消费接口回调逻辑");
         });
     }
 }

持久化

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

队列持久化

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

 // 声明队列
 // 持久化 需要让Queue持久化
 boolean durable = true;
 channel.queueDeclare(TASK_QUEUE_NAME,durable,false,false,null);

需要注意的就是如果之前声明的队列不是持久化的，需要把原先队列先删除或者重新创建一个持久化的队列，不然就会出现错误。

消息持久化

要想让消息实现持久化需要在消息生产者修改代码,MessageProperties,PERSISTENT_TEXT_PLAIN添加这个属性。
将消息标记为持久化并不能完全保证不会丢失消息。尽管它告诉RabbitMQ将消息保存到磁盘，但是这里依然存在当消息刚准备存储在磁盘的时候但是还没有存储完，消息还在缓存的一个间隔点。此时并没有真正写入磁盘。持久性保证并不强，但是对于我们的简单任务队列而言，这已经绰绰有余了。

 //设置生产者发送消息为持久化消息（要求保存到磁盘上）
 channel.basicPublish("",TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN
                      ,message.getBytes(StandardCharsets.UTF_8));
 System.out.println("生产者发出消息："+message);

不公平分发

在最开始的时候我们学习到RabbitMQ.分发消息采用的轮训分发，但是在某种场景下这种策略并不是很好，比方说有两个消费者在处理任务，其中有个消费者1处理任务的速度非常快，而另外一个消费者2处理速度却很慢，这个时候我们还是采用轮训分发的化就会到这处理速度快的这个消费者很大一部分时间处于空闲状态，而处理慢的那个消费者一直在干活，这种分配方式在这种情况下其实就不太好，但是RabbitMQ并不知道这种情况，它依然很公平的进行分发。
为了避免这种情况，我们可以设置参数channel.basicQos(1)。

// 消费者设置不公平分发
int prefetchCount = 1;
channel.basicQos(prefetchCount);

prefetchCount默认是0，代表是轮询分发消息；1是不公平分发，能这多劳；其他的是代表着预期值。

预取值

本身消息的发送就是异步发送的，所以在任何时候，channel上肯定不止只有一个消息另外来自消费者的手动确认本质上也是异步的。因此这里就存在一个未确认的消息缓冲区，因此希望开发人员能限制此缓冲区的大小，以避免缓冲区里面无限制的未确认消息问题。这个时候就可以通过使用basic.gos.方法设置“预取计数”值来完成的。该值定义通道上允许的未确认消息的最大数量。一旦数量达到配置的数量，RabbitMQ将停止在通道上传递更多消息，除非至少有一个未处理的消息被确认，例如，假设在通道上有未确认的消息5、6、7，8，并且通道的预取计数设置为4，此时RabbitMQ.将不会在该通道上再传递任何消息，除非至少有一个未应答的消息被ack。比方说tag=6这个消息刚刚被确认ACK，RabbitMQ将会感知这个情况到并再发送一条消息。

发布确认

原理：
生产者将信道设置成confirm模式，一旦信道进入confirm模式，所有在该信道上面发布的消息都将会被指派一个唯一的ID(从1开始)，一旦消息被投递到所有匹配的队列之后，broker就会发送一个确认给生产者(包含消息的唯一ID)，这就使得生产者知道消息已经正确到达目的队列了，如果消息和队列是可持久化的，那么确认消息会在将消息写入磁盘之后发出，broker回传给生产者的确认消息中delivery-tag域包含了确认消息的序列号，此外 broker也可以设置basic.ack 的multiple域，表示到这个序列号之前的所有消息都已经得到了处理。
confirm模式最大的好处在于他是异步的，一旦发布一条消息，生产者应用程序就可以在等信道返回确认的同时继续发送下一条消息，当消息最终得到确认之后，生产者应用便可以通过回调方法来处理该确认消息，如果RabbitMQ因为自身内部错误导致消息丢失，就会发送一条nack消息，生产者应用程序同样可以在回调方法中处理该nack.消息。

发布确认策略：
开启发布确认的方法
发布确认默认是没有开启的，如果要开启需要调用方法 confirmSelect，每当你要想使用发布角认，都需要在channel上调用该方法

Channel channel = connection.createChannel();
channel.confirmSelect();

单个发布确认

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

//消息的个数
private static final int MESSAGE_COUNT=1000;

public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
    publishMessageIndividually();//单个确认发布1000条数据需要7396ms

}

public static void publishMessageIndividually() throws IOException, TimeoutException, InterruptedException {
    Channel channel = RabbitMqUtils.getChannel();

    //声明队列
    String queueName = UUID.randomUUID().toString();

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

    //开启发布确认
    channel.confirmSelect();
    //开启时间
    long begin = System.currentTimeMillis();
    //批量发送消息
    for (int i=0;i<MESSAGE_COUNT;i++){
        String message =i+"";
        channel.basicPublish("",queueName,null,message.getBytes());
        //单个消息就马上发布确认
        boolean flag = channel.waitForConfirms();
        if (flag) {
            System.out.println("消息发送成功");
        }

    }
    long time = System.currentTimeMillis() - begin;
    System.out.println("发布:"+time);

}

批量发布确认

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

 public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
//        publishMessageIndividually();//单个确认发布1000条数据需要7396ms
        publishMessageBatch();//批量确认发布1000条数据需要1358ms

    }

    public static void publishMessageBatch() throws IOException, TimeoutException, InterruptedException {
        Channel channel = RabbitMqUtils.getChannel();

        //声明队列
        String queueName = UUID.randomUUID().toString();

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

        //开启发布确认
        channel.confirmSelect();
        //开启时间
        long begin = System.currentTimeMillis();

        //批量确认消息大小
        int batchSize = 100;

        //批量发送消息  批量发布确认
        for (int i=0;i<MESSAGE_COUNT;i++){
            String message =i+"";
            channel.basicPublish("",queueName,null,message.getBytes());

            if (i % 100 == 0) {
                boolean flag = channel.waitForConfirms();
                if (flag) {
                    System.out.println("消息发送成功");
                }
            }
        }

        long time = System.currentTimeMillis() - begin;
        System.out.println("发布:"+time);

    }

异步发布确认

异步确认虽然编程逻辑比上两个要复杂，但是性价比最高，无论是可靠性还是效率都没得说，他是利用回调函数来达到消息可靠性传递的,这个中间件也是通过函数回调来保证是否投递成功，下面就让我们来详细讲解异步确认是怎么实现的。

public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
//        publishMessageIndividually();//单个确认发布1000条数据需要7396ms
//        publishMessageBatch();//批量确认发布1000条数据需要1358ms
        publishMessageAsync();//异步确认发布1000条数据需要537ms
    }

    public static void publishMessageAsync() throws IOException, TimeoutException, InterruptedException {
    Channel channel = RabbitMqUtils.getChannel();

    //声明队列
    String queueName = UUID.randomUUID().toString();

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

    //开启发布确认
    channel.confirmSelect();
    //开启时间
    long begin = System.currentTimeMillis();

    //消息确认成功回调函数
    ConfirmCallback ackCallback=(deliveryTag,multiple)->{

    };

    //消息确认失败回调函数
    ConfirmCallback nackCallback=(deliveryTag,multiple)->{
        System.out.println("未确认的消息："+deliveryTag);
    };
    //准备消息的监听器 监听哪些消息成功了  哪些消息失败了
    channel.addConfirmListener(ackCallback,nackCallback);//异步通知



    //批量发送消息
    for (int i=0;i<MESSAGE_COUNT;i++){
        String message =i+"";
        channel.basicPublish("",queueName,null,message.getBytes());
    }


    long time = System.currentTimeMillis() - begin;
    System.out.println("发布:"+time);

}

如何处理异步未确认信息？
最好的解决方案就是把未确认的消息放到一个基于内存的能被发布线程访问的队列，比如说用ConcurrentSkipListMap在confirm callbacks与发布线程之间进行消息的传递.

public static void publishMessageAsync() throws IOException, TimeoutException, InterruptedException {
    Channel channel = RabbitMqUtils.getChannel();

    //声明队列
    String queueName = UUID.randomUUID().toString();

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

    //开启发布确认
    channel.confirmSelect();
    //开启时间
    long begin = System.currentTimeMillis();

    /**
     *  线程安全有序的哈希表，适用于高并发
     *  1.轻松地将序号和消息进行关联
     *  2.轻松地批量删除，只要给到序号
     *  3.支持高并发
     */
    ConcurrentSkipListMap<Long,String> outstandingConfirms = new ConcurrentSkipListMap<>();

    //消息确认成功回调函数
    ConfirmCallback ackCallback=(deliveryTag,multiple)->{
        //删除到已经确定发布的消息，删除哈希表中的数据
        if(multiple){
            //如果是批量发布确认，全部删除
            ConcurrentNavigableMap<Long, String> confirmed = outstandingConfirms.headMap(deliveryTag);
            confirmed.clear();
        }else {
            outstandingConfirms.remove(deliveryTag);
        }
    };

    //消息确认失败回调函数
    ConfirmCallback nackCallback=(deliveryTag,multiple)->{
        //打印为确认的消息有哪些
        String message = outstandingConfirms.get(deliveryTag);
        System.out.println("未确认的消息："+deliveryTag);
        
    };

    //准备消息的监听器 监听哪些消息成功了  哪些消息失败了
    channel.addConfirmListener(ackCallback,nackCallback);//异步通知





    //批量发送消息
    for (int i=0;i<MESSAGE_COUNT;i++){
        String message =i+"";
        channel.basicPublish("",queueName,null,message.getBytes());

        //记录所有要发送消息的总和
        outstandingConfirms.put(channel.getNextPublishSeqNo(),message);
    }


    long time = System.currentTimeMillis() - begin;
    System.out.println("发布:"+time);

}

交换机

RabbitMQ消息传递模型的核心思想是：生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。
相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。
总共有以下几个类型：
直接（direct）、主题（topic）、标题（headers）、扇出（fanout）
无名交换机：
在本教程的前面部分我们对exchange一无所知，但仍然能够将消息发送到队列。之前能实现的原因是因为我们使用的是默认交换，我们通过空字符串(“”)进行标识。
第一个参数是交换机的名称。空字符串表示默认或无名称交换机:消息能路由发送到队列中其实是由routingKey(bindingkey)绑定key指定的，如果它存在的话

channel.basiPublish("","hello",null,message.getBytes())；

Fanout

Fanout这种类型非常简单。正如从名称中猜到的那样，它是将接收到的所有消息广播到它知道的所有队列中。系统中默认有些exchange类型.
消费者

public class ReceiveLog01 {

    private static final String EXCHANGE_NAME="logs";

    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //声明一个队列  临时队列  名称随机 当消费者断开与队列连接时队列自动删除
        String queue = channel.queueDeclare().getQueue();
        //交换机绑定队列
        channel.queueBind(queue,EXCHANGE_NAME,"");
        System.out.println("等待接收消息......");

        //接收信息参数
        DeliverCallback deliverCallback =(consumerTag, message)->{
            System.out.println("ReceiveLogs01控制台打印接受到的消息：" + new String(message.getBody()));
        };

        //声明取消消息
        CancelCallback cancelCallback= consumerTag ->{
            System.out.println(consumerTag+"消费者取消消费接口回调逻辑");
        };


        channel.basicConsume(queue,true,deliverCallback,cancelCallback);

    }
}

生产者

public class EmitLog {

    private static final String EXCHANGE_NAME="logs";

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

        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
//        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");

        Scanner scanner=new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes(StandardCharsets.UTF_8));
            System.out.println("生产者发出的消息："+ message);
        }
    }
}

Direct

生产者

public class DirectLogs {
 // 交换机的名称
 public  static  final String EXCHANGE_NAME = "direct_logs";

 public static void main(String[] args) throws  Exception{
     Channel channel = RabbitMqUtils.getChannel();
     channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

     Scanner scanner = new Scanner(System.in);
     while (scanner.hasNext()){
         String message = scanner.next();
         channel.basicPublish(EXCHANGE_NAME,"info",null,message.getBytes(StandardCharsets.UTF_8));
         System.out.println("生产者发出的消息："+ message);
     }
 }
}

消费者

public class ReceiveLogsDirect01 {
 public static final String EXCHANGE_NAME = "direct_logs";

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

     //声明一个队列
     channel.queueDeclare("console",false,false,false,null);

     //绑定交换机与队列
     channel.queueBind("console",EXCHANGE_NAME,"info");
     channel.queueBind("console",EXCHANGE_NAME,"warning");


     DeliverCallback deliverCallback = (consumerTag, message) -> {
         System.out.println("ReceiveLogsDirect01控制台打印接受到的消息：" + new String(message.getBody()));
     };

     channel.basicConsume("console",true,deliverCallback,consumerTag -> {});
 }
}

public class ReceiveLogsDirect02 {
 public static final String EXCHANGE_NAME = "direct_logs";

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

     //声明一个队列
     channel.queueDeclare("disk",false,false,false,null);

     //绑定交换机与队列
     channel.queueBind("disk",EXCHANGE_NAME,"error");


     DeliverCallback deliverCallback = (consumerTag, message) -> {
         System.out.println("ReceiveLogsDirect02控制台打印接受到的消息：" + new String(message.getBody()));
     };

     channel.basicConsume("disk",true,deliverCallback,consumerTag -> {});
 }
}

Topics

发送到类型是topic交换机的消息的routing_key不能随意写，必须满足一定的要求，它必须是一个单词列表，以点号分隔开。这些单词可以是任意单词，比如说: “stock.usd.nyse” ， “nyse.vmw”，"quick.orange.rabbit"这种类型的。当然这个单词列表最多不能超过255个字节。
在这个规则列表中，其中有两个替换符：
*可以代替一个单词 #可以代替零个或多个单词

下图绑定关系如下：
Q1绑定的是：中间带orange的三个单词的字符串：*.orange.*
Q2绑定的是：最后一个单词是rabbit的单个单词：*.*.rabbit，第一个单词是lazy的多个单词：lazy.#

数据接收情况如下：

quick.orange.rabbit：被队列Q1Q2接收到
quick.orange.fox：被队列Q1接收到
lazy.brown.fox：被队列Q2接收到
lazy.pink.rabbit：虽然满足队列Q2的两个绑定但是只会被接收一次
quick.orange.male.rabbit：四个单词不匹配任何绑定会被丢弃

结论：
当一个队列绑定键是#,那么这个队列将接收所有数据，就有点像fanout了；
如果队列绑定键当中没有#和*出现，那么该队列绑定类型就是direct了。

生产者

public class EmitLogTopic {
 //交换机的名称
 public static final String EXCHANGE_NAME = "topic_logs";

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


     HashMap<String, String> map = new HashMap<>();
     map.put("quick.orange.rabbit","被队列Q1Q2接收到");
     map.put("quick.orange.fox","被队列Q1接收到");
     map.put("lazy.brown.fox","被队列Q2接收到 ");
     map.put("lazy.pink.rabbit","虽然满足队列Q2的两个绑定但是只会被接收一次");
     map.put("quick.orange.male.rabbit","四个单词不匹配任何绑定会被丢弃");

     for (Map.Entry<String, String> bindingKeyEntry : map.entrySet()) {
         String routingKey = bindingKeyEntry.getKey();
         String message = bindingKeyEntry.getValue();

         channel.basicPublish(EXCHANGE_NAME,routingKey,null,message.getBytes(StandardCharsets.UTF_8));
         System.out.println("生产者发送消息："+ message );

     }
  }
}

消费者

/*
* 声明主题交换机及相关队列
* 消费者C1
* */
public class ReceiveLogsTopic01 {
    //交换机名称
    public static final String EXCHANGE_NAME = "topic_logs";

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

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        //声明队列
        String queueName = "Q1";
        channel.queueDeclare(queueName,false,false,false,null);

        //队列捆绑
        channel.queueBind(queueName,EXCHANGE_NAME,"*.orange.*");
        System.out.println("等待接收消息......");

        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println(new String(message.getBody()));
            System.out.println("接收队列："+ queueName + "绑定键：" + message.getEnvelope().getRoutingKey());
        };

        //接收消息
        channel.basicConsume(queueName,true,deliverCallback,consumerTag -> {});
    }
}

/*
* 声明主题交换机及相关队列
* 消费者C2
* */
public class ReceiveLogsTopic02 {
    //交换机名称
    public static final String EXCHANGE_NAME = "topic_logs";

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

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        //声明队列
        String queueName = "Q2";
        channel.queueDeclare(queueName,false,false,false,null);

        //队列捆绑
        channel.queueBind(queueName,EXCHANGE_NAME,"*.*.rabbit");
        channel.queueBind(queueName,EXCHANGE_NAME,"*lazy.#");
        System.out.println("等待接收消息......");

        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println(new String(message.getBody()));
            System.out.println("接收队列："+ queueName + "绑定键：" + message.getEnvelope().getRoutingKey());
        };

        //接收消息
        channel.basicConsume(queueName,true,deliverCallback,consumerTag -> {});
    }
}

死信队列

死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到 broker或者直接到queue里了,consumer 从 queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。
应用场景：为了保证订单业务的消息数据不丢失，需要使用到RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中.还有比如说:用户在商城下单成功并点击去支付后在指定时间未支付时自动失效。

来源：

消息TTL过期；
队列达到最大长度（队列满了，无法再添加数据到mq中）；
消息被拒绝（basic.reject或basic.nack）并且requeue=false。

消息TTL过期

生产者

    /*
 * 死信队列之生产者代码
 *
 * */
 public class Producer {
 
     //普通交换机的名称
     public static final String NORMAL_EXCHANGE = "normal_exchange";
     public static void main(String[] args) throws Exception{
         Channel channel = RabbitMqUtils.getChannel();
 
         //死信消息，设置TTL时间  单位是ms  10000ms是10s
         AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
 
         for (int i = 0; i < 10; i++) {
             String message = "info" + i;
             channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",properties,message.getBytes(StandardCharsets.UTF_8));
         }
     }
 }

消费者

    /*
 * 死信队列实战
 * 消费者01
 * */
 public class Consumer01 {
 
     //普通交换机名称
     public static final String NORMAL_EXCHANGE = "normal_exchange";
 
     //死信交换机名称
     public static final String DEAD_EXCHANGE = "dead_exchange";
 
     //普通队列名称
     public static final String NORMAL_QUEUE = "normal_queue";
 
     //死信队列名称
     public static final String DEAD_QUEUE = "dead_queue";
 
     public static void main(String[] args) throws  Exception{
         Channel channel = RabbitMqUtils.getChannel();
 
         //声明死信和普通的交换机类型为direct
         channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
         channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
 
         //声明普通队列
         HashMap<String, Object> arguments = new HashMap<>();
 
          //过期时间  也可以不设置  由生产者设置过期时间，更灵活
          //arguments.put("x-message-ttl",10000);
         //正常队列设置死信队列
         arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
         //设置死信RoutingKey
         arguments.put("x-dead-letter-routing-key","lisi");

     //声明死信和普通队列
     channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);
     channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

     //绑定普通的交换机与普通的队列
     channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
     //绑定死信的交换机与死信的队列
     channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");
     System.out.println("等待接收消息......");

     DeliverCallback deliverCallback = (consumerTag,message) -> {
         System.out.println("Consumer01接收的消息是：" + new String(message.getBody()));
     };

     channel.basicConsume(NORMAL_QUEUE,true,deliverCallback,consumerTag->{});
 }
}

 /*
 * 死信队列实战
 * 消费者02
 * */
 public class Consumer02 {
 
     //死信队列名称
     public static final String DEAD_QUEUE = "dead_queue";
 
     public static void main(String[] args) throws  Exception{
         Channel channel = RabbitMqUtils.getChannel();
         System.out.println("等待接收消息......");

     DeliverCallback deliverCallback = (consumerTag,message) -> {
         System.out.println("Consumer02接收的消息是：" + new String(message.getBody()));
     };

     channel.basicConsume(DEAD_QUEUE,true,deliverCallback,consumerTag->{});
 }
}

效果：启动生产者后，10条消息被传送到NORMAL_QUEUE，然后被传送到DEAD_QUEUE，此时启动消费者02，消息全被接收。

队列达到最大长度

生产者

public class Producer {
    //普通交换机名称
    private static final String NORMAL_EXCHANGE = "normal_exchange";

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

        //死信消息，设置TTL时间 单位是ms
//        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();

        for (int i = 0; i < 10; i++) {
            String message = "info" + i;
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",null,message.getBytes(StandardCharsets.UTF_8));
        }
    }
}

消费者

public class Consumer01 {
    
    //普通交换机名称
    private static final String NORMAL_EXCHANGE = "normal_exchange";
    //死信交换机名称
    private static final String DEAD_EXCHANGE = "dead_exchange";

    //普通队列名称
    public static final String NORMAL_QUEUE = "normal_queue";

    //死信队列名称
    public static final String DEAD_QUEUE = "dead_queue";

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

        //声明两个交换机类型为direct
        channel.exchangeDeclare(NORMAL_EXCHANGE,"direct");
        channel.exchangeDeclare(DEAD_EXCHANGE,"direct");

        //声明普通队列
        HashMap<String, Object> arguments = new HashMap<>();

        //过期时间  也可以不设置  由生产者设置过期时间
//        arguments.put("x-message-ttl",10000);
        //正常队列设置死信队列
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信RoutingKey
        arguments.put("x-dead-letter-routing-key","lisi");
        //设置正常队列的长度的限制
        arguments.put("x-max-length",6);

        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);

        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //绑定普通交换机和普通的队列
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        //绑定死信交换机和死信队列
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");
        System.out.println("等待接收消息");

        DeliverCallback deliverCallback=(consumerTag, message)->{
            System.out.println("Consumer01接收的消息："+ new String(message.getBody()));
        };

        channel.basicConsume(NORMAL_QUEUE,true, deliverCallback, consumerTag -> {});
    }

}

消息被拒绝

生产者代码不需要改变
消费者

DeliverCallback deliverCallback=(consumerTag, message)->{
    String msg = new String(message.getBody());
    if (msg.equals("info6")){
        //拒绝消息info6
        System.out.println("Consumer01接收到的消息是："+msg +":此消息被C1拒绝了");
        channel.basicReject(message.getEnvelope().getDeliveryTag(),false);
    }else {
        System.out.println("Consumer01接收的消息："+msg );
        channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
    }
    
};

//开启手动应答
channel.basicConsume(NORMAL_QUEUE,false, deliverCallback, consumerTag -> {});

延迟队列

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

使用场景：

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

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

整合springboot

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

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

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

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

     <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>fastjson</artifactId>
         <version>1.2.73</version>
     </dependency>

     <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
     </dependency>

     <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger2</artifactId>
         <version>2.9.2</version>
     </dependency>

     <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger-ui</artifactId>
         <version>2.9.2</version>
     </dependency>

     <dependency>
         <groupId>org.springframework.amqp</groupId>
         <artifactId>spring-rabbit-test</artifactId>
         <scope>test</scope>
     </dependency>

 spring.rabbitmq.host=192.168.24.8
 spring.rabbitmq.port=5672
 spring.rabbitmq.username=admin
 spring.rabbitmq.password=123

 @Configuration
 @EnableSwagger2
 public class SwaggerConfig {
     @Bean
     public Docket webApiConfig(){
         return new Docket(DocumentationType.SWAGGER_2)
                 .groupName("webApi")
                 .apiInfo(webApiInfo())
                 .select()
                 .build();
     }

 private ApiInfo webApiInfo(){
     return new ApiInfoBuilder()
             .title("rabbitmq接口文档")
             .description("本文档描述了rabbitmq微服务接口定义")
             .version("1.0")
             .contact(new Contact("enjoy6288","http://atguigu.com","123456@qq.com"))
             .build();
 }
}

队列实现

配置

/*
* TTL队列 配置文件类代码
*
* */
@Configuration
public class TtlQueueConfig {


    //普通交换机的名称
    public static final String  X_EXCHANGE = "X";
    //死信交换机的名称
    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    //普通队列的名称
    public static final String QUEUE_A = "QA";
    public static final String QUEUE_B = "QB";
    //死信队列的名称
    public static final String DEAD_LATTER_QUEUE = "QD";

    //声明xExchange
    @Bean("xExchange")
    public DirectExchange xExchange(){
        return new DirectExchange(X_EXCHANGE);
    }

    //声明yExchange
    @Bean("yExchange")
    public DirectExchange yExchange(){
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }

    //声明队列
    @Bean("queueA")
    public Queue queueA(){
        Map<String, Object> arguments = new HashMap<>(3);
        //设置死信交换机
        arguments.put("x-dead-letter-exchange",Y_DEAD_LETTER_EXCHANGE);
        //设置死信Routing-key
        arguments.put("x-dead-letter-routing-key","YD");
        //设置TTL 单位是ms
        arguments.put("x-message-ttl",10000);
        return QueueBuilder.durable(QUEUE_A).withArguments(arguments).build();
    }

    //声明普通队列 TTL为40s
    @Bean("queueB")
    public Queue queueB(){
        Map<String, Object> arguments = new HashMap<>(3);
        //设置死信交换机
        arguments.put("x-dead-letter-exchange",Y_DEAD_LETTER_EXCHANGE);
        //设置死信Routing-key
        arguments.put("x-dead-letter-routing-key","YD");
        //设置TTL 单位是ms
        arguments.put("x-message-ttl",40000);
        return QueueBuilder.durable(QUEUE_B).withArguments(arguments).build();
    }

    //死信队列
    @Bean("queueD")
    public Queue queueD(){
        return QueueBuilder.durable(DEAD_LATTER_QUEUE).build();
    }

    //绑定
    @Bean
    public Binding queueABindingX(@Qualifier("queueA") Queue queueA,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queueA).to(xExchange).with("XA");
    }

    //绑定
    @Bean
    public Binding queueBBindingX(@Qualifier("queueB") Queue queueB,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queueB).to(xExchange).with("XB");
    }

    //绑定
    @Bean
    public Binding queueDBindingX(@Qualifier("queueD") Queue queueD,
                                  @Qualifier("yExchange") DirectExchange yExchange){
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }
}

消费者代码

 /*
 * 队列TTL 消费者
 * */
 @Slf4j
 @Component
 public class DeadLetterQueueConsumer {
 
     //接收消息
     @RabbitListener(queues = "QD")
     public void receiveD(Message message, Channel channel) throws Exception {
         String msg = new String(message.getBody());
         log.info("当前时间：{}，收到死信队列的消息：{}",new Date().toString(),msg);
     }
 }

生产者代码

 /*
 * 发送延迟消息
 * */
 @Slf4j
 @RestController
 @RequestMapping("/ttl")
 public class SendMsgController {
 
     @Autowired
     private RabbitTemplate rabbitTemplate;
 
     //开始发消息
     @GetMapping("/sendMsg/{message}")
     public void sendMsg(@PathVariable String message){
       log.info("当前时间：{}，发送一条信息给两个TTL队列：{}",new Date().toString(),message);
 
       rabbitTemplate.convertAndSend("X","XA","消息来自TTL为10s的队列：" + message);
       rabbitTemplate.convertAndSend("X","XB","消息来自TTL为40s的队列：" + message);
 
     }
 }

队列优化

第一条消息在10S后变成了死信消息，然后被消费者消费掉，第二条消息在40S之后变成了死信消息，然后被消费掉，这样一个延时队列就打造完成了。
不过，如果这样使用的话，岂不是每增加一个新的时间需求，就要新增一个队列，这里只有10S和40S两个时间选项，如果需要一个小时后处理，那么就需要增加TTL为一个小时的队列，如果是预定会议室然后提前通知这样的场景，岂不是要增加无数个队列才能满足需求？

配置文件类

 /*
 * TTL队列 配置文件类代码
 *
 * */
 @Configuration
 public class TtlQueueConfig {
 
 
     //普通交换机的名称
     public static final String  X_EXCHANGE = "X";
     //死信交换机的名称
     public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
     //普通队列的名称
     public static final String QUEUE_A = "QA";
     public static final String QUEUE_B = "QB";
     public static final String QUEUE_C = "QC";
     //死信队列的名称
     public static final String DEAD_LATTER_QUEUE = "QD";
 
     //声明QC队列
     @Bean("queueC")
     public Queue queueC(){
         Map<String, Object> arguments = new HashMap<>();
         //设置死信交换机
         arguments.put("x-dead-letter-exchange",Y_DEAD_LETTER_EXCHANGE);
         //设置死信RoutingKey
         arguments.put("x-dead-letter-routing-key","YD");
         return QueueBuilder.durable().withArguments(arguments).build();
     }
 
     @Bean
     public Binding queueCBindingX(@Qualifier("queueC") Queue queueC,@Qualifier("xExchange") DirectExchange xExchange){
         return BindingBuilder.bind(queueC).to(xExchange).with("XC");
     }
 
     //声明xExchange
     @Bean("xExchange")
     public DirectExchange xExchange(){
         return new DirectExchange(X_EXCHANGE);
     }
 
     //声明yExchange
     @Bean("yExchange")
     public DirectExchange yExchange(){
         return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
     }
 
     //声明队列
     @Bean("queueA")
     public Queue queueA(){
         Map<String, Object> arguments = new HashMap<>(3);
         //设置死信交换机
         arguments.put("x-dead-letter-exchange",Y_DEAD_LETTER_EXCHANGE);
         //设置死信Routing-key
         arguments.put("x-dead-letter-routing-key","YD");
         //设置TTL 单位是ms
         arguments.put("x-message-ttl",10000);
         return QueueBuilder.durable(QUEUE_A).withArguments(arguments).build();
     }
 
     //声明普通队列 TTL为40s
     @Bean("queueB")
     public Queue queueB(){
         Map<String, Object> arguments = new HashMap<>(3);
         //设置死信交换机
         arguments.put("x-dead-letter-exchange",Y_DEAD_LETTER_EXCHANGE);
         //设置死信Routing-key
         arguments.put("x-dead-letter-routing-key","YD");
         //设置TTL 单位是ms
         arguments.put("x-message-ttl",40000);
         return QueueBuilder.durable(QUEUE_B).withArguments(arguments).build();
     }
 
     //死信队列
     @Bean("queueD")
     public Queue queueD(){
         return QueueBuilder.durable(DEAD_LATTER_QUEUE).build();
     }
 
     //绑定
     @Bean
     public Binding queueABindingX(@Qualifier("queueA") Queue queueA,
                                   @Qualifier("xExchange") DirectExchange xExchange){
         return BindingBuilder.bind(queueA).to(xExchange).with("XA");
     }
 
     //绑定
     @Bean
     public Binding queueBBindingX(@Qualifier("queueB") Queue queueB,
                                   @Qualifier("xExchange") DirectExchange xExchange){
         return BindingBuilder.bind(queueB).to(xExchange).with("XB");
     }
 
     //绑定
     @Bean
     public Binding queueDBindingX(@Qualifier("queueD") Queue queueD,
                                   @Qualifier("yExchange") DirectExchange yExchange){
         return BindingBuilder.bind(queueD).to(yExchange).with("YD");
     }
 }

 /*
 * 发送延迟消息
 * */
 @Slf4j
 @RestController
 @RequestMapping("/ttl")
 public class SendMsgController {
 
     @Autowired
     private RabbitTemplate rabbitTemplate;
 
 
 
     //开始发消息
     @GetMapping("/sendMsg/{message}")
     public void sendMsg(@PathVariable String message){
       log.info("当前时间：{}，发送一条信息给两个TTL队列：{}",new Date().toString(),message);
 
       rabbitTemplate.convertAndSend("X","XA","消息来自TTL为10s的队列：" + message);
       rabbitTemplate.convertAndSend("X","XB","消息来自TTL为40s的队列：" + message);
 
     }
     //开始发消息
     @GetMapping("sendExpirationMsg/{message}/{ttlTime}")
     public void sendMsg(@PathVariable String message,@PathVariable String ttlTime){
         log.info("当前时间：{}，发送一条时长{}毫秒TTL信息给队列QC：{}",
                 new Date().toString(),ttlTime,message);
         rabbitTemplate.convertAndSend("X","XC",message,msg->{
             //发送消息的时候 延迟时长
             msg.getMessageProperties().setExpiration(ttlTime);
             return msg;
         });
     }
 }

消费者代码无需改变

插件实现延迟队列

下载延迟插件
https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases/download/3.8.9/rabbitmq_delayed_message_exchange-3.8.9-0199d11c.ez

将延迟插件放到RabbitMQ的插件目录下：

安装插件并重启服务

 rabbitmq-plugins enable rabbitmq_delayed_message_exchange
 systemctl restart rabbitmq-server

配置文件类

 @Configuration
 public class DelayedQueueConfig {

 //队列
 public static final String DELAYED_QUEUE_NAME = "delayed.queue";
 //交换机
 public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
 //routingKey
 public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";

 //声明队列
 @Bean
 public Queue delayedQueue(){
   return new Queue(DELAYED_QUEUE_NAME);
 };



 //声明交换机
 @Bean
 public CustomExchange delayedExchange(){

     Map<String, Object> arguments = new HashMap<>();
     arguments.put("x-delayed-type","direct");

     return new CustomExchange(DELAYED_EXCHANGE_NAME,"x-delayed-message",
             true,false,arguments);
 }
 //绑定
 @Bean
 public Binding delayedQueueBindingDelayedExchange(@Qualifier("delayedQueue") Queue delayedQueue,
                                                   @Qualifier("delayedExchange") CustomExchange delayedExchange){
     return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
 }
}

 // 消费者代码 基于插件的延迟消息
 @Slf4j
 @Component
 public class DelayQueueConsumer {

 //监听消息
 @RabbitListener(queues = DelayedQueueConfig.DELAYED_QUEUE_NAME)
 public void recieveDelayQueue(Message message){
     String msg = new String(message.getBody());
     log.info("当前时间：{}，收到延迟队列的消息：{}",new Date().toString(),msg);
 }
}

 /*
 * 发送延迟消息
 * */
 @Slf4j
 @RestController
 @RequestMapping("/ttl")
 public class SendMsgController {
 
     @Autowired
     private RabbitTemplate rabbitTemplate;
 
     //开始发消息 基于插件的 消息 及 延迟的时间
     @GetMapping("/sendDelayMsg/{message}/{delayTime}")
     public void sendMsg(@PathVariable String message,@PathVariable Integer delayTime){
         log.info("当前时间：{}，发送一条时长{}毫秒信息给延迟队列delayed.queue：{}",
                 new Date().toString(),delayTime,message);
         rabbitTemplate.convertAndSend(DelayedQueueConfig.DELAYED_EXCHANGE_NAME
                 ,DelayedQueueConfig.DELAYED_ROUTING_KEY,message,msg -> {
             // 发送消息的时候 延迟时长 单位ms
             msg.getMessageProperties().setDelay(delayTime);
             return msg;
                 });
     }
 }

总结：
延时队列在需要延时处理的场景下非常有用，使用RabbitMQ来实现延时队列可以很好的利用；
RabbitMQ的特性，如:消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正确处理的消息不会被丢弃。另外，通过RabbitMQ集群的特性，可以很好的解决单点故障问题，不会因为单个节点挂掉导致延时队列不可用或者消息丢失；
当然，延时队列还有很多其它选择，比如利用Java的DelayQueue，利用Redis的zsset，利用Quartz或者利用kafka的时间轮，这些方式各有特点,看需要适用的场景。

发布确认高级

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

配置文件

配置文件及消息发送方

NONE：禁用发布确认模式，是默认值
CORRELATED：发布消息成功到交换器后会触发回调方法
SIMPLE：经测试有两种效果，其一效果和CORRELATED值一样会触发回调方法，
其二在发布消息成功后使用rabbitTemplate调用waitForConfirms,或 waitForConfirmsOrDie方法
等待broker节点返回发送结果，根据返回结果来判定下一步的逻辑，
要注意的点是waitForConfirmsOrDiea方法如果返回false则会关闭channel，
则接下来无法发送消息到broker

spring.rabbitmq.publisher-confirm-type = correlated

// 配置类：发布确认（高级）
@Configuration
public class ConfirmConfig {

    //交换机
    public static final String CONFIRM_EXCHANGE_NAME = "confirm_exchange";
    //队列
    public static final String CONFIRM_QUEUE_NAME = "confirm_queue";
    //RoutingKey
    public static final String CONFIRM_routing_key = "key1";

    //声明交换机
    @Bean
    public DirectExchange confirmExchange(){
        return new DirectExchange(CONFIRM_EXCHANGE_NAME);
    }

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

    //绑定
    @Bean
    public Binding queueBindingExchange(@Qualifier("confirmQueue") Queue confirmQueue,
                                        @Qualifier("confirmExchange")DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_routing_key);
    }
}

生产者

 // 开始发消息 测试确认
 @RestController
 @Slf4j
 @RequestMapping("/confirm")
 public class ProducerController {

 @Autowired
 private RabbitTemplate rabbitTemplate;

 //发消息
 @GetMapping("/sendMessage/{message}")
 public void sendMessage(@PathVariable String message){
     CorrelationData correlationData = new CorrelationData("1");
     rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE_NAME
             ,ConfirmConfig.CONFIRM_routing_key
             ,message,correlationData);
     log.info("发送消息内容：{}",message);
 }
}

消费者

 // 接收消息
 @Slf4j
 @Component
 public class Consumer {

 @RabbitListener(queues = ConfirmConfig.CONFIRM_QUEUE_NAME)
 public void receiveConfirmMessage(Message message){
     String msg = new String(message.getBody());
     log.info("接受到的队列confirm.queue消息：{}",msg);
 }
}

回调接口

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

 @Autowired
 private RabbitTemplate rabbitTemplate;

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

 /*
 * 交换机确认回调方法,发消息后，交换机接收到了就回调
 *   1.1 correlationData：保存回调消息的ID及相关信息
 *   1.2 b:交换机收到消息，为true
 *   1.3 s:失败原因，成功为null
 *
 * 发消息，交换机接受失败，也回调
 *   2.1 correlationData：保存回调消息的ID及相关信息
 *   2.2 b:交换机没收到消息，为false
 *   2.3 s:失败的原因
 *
  * */

 @Override
 public void confirm(CorrelationData correlationData, boolean b, String s) {
     String id = correlationData!=null ? correlationData.getId():"";
     if (b){
         log.info("交换机已经收到ID为：{}的信息",id);
     }else {
         log.info("交换机还未收到ID为：{}的消息，由于原因：{}",id,s);
     }
   }
 }

回退消息

在仅开启了生产者确认机制的情况下，交换机接收到消息后，会直接给消息生产者发送确认消息，如果发现该消息不可路由，那么消息会被直接丢弃，此时生产者是不知道消息被丢弃这个事件的。那么如何让无法被路由的消息帮我想办法处理一下?最起码通知我一声，我好自己处理啊。通过设置mandatory参数可以在当消息传递过程中不可达目的地时将消息返回给生产者。

配置类

spring.rabbitmq.publisher-returns=true

回退接口

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

 @Autowired
 private RabbitTemplate rabbitTemplate;

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

 /*
 * 交换机确认回调方法,发消息后，交换机接收到了就回调
 *   1.1 correlationData：保存回调消息的ID及相关信息
 *   1.2 b:交换机收到消息，为true
 *   1.3 s:失败原因，成功为null
 *
 * 发消息，交换机接受失败，也回调
 *   2.1 correlationData：保存回调消息的ID及相关信息
 *   2.2 b:交换机没收到消息，为false
 *   2.3 s:失败的原因
 *
  * */

 @Override
 public void confirm(CorrelationData correlationData, boolean b, String s) {
     String id = correlationData!=null ? correlationData.getId():"";
     if (b){
         log.info("交换机已经收到ID为：{}的信息",id);
     }else {
         log.info("交换机还未收到ID为：{}的消息，由于原因：{}",id,s);
     }
 }

 //可以在当消息传递过程中不可达目的的时将消息返回给生产者
 //只有不可达目的地的时候才可回退
 @Override
 public void returnedMessage(ReturnedMessage returnedMessage) {
     log.error("消息{}，被交换机{}退回，退回的原因：{},路由Key：{}",
             new String(returnedMessage.getMessage().getBody())
             , returnedMessage.getExchange()
             , returnedMessage.getReplyText()
             , returnedMessage.getRoutingKey());
   }
 }

发布测试

 // 开始发消息 测试确认
 @RestController
 @Slf4j
 @RequestMapping("/confirm")
 public class ProducerController {

 @Autowired
 private RabbitTemplate rabbitTemplate;

 //发消息
 @GetMapping("/sendMessage/{message}")
 public void sendMessage(@PathVariable String message){
     CorrelationData correlationData = new CorrelationData("1");
     rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE_NAME
             ,ConfirmConfig.CONFIRM_routing_key
             ,message+"key1",correlationData);
     log.info("发送消息内容：{}",message+"key1");

     CorrelationData correlationData2 = new CorrelationData("2");
     rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE_NAME
             ,ConfirmConfig.CONFIRM_routing_key+"2"
             ,message+"key12",correlationData2);
     log.info("发送消息内容：{}",message+"key12");
 }
}