RabbitMQ消息中间件

docker run -d -e RABBITMQ_DEFAULT_USER=root -e RABBITMQ_DEFAULT_PASS=123456 -v rabbitmq-plugins:/pligins --name rabbitmq --hostname rabbitmq -p 15672:15672 -p5672:5672 rabbitmq:3.8-management

-d 以守护方式后台运行；

--name 指定容器名；

-p 指定服务运行的端口（5672：应用访问端口；15672：控制台Web端口号）；

-v 映射目录或文件；

--hostname 主机名（RabbitMQ的一个重要注意事项是它根据所谓的 “节点名称” 存储数据，默认为主机名）；

-e 指定环境变量；

(RABBITMQ_DEFAULT_USER：默认的用户名；RABBITMQ_DEFAULT_PASS：默认用户名的密码）

2.3.4查看启动后的容器

docker ps -a

2.3.5访问RabbitMQ管理界面

http://ip:15672

账号:root

密码:123456

2.3.6注意事项

Linux服务器检查防火墙是否关闭

1.查看防火墙状态

systemctl status firewalld

2.关闭防火墙

systemctl stop firewalld

3.开启防火墙

systemctl start firewalld

2.4RabbitMQ的web控制台

每个虚拟主机默认有7个交换机

3.Java项目创建整合RabbitMQ

3.1创建maven工程

注意:jdk的版本号！！！！

3.2导入依赖

    <!--jdk的编译版本-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <!--rabbitmq依赖客户端-->
    <dependencies>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.10.0</version>
        </dependency>
    </dependencies>

3.3消息生产者

3.3.1代码实现:

/**
 * 生产者
 */
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.20.139");
        //设置用户名+密码
        factory.setUsername("root");
        factory.setPassword("123456");

        //创建连接
        Connection connection = factory.newConnection();
        //获取信道
        Channel channel = connection.createChannel();
        /**
         * 创建一个队列
         * args含义:
         * 1.队列名称
         * 2.队列面的消息是否持久化，默认情况下消息存储在内存中
         * 3.该队列是否直供一个消费者消费，是否进行消息的共享，true可以多个消费者消费,false只能一个消费者消费
         * 4.是否自动删除最后一个消费者断开连接以后，该队列是否自动删除，true自动删除，false不自动删除
         * 5.其他参数
         */
        channel.queueDeclare(QUEUE_NAME, true,false,false,null);

        //发消息
        String message="hello,RabbitMQ";

        /**
         * 发送一个消息
         * args含义:
         * 1.发送到那个交换机
         * 2.路由的key值是哪个 本次是队列名称
         * 3.其他参数信息
         * 4.发送的消息的消息体(二进制)
         */
        channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
        System.out.println("消息发送完毕");
    }
}

3.3.2web页面

3.4消息消费者

3.4.1代码实现

/**
 * 消费者:接收消息
 */
public class Consumer {
    //队列名称-->与生产者保持一致
    public static final String QUEUE_NAME="hello";

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

        //设置ip
        factory.setHost("192.168.20.139");

        //账户+密码
        factory.setUsername("root");
        factory.setPassword("123456");
        //创建连接
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();


        //声明 接收消息
        DeliverCallback deliverCallback=(String consumerTag, Delivery delivery)->{
            //避免接收到消息地址，转换String接受消息体
            String message=new String(delivery.getBody());
            System.out.println(message);

        };

        //取消消息的回调
        CancelCallback cancelCallback=(String var1)->{
            System.out.println("消息消费被中断");
        };
        /**
         * 消费者:接收消息
         * args含义:
         * 1.消费哪个队列
         * 2.消费成功之后，是否自动应答；true自动应答 false手动应答
         * 3.消费者未成功消费的回调
         * 4.消费者取消消费的回调
         */
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);

    }
}

3.4.2web页面

4.Work Queues

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

4.1轮训分发消息

案例中启动两个工作线程，一个消息发送线程。

4.1.1抽取工具类

/**
 * 为连接工厂创建信道的工具类
 */
public class RabbitMQUtils {
    //得到一个连接的channel
    public static Channel getChannel() throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.20.143");
        factory.setUsername("root");
        factory.setPassword("123456");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        return channel;
    }
}

4.1.2启动两个工作线程

第一个工作线程

/**
 * 这是一个工作线程(等价于消费者)
 */
public class Worker01 {
    public static final String QUEUE_NAME = "work";

    //接受消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //调取工具类里面的信道
        Channel channel = RabbitMQUtils.getChannel();


        //消息接受
        DeliverCallback deliverCallback = (String var1, Delivery var2) -> {
            String message = new String(var2.getBody());
            System.out.println("接收到的消息:" + message);
        };

        //消息接受被取消时接受下面的内容
        CancelCallback cancelCallback = (String var1) -> {
            System.out.println(var1+"消息被取消");
        };

        //表明身份
        System.out.println("x1等待接收消息....");
        //消息的接受
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
    }
}

第二个线程（与第一个工作线程没有本质区别）

/**
 * 这是二个工作线程(等价于消费者)
 */
public class Worker02 {
    public static final String QUEUE_NAME = "work";

    //接受消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //调取工具类里面的信道
        Channel channel = RabbitMQUtils.getChannel();


        //消息接受
        DeliverCallback deliverCallback = (String var1, Delivery var2) -> {
            String message = new String(var2.getBody());
            System.out.println("接收到的消息:" + message);
        };

        //消息接受被取消时接受下面的内容
        CancelCallback cancelCallback = (String var1) -> {
            System.out.println(var1+"消息被取消");
        };

        //表明身份
        System.out.println("x2等待接收消息....");
        //消息的接受
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
    }
}

4.1.3创建生产者

/**
 * 生产者
 */
public class Task01 {
    public static final String QUEUE_NAME = "work";

    //发送消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();
        /**
         * 创建一个队列
         * args含义:
         * 1.队列名称
         * 2.队列面的消息是否持久化，默认情况下消息存储在内存中
         * 3.该队列是否直供一个消费者消费，是否进行消息的共享，true可以多个消费者消费,false只能一个消费者消费
         * 4.是否自动删除最后一个消费者断开连接以后，该队列是否自动删除，true自动删除，false不自动删除
         * 5.其他参数
         */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //从控制台接收信息

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String message = scanner.next();
            System.out.println("你的消息体["+message+"]");
            /**
             * 发送一个消息
             * args含义:
             * 1.发送到那个交换机
             * 2.路由的key值是哪个 本次是队列名称
             * 3.其他参数信息
             * 4.发送的消息的消息体(二进制)
             */
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println("发送[" + message + "]消息完成");
        }
    }
}

