Java使用原生AMQP客户端连接RabbitMQ

package cn.ant.utils;
 
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
 * 创建信道的工具类
 * @author Anhui AntLaddie (掘金蚂蚁小哥)
 * @version 1.0
 **/
public class ChannelUtil {
 
    private static final String HOST = "***.***.***.***";       // 服务器IP
    private static final String USER_NAME = "rabbit";           // 用户信息
    private static final String PASSWORD = "1234";              // 用户密码
    private static final String VIRTUAL_HOST = "nativeStudy";   // 虚拟主机
 
    /***
     * 获取连接中的一个信道
     * @return Channel
     */
    public static Channel getChannel() {
        //创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置RabbitMQ服务的IP、账号、密码、Vhost虚拟主机(默认 "/" 则不需要设置)
        factory.setHost(HOST);
        factory.setUsername(USER_NAME);
        factory.setPassword(PASSWORD);
        factory.setVirtualHost(VIRTUAL_HOST);
 
        try {
            //通过工厂对象获取一个连接
            Connection connection = factory.newConnection();
            //通过连接来获取一个信道并返回
            return connection.createChannel();
        } catch (IOException | TimeoutException e) {
            throw new RuntimeException(e);
        }
    }
}

/**
 * 生产者（生产任务）
 * @author Anhui AntLaddie (掘金蚂蚁小哥)
 * @version 1.0
 **/
public class Producer {
 
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(Producer.class);
    // 简单队列名称
    public static final String QUEUE_NAME = "helloWorldQueue";
 
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
 
        // 声明队列（若重复执行相同参数的队列创建则不会执行任何操作，当队列第二次创建时参数不同则报错）
        // 参数一：队列名称
        // 参数二：队列信息是否持久化，true代表队列在RabbitMQ重启后仍然存在，默认false。
        //      说明：这里是队列设置持久化，可不是消息持久化，消息持久化是后面设置的deliveryMode=2
        // 参数三：指定队列是否为独占队列，该队列是否只供一个消费者进行消费的独占队列。
        //      true = 该队列只能由当前第一个连接的消费者使用，连接关闭后队列将被删除。
        //      false = 允许多个消费者连接到该队列（默认值）
        // 参数四：指定队列是否在最后一个消费者断开连接后自动删除；
        //      true = 当最后一个消费者断开连接时，队列将被自动删除。
        //      false = 队列在消费者断开连接后仍然存在（默认值）。
        // 参数五：构建队列的其它属性，可以用于设置队列的额外属性，例如消息 TTL（生存时间）、最大长度等.
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
 
        // 发送的消息
        byte[] msg = ("这是一条测试消息:" + LocalTime.now()).getBytes(StandardCharsets.UTF_8);
        // 发送消息
        // 参数一：要将消息发送到RabbitMQ服务器上的哪个交换机名称上。
        //      说明：交换机负责接收来自生产者的消息，并根据路由规则将消息转发到一个或多个队列。
        //      交换机的类型（如 `direct`、`fanout`、`topic`、`headers`）决定了消息的路由方式。
        // 参数二：设置路由的key是什么；用于确定消息应该被路由到哪个队列
        // 参数三：其它参数，如：内容类型、消息优先级、过期时间、消息持久性等
        // 参数四：发送的消息的具体内容，通常是一个字节数组（byte[]）
        channel.basicPublish("", QUEUE_NAME, null, msg);
        logger.info("生产者消息发送完成");
    }
}

/**
 * 消费者（消费任务）
 * @author Anhui AntLaddie (掘金蚂蚁小哥)
 * @version 1.0
 **/
public class Consumer {
 
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(Consumer.class);
    // 简单队列名称
    public static final String QUEUE_NAME = "helloWorldQueue";
 
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        logger.info("消费者开始监听队列消息....");
 
        // 推送的消息如何进行消费的接口回调
        DeliverCallback deliverCallback = new DeliverCallback() {
            @Override
            public void handle(String consumerTag, Delivery message) {
                logger.info("获取队列信息：{}",
                        new String(message.getBody(), StandardCharsets.UTF_8));
            }
        };
 
