RabbitMQ的五种常见模式

最新推荐文章于 2024-07-10 13:22:05 发布

未来.....

最新推荐文章于 2024-07-10 13:22:05 发布

阅读量518

点赞数

分类专栏： # RabbitMQ 文章标签： rabbitmq

本文链接：https://blog.csdn.net/weixin_43451430/article/details/115920851

版权

RabbitMQ 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

RabbitMQ的五种常见模式

在练习RabbitMQ之前，请确认自己的RabbitMQ已经安装并开启。

1、简单模式

在这里插入图片描述

从图上可以看到只有三个角色:
p 【product】: 生产者发生消息的
红色[queue]: 队列。存储消息的
C [consumer]: 消费者消费消息

创建一个maven项目，创建一个消费者和一个生产者。
在这里插入图片描述
生产者代码：

public class Product {
    public static void main(String[] args) throws Exception{
        //创建链接工厂  ---配置链接信息
        ConnectionFactory factory = new ConnectionFactory();
        //链接地址
        factory.setHost("192.168.31.33");
        //创建链接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        channel.queueDeclare("ban_queue",true,false,false,null);
        //发送消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
            String msg="(*Φ皿Φ*)";
            channel.basicPublish("","ban_queue",null,msg.getBytes());
    }
}

消费者代码：

public class Consumer {
    public static void main(String[] args)throws Exception {
        //创建链接工厂  ---配置链接信息
        ConnectionFactory factory = new ConnectionFactory();
        //链接地址
        factory.setHost("192.168.31.33");
        //创建链接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //接受消息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body接受的信息
                System.out.println("消费者01"+new String(body));
            }
        };
        channel.basicConsume("ban_queue",true,callback);
    }
}

先运行生产者代码，在运行消费者，运行结果如下。
在这里插入图片描述

2、工作者模式

在这里插入图片描述
特点:
1. 一个生产者
2. 由多个消费。
3. 统一个队列。
4. 这些消费者之间存在竞争关系。

用处:
比如批量处理上. rabbitMQ里面积压了大量的消息。

项目同上：
生产者代码：

public class Product {
    public static void main(String[] args) throws Exception{
        //创建链接工厂  ---配置链接信息
        ConnectionFactory factory = new ConnectionFactory();
        //链接地址
        factory.setHost("192.168.31.33");
        //创建链接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        channel.queueDeclare("ban_queue_work",true,false,false,null);
        //发送消息
         for (int i = 0; i < 10; i++) {
            String msg="(*Φ皿Φ*)";
            channel.basicPublish("","ban_queue_work",null,msg.getBytes());
        }
    }
}

如果只运行消费者，通过rabbitMQ的可视化界面发现，队列中有了十条数据，只是没有消费者需要消费。
在这里插入图片描述 消费者01代码：

public class Consumer01 {
    public static void main(String[] args)throws Exception {
        //创建链接工厂  ---配置链接信息
        ConnectionFactory factory = new ConnectionFactory();
        //链接地址
        factory.setHost("192.168.31.33");
        //创建链接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //接受消息
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body接受的信息
                System.out.println("消费者01"+new String(body));
            }
        };
        channel.basicConsume("ban_queue_work",true,callback);
    }
}

消费者02代码：

public class Consumer02 {
    public static void main(String[] args)throws Exception {
        //创建链接工厂  ---配置链接信息
        ConnectionFactory factory = new ConnectionFactory();
        //链接地址
        factory.setHost("192.168.31.33");
        //创建链接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //接受消息
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body接受的信息
                System.out.println("消费者02"+new String(body));
            }
        };
        channel.basicConsume("ban_queue_work",true,callback);
    }
}

运行后，发现消费者开始消费，同时，这里的信息是按照平均分配。
在这里插入图片描述

3、发布订阅模式

在这里插入图片描述
特点:
1.一个生产者
2.多个消费者
3.多个队列。
4.交换机转发消息。