4.1.4控制台打印结果

4.1.5轮训总结

1.先启动两个消费者，在启动生产者

2.缺点:存在不部分节点消费过快，部分节点消费慢，导致不能合理处理消息

4.2消息应答

4.2.1概念

消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅完成了部分然后它突然挂掉。RabbitMQ一旦向消费者传递了一条消息，便立即将该消息标记为删除。在这种情况下，突然有消费者挂掉，我们将丢失正在处理的消息，以及后续发送给该消费者的消息，因为他无法接受消息。

消息应答:保证了消息再发送过程中不丢失；消费者在接到消息并处理该消息之后，告诉RabbitMQ他已经处理了，RabbitMQ可以把消息删除了。

4.2.2自动应答

消息发送后立即被认为已经传送成功，这种模式需要在高吞吐量和数据传输安全性方面做权衡。所以这中模式仅适用在消费者可以高效并以某种速率能够处理这些消息的情况下使用。

4.2.3手动应答

4.2.3.1手动应答的好处

可以批量应答并且减少网络拥堵

4.2.3.2消息应答的方法

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

2.channel.basicNack();用于否定确认，

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

4.2.4Multiple的解释

第二个参数代表：Multiple

4.2.4.1true

代表批量应答channel上为应答的消息。eg：channel上传送tag的消息1，2，3，4，当前tag是4那么此时1-4的这些还未应答的消息都会被确认收到消息应答。

4.2.4.2false

同上相比，只会应答tag=4的消息，1，2，3这三个消息依然不会被确认收到消息应答。

4.2.5消息自动重新入队

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

4.2.6消息手动应答代码

4.2.6.1生产者

/**
 * 消息在手动应答时不丢失，放回队列中重新消费
 */
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("utf-8"));
            System.out.println("生产者发出消息:"+message);
        }
    }

}

4.2.6.2消费者1

/**
 * 消息在手动应答时不丢失，放回队列中重新消费
 */
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("c1等待接收消息处理时间短~");

        //采用手动应答接受消息
        DeliverCallback deliverCallback = (String consumerTag, Delivery message) -> {
            //沉睡1秒
            SleepUtils.sleep(1);
            System.out.println("接收到的消息:" + new String(message.getBody(), "utf-8"));
            //手动应答
            /**
             * 参数含义
             * 1.消息的标记tag
             * 2.是否批量应答信道中的消息
             */
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);

        };
        //
        CancelCallback cancelCallback=(String var1)->{
            System.out.println(var1+"消费者取消消费");
        };

        //false:采取手动应答
        channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback,cancelCallback);

    }
}

4.2.6.3消费者2

/**
 * 消息在手动应答时不丢失，放回队列中重新消费
 */
public class Worker04 {

    //队列名
    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 = (String consumerTag, Delivery message) -> {
            //沉睡1秒
            SleepUtils.sleep(30);
            System.out.println("接收到的消息:" + new String(message.getBody(), "utf-8"));
            //手动应答
            /**
             * 参数含义
             * 1.消息的标记tag
             * 2.是否批量应答信道中的消息
             */
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);

        };
        //
        CancelCallback cancelCallback=(String var1)->{
            System.out.println(var1+"消费者取消消费");
        };

        //false:采取手动应答
        channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback,cancelCallback);

    }
}

4.2.7控制台结果

4.2.7.1c1和c2都正常

4.2.7.2c2挂掉

在c2睡眠过程中，终止它，生产发出的消息会被c1处理，不会造成消息的丢失

4.3RabbitMQ的持久化

4.3.1概念

确保消息不会不丢失需要做两件事：需要将队列和消息都标记为持久化。

4.3.2队列实现持久化

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

但是，运行时会报错

解决办法：删除原先的队列

接着运行发现大写的D,说明持久化成功

4.3.3消息实现持久化

让消息实现持久化，添加MessageProperties.PERSISENT_TEXT_PLAIN

channel.basicPublish("", queueName, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());

4.3.4不公平分发

RabbitMQ分发消息采用的轮训分发，当消费者1处理任务十分快，消费者2处理任务很慢，就会导致消费者1大部分时间处于空闲，而消费者2一直在干活，这种分配方式很不友好。

为了避免上述情况，消费者设置参数channel.basicQos(1);

 //不公平分发
        channel.basicQos(1);

这样就形成了能者多劳！

4.3.5预取值

提前设定消费者处理消息的数量

5.发布确认

5.1发布确认原理

是一个保证RabbitMQ可靠性的一个机制！！！

生产者将信道a设置成confirm模式,所有在该信道上发布的消息都会指定一个唯一的ID,一旦消息投递到队列中,就是发送成功了, broker会立刻发送一个确认ack给生产者,这个时候,生产者就知道消息已经发送成功了。

如果队列和信息是持久化的，那么确认消息会在将消息写入磁盘之后再发出，broker返回的确认包含确认消息的序列号,还可以设置 multiple,表示此序号前的所有消息都得到了处理。

保证可靠性需要三步：

1.设置要求队列必须持久化

2.设置要求队列中的消息必须持久化

3.发布确认,保证写到磁盘

5.2开启发布确认的方法

发布确认默认是没有开启的，如果需要开启需要调用confirmSelect，每当要使用发布确认，都要在channel上调用该方法注：在发消息之前开启！！！信道channel创建之后

//开启发布确认
        channel.confirmSelect();

5.3 单个确认发布