        // 取消消费的一个回调接口 如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = new CancelCallback() {
            @Override
            public void handle(String consumerTag) {
                logger.info("监听的队列出现异常；可能队列被删除！{}", consumerTag);
            }
        };
 
        //消费者消费消息
        //参数一：要消费的队列的名称，消费者将从这个队列中接收消息。
        //      说明：队列必须已经存在，在调用basicConsume方法之前，生产者已经向该队列发送了消息。
        //参数二：指示消费者在接收到消息后是否自动发送应答
        //      true = 自动应答，消费者在接收到消息后，RabbitMQ 会自动将该消息标记为已处理。
        //          这意味着即使消费者在处理消息时发生错误，消息也不会被重新投递。
        //      false = 手动应答，消费者需要在处理完消息后显式地发送应答（acknowledgment）。
        //          如果消费者在处理消息时发生错误且未发送应答，RabbitMQ 会将该消息重新投递给其他消费者。
        //参数三：这是一个实现了DeliverCallback接口的回调对象，用于处理接收到的消息。
        //      说明：消费者从队列中接收到消息时，RabbitMQ会调用这个回调方法，可以在这里写处理消息的逻辑。
        //参数四：这是一个实现了CancelCallback接口的回调对象，用于处理消费者取消消费的情况。
        //      说明：当消费者被取消（如，队列被删除，或者消费者主动取消）时，
        //      RabbitMQ会调用这个回调方法。您可以在这里编写处理取消的逻辑。
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
    }
}

/**
 * 生产者（生产任务）
 * @author Anhui AntLaddie (掘金蚂蚁小哥)
 * @version 1.0
 **/
public class Producer {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(Producer.class);
    // 工作队列名称
    public static final String QUEUE_NAME = "WorkQueues";
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 声明一个队列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        // 循环发送消息（循环20条发生）
        for (int i = 1; i <= 20; i++) {
            String str = "这是一个编号为：" + i + " 的待处理的消息";
            byte[] msg = (str + LocalTime.now()).getBytes(StandardCharsets.UTF_8);
            channel.basicPublish("", QUEUE_NAME, null, msg);
        }
        logger.info("工作队列的生产者消息发送完成！");
    }
}

/**
 * 消费者A（消费任务）
 * @author Anhui AntLaddie (掘金蚂蚁小哥)
 * @version 1.0
 **/
public class ConsumerA {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(ConsumerA.class);
    // 工作队列名称
    public static final String QUEUE_NAME = "WorkQueues";
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 提前声明一个需要的队列，以防先启动消费者后发现队列不存在报错
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        logger.info("消费者A开始监听队列消息....");
        // 消费者消费消息
        channel.basicConsume(QUEUE_NAME, true, (consumerTag, message) -> {
            // 获取从队列取出的数据并打印
            String str = new String(message.getBody(), StandardCharsets.UTF_8);
            // 这个消费者延迟1秒处理一条消息（不能理解为1秒执行一条后，再去队列获取哟）
            try {
                Thread.sleep(1000);
                logger.info("A消费者获取队列信息并处理：{}", str);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, consumerTag -> {
            logger.info("监听的队列出现异常；可能队列被删除！{}", consumerTag);
        });
    }
}
 
/**
 * 消费者B（消费任务）
 * @author Anhui AntLaddie (掘金蚂蚁小哥)
 * @version 1.0
 **/
public class ConsumerB {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(ConsumerB.class);
    // 工作队列名称
    public static final String QUEUE_NAME = "WorkQueues";
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 提前声明一个需要的队列，以防先启动消费者后发现队列不存在报错
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        logger.info("消费者B开始监听队列消息....");
        // 消费者消费消息
        channel.basicConsume(QUEUE_NAME, true, (consumerTag, message) -> {
            // 获取从队列取出的数据并打印
            String str = new String(message.getBody(), StandardCharsets.UTF_8);
            logger.info("B消费者获取队列信息并处理：{}", str);
        }, consumerTag -> {
            logger.info("监听的队列出现异常；可能队列被删除！{}", consumerTag);
        });
    }
}

