RabbitMQ的发布订阅模型学习

qinxun2008081

已于 2023-04-07 17:34:59 修改

阅读量95

点赞数

文章标签： java-rabbitmq rabbitmq 学习

于 2023-04-07 16:40:57 首次发布

本文链接：https://blog.csdn.net/qinxun2008081/article/details/130015504

版权

发布订阅模型(Publish/Subscribe)：简单的说就是队列里面的消息会被多个消费者同时接受到，消费者接收到的信息一致。

工具类:

/**
 * @author qx
 * @date 2023-04-07
 * @Descripion: rabbitmq 连接工具类
 */
public class ConnectionUtil {

    /**
     * 获取rabbitmq请求连接
     */
    public static Connection getConnection(){
        ConnectionFactory factory = new ConnectionFactory();
        // 连接地址
        factory.setHost("127.0.0.1");
        // 端口
        factory.setPort(5672);
        // 用户名
        factory.setUsername("guest");
        // 密码
        factory.setPassword("guest");
        // 设置虚拟主机
        factory.setVirtualHost("/");
        try {
            return factory.newConnection();
        } catch (IOException | TimeoutException e) {
            e.printStackTrace();
        }
        return null;
    }

}

1.引入依赖

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

2.创建生产者

/**
 * @author qx
 * @date 2023-04-07
 * @Descripion: 生产者 控制层
 */
@RestController
@RequestMapping("/producer")
public class ProducerController {

    // 交换机名称
    private static final String EXCHANGE_NAME = "exchange_publish";

    @RequestMapping
    public void createMessage() throws IOException, TimeoutException {
        // 获取连接
        Connection connection = ConnectionUtil.getConnection();
        if (connection == null) {
            return;
        }
        // 创建数据传输通道
        Channel channel = connection.createChannel();
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        // 发送消息到交换机
        for (int i = 0; i < 100; i++) {
            channel.basicPublish(EXCHANGE_NAME, "", null, ("发布订阅模式第" + i + "条消息").getBytes());
        }
        //  关闭通道
        channel.close();
        // 关闭连接
        connection.close();
    }
}

3.创建两个消费者

/**
 * @author qinxun
 * @date 2023-04-07
 * @Descripion: 消费者1 控制层
 */
@RestController
@RequestMapping("/consumer1")
public class Consumer1Controller {

    // 交换机名称
    private static final String EXCHANGE_NAME = "exchange_publish";
    // 队列名称
    private static final String QUEUE_NAME = "queue_publish_1";

    @RequestMapping
    public void consumerMessage1() throws IOException {
        // 获取连接
        Connection connection = ConnectionUtil.getConnection();
        if (connection == null) {
            return;
        }
        // 创建数据传输通道
        Channel channel = connection.createChannel();
        // 声明队列
        // 参数1:队列的名字
        // 参数2:是否持久化 比如现在发送到队列里面的消息，如果没有持久化，重启这个队列后数 据会丢失(false) true：重启之后数据依然在
        // 参数3:是否排外 连接关闭之后 这个队列是否自动删除（false：不自动删除） 是否允许其他通道来进行访问这个数据（false：不允许）
        // 参数4:是否自动删除 就是当最后一个连接断开的时候，是否自动删除这个队列（false：不删除）
        // 参数5:附带参数 声明队列的时候，附带的一些参数
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 声明交换机
        // 参数1:交换机名称
        // 参数2:交换机类型 direct（路由模式）、fanout（发布订阅模式）、topic（topic模式-模糊匹配）、headers（标头交换，由Headers的参数分配，不常用）
        // 参数3：durable，是否持久化交换机   false：默认值，不持久化
        // 参数4：autoDelete，没有消费者使用时，是否自动删除交换机   false：默认值，不删除
        // 参数5：internal，是否内置,如果设置 为true,则表示是内置的交换器, 客户端程序无法直接发送消息到这个交换器中, 只能通过交换器路由到交换器的方式  false：默认值，允许外部直接访问
        // 参数6：arguments，交换机的一些其他属性，默认值为 null
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        // 将队列绑定到交换机
        // 参数1:队列的名字
        // 参数2:交换机的名字
        // 参数3:路由
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        // 声明消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("队列1接收到的消息是：" + new String(body));
            }
        };
        // 绑定消费者
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

/**
 * @author qx
 * @date 2023-04-07
 * @Descripion: 消费者2 控制层
 */
@RestController
@RequestMapping("/consumer2")
public class Consumer2Controller {

    // 交换机名称
    private static final String EXCHANGE_NAME = "exchange_publish";
    // 队列名称
    private static final String QUEUE_NAME = "queue_publish_2";