生产者代码：

    public static void main(String[] args) throws Exception{
        //创建链接工厂  ---配置链接信息
        ConnectionFactory factory = new ConnectionFactory();
        //链接地址
        factory.setHost("192.168.31.33");
        //创建链接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        channel.queueDeclare("ban_queue_fanout01",true,false,false,null);
        channel.queueDeclare("ban_queue_fanout02",true,false,false,null);
        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        channel.exchangeDeclare("ban_exchange_fanout03", BuiltinExchangeType.FANOUT,true);
        //绑定交换机
        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        channel.queueBind("ban_queue_fanout01","ban_exchange_fanout03","");
        channel.queueBind("ban_queue_fanout02","ban_exchange_fanout03","");
        //发送消息
         for (int i = 0; i < 10; i++) {
             String msg="(*Φ皿Φ*)"+"第"+i+"次";
            channel.basicPublish("ban_exchange_fanout03","",null,msg.getBytes());
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        channel.close();
        connection.close();
    }

消费者代码01：
代码同上，只需更改队列名。

channel.basicConsume("ban_queue_fanout01",true,callback);

消费者代码02：
代码同上，只需更改队列名。

channel.basicConsume("ban_queue_fanout02",true,callback);

此时运行发布者，然后再RabbitMQ可视化管理界面发现，两个队列都已经获取到了所有信息。

在这里插入图片描述
注意：
如果只运行发布者，此时应该如上图两个队列都拿到信息，但是会出现意外情况，出现下面这种情况，有一个队列直接将信息消费掉了(此时没有运行消费者)
解决方法：在RabbitMQ可视化界面中将两个队列和交换机全部干掉，重新运行发布者，此时应该会恢复正常。

在这里插入图片描述

4、路由模式

在这里插入图片描述
‘’

特点:
1.一个生产者
2.多个消费者
3.多个队列。
4.交换机转发消息。
5.routekey:路由key 只要routekey匹配的消息可以到达对应队列。
生产者代码：

public static void main(String[] args) throws Exception{
        //创建链接工厂  ---配置链接信息
        ConnectionFactory factory = new ConnectionFactory();
        //链接地址
        factory.setHost("192.168.31.33");
        //创建链接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        channel.queueDeclare("ban_queue_direct01",true,false,false,null);
        channel.queueDeclare("ban_queue_direct02",true,false,false,null);
        //创建交换机
        channel.exchangeDeclare("ban_exchange_direct", BuiltinExchangeType.DIRECT,true);
        //绑定交换机
        channel.queueBind("ban_queue_direct01","ban_exchange_direct","error");

        channel.queueBind("ban_queue_direct02","ban_exchange_direct","info");
        channel.queueBind("ban_queue_direct02","ban_exchange_direct","error");
        channel.queueBind("ban_queue_direct02","ban_exchange_direct","warning");
        //发送消息
         for (int i = 0; i < 10; i++) {
             String msg="(*Φ皿Φ*)"+"第"+i+"次";
             //发送info
            channel.basicPublish("ban_exchange_direct","info",null,msg.getBytes());
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        channel.close();
        connection.close();
    }

只运行发布者代码可以发现，只有一个队列接收到了信息。

在这里插入图片描述

修改发布者key，改为error，再次运行。
在这里插入图片描述
两个队列都获取到了信息。

消费者代码01：
代码同上，只需更改队列名。

channel.basicConsume("ban_exchange_direct",true,callback);

消费者代码02：
代码同上，只需更改队列名。

channel.basicConsume("ban_exchange_direct",true,callback);

5、主体模式

在这里插入图片描述 特点：
绑定按照通配符的模式。
*: 统配一个单词。
#: 统配n个单词

例如：
hello.orange.rabbit

lazy.orange

生产者代码：

public static void main(String[] args) throws Exception{
        //创建链接工厂  ---配置链接信息
        ConnectionFactory factory = new ConnectionFactory();
        //链接地址
        factory.setHost("192.168.31.33");
        //创建链接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        channel.queueDeclare("ban_queue_topic01",true,false,false,null);
        channel.queueDeclare("ban_queue_topic02",true,false,false,null);
        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        channel.exchangeDeclare("ban_exchange_topic", BuiltinExchangeType.TOPIC,true);
        //绑定交换机
        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        channel.queueBind("ban_queue_topic01","ban_exchange_topic","*.orange.*");
        channel.queueBind("ban_queue_topic02","ban_exchange_topic","*.*.rabbit");
        channel.queueBind("ban_queue_topic02","ban_exchange_topic","lazy.#");
        //发送消息
         for (int i = 0; i < 10; i++) {
             String msg="(*Φ皿Φ*)"+"第"+i+"次";
            channel.basicPublish("ban_exchange_topic","lazy.orange.rabbit",null,msg.getBytes());
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        channel.close();
        connection.close();
    }

只运行发布者代码可以发现，两个队列接收到了信息。

在这里插入图片描述
修改发布者key，改为lazy.rabbit，再次运行，发现只有队列2获取到了消息。

channel.basicPublish("ban_exchange_topic","lazy.rabbit",null,msg.getBytes());

在这里插入图片描述

未来.....

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
RabbitMQ的五种常见模式

RabbitMQ的五种常见模式在练习RabbitMQ之前，请确认自己的RabbitMQ已经安装并开启。1、简单模式从图上可以看到只有三个角色: p 【product】: 生产者发生消息的红色[queue]: 队列。存储消息的 C [consumer]: 消费者消费消息创建一个maven项目，创建一个消费者和一个生产者。生产者代码：public class Product { public static void main(String[] args)
复制链接

扫一扫