这一种简单的确认方式，它是一种 同步确认发布的方式。(发布一个消息之后只有他被确认发布，后续的消息才能继续发布）

缺点:发布速度慢

5.3.2代码实现


public class ConfirmMessage {

    //批量发消息的个数
    public static final int MESSAGE_COUNT=1000;

    public static void main(String[] args) throws Exception {
        //  1.单个确认
        publishMessageIndividually();
    }

    /**
     * 单个确认
     */
    public static void publishMessageIndividually() throws Exception {

        //创建信道
        Channel channel = RabbitMQUtils.getChannel();


        //队列名的创建
        String queueName = UUID.randomUUID().toString();


        //创建一个队列
        channel.queueDeclare(queueName,true,false,false,null);

        //开启确认发布
        channel.confirmSelect();

        //记录开始的时间
        long startTime = System.currentTimeMillis();

        //批量发消息
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message=i+"";
            channel.basicPublish("",queueName,MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
            //单个消息发布确认
            boolean flag = channel.waitForConfirms();
            if (flag){
                System.out.println("消息发送成功~");
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("发布"+MESSAGE_COUNT+"个单独确认消息，耗时"+(endTime-startTime)+"ms");
    }

}

5.4批量确认发布


public class ConfirmMessage {

    //批量发消息的个数
    public static final int MESSAGE_COUNT = 1000;

    public static void main(String[] args) throws Exception {
        //批量确认
        publishMessageBatch();
    }
 /**
     * 批量发布确认
     */
    public static void publishMessageBatch() throws Exception {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

        //创建队列名
        String queueName = UUID.randomUUID().toString();

        //创建队列
        channel.queueDeclare(queueName, true, false, false, null);

        //开启确认发布
        channel.confirmSelect();

        //开始时间
        long startTime = System.currentTimeMillis();

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

        for (int i = 0; i < MESSAGE_COUNT; i++) {
            //消息体
            String Message = i + "";
            //发消息
            channel.basicPublish("", queueName, MessageProperties.PERSISTENT_TEXT_PLAIN, Message.getBytes());

            //判断达到100条消息的时候，批量确认一次
            if (i % 100 == 0) {
                //发布确认
                channel.waitForConfirms();
            }
        }

        //结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("发布" + MESSAGE_COUNT + "个批量确认消息，耗时" + (endTime - startTime) + "ms");
    }


}

5.5异步确认发布

异步确认逻辑上较上面两个要复杂，但是性价比最高，他是利用回调函数来达到消息的可靠性传递的，这个中间件也是通过函数回调来保证是否投递成功的。

5.5.1代码实现

public class ConfirmMessage {

    //批量发消息的个数
    public static final int MESSAGE_COUNT = 1000;

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

    /**
     * 批量发布确认
     */
    public static void publishMessageBatch() throws Exception {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

        //创建队列名
        String queueName = UUID.randomUUID().toString();

        //创建队列
        channel.queueDeclare(queueName, true, false, false, null);

        //开启确认发布
        channel.confirmSelect();

        //开始时间
        long startTime = System.currentTimeMillis();

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

        for (int i = 0; i < MESSAGE_COUNT; i++) {
            //消息体
            String Message = i + "";
            //发消息
            channel.basicPublish("", queueName, MessageProperties.PERSISTENT_TEXT_PLAIN, Message.getBytes());

            //判断达到100条消息的时候，批量确认一次
            if (i % 100 == 0) {
                //发布确认
                channel.waitForConfirms();
            }
        }

        //结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("发布" + MESSAGE_COUNT + "个批量确认消息，耗时" + (endTime - startTime) + "ms");
    }

    /**
     * 异步发布确认
     */
    public static void publishMessageAsync() throws Exception {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

        //创建队列名
        String queueName = UUID.randomUUID().toString();

        //创建队列
        channel.queueDeclare(queueName, true, false, false, null);

        //开启发布确认
        channel.confirmSelect();

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


        /**
         * 消息确认成功回调函数
         * 参数含义
         * 1.消息的标记
         * 2.是否为批量确认
         */
        ConfirmCallback ackCallback = (long deliverTag, boolean multiple) -> {
            //如果批量删除
            if (multiple){
                //第二步：删除掉已经确认的消息 剩下的就是未确认的消息
                ConcurrentNavigableMap<Long, String> confirmed = outstandingConfirms.headMap(deliverTag);
                confirmed.clear();
            }else{
                //不批量删除
                outstandingConfirms.remove(deliverTag);
            }
        };
        /**
         * 消息确认失败回调函数
         * 参数含义
         * 1.消息的标记
         * 2.是否为批量确认
         */
        ConfirmCallback nackCallback = (long deliverTag, boolean multiple) -> {
            //第三步: 打印未确认的消息
            String message = outstandingConfirms.get(deliverTag);
            System.out.println("未确认的消息是:" + message+",他的标记:"+deliverTag);
        };

        /**
         * 准备监听器，监听哪些消息成功了，哪些消息失败了
         * 1.哪些消息成功
         * 2.哪些消息失败
         */

        channel.addConfirmListener(ackCallback, nackCallback);// 异步监听

        //记录开始时间
        long startTime = System.currentTimeMillis();

        //批量发送消息
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            //获取消息体
            String message = "消息:" + i;
            channel.basicPublish("", queueName, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
            //第一步记录所有要发的消息总和
            outstandingConfirms.put(channel.getNextPublishSeqNo(),message);
        }


        //结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("发布" + MESSAGE_COUNT + "个异步确认消息，耗时" + (endTime - startTime) + "ms");


    }
}

5.5.2处理异步未确认消息

把未确认的消息放到一个基于内存的能被发布线程访问的队列，比如ConcurrentLinkedQueue这个队列在confim callbacks与发布线程之间进行消息的传递

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

1.第一步:记录所有要发的消息

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

2.删除已经确认的消息，剩下的就是为确认的消息

        /**
         * 消息确认成功回调函数
         * 参数含义
         * 1.消息的标记
         * 2.是否为批量确认
         */
        ConfirmCallback ackCallback = (long deliverTag, boolean multiple) -> {
            //如果批量删除
            if (multiple){
                //第二步：删除掉已经确认的消息 剩下的就是未确认的消息
                ConcurrentNavigableMap<Long, String> confirmed = outstandingConfirms.headMap(deliverTag);
                confirmed.clear();
            }else{
                //不批量删除
                outstandingConfirms.remove(deliverTag);
            }
        };

3.打印未确认的消息

       /**
         * 消息确认失败回调函数
         * 参数含义
         * 1.消息的标记
         * 2.是否为批量确认
         */
        ConfirmCallback nackCallback = (long deliverTag, boolean multiple) -> {
            //第三步: 打印未确认的消息
            String message = outstandingConfirms.get(deliverTag);
            System.out.println("未确认的消息是:" + message+",他的标记:"+deliverTag);
        };

4.准备监听器

   /**
         * 准备监听器，监听哪些消息成功了，哪些消息失败了
         * 1.哪些消息成功
         * 2.哪些消息失败
         */

        channel.addConfirmListener(ackCallback, nackCallback);// 异步监听

5.5.3三种发布确认速度比对

1.单独发布消息:同步等待确认，简单，但吞吐量非常有限。

2.批量发布消息:批量同步等待确认，简单，合理的吞吐量。一旦出现问题，很难判断是哪条消息出现了问题。

3.异步发布消息:最佳资源和性能使用，并且能判断是哪条消息出现了问题，但逻辑较为复杂。

6.交换机

将消息传达给多个消费者，这种模式叫“发布/订阅”

6.1Exchanges

6.1.1Exhcanges概念

RabbitMQ消息传递模型的核心思想是：生产者生产的消息从不会直接发送到队列。实际上，生产者甚至都不知道这些消息传递到了哪些队列中。

生产者只能将消息发送给交换机，交换机工作内容:一方面接受来自生产者的消息，另一方面将他们推入队列。交换机必须明确知道如何处理收到的消息，把消息放到特定的队列还是说把他们放到许多队列还是说丢弃他们，这就由交换机的类型决定。

6.1.2Exchanges的类型

直接(direct)（路由）,主题(topic),标题(headers),扇出(fanout)

6.1.3无名exchanges

之前我们使用的是默认交换机，我们通过空字符串进行标识

 channel.basicPublish("",QUEUE_NAME,null,message.getBytes());

第一个参数是交换机，空字符串表示默认或者无名交换机:消息能路由发送到队列中，其实是由rountingKey(bindingKey)绑定的key指定的。

6.2临时队列

每当我们连接到RabbitMQ，都需要一个全新的空队列，为此我们可以创建一个具有随即名称的队列，或者让服务器为我们选择一个随机队列名称。其次，一旦我们断开消费者连接，队列将被自动删除。

创建临时队列的方式:

String queue = channel.queueDeclare().getQueue();

6.3绑定(bindings)

binding其实就是Exchange和Queue之间的桥梁，他告诉exchange和哪个队列进行了绑定关系。

6.4Fanout

将接收到的所有消息广播到他知道的所有队列中。

6.4.1Fanout实战

生产者代码:

public class EmitLog {
    //交换机名字
    public static final String EXCHANGE_NAME="logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");

        while (true){
            Scanner scanner=new Scanner(System.in);
            System.out.println("请输入:");
            String message = scanner.next();
            channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes("utf-8"));
            System.out.println("发出消息:"+message);
        }
    }

}