public static void singleReleaseConfirmation() throws IOException, InterruptedException {
    // 通过工具类获取一个信道
    Channel channel = ChannelUtil.getChannel();
    // 声明一个队列
    channel.queueDeclare(SINGLE_RELEASE_CONFIRMATION, true, false, false, null);
    // 开启发布确认功能！！！
    channel.confirmSelect();
    // 记录开始时间
    long start = System.currentTimeMillis();
    // 发送消息
    for (int i = 1; i <= 100; i++) {
        byte[] msg = ("这是一个编号为：" + i + " 的待处理的消息").getBytes(StandardCharsets.UTF_8);
        // 依次发送每一条消息到消息队列中
      channel.basicPublish("", SINGLE_RELEASE_CONFIRMATION, MessageProperties.PERSISTENT_BASIC, msg);
        // 验证是否发送成功（阻塞等待队列返回的确认消息）
        // 发送三秒后没得到回复将断定未发送过去
        // boolean waitTime = channel.waitForConfirms(3000);
        // 将一直等待刚才发送的消息是否被RabbitMQ确认
        boolean waitSuccess = channel.waitForConfirms();
        if (waitSuccess) {
            // 如果选择的是info日志级别，所花的时间会高一点，因为日志级别为info，打印耗费一些时间
            logger.info("[单个发布确认]发送成功了，已发送到RabbitMQ队列中，发送信息为：{}", i);
        } else {
            logger.info("[单个发布确认]发送失败，未收到RabbitMQ确认信息，发送信息为：{}", i);
        }
    }
    long end = System.currentTimeMillis();
    logger.info("生产者消息发送完成【单个发布确认，用时：{}】", end - start);
}

public static void batchConfirmation() throws IOException, InterruptedException {
    // 通过工具类获取一个信道
    Channel channel = ChannelUtil.getChannel();
    // 声明一个队列
    channel.queueDeclare(BATCH_CONFIRMATION, true, false, false, null);
    // 开启发布确认功能！！！
    channel.confirmSelect();
    // 记录开始时间
    long start = System.currentTimeMillis();
    // 定义每次批量处理多少消息进行确认
    int batchNumber = 10;
    // 发送的消息
    for (int i = 1; i <= 100; i++) {
        byte[] msg = ("这是一个编号为：" + i + " 的待处理的消息").getBytes(StandardCharsets.UTF_8);
        // 依次发送每一条消息到消息队列中
        channel.basicPublish("", BATCH_CONFIRMATION, MessageProperties.PERSISTENT_BASIC, msg);
        // 验证是否发送成功，对10求余，代表每发送10条消息会批量看看是否成功（等待确认）
        if (i % batchNumber == 0) {
            boolean waitSuccess = channel.waitForConfirms();
            // 计算，到时候日志需要打印
            String str = (i - (batchNumber - 1)) + " ~ " + i;
            // 判断是否批量确认成功
            if (waitSuccess) {
                // 如果选择的是info日志级别，所花的时间会高一点，因为日志级别为info，打印耗费一些时间
                logger.debug("[批量发布确认]发送成功了，已发送到RabbitMQ队列中，发送信息范围：{}", str);
            } else {
                logger.debug("[批量发布确认]发送失败，未收到RabbitMQ确认信息，发送信息范围：{}", str);
            }
        }
    }
    long end = System.currentTimeMillis();
    logger.info("生产者消息发送完成【批量发布确认，用时：{}】", end - start);
}

'创建交换机的方法：'
    void exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable,
                    boolean autoDelete, boolean internal, Map<String, Object> arguments)
'参数详细解释：'
    'exchange(String)：'
        作用：指定要创建的交换机的名称。这个名称在RabbitMQ中必须是唯一的。
        注意：如果交换机已经存在，exchangeDeclare方法会检查提供的参数是否与现有交换机的参数匹配。
             如果不匹配，RabbitMQ会抛出错误。
    'type(BuiltinExchangeType)：'
        作用：定义交换机的类型，决定了交换机如何路由消息。
        选项：
            BuiltinExchangeType.DIRECT：（默认交换机）消息只发送到与路由键完全匹配的队列。
            BuiltinExchangeType.FANOUT：（扇出交换机）基于路由键的模式匹配，将消息路由到多个队列。
            BuiltinExchangeType.TOPIC：（主题交换机）将消息广播到所有绑定到此交换机的队列。
            BuiltinExchangeType.HEADERS：（标题交换机）基于消息头的匹配规则路由消息（不常用）。
    'durable(boolean)：'
        作用：如果设置为true，交换机将被持久化，即RabbitMQ重启后，交换机仍然存在。
        注意：持久化只保证交换机本身的持久性，不保证消息的持久性。
    'autoDelete(boolean)：'
        作用：如果设置为true，当与此交换机的最后一个队列解绑时，交换机会被自动删除。
        注意：这是一个“使用后删除”的策略，适用于临时交换机。
    'internal(boolean)：'
        作用：若设置为true（默认false），交换机只能由RabbitMQ内部使用，客户端不能直接发布消息到这个交换机
        用途：主要用于RabbitMQ的内部机制，如死信交换机。
    'arguments (Map<String, Object>)：'
        作用：用于传递额外的参数，这些参数可以用来定制交换机的行为或实现AMQP协议的扩展功能。
        常用参数：
           alternate-exchange：指定一个备用交换机，当消息无法路由到任何队列时，消息会转发到这个备用交换机
           x-dead-letter-exchange：指定一个死信交换机，当消息被拒绝或过期时，消息会转发到这个交换机