    @RequestMapping
    public void consumerMessage1() throws IOException {
        // 获取连接
        Connection connection = ConnectionUtil.getConnection();
        if (connection == null) {
            return;
        }
        // 创建数据传输通道
        Channel channel = connection.createChannel();
        // 声明队列
        // 参数1:队列的名字
        // 参数2:是否持久化 比如现在发送到队列里面的消息，如果没有持久化，重启这个队列后数 据会丢失(false) true：重启之后数据依然在
        // 参数3:是否排外 连接关闭之后 这个队列是否自动删除（false：不自动删除） 是否允许其他通道来进行访问这个数据（false：不允许）
        // 参数4:是否自动删除 就是当最后一个连接断开的时候，是否自动删除这个队列（false：不删除）
        // 参数5:附带参数 声明队列的时候，附带的一些参数
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 声明交换机
        // 参数1:交换机名称
        // 参数2:交换机类型 direct（路由模式）、fanout（发布订阅模式）、topic（topic模式-模糊匹配）、headers（标头交换，由Headers的参数分配，不常用）
        // 参数3：durable，是否持久化交换机   false：默认值，不持久化
        // 参数4：autoDelete，没有消费者使用时，是否自动删除交换机   false：默认值，不删除
        // 参数5：internal，是否内置,如果设置 为true,则表示是内置的交换器, 客户端程序无法直接发送消息到这个交换器中, 只能通过交换器路由到交换器的方式  false：默认值，允许外部直接访问
        // 参数6：arguments，交换机的一些其他属性，默认值为 null
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        // 将队列绑定到交换机
        // 参数1:队列的名字
        // 参数2:交换机的名字
        // 参数3:路由
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        // 声明消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("队列2接收到的消息是：" + new String(body));
            }
        };
        // 绑定消费者
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

4.测试

先启动2个消费者，再启动生产者