消费者1代码：

public class ReceiveLogs01 {

    //交换机名称
    public static final String EXCHANGE_NAME = "logs";


    public static void main(String[] args) throws IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        //声明一个临时队列
        /**
         * 生成一个临时队列，队列的名称是随机的
         * 当消费者断开与队列的连接的时候队列就自动删除
         */
        String queueName = channel.queueDeclare().getQueue();

        /**
         * 绑定交换机与队列
         * 1.队列名称
         * 2.交换机名称
         * 3.绑定信息
         */
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        System.out.println("等待接收消息~，打印控制台......");

        //接收消息
        DeliverCallback deliverCallback = (String var1, Delivery var2) -> {
            System.out.println("消费者1消息:"+new String(var2.getBody(),"utf-8"));
        };

        //取消消息
        CancelCallback cancelCallback = (String var1) -> {
            System.out.println("接收消息失败");
        };

        //接收消息
        channel.basicConsume(queueName, true, deliverCallback, cancelCallback);
    }
}

消费者2代码：

public class ReceiveLogs02 {

    //声明交换机名称
    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        // 声明一个临时队列
        String queueName = channel.queueDeclare().getQueue();

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

        System.out.println("等待接收消息~，打印控制台......");

        //接收消息
        DeliverCallback deliverCallback = (String var1, Delivery var2) -> {
            System.out.println("消费者2消息:" + new String(var2.getBody(), "utf-8"));
        };

        //接收消息失败
        CancelCallback cancelCallback = (String var1) -> {
            System.out.println("接收消息失败");
        };

        //接收消息
        channel.basicConsume(queueName, true, deliverCallback, cancelCallback);


    }
}

运行结果：

结果：生产者发出一条消息，消费者1和消费者2都能收到消息~

6.5Direct Exchange

消息只去到他绑定的rountingKey队列中去

生产者发布消息到交换机，绑定键为orange的消息会被发布到队列Q1，绑定键为blackk/green的消息会被发布到队列Q2，其他消息类型将被丢弃。

6.5.1Direct实战

消费者1:

public class ReceiveLogsDirect01 {

    //交换机名字
    public static final String EXCHANGE_NAME="direct_logs";

    //队列名字
    public static final String QUEUE_NAME="console";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取信道
        Channel channel = RabbitMQUtils.getChannel();

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

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

        //交换机与队列捆绑
        /**
         * 1.队列的名字
         * 2.交换机的名字
         * 3.Routing key
         */
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"info");
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"warning");

        //接收消息
        DeliverCallback deliverCallback=(String var1, Delivery var2)->{
            System.out.println("direct01消息:"+new String(var2.getBody()));
        };

        //接受消息失败
        CancelCallback cancelCallback=(String var1)->{
            System.out.println("接收消息失败");
        };

        //
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);


    }
}

消费者2：

public class ReceiveLogsDirect02 {
    //交换机名字
    public static final String EXCHANGE_NAME="direct_logs";
    //队列名字
    public static final String QUEUE_NAME="disk";

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

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

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

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

        //接收消息函数
        DeliverCallback deliverCallback=(String var1, Delivery var2)->{
            System.out.println("direct02消息:"+new String(var2.getBody()));
        };

        //接受消息取消
        CancelCallback cancelCallback=(String var1)->{
            System.out.println("接收消息失败");
        };
        //接收消息
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}

生产者：

public class DirectLogs {
    //声明交换机
    public static final String EXCHANGE_NAME="direct_logs";

    //发消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

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

        //发消息
        while (true){
            Scanner scanner=new Scanner(System.in);
            System.out.println("请输入内容:");
            String message = scanner.next();
            channel.basicPublish(EXCHANGE_NAME,"error",null,message.getBytes("utf-8"));
        }
    }
}

6.6Topics

6.6.1 Topics的要求

发送到类型是topic交换机的消息routing_key不能随意写，他必须是一个单词列表，以点号分隔开。

*:可以替代一个单词

#:可以替代零个或多个单词

eg: quick.orange.rabbit ------------被队列Q1和Q2接收

lazy.orangee.elephant -------------被队列Q1和Q2接收