public class Producer {
    //通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(Producer.class);
    // 扇出交换机名称
    public static final String EXCHANGE_NAME = "fanoutExchange";
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 创建名称为"fanoutExchange"的扇出交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT,
                true, false, false, null);
        // 循环发送消息（循环20条发生）
        for (int i = 1; i <= 20; i++) {
            String str = "这是一个编号为：" + i + " 的待处理的消息";
            byte[] msg = (str + LocalTime.now()).getBytes(StandardCharsets.UTF_8);
            //发送消息到交换机 EXCHANGE_NAME
            channel.basicPublish(EXCHANGE_NAME, "", MessageProperties.PERSISTENT_BASIC, msg);
        }
        logger.info("生产者消息发送完成！");
    }
}

// 可以多搞几个消费者，消费者代码都是相同的，只不过日志打印的名称不一样
public class ConsumerA {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(ConsumerA.class);
    // 扇出交换机名称
    public static final String EXCHANGE_NAME = "fanoutExchange";
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 声明exchange交换机 并设置发布订阅模式（扇出模式）;防止消费者先启动报错，找不到交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT,
                true, false, false, null);
        // 创建一个临时队列（下面两种都是等同效果）
        // String queueName = channel.queueDeclare("", false, true, true, null).getQueue();
        String queueName = channel.queueDeclare().getQueue();
        // 把队列绑定到指定的交换机上
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        logger.info("消费者A开始监听队列消息....");
        // 消费者消费消息
        channel.basicConsume(queueName, false, (consumerTag, message) -> {
            // 获取从队列取出的数据并打印
            String str = new String(message.getBody(), StandardCharsets.UTF_8);
            logger.info("A消费者获取队列信息并处理：{}", str);
            // 手动应答,不批量应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
        }, consumerTag -> {
            logger.info("监听的队列出现异常；可能队列被删除！{}", consumerTag);
        });
    }
}

public class Producer {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(Producer.class);
    // 直接交换机名称
    public static final String LOG_EXCHANGE = "LogExchange";
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 创建名称为"LogExchange"的直接交换机
        channel.exchangeDeclare(LOG_EXCHANGE, BuiltinExchangeType.DIRECT,
                true, false, false, null);
        // 待发送的消息
        HashMap<String, List<String>> sendMsg = new HashMap<>();
        List<String> errMsg = Arrays.asList("[101]系统存在重大问题，可能会发生宕机！", "[102]电脑受到蠕虫病毒攻击！");
        List<String> basicMsg = Arrays.asList("[201]尊敬的蚂蚁小哥欢迎登录系统", "[202]蚂蚁小哥已退出账号");
        sendMsg.put("ErrKey", errMsg);
        sendMsg.put("BasicLogKey", basicMsg);
        // 循环发送消息任务
        for (Map.Entry<String, List<String>> msg : sendMsg.entrySet()) {
            String key = msg.getKey(); // 路由key
            List<String> messages = msg.getValue(); // 待发送的消息
            for (String message : messages) {
                channel.basicPublish(LOG_EXCHANGE, key, MessageProperties.PERSISTENT_TEXT_PLAIN,
                        message.getBytes(StandardCharsets.UTF_8));
            }
        }
        logger.info("生产者消息发送完成...");
    }
}