队列2接收到的消息是：发布订阅模式第0条消息
队列1接收到的消息是：发布订阅模式第0条消息
队列2接收到的消息是：发布订阅模式第1条消息
队列2接收到的消息是：发布订阅模式第2条消息
队列1接收到的消息是：发布订阅模式第1条消息
队列1接收到的消息是：发布订阅模式第2条消息
队列1接收到的消息是：发布订阅模式第3条消息
队列1接收到的消息是：发布订阅模式第4条消息
队列1接收到的消息是：发布订阅模式第5条消息
队列1接收到的消息是：发布订阅模式第6条消息
队列2接收到的消息是：发布订阅模式第3条消息
队列2接收到的消息是：发布订阅模式第4条消息
队列2接收到的消息是：发布订阅模式第5条消息
队列2接收到的消息是：发布订阅模式第6条消息
队列2接收到的消息是：发布订阅模式第7条消息
队列2接收到的消息是：发布订阅模式第8条消息
队列2接收到的消息是：发布订阅模式第9条消息
队列2接收到的消息是：发布订阅模式第10条消息
队列2接收到的消息是：发布订阅模式第11条消息
队列2接收到的消息是：发布订阅模式第12条消息
队列2接收到的消息是：发布订阅模式第13条消息
队列2接收到的消息是：发布订阅模式第14条消息
队列2接收到的消息是：发布订阅模式第15条消息
队列2接收到的消息是：发布订阅模式第16条消息
队列2接收到的消息是：发布订阅模式第17条消息
队列2接收到的消息是：发布订阅模式第18条消息
队列1接收到的消息是：发布订阅模式第7条消息
队列1接收到的消息是：发布订阅模式第8条消息
队列1接收到的消息是：发布订阅模式第9条消息
队列1接收到的消息是：发布订阅模式第10条消息
队列1接收到的消息是：发布订阅模式第11条消息
队列1接收到的消息是：发布订阅模式第12条消息
队列1接收到的消息是：发布订阅模式第13条消息
队列1接收到的消息是：发布订阅模式第14条消息
队列1接收到的消息是：发布订阅模式第15条消息
队列1接收到的消息是：发布订阅模式第16条消息
队列1接收到的消息是：发布订阅模式第17条消息
队列1接收到的消息是：发布订阅模式第18条消息
队列1接收到的消息是：发布订阅模式第19条消息
队列1接收到的消息是：发布订阅模式第20条消息
队列1接收到的消息是：发布订阅模式第21条消息
队列1接收到的消息是：发布订阅模式第22条消息
队列2接收到的消息是：发布订阅模式第19条消息
队列2接收到的消息是：发布订阅模式第20条消息
队列2接收到的消息是：发布订阅模式第21条消息
队列2接收到的消息是：发布订阅模式第22条消息
队列2接收到的消息是：发布订阅模式第23条消息
队列2接收到的消息是：发布订阅模式第24条消息
队列2接收到的消息是：发布订阅模式第25条消息
队列2接收到的消息是：发布订阅模式第26条消息
队列1接收到的消息是：发布订阅模式第23条消息
队列1接收到的消息是：发布订阅模式第24条消息
队列1接收到的消息是：发布订阅模式第25条消息
队列1接收到的消息是：发布订阅模式第26条消息
队列1接收到的消息是：发布订阅模式第27条消息
队列1接收到的消息是：发布订阅模式第28条消息
队列1接收到的消息是：发布订阅模式第29条消息
队列1接收到的消息是：发布订阅模式第30条消息
队列1接收到的消息是：发布订阅模式第31条消息
队列1接收到的消息是：发布订阅模式第32条消息
队列1接收到的消息是：发布订阅模式第33条消息
队列1接收到的消息是：发布订阅模式第34条消息
队列1接收到的消息是：发布订阅模式第35条消息
队列1接收到的消息是：发布订阅模式第36条消息
队列2接收到的消息是：发布订阅模式第27条消息
队列1接收到的消息是：发布订阅模式第37条消息
队列2接收到的消息是：发布订阅模式第28条消息
队列2接收到的消息是：发布订阅模式第29条消息
队列2接收到的消息是：发布订阅模式第30条消息
队列2接收到的消息是：发布订阅模式第31条消息
队列2接收到的消息是：发布订阅模式第32条消息
队列1接收到的消息是：发布订阅模式第38条消息
队列2接收到的消息是：发布订阅模式第33条消息
队列2接收到的消息是：发布订阅模式第34条消息
队列2接收到的消息是：发布订阅模式第35条消息
队列2接收到的消息是：发布订阅模式第36条消息
队列2接收到的消息是：发布订阅模式第37条消息
队列1接收到的消息是：发布订阅模式第39条消息
队列1接收到的消息是：发布订阅模式第40条消息
队列1接收到的消息是：发布订阅模式第41条消息
队列1接收到的消息是：发布订阅模式第42条消息
队列1接收到的消息是：发布订阅模式第43条消息
队列1接收到的消息是：发布订阅模式第44条消息
队列1接收到的消息是：发布订阅模式第45条消息
队列2接收到的消息是：发布订阅模式第38条消息
队列1接收到的消息是：发布订阅模式第46条消息
队列1接收到的消息是：发布订阅模式第47条消息
队列1接收到的消息是：发布订阅模式第48条消息
队列1接收到的消息是：发布订阅模式第49条消息
队列1接收到的消息是：发布订阅模式第50条消息
队列1接收到的消息是：发布订阅模式第51条消息
队列1接收到的消息是：发布订阅模式第52条消息
队列1接收到的消息是：发布订阅模式第53条消息
队列1接收到的消息是：发布订阅模式第54条消息
队列2接收到的消息是：发布订阅模式第39条消息
队列2接收到的消息是：发布订阅模式第40条消息
队列2接收到的消息是：发布订阅模式第41条消息
队列2接收到的消息是：发布订阅模式第42条消息
队列2接收到的消息是：发布订阅模式第43条消息
队列2接收到的消息是：发布订阅模式第44条消息
队列2接收到的消息是：发布订阅模式第45条消息
队列2接收到的消息是：发布订阅模式第46条消息
队列2接收到的消息是：发布订阅模式第47条消息
队列2接收到的消息是：发布订阅模式第48条消息
队列1接收到的消息是：发布订阅模式第55条消息
队列1接收到的消息是：发布订阅模式第56条消息
队列1接收到的消息是：发布订阅模式第57条消息
队列1接收到的消息是：发布订阅模式第58条消息
队列1接收到的消息是：发布订阅模式第59条消息
队列1接收到的消息是：发布订阅模式第60条消息
队列1接收到的消息是：发布订阅模式第61条消息
队列1接收到的消息是：发布订阅模式第62条消息
队列1接收到的消息是：发布订阅模式第63条消息
队列1接收到的消息是：发布订阅模式第64条消息
队列1接收到的消息是：发布订阅模式第65条消息
队列1接收到的消息是：发布订阅模式第66条消息
队列1接收到的消息是：发布订阅模式第67条消息
队列1接收到的消息是：发布订阅模式第68条消息
队列1接收到的消息是：发布订阅模式第69条消息
队列1接收到的消息是：发布订阅模式第70条消息
队列2接收到的消息是：发布订阅模式第49条消息
队列2接收到的消息是：发布订阅模式第50条消息
队列2接收到的消息是：发布订阅模式第51条消息
队列2接收到的消息是：发布订阅模式第52条消息
队列2接收到的消息是：发布订阅模式第53条消息
队列2接收到的消息是：发布订阅模式第54条消息
队列2接收到的消息是：发布订阅模式第55条消息
队列2接收到的消息是：发布订阅模式第56条消息
队列2接收到的消息是：发布订阅模式第57条消息
队列2接收到的消息是：发布订阅模式第58条消息
队列2接收到的消息是：发布订阅模式第59条消息
队列2接收到的消息是：发布订阅模式第60条消息
队列2接收到的消息是：发布订阅模式第61条消息
队列2接收到的消息是：发布订阅模式第62条消息
队列2接收到的消息是：发布订阅模式第63条消息
队列2接收到的消息是：发布订阅模式第64条消息
队列1接收到的消息是：发布订阅模式第71条消息
队列1接收到的消息是：发布订阅模式第72条消息
队列1接收到的消息是：发布订阅模式第73条消息
队列1接收到的消息是：发布订阅模式第74条消息
队列1接收到的消息是：发布订阅模式第75条消息
队列1接收到的消息是：发布订阅模式第76条消息
队列1接收到的消息是：发布订阅模式第77条消息
队列1接收到的消息是：发布订阅模式第78条消息
队列1接收到的消息是：发布订阅模式第79条消息
队列1接收到的消息是：发布订阅模式第80条消息
队列1接收到的消息是：发布订阅模式第81条消息
队列1接收到的消息是：发布订阅模式第82条消息
队列1接收到的消息是：发布订阅模式第83条消息
队列1接收到的消息是：发布订阅模式第84条消息
队列1接收到的消息是：发布订阅模式第85条消息
队列1接收到的消息是：发布订阅模式第86条消息
队列2接收到的消息是：发布订阅模式第65条消息
队列2接收到的消息是：发布订阅模式第66条消息
队列2接收到的消息是：发布订阅模式第67条消息
队列2接收到的消息是：发布订阅模式第68条消息
队列2接收到的消息是：发布订阅模式第69条消息
队列2接收到的消息是：发布订阅模式第70条消息
队列2接收到的消息是：发布订阅模式第71条消息
队列2接收到的消息是：发布订阅模式第72条消息
队列2接收到的消息是：发布订阅模式第73条消息
队列2接收到的消息是：发布订阅模式第74条消息
队列2接收到的消息是：发布订阅模式第75条消息
队列2接收到的消息是：发布订阅模式第76条消息
队列2接收到的消息是：发布订阅模式第77条消息
队列2接收到的消息是：发布订阅模式第78条消息
队列2接收到的消息是：发布订阅模式第79条消息
队列2接收到的消息是：发布订阅模式第80条消息
队列1接收到的消息是：发布订阅模式第87条消息
队列1接收到的消息是：发布订阅模式第88条消息
队列1接收到的消息是：发布订阅模式第89条消息
队列1接收到的消息是：发布订阅模式第90条消息
队列1接收到的消息是：发布订阅模式第91条消息
队列1接收到的消息是：发布订阅模式第92条消息
队列1接收到的消息是：发布订阅模式第93条消息
队列1接收到的消息是：发布订阅模式第94条消息
队列1接收到的消息是：发布订阅模式第95条消息
队列1接收到的消息是：发布订阅模式第96条消息
队列1接收到的消息是：发布订阅模式第97条消息
队列1接收到的消息是：发布订阅模式第98条消息
队列1接收到的消息是：发布订阅模式第99条消息
队列2接收到的消息是：发布订阅模式第81条消息
队列2接收到的消息是：发布订阅模式第82条消息
队列2接收到的消息是：发布订阅模式第83条消息
队列2接收到的消息是：发布订阅模式第84条消息
队列2接收到的消息是：发布订阅模式第85条消息
队列2接收到的消息是：发布订阅模式第86条消息
队列2接收到的消息是：发布订阅模式第87条消息
队列2接收到的消息是：发布订阅模式第88条消息
队列2接收到的消息是：发布订阅模式第89条消息
队列2接收到的消息是：发布订阅模式第90条消息
队列2接收到的消息是：发布订阅模式第91条消息
队列2接收到的消息是：发布订阅模式第92条消息
队列2接收到的消息是：发布订阅模式第93条消息
队列2接收到的消息是：发布订阅模式第94条消息
队列2接收到的消息是：发布订阅模式第95条消息
队列2接收到的消息是：发布订阅模式第96条消息
队列2接收到的消息是：发布订阅模式第97条消息
队列2接收到的消息是：发布订阅模式第98条消息
队列2接收到的消息是：发布订阅模式第99条消息

消费者1和消费者2接收到的消息是一模一样的，每个消费者都收到了生产者发送的消息；