quick.orange.fox -------------被队列Q1接收

lazy.brown.fox --------------被队列Q2接收

quick.brown.fox --------------不匹配任何绑定会被丢弃

注意: 当一个队列绑定的键是#，那么这个队列将接受所有数据，有点像fanout了

如果队列绑定键当中没有#和*出现，那么该队列类型就是dirrect了

6.6.2实战

消费者1

public class ReceiveLogsTopic01 {
    //交换机名字
    public static final String EXCHANGE_NAME="topic_logs";

    //队列名名字
    public static final String QUEUE_NAME="Q1";

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

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

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

        //队列与交换机绑定
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"*.orange.*");
        System.out.println("等待接收消息......");

        //消息接收
        DeliverCallback deliverCallback=(String var1, Delivery var2)->{
            System.out.println("topic01消息:"+new String(var2.getBody(),"utf-8"));
            System.out.println("接收队列:"+QUEUE_NAME+",绑定键:"+var2.getEnvelope().getRoutingKey());
        };
        //消费者取消消息
        CancelCallback cancelCallback=(String var1)->{
            System.out.println("接受消息失败");
        };

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

消费者2

public class ReceiveLogsTopic02 {
    //交换机名字
    public static final String EXCHANGE_NAME = "topic_logs";

    //队列名字
    public static final String QUEUE_NAME="Q2";
    //接收消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //队列与交换机绑定
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"*.*.rabbit");
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"lazy.#");

        System.out.println("等待接收消息.....");

        //接受消息
        DeliverCallback deliverCallback=(String var1, Delivery var2)->{
            System.out.println("topic02消息:"+new String(var2.getBody(),"utf-8"));
            System.out.println("接收队列:"+QUEUE_NAME+",绑定键:"+var2.getEnvelope().getRoutingKey());
        };
        //消费者取消接收消息
        CancelCallback cancelCallback=(String var1)->{
            System.out.println("接收消息失败");
        };
        //接收消息
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}

生产者

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

    //发消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取信道
        Channel channel = RabbitMQUtils.getChannel();


        String[] bindingKey = new String[]{"quick.orange.rabbit", "lazy.orange.elephant",
                "quick.orange.fox", "lazy.brown.fox", "quick.brown.fox"};
        //发消息
        for (int i = 0; i < bindingKey.length; i++) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入:");
            String message = scanner.next();
            channel.basicPublish(EXCHANGE_NAME, bindingKey[i], null, message.getBytes("utf-8"));
            System.out.println("生产者发出消息:"+message);
        }

    }
}

结果:

7.死信队列

7.1死信概念

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

应用场景

为了保证订单业务消息数据不丢失，需要用到RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中。

7.2死信的来源

1.消息TTL过期（存活时间）

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

3.消息被拒绝

7.3实战

7.3.1TTL过期

消费者1

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 IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

        //声名普通交换机和死信交换机，类型为direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        //声明普通队列
        Map<String, Object> map = new HashMap<>();
        //过期时间(发消息时设置)

        //正常队列设置死信交换机是谁
        map.put("x-dead-letter-exchange", DEAD_EXCHANGE);

        //设置死信RoutingKey
        map.put("x-dead-letter-routing-key", "lisi");

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


        //声明死信队列
        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 = (String var1, Delivery var2) -> {
            System.out.println("c1接受的消息:" + new String(var2.getBody(), "utf-8"));
        };

        //不接受消息回调
        CancelCallback cancelCallback = (String var1) -> {
            System.out.println("消息接受失败");
        };
        //接收消息
        channel.basicConsume(NORMAL_QUEUE, true, deliverCallback, cancelCallback);
    }
}

生产者

public class Producer {
    //声明普通交换机
    public static final String NORMAL_EXCHANGE = "normal_exchange";

    //发消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();
        //发消息  延迟或死信
        //设置TTL时间10s
        AMQP.BasicProperties properties=new AMQP.BasicProperties().builder().expiration("10000").build();

        for (int i = 1; i <11 ; i++) {
            String message="消息:"+i;
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",properties,message.getBytes());

        }
    }

}

消费者2

public class Consumer02 {
    //声明死信交换机
    public static final String DEAD_EXCHANGE = "dead_exchange";
    //声明死信队列
    public static final String DEAD_QUEUE = "dead_queue";

    //接收消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

        //声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        //声明死信队列
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //绑定队列和交换机
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");
        System.out.println("等待接收消息......");

        //接受消息
        DeliverCallback deliverCallback=(String var1, Delivery var2)->{
            System.out.println("c2接收消息:"+new String(var2.getBody(),"utf-8"));
        };
        //接收消息失败
        CancelCallback cancelCallback=(String var1)->{
            System.out.println("接收消息失败");
        };
        //接收消息
        channel.basicConsume(DEAD_QUEUE,true,deliverCallback,cancelCallback);
    }
}

总结：先启动消费者1，创建交换机和队列，然后停止他，模拟消息发送失败成为死信，

<---- 生产者发消息，在启动消费者2，正常接收消息---->

注意：普通交换机和普通队列，死信交换机与死信队列的捆绑，以及普通队列和死信交换机的关机，发生在消费者1里面。

7.3.2队列达到最大长度

消费者1

public class Consumer001 {
    //普通交换机名字
    public static final String NORMAL_EXCHANGE="normal_exchange-1";
    //死心交换机名字
    public static final String DEAD_EXCHANGE="dead_exchange-1";
    //普通队列名字
    public static final String NORMAL_QUEUE="normal_queue-1";
    //死信队列名字
    public static final String DEAD_QUEUE="dead_queue-1";

    //接收消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取信道
        Channel channel = RabbitMQUtils.getChannel();

        //声明普通交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE,BuiltinExchangeType.DIRECT);

        //声明普通队列
        Map<String,Object> map=new HashMap<>();
        //正常的队列设置死信交换机
        map.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信RoutingKey
        map.put("x-dead-letter-routing-key","lisi");
        //设置正常队列的长度的限制
        map.put("x-max-length",6);
        channel.queueDeclare(NORMAL_QUEUE,false,false,false,map);




        //声明死信队列
        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=(String var1, Delivery var2)->{
            System.out.println("c1接受消息:"+new String(var2.getBody(),"utf-8"));
        };
        //接收消息失败
        CancelCallback cancelCallback=(String var1)->{
            System.out.println("接收消息失败~");
        };
        //接受消息
        channel.basicConsume(NORMAL_QUEUE,true,deliverCallback,cancelCallback);
    }
}