// BasicLogConsumer(基本日志队列)
public class BasicLogConsumer {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(BasicLogConsumer.class);
    // 交换机名称
    public static final String LOG_EXCHANGE = "LogExchange";
    // 队列名称
    public static final String BASIC_LOG_QUEUE = "BasicLogQueue";
    // 路由绑定关系 Routing Key
    public static final String BASIC_LOG_KEY = "BasicLogKey";
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 声明exchange交换机，并设置为直接交换机；防止消费者先启动报错，找不到交换机
        // channel.exchangeDeclare(LOG_EXCHANGE, BuiltinExchangeType.DIRECT,
        //         true, false, false, null);
        // 创建一个基本日志队列
        channel.queueDeclare(BASIC_LOG_QUEUE, true, false, false, null);
        // 基本日志队列绑定到交换机上，并通过路由key将交换机和队列关联起来。
        channel.queueBind(BASIC_LOG_QUEUE, LOG_EXCHANGE, BASIC_LOG_KEY);
        logger.info("BasicLogConsumer（基本日志队列）开始监听队列消息....");
        // 接收队列消息
        channel.basicConsume(BASIC_LOG_QUEUE, true, (consumerTag, message) -> {
            logger.info("BasicLogConsumer（基本日志队列）获取队列信息并处理：{}",
                    new String(message.getBody(), StandardCharsets.UTF_8));
        }, consumerTag -> {
            logger.info("监听的队列（BasicLogConsumer）出现异常；可能队列被删除！{}", consumerTag);
        });
    }
}
 
// ErrConsumer(错误队列)
public class ErrConsumer {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(ErrConsumer.class);
    // 交换机名称
    public static final String LOG_EXCHANGE = "LogExchange";
    // 队列名称
    public static final String ERR_QUEUE = "ErrQueue";
    // 路由绑定关系 Routing Key
    public static final String ERR_KEY = "ErrKey";
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 声明exchange交换机，并设置为直接交换机；防止消费者先启动报错，找不到交换机
        // channel.exchangeDeclare(LOG_EXCHANGE, BuiltinExchangeType.DIRECT,
        //        true, false, false, null);
        // 创建一个错误队列
        channel.queueDeclare(ERR_QUEUE, true, false, false, null);
        // 错误队列绑定到交换机上，并通过路由key将交换机和队列关联起来。
        channel.queueBind(ERR_QUEUE, LOG_EXCHANGE, ERR_KEY);
        logger.info("ErrConsumer（错误队列）开始监听队列消息....");
        // 接收队列消息
        channel.basicConsume(ERR_QUEUE, true, (consumerTag, message) -> {
            logger.info("ErrConsumer（错误队列）获取队列信息并处理：{}",
                    new String(message.getBody(), StandardCharsets.UTF_8));
        }, consumerTag -> {
            logger.info("监听的队列（ErrConsumer）出现异常；可能队列被删除！{}", consumerTag);
        });
    }
}
 
// NotifyConsumer（通知队列）
public class NotifyConsumer {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(NotifyConsumer.class);
    // 交换机名称
    public static final String LOG_EXCHANGE = "LogExchange";
    // 队列名称
    public static final String NOTIFY_QUEUE = "NotifyQueue";
    // 路由绑定关系 Routing Key
    public static final String ERR_KEY = "ErrKey";
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 声明exchange交换机 并设置为直接交换机；防止消费者先启动报错，找不到交换机
        // channel.exchangeDeclare(LOG_EXCHANGE, BuiltinExchangeType.DIRECT,
        //        true, false, false, null);
        // 创建一个通知队列
        channel.queueDeclare(NOTIFY_QUEUE, true, false, false, null);
        // 通知队列绑定到交换机上，并通过路由key将交换机和队列关联起来。
        channel.queueBind(NOTIFY_QUEUE, LOG_EXCHANGE, ERR_KEY);
        logger.info("NotifyConsumer（通知队列）开始监听队列消息....");
        //接收队列消息
        channel.basicConsume(NOTIFY_QUEUE, true, (consumerTag, message) -> {
            logger.info("NotifyConsumer（通知队列）获取队列信息并处理：{}",
                    new String(message.getBody(), StandardCharsets.UTF_8));
        }, consumerTag -> {
            logger.info("监听的队列（NotifyConsumer）出现异常；可能队列被删除！{}", consumerTag);
        });
    }
}