生产者

public class Producer {
    //声明普通交换机
    public static final String NORMAL_EXCHANGE = "normal_exchange-1";

    //发消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

        for (int i = 1; i <11 ; i++) {
            String message="消息"+i;
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",null,message.getBytes());

        }
    }

}

消费者2

public class Consumer02 {
    //声明死信交换机
    public static final String DEAD_EXCHANGE = "dead_exchange-1";
    //声明死信队列
    public static final String DEAD_QUEUE = "dead_queue-1";

    //接收消息
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建信道
        Channel channel = RabbitMQUtils.getChannel();

        //声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        //声明死信队列
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //绑定队列和交换机
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");
        System.out.println("等待接收消息......");

        //接受消息
        DeliverCallback deliverCallback=(String var1, Delivery var2)->{
            System.out.println("c2接收消息:"+new String(var2.getBody(),"utf-8"));
        };
        //接收消息失败
        CancelCallback cancelCallback=(String var1)->{
            System.out.println("接收消息失败");
        };
        //接收消息
        channel.basicConsume(DEAD_QUEUE,true,deliverCallback,cancelCallback);
    }
}

总结

先启动生产者1，创建队列与交换机，添加队列的最大长度值，在关闭生产者1，启动生产者，让消息堆积，但最多堆积6条，剩下4条转为死信。

注意:普通队列与死信交换机之间的关系绑定。

7.3.3消息被拒


        //接受消息
        DeliverCallback deliverCallback = (String var1, Delivery var2) -> {
            String message = new String(var2.getBody(), "utf-8");
            if (message.equals("消息5")) {
                System.out.println("拒绝接收["+message+"]消息");
                channel.basicReject(var2.getEnvelope().getDeliveryTag(),false);
            } else {
                System.out.println("c1接受消息:" + message);
                channel.basicAck(var2.getEnvelope().getDeliveryTag(),false);
            }
        };
        //接收消息失败
        CancelCallback cancelCallback = (String var1) -> {
            System.out.println("接收消息失败~");
        };
        //开启手动应答
        channel.basicConsume(NORMAL_QUEUE, false, deliverCallback, cancelCallback);

注意:记得开启手动应答~

8.延迟队列

8.1概念

队列内部是有序的，延迟队列就是用来存放需要在指定时间被处理的元素队列

8.2应用场景

1.订单在十分钟之内未支付则自动取消。

2·新创建的店铺,如果在十天内都没有上传过商品,则自动发送消息提醒。

3·用户注册成功后,如果三天内没有登陆则进行短信提醒。

4·用户发起退款,如果三天内没有得到处理则通知相关运营人员。

5·预定会议后,需要在预定的时间点前十分钟通知各个与会人员参加会议。

8.3整合SpringBoot

8.3.1创建项目

注意：jdk版本和打包方式

特别注意:构建工具导入自己的maven，否则构建会报错

无法解析 org.springframework:spring-test:5.3.30

8.3.2导入依赖


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

        <!--RabbitMQ依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>3.1.2</version>
        </dependency>

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

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.32</version>
        </dependency>
        <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>
        <!--RabbitMQ测试依赖-->
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <version>3.0.6</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

8.3.3添加RabbitMQ配置

spring.rabbitmq.host=192.168.20.149
spring.rabbitmq.port=5672
spring.rabbitmq.username=root
spring.rabbitmq.password=123456
#不添加后面启动服务爆空指针异常
spring.mvc.pathmatch.matching-strategy=ant_path_matcher

8.3.4添加Swagger配置类

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example"))
                .paths(PathSelectors.any())
                .build()
                .apiInfo(apiInfo());
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("My API Documentation")
                .description("Description of my API")
                .version("1.0.0")
                .build();
    }
}

8.4队列TTL

创建两个队列QA和QB,两者队列TTL分别设置为10S和40S,然后在创建一个交换机×和死信交换机 Y，它们的类型都是 direct，创建一个死信队列 QD，它们的绑定关系如下：

8.4.1配置类文件代码

/**
 * TTL队列，配置文件类代码
 */

@Configuration
public class TtlQueueConfig {
    //普通交换机名称
    public static final String NORMAL_EXCHANGE = "X";
    //死信交换机名称
    public static final String DEAD_EXCHANGE = "Y";
    //普通队列名称
    public static final String NORMAL_QUEUE_A = "QA";
    public static final String NORMAL_QUEUE_B = "QB";
    //死信队列名称
    public static final String DEAD_QUEUE = "QD";

    //声明NORMAL_EXCHANGE交换机
    @Bean("xExchange")//别名
    public DirectExchange xExchange() {
        return new DirectExchange(NORMAL_EXCHANGE);
    }

    //声明DEAD_EXCHANGE交换机
    @Bean("yExchange")//别名
    public DirectExchange yExchange() {
        return new DirectExchange(DEAD_EXCHANGE);
    }

    //声明普通队列 TTL 10s
    @Bean("queueA")//别名
    public Queue queueA() {
        Map<String, Object> map = new HashMap<>(3);
        //设置死信交换机
        map.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //设置死信RoutingKey
        map.put("x-dead-letter-routing-key", "YD");
        //设置存过时间
        map.put("x-message-ttl", 10000);

        return QueueBuilder.durable(NORMAL_QUEUE_A).withArguments(map).build();
    }

    //声明普通队列 TTL 40s
    @Bean("queueB")//别名
    public Queue queueB() {
        Map<String, Object> map = new HashMap<>(3);
        //设置死信交换机
        map.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //设置死信RoutingKey
        map.put("x-dead-letter-routing-key", "YD");
        //设置存过时间
        map.put("x-message-ttl", 40000);

        return QueueBuilder.durable(NORMAL_QUEUE_B).withArguments(map).build();
    }

    //声明死信队列
    @Bean("queueD")
    public Queue queueD() {
        return QueueBuilder.durable(DEAD_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");
    }
}

8.4.2生产者代码

/**
 * 发送延迟消息
 */
@Slf4j
@RestController
@RequestMapping("/ttl")
public class SendMessageController {

    @Autowired
    private RabbitTemplate rabbitTemplate;