public class Producer {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(Producer.class);
    // 主题交换机名称
    public static final String TOPIC_EXCHANGE = "TopicExchange";
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 创建名称为"LogExchange"的直接交换机
        channel.exchangeDeclare(TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC,
                true, false, false, null);
        // 准备需要发送的消息任务
        HashMap<String, String> sendMsg = new HashMap<>();
        sendMsg.put("quick.orange.rabbit", "被队列 Q1 Q2 接收到");
        sendMsg.put("lazy.orange.elephant", "被队列 Q1 Q2 接收到");
        sendMsg.put("quick.orange.fox", "被队列 Q1 接收到");
        sendMsg.put("lazy.brown.fox", "被队列 Q2 接收到");
        sendMsg.put("lazy.pink.rabbit", "虽然满足两个绑定规则但两个规则都是在Q2队列，所有只要Q2接收一次");
        sendMsg.put("quick.brown.fox", "不匹配任何绑定不会被任何队列接收到会被丢弃");
        sendMsg.put("quick.orange.male.rabbit", "是四个单词不匹配任何绑定会被丢弃");
        sendMsg.put("lazy.orange.male.rabbit", "是四个单词但匹配 Q2");
        // 循环发送消息任务
        for (Map.Entry<String, String> msg : sendMsg.entrySet()) {
            String routKey = msg.getKey();  // 主题路由key
            String message = msg.getValue();// 消息任务
            channel.basicPublish(TOPIC_EXCHANGE, routKey, MessageProperties.PERSISTENT_BASIC,
                    message.getBytes(StandardCharsets.UTF_8));
        }
        logger.info("生产者消息发送完成...");
    }
}

// 消费者A；队列名Q1Queue；匹配*.orange.*主题；
public class CAConsumer {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(CAConsumer.class);
    // 交换机名称
    public static final String TOPIC_EXCHANGE = "TopicExchange";
    // 队列Q1名称
    public static final String Q1 = "Q1Queue";
    // 路由绑定关系（Routing Key）
    public static final String Q1_KEY = "*.orange.*";
    public static void main(String[] args) throws IOException {
        // 调用自己的工具类获取信道
        Channel channel = ChannelUtil.getChannel();
        // 声明exchange交换机 并设置为主题交换机；防止消费者先启动报错，找不到交换机
        channel.exchangeDeclare(TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC,
                true, false, false, null);
        // 创建一个基本日志队列
        channel.queueDeclare(Q1, true, false, false, null);
        // 队列绑定到交换机上，并通过路由key来对应两者的连接
        channel.queueBind(Q1, TOPIC_EXCHANGE, Q1_KEY);
        logger.info("CAConsumer（消费者A）开始监听Q1队列消息....");
        // 接收队列消息
        channel.basicConsume(Q1, false, (consumerTag, message) -> {
            // 当前接收的消息
            String msg = new String(message.getBody(), StandardCharsets.UTF_8);
            // 当前从哪个路由key上获取的消息
            String routingKey = message.getEnvelope().getRoutingKey();
            // 当前从哪个交换机里分配的消息
            String exchange = message.getEnvelope().getExchange();
            logger.info("CAConsumer(消费者A)获取队列信息并处理：{}，绑定的路由名称：{}，" +
                    "分发过来的路由名称：{}，哪个交换机分发过来的消息：{}", msg, Q1_KEY, routingKey, exchange);
            // 手动确认
            channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
        }, consumerTag -> {
            logger.info("CAConsumer(消费者A)出现异常；可能队列被删除！{}", consumerTag);
        });
    }
}
 
 
// 消费者B；队列名Q2Queue；匹配 *.*.rabbit 和 lazy.#主题；
public class CBConsumer {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(CBConsumer.class);
    // 交换机名称
    public static final String TOPIC_EXCHANGE = "TopicExchange";
    // 队列Q2名称
    public static final String Q2 = "Q2Queue";
    // 路由绑定关系（Routing Key 1）
    public static final String Q2_KEY_A = "*.*.rabbit";
    // 路由绑定关系（Routing Key 2）
    public static final String Q2_KEY_B = "lazy.#";
    public static void main(String[] args) throws IOException {
        // 调用自己的工具类获取信道
        Channel channel = ChannelUtil.getChannel();
        // 声明exchange交换机 并设置为主题交换机；防止消费者先启动报错，找不到交换机
        channel.exchangeDeclare(TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC,
                true, false, false, null);
        // 创建一个基本日志队列
        channel.queueDeclare(Q2, true, false, false, null);
        // 队列绑定到交换机上，并通过路由key来对应两者的连接(这里设置了2个路由连接)
        channel.queueBind(Q2, TOPIC_EXCHANGE, Q2_KEY_A);
        channel.queueBind(Q2, TOPIC_EXCHANGE, Q2_KEY_B);
        logger.info("CBConsumer(消费者B)开始监听Q2队列消息....");
        // 接收队列消息
        channel.basicConsume(Q2, false, (consumerTag, message) -> {
            // 当前接收的消息
            String msg = new String(message.getBody(), StandardCharsets.UTF_8);
            // 当前从哪个路由key上获取的消息
            String routingKey = message.getEnvelope().getRoutingKey();
            // 当前从哪个交换机里分配的消息
            String exchange = message.getEnvelope().getExchange();
            logger.info("CBConsumer(消费者B)获取队列信息并处理：{}，绑定的路由名称：{}，" +
                            "分发过来的路由名称：{}，哪个交换机分发过来的消息：{}",
                    msg, Q2_KEY_A + " AND " + Q2_KEY_B, routingKey, exchange);
            // 手动确认
            channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
        }, consumerTag -> {
            logger.info("CBConsumer(消费者B)出现异常；可能队列被删除！{}", consumerTag);
        });
    }
}

public class DLXConsumer {
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(DLXConsumer.class);
 
    // 声明死信交换机名称
    public static final String DLX_EXCHANGE = "DLXExchange";
    // 声明死信队列名称
    public static final String DLX_QUEUE = "DLXQueue";
    // 声明死信交换机到死信队列路由绑定关系（Routing Key）
    public static final String DLX_KEY = "DLXKey";
 
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
 
        // 创建死信交换机（此时死信交换机为直接交换机（路由模式）直接路由到指定队列）
        channel.exchangeDeclare(DLX_EXCHANGE, BuiltinExchangeType.DIRECT,
                true, false, null);
        // 创建死信队列，并设置队列持久化
        channel.queueDeclare(DLX_QUEUE, true, false, false, null);
 
        // 把死信队列绑定到死信交换机上
        channel.queueBind(DLX_QUEUE, DLX_EXCHANGE, DLX_KEY);
        logger.info("死信队列开始监听队列消息....");
 
        // 接收消息；自动确认
        channel.basicConsume(DLX_QUEUE, true, (consumerTag, message) -> {
            logger.info("死信队列（DLXQueue）接收并处理本次消息：{}",
                    new String(message.getBody(), StandardCharsets.UTF_8));
        }, (consumerTag) -> {
            logger.info("监听的死信队列（DLXQueue）出现异常；可能队列被删除！{}", consumerTag);
        });
    }
}

public class Consumer {
 
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(Consumer.class);
 
    // 直接交换机名称
    public static final String NORMAL_EXCHANGE = "NormalExchange";
    // 队列名称
    public static final String NORMAL_QUEUE = "NormalQueue";
    // 路由Key（Routing Key）
    public static final String NORMAL_KEY = "NormalKey";
 
    // 声明死信交换机名称
    public static final String DLX_EXCHANGE = "DLXExchange";
    // 声明死信交换机到死信队列路由绑定关系（Routing Key）
    public static final String DLX_KEY = "DLXKey";
 
    /***
     * 正常的消费者，用来消息消息
     */
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 创建名称为"NormalExchange"的直接交换机；防止消费者先启动报错，找不到交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT,
                true, false, false, null);
 
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~ 设置队列配置参数Start ~~~~~~~~~~~~~~~~~~~~~~~~~~
        Map<String, Object> arguments = new HashMap<>();
        // 正常队列设置死信交换机 参数key是固定值；（就是说死去的消息发送到哪个交换机）
        arguments.put("x-dead-letter-exchange", DLX_EXCHANGE);
        // 正常队列设置死信交换机到死信队列绑定的 Routing Key，参数key是固定值；
        // 就是说死去的消息在交换机里通过什么路由发送到死信队列
        arguments.put("x-dead-letter-routing-key", DLX_KEY);
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~  设置队列配置参数End  ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
        // 创建一个队列（其中arguments配置参数里面设置了死信交换机）
        channel.queueDeclare(NORMAL_QUEUE, true, false, false, arguments);
        // 把队列绑定到指定交换机上
        channel.queueBind(NORMAL_QUEUE, NORMAL_EXCHANGE, NORMAL_KEY);
        logger.info("消费者（TTLConsumer）开始监听队列消息....");
 
        // ## 消息TTL过期产生死信
        // 若不写从队列中取出消息消费的代码，那么就等消息在队列中自动过期，消息10秒过期（生产者中设置）
    }
}

public class Producer {
 
    // 通过日志管理器获取Logger对象
    static Logger logger = LogManager.getLogger(Producer.class);
    // 直接交换机名称
    public static final String NORMAL_EXCHANGE = "NormalExchange";
    // 路由Key
    public static final String NORMAL_KEY = "NormalKey";
 