    @GetMapping("/sendMsg/{message}")
    public void sendMessage(@PathVariable String message){
      log.info("当前时间:{},发送一条信息给两个队列:{}",new Date().toString(),message);
      rabbitTemplate.convertAndSend("X","XA","消息来自ttl为10s"+message);
      rabbitTemplate.convertAndSend("X","XB","消息来自ttl为40s"+message);
    }
}

8.4.3消费者代码

/**
 * 队列TTL 消费者
 */
@Slf4j
@Component
public class DeadLetterQueueConsumer {

    //接收消息
    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel) throws Exception{
        String mgs=new String(message.getBody());
        log.info("当前时间:{}，收到死信队列的消息:{}",new Date().toString(),mgs);
    }
}

localhost:8080/ttl//sendMsg/回敲代码的小张:结果：

8.5延迟队列优化

新增队列QC，该队列不设置TTL时间

声明并绑定新增队列QC

  //声明普通队列  不设置TTL
    @Bean("queueC")//别名
    public Queue queueC() {
        Map<String, Object> map = new HashMap<>(3);
        //设置死信交换机
        map.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //设置死信RoutingKey
        map.put("x-dead-letter-routing-key", "YD");
        return QueueBuilder.durable(NORMAL_QUEUE_C).withArguments(map).build();
    }


     //普通交换机和普通队列绑定
    @Bean
    public Binding queueCBindingX(@Qualifier("queueC") Queue queueC,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueC).to(xExchange).with("XC");
    }

发消息

   @GetMapping("/sendExpirationMsg/{message}/{ttlTime}")
    public void sendMessage(@PathVariable String message,@PathVariable String ttlTime){
      log.info("当前时间:{},发送一条时长是{}毫秒TTL信息给两个队列QC:{}",new Date().toString(),ttlTime,message);
      rabbitTemplate.convertAndSend("X","XC",message,message1 -> {
          //设置发送消息的延迟时长
          message1.getMessageProperties().setExpiration(ttlTime);
          return message1;
      });
    }

localhost:8080/ttl/sendExpirationMsg/回敲代码的小张01/20000

localhost:8080/ttl/sendExpirationMsg/回敲代码的小张02/2000

结果:

按理说，02的时间短应该比01先到，但是结果恰恰相反。原因：（队列阻塞）RabbitMQ只会检查第一个消息是否过期，如果过期则丢到死信队列，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。

8.6插件实现延迟队列

8.7总结

使用RabbitMQ来实现延时队列可以很好利用RabbitMQ的特性，如：消息可靠发送，消息可靠投递，死信队列来保障消息至少被消费一次以及未被正确处理的消息不会被丢弃。

9.发布确认高级

消息的可靠性

保证消息百分百传递到消息对列中

RabiitQM投递路径：生产者----->交换机------>队列------->消费者

通过两点控制消息的可靠性投递

1.生产者到交换机，通过confirmCallback

2.交换机到队列，通过returnCallback

9.1发布确认(springboot)

原因RabbitMQ宕机，消息丢弃

9.1.1架构图

9.1.2配置文件

spring.rabbitmq.publisher-confirm-type=correlated

NONE:禁用发布确认模式，是默认值

CORRELATED：发布消息成功到交换器后会触发回调方法

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

spring.rabbitmq.host=192.168.20.149
spring.rabbitmq.port=5672
spring.rabbitmq.username=root
spring.rabbitmq.password=123456
spring.mvc.pathmatch.matching-strategy=ant_path_matcher

spring.rabbitmq.publisher-confirm-type=correlated

9.1.3配置类

@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 = "key1";

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

    //声明队列
    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE).build();
    }

    //队列与交换机绑定
    @Bean
    public Binding queueBindingExchange(@PathVariable("confirmQueue") Queue confirmQueue,
                                        @PathVariable("confirmExchange")DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM__ROUTING_KEY);
    }


}

9.1.4生产者

@Slf4j
@RestController
@RequestMapping("/confirm")
public class ProducerController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendMessage/{message}")
    public void sendMessage(@PathVariable String message){
        rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE,
                                      ConfirmConfig.CONFIRM__ROUTING_KEY,
                                      message);
        log.info("消息内容:{}",message);
    }
}

9.1.5消费者

@Slf4j
@Component
public class Consumer {

    //接收消息
    @RabbitListener(queues = ConfirmConfig.CONFIRM_QUEUE)
    public void receiveMessageConfirm(Message message){
        String mgs=new String(message.getBody());
        log.info("当前时间:{}，收到的消息:{}",new Date().toString(),mgs);
    }
}

9.1.6回调接口

‘

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

    @Autowired
    private RabbitTemplate rabbitTemplate;


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

    /**
     * 交换机确认回调方法
     * 1.发消息 交换机收到了  回调
     * ages含义:
     * 1.1 correlationData：保存回调消息的ID以及相关信息
     * 1.2 ack:交换机收到消息 为true
     * 1.3 cause： null
     * ======================================================
     * 2.发消息   交换机接受失败 回调
     * 2.1 correlationData：保存回调消息的ID以及相关信息
     * 2.2 ack:false
     * 2.3 cause：失败的原因
     */
    @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);
        }
    }
}

9.2回退消息

配置文件添加配置:

spring.rabbitmq.publisher-returns=true

9.2.1mandatory参数

在仅开启了生产者确认机制的情况下,交换机接收到消息后,会直接给消息生产者发送确认消息,如果发现该消息不可路由,那么消息会被直接丢弃,此时生产者是不知道消息被丢弃这个事件的。通过设置mandatory参数可以在当消息传递过程中不可达目的地时将消息返回给生产者。

9.2.2回调接口

@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.发消息 交换机收到了  回调
     * ages含义:
     * 1.1 correlationData：保存回调消息的ID以及相关信息
     * 1.2 ack:交换机收到消息 为true
     * 1.3 cause： null
     * ======================================================
     * 2.发消息   交换机接受失败 回调
     * 2.1 correlationData：保存回调消息的ID以及相关信息
     * 2.2 ack:false
     * 2.3 cause：失败的原因
     */
    @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);
        }
    }


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

}

9.3备份交换机

9.3.1配置类