    public static void main(String[] args) throws IOException {
        // 通过工具类获取一个信道
        Channel channel = ChannelUtil.getChannel();
        // 创建名称为"NormalExchange"的直接交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT,
                true, false, false, null);
 
        // 设置需要发送的内容，并循环发送
        List<String> msgContentList = Arrays.asList("a11", "b22", "a33", "b44", "a55");
        msgContentList.forEach(e -> {
            try {
                // 创建消息，并每隔2秒发送消息到NORMAL_EXCHANGE交换机
                byte[] msg = ("[消息：" + e + "]").getBytes(StandardCharsets.UTF_8);
                Thread.sleep(2000);
                // 消息参数配置信息；expiration过期时间10秒、deliveryMode=2为消息持久化
                AMQP.BasicProperties properties = new AMQP.BasicProperties().builder()
                        .expiration("10000").deliveryMode(2).build();
                // 发送消息
                channel.basicPublish(NORMAL_EXCHANGE, NORMAL_KEY, properties, msg);
                logger.info("生产者发送了一条消息，消息内容为：" + new String(msg));
            } catch (Exception ex) {
                logger.error("生产者消息发送失败×××");
                throw new RuntimeException(ex.getMessage());
            }
        });
        logger.info("生产者消息发送完成...");
    }
}

'案例一：订单超时取消'
    场景：电商平台中，用户下单后如果规定时间内未支付，订单应自动取消并释放库存。
    实现：
        ● 订单被投递到延迟队列中，设置超时时间（如 30 分钟）。
        ● 超时时间到达后，消息被推送给消费者，触发订单取消逻辑。
    补充：如何确保只取消未支付的订单？
       在消费者处理这条超时消息时，必须再次检查订单状态，确保订单仍然是“未支付”状态，才执行取消逻辑。
       否则，如果订单已经支付，则直接丢弃消息，不执行取消操作。
 
'案例二：秒杀库存超时释放'
    场景：在限时秒杀活动中，用户下单后，系统会暂时锁定库存。
    如果用户未在规定时间内完成支付，库存应自动释放，以便其他用户购买。
    实现：
        ● 订单创建后，将订单信息投递到延迟队列，设置库存锁定时间（如 10 分钟）。
        ● 超时时间到达后，消息被推送给消费者，触发库存释放逻辑。
    补充：如何确保库存不会被错误释放？
        在消费者处理超时消息时，必须再次检查订单状态：
            若订单仍然是“未支付”，则释放库存。
            若订单已支付，则直接丢弃该消息，不执行释放操作。
 
'案例三：用户注册后发送激活邮件'
    场景：用户注册后，需要在24小时内点击激活邮件完成账户激活，未激活的账户将被清理或提醒用户。
    实现：
        ● 用户注册后，将账户信息投递到延迟队列，设置24小时延迟时间。
        ● 24小时后，消息被推送给消费者，检查账户状态：
            若用户仍未激活，则发送激活提醒邮件或自动注销账户。
            若用户已激活，则丢弃消息。
    补充：如何避免误删已激活账户？
        消费者在处理消息时，先查询数据库，确保用户状态仍然是“未激活”，才执行清理或提醒逻辑。
 
'案例四：社交平台的“消息撤回”功能'
    场景：在社交软件（如微信、钉钉）中，用户发送消息后，允许在2分钟内撤回，超过时间则不可撤回。
    实现：
        ● 用户发送消息后，将消息ID投递到延迟队列，设置2分钟延迟时间。
        ● 2分钟后，消息被推送给消费者，检查消息是否已撤回：
            若用户未撤回，则从消息数据库移除撤回选项，用户不能再操作。
            若用户已撤回，则丢弃消息，不做任何操作。
    补充：如何保证用户体验？
        采用前端倒计时 + 后端延迟队列双重控制，确保撤回功能准确生效。
 
'案例五：会员到期续费提醒'
    场景：用户的VIP会员即将到期，系统需提前提醒用户续费，避免会员权益中断。
    实现：
        ● 会员注册或续费成功后，投递到延迟队列，设置到期前3天的提醒时间。
        ● 延迟时间到达后，消息被推送给消费者，触发短信/邮件/APP推送提醒续费。
    补充：如何确保不会重复提醒？
        处理消息前，先检查用户是否已经续费：
            若用户已续费，则丢弃消息，不再推送提醒。
            若用户未续费，则发送提醒。