@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 = "key1";


    //备份交换机
    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("backupExchange")
    public FanoutExchange backupExchange(){
        return new FanoutExchange(BACKUP_EXCHANGE);
    }

    //声明队列
    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE).build();
    }

    //声明备份队列
    @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 queueBindingExchange(@PathVariable("confirmQueue") Queue confirmQueue,
                                        @PathVariable("confirmExchange")DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM__ROUTING_KEY);
    }

    //备份队列和备份交换机绑定
    @Bean
    public Binding backupQueueBindingBackupExchange(@PathVariable("backupQueue") Queue backupQueue,
                                        @PathVariable("backupExchange")FanoutExchange backupExchange){
        return BindingBuilder.bind(backupQueue).to(backupExchange);
    }
    //报警队列和备份交换机绑定
    @Bean
    public Binding warningQueueBindingBackupExchange(@PathVariable("warningQueue") Queue warningQueue,
                                                    @PathVariable("backupExchange")FanoutExchange backupExchange){
        return BindingBuilder.bind(warningQueue).to(backupExchange);
    }

}

9.3.2消费者

@Slf4j
@Component
public class WarningConsumer {

    @RabbitListener(queues = ConfirmConfig.WARNING_QUEUE)
    public void receiveWarningMessage(Message message){
        String msg=new String(message.getBody());
        log.info("报警发现不可路由消息:{}",msg);
    }
}

10.RabbitMQ集群

rabbitmq集群有两种:普通集群，镜像集群

10.1普通集群

普通集群:默认的集群模式,比如有节点node1和node2、node3,三个节点是普通集群,但是他们仅有相同的元数据,即交换机、队列的结构。消费者消费消息时，会从各个节点拉取消息。

问题：

假如node1故障,那node2无法获取node1存储未被消费的消息;

如果node1持久化后故障,那需要等node1恢复后才可以正常消费

如果ndoe1没做持久化后故障,那消息将会丢失。

注意:集群需要保证各个节点有相同的token令牌！！！

10.1.1拉取镜像

docker pull rabbitmq:3.8-management

10.1.2创建节点

创建三个节点，一主两从。注意:关闭防火墙！！！

#主节点
docker run -d --name rabbitmq1 --hostname rabbit_host01 -p 15672:15672 -p 5672:5672  -e RABBITMQ_DEFAULT_USER=root  -e RABBITMQ_DEFAULT_PASS=123456  -e RABBITMQ_ERLANG_COOKIE='rabbitmqCookie' --privileged=true  -v /usr/local/rabbitmq/rabbitmq01/lib:/var/lib/rabbitmq  rabbitmq:3.8-management
#从节点1
docker run -d --name rabbitmq2 --hostname rabbit_host02 -p 15673:15672 -p 5673:5672  -e RABBITMQ_DEFAULT_USER=root  -e RABBITMQ_DEFAULT_PASS=123456  -e RABBITMQ_ERLANG_COOKIE='rabbitmqCookie' --privileged=true  -v /usr/local/rabbitmq/rabbitmq02/lib:/var/lib/rabbitmq  --link rabbitmq1:rabbit_host01 rabbitmq:3.8-management
#从节点2
docker run -d --name rabbitmq3 --hostname rabbit_host03 -p 15674:15672 -p 5674:5672  -e RABBITMQ_DEFAULT_USER=root  -e RABBITMQ_DEFAULT_PASS=123456  -e RABBITMQ_ERLANG_COOKIE='rabbitmqCookie' --privileged=true  -v /usr/local/rabbitmq/rabbitmq03/lib:/var/lib/rabbitmq  --link rabbitmq1:rabbit_host01  --link rabbitmq2:rabbit_host02 rabbitmq:3.8-management

-d ：后台运行容器。

--name:指定容器名称。

--hostname：主机名(rabbitmq它根据所谓的 “节点名称” 存储数据，默认为主机名)。

-p：指定运行端口（5672：应用访问端口；15672：控制台Web端口号），

控制台端口用于管理rabbitmq，应用访问端口号为rabbitclient等应用访问。

-e ：指定环境变量：RABBITMQ_DEFAULT_VHOST：默认虚拟机名，

RABBITMQ_DEFAULT_USER：默认的用户名，

RABBITMQ_DEFAULT_USER：默认的用户名，

RABBITMQ_ERLANG_COOKIE 节点认证作用。

--privileged=true:容器内的root拥有真正的root权限，否则报错：pression denied。

-v：映射目录或文件

-link: 用于容器的链接

注意： RABBITMQ_ERLANG_COOKIE的值必须相同！！！

查看运行的容器:

登录页面查看：

主节点：

从节点1：

从节点2：

10.1.3搭建集群

将从从节点1和从节点2加入主节点。

主节点配置:

docker exec -it rabbitmq1 bash

rabbitmqctl stop_app

rabbitmqctl reset

rabbitmqctl start_app

exit

从节点1配置:

docker exec -it rabbitmq2 bash

rabbitmqctl stop_app

rabbitmqctl reset
rabbitmqctl join_cluster --ram rabbit@rabbit_host01

rabbitmqctl start_app

exit

从节点2配置:

docker exec -it rabbitmq3 bash

rabbitmqctl stop_app

rabbitmqctl reset
rabbitmqctl join_cluster --ram rabbit@rabbit_host01

rabbitmqctl start_app

exit

查看集群状态

rabbitmqctl cluster_status

配置启动了三个节点，一个磁盘节点两个内存节点

访问web控制台

10.2镜像集群

前面搭建了普通集群,如果磁盘节点挂掉后,如果没开启持久化数据就丢失了,其他节点也无法获取消息，所以我们这个集群方案需要进一步改造为镜像模式集群

10.1概念

队列做成镜像队列，让各队列存在于多个节点中。

和普通集群比较大的区别就是队列queue的消息message 会在集群各节点之间同步,且并不是在consumer 获取数据时临时拉取，而普通集群则是临时从存储的节点里面拉取对应的数据。

优点:实现了高可用性,部分节点挂掉后,不影响正常的消费。

缺点:由于镜像队列模式下,消息数量过多,大量的消息同步也会加大网络带宽开销,适合高可用。

10.2基于web控制台

路径:rabbitmq管理页面 -> Admin-> Policies -> Add / update a policy

name:自定义策略名称.

Pattern:^ 匹配符，代表匹配所有.

Definition: ha-mode=all为匹配类型,分为3种模式: all (表示所有的queue).

ha-mode：指明镜像队列的模式，可选下面的其中一个.

all:表示在集群中所有的节点上进行镜像同步(一般都用这个参数).

exactly:表示在指定个数的节点上进行镜像同步,节点的个数由ha-params指定.

nodes：表示在指定的节点上进行镜像同步，节点名称通过ha-params指定.

ha-sync-mode：镜像消息同步方式 automatic（自动），manually（手动）.