RabbitMQ从入门到精通（二）+几种模式及java如何操作

最新推荐文章于 2024-07-10 13:22:05 发布
置顶 最新推荐文章于 2024-07-10 13:22:05 发布
阅读量756 收藏 11
点赞数 9
文章标签： rabbitmq java 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigGreySheep/article/details/115321774
版权

一，RabbitMQ的五种模式

1.简单模式
包含一个生产者、一个消费者和一个队列，生产者向队列发送消息，消费者从队列中获取并消费消息。
在这里插入图片描述
P为生产者，C为消费者，中间为消息队列，下面我们简单的用代码实现。
首先，新建一个maven项目，导入相关的maven依赖。

 <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>5.9.0</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.25</version>
    </dependency>

在这里插入图片描述
简单模式的系统结构，新建一个生产者和消费者。
生产者的代码如下

public class Produce {

    @Test
    public void sendMessage() throws Exception {
        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2.设置相关参数
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("123456");
        connectionFactory.setVirtualHost("v-test");
        //3.从连接工厂里面创建一个连接
        Connection connection = connectionFactory.newConnection();
        //4.创建一个通道
        Channel channel = connection.createChannel();
        /**
         * 5.绑定队列
         *
         * 参数1：队列名，如果发送消息时，队列在mq里面不存在，它会创建一个新的队列；
         * 参数2：是否持久化 如果为False,当MQ重启时，消息会丢失；D代表持久化（队列持久化）
         * 参数3：是否独享，true代表只有当前的connection可以访问到这个队列；
         * 参数4：是否自动删除，是否用完之后就删除这个队列
         * 参数5：其他参数
         */
        channel.queueDeclare("hello", true, false, false, null);

        /**
         * 6.发消息
         *
         * 参数1：交换机
         * 参数2：队列名
         * 参数3：相关属性（消息持久化）
         * 参数4：消息体
         *
         */
        channel.basicPublish("", "hello", MessageProperties.PERSISTENT_TEXT_PLAIN, "hello rabbitmq".getBytes());
        //7.关闭通道和连接
        channel.close();
        connection.close();

        System.out.println("消息发送成功");

    }
}

消费者的代码如下

public class Consumer {


    @Test
    public void receiveMessage() throws Exception {
        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2.设置相关参数
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("123456");
        connectionFactory.setVirtualHost("v-test");
        //3.从连接工厂里面创建一个连接
        Connection connection = connectionFactory.newConnection();
        //4.创建一个通道
        Channel channel = connection.createChannel();
        /**
         * 5.绑定队列
         *
         * 参数1：队列名，如果发送消息时，队列在mq里面不存在，它会创建一个新的队列；
         * 参数2：是否持久化 如果为False,当MQ重启时，消息会丢失；D代表持久化（队列持久化）
         * 参数3：是否独享，true代表只有当前的connection可以访问到这个队列；
         * 参数4：是否自动删除，是否用完之后就删除这个队列
         * 参数5：其他参数
         */
        channel.queueDeclare("hello", true, false, false, null);

        /**
         * 6.接收消息
         *
         * 参数一：队列名
         * 参数二：是否自动签收
         *
         */
        channel.basicConsume("hello", true, new DefaultConsumer(channel) {
        /**
         *
         * @param consumerTag
         * @param envelope
         * @param properties
         * @param body     消息体
         * @throws IOException
         */
        @Override
        public void handleDelivery (String consumerTag, Envelope envelope, AMQP.BasicProperties properties,byte[] body) throws
        IOException {
            System.out.println("消费者接收到消息体：" + new String(body));
        }
    });

        //不能让程序结束
        System.in.read();

}
}

生产者发送消息成功
在这里插入图片描述
消费者接收消息成功
在这里插入图片描述
2.工作模式（workPattern）
工作模式是指多个相互竞争的消费者发送消息的模式，它包含一个生产者、两个消费者和一个队列。两个消费者同时绑定到一个队列上去，当消费者获取消息处理耗时任务时，空闲的消费者从队列中获取b并消费队列。
在这里插入图片描述

由于我们的生产者和消费者都要连接Rabbitmq导致有很多重复性代码，所以，将连接代码写成工具类以供调用。
工具类代码

public class RabbitMQUtil {
    private static ConnectionFactory connectionFactory;
    static {
        //创建一个连接工厂
        connectionFactory = new ConnectionFactory();
        //设置相关参数
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("123456");
        connectionFactory.setVirtualHost("/v-test");
    }

    /**
     * 获取连接的方法
     */
    public static Connection getConnection() {
        try {
            //从连接工厂里面创建一个连接
            Connection connection = connectionFactory.newConnection();
            return connection;
        } catch (Exception e) {
            System.out.println("抛出异常：" + e);
        }
        return null;
    }

    /**
     * 关闭连接及通道
     * @param connection
     * @param channel
     */
    public static void closeChannelAndConnection(Connection connection, Channel channel){
        try{
            connection.close();
            channel.close();
        }catch (Exception e){
            System.out.println(e);
        }

    }
}

工作模式的代码结构
在这里插入图片描述
生产者的代码：

public class Produce {
    @Test
    public void sendMessage() throws Exception {
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("hello", false, false, false, null);
        //发送消息
        for (int i = 0; i < 10; i++) {
            channel.basicPublish("", "hello", null, ("helloRabbitMq" + i).getBytes());
        }
        //关闭
        RabbitMQUtil.closeChannelAndConnection(connection, channel);
        System.out.println("消息发送完成");
    }
}

消费者1的代码：

public class Consumer1 {
    private int i = 0;

    @Test
    public void receiveMessage() throws Exception {
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        final Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("hello", false, false, false, null);
        //设置一次只接收一条未接受的数据
        channel.basicQos(2);
        //接收消息
        channel.basicConsume("hello", false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//                try {
//                    Thread.sleep(500);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                i++;
//                if (i <= 2) {
//                    int a = 10 / 0;
//                }
                System.out.println("消费者【1】接收到消息:" + new String(body));
                /**
                 * 手动确认签收消息（消费完一条消息要自动发送消息给MQ）
                 * 标签1：消息的投递ID
                 * 标签2：是否批量签收
                 */
                channel.basicAck(envelope.getDeliveryTag(), false);
            }

        });

        //不能让程序结束
        System.in.read();
        RabbitMQUtil.closeChannelAndConnection(connection, channel);
        }
    }

消费者2的代码：

public class Consemer2 {
    @Test
    public void receiveMessage() throws Exception {
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("hello", false, false, false, null);
        //接收消息
        channel.basicConsume("hello", true, 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));
            }
        });

        //不能让程序结束
        System.in.read();
        RabbitMQUtil.closeChannelAndConnection(connection, channel);

    }
}

运行结果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
根据两个消费者的消费力不同，所以消费的数据量并不相同。
3.发布/订阅模式（fanout）
指同时向多个消费者发送消息的模式（类似广播），它包括一个生产者、两个消费者、两个队列和一个交换机。两个消费者同时绑定到不同的队列上，两个队列绑定到交换机上去，生产者通过发送消息到交换机，所有消费者接收并消费消息。
在这里插入图片描述
fanout模式结构
在这里插入图片描述
生产者代码：

public class Produce {

    @Test
    public void sendMessage() throws Exception{
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //设置交换机
        channel.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
        //向交换机发消息
        channel.basicPublish("logs","",null,"我是一个fount类型的消息".getBytes());
        //关闭资源
        RabbitMQUtil.closeChannelAndConnection(connection,channel);

    }
}

消费者1代码：

public class Consumer1 {
    @Test
    public void receiveMessage() throws Exception {
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //设置交换机
        channel.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
        //从通道里面获取一个临时队列
        String queue = channel.queueDeclare().getQueue();
        /**
         * 把临时队列和交换机进行绑定
         *
         * 参数1：队列
         * 参数2：交换机
         * 参数3：路由key
         */
        channel.queueBind(queue,"logs","");
        //接收消息
        channel.basicConsume(queue,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));
            }
        });
        System.out.println("消费者【1】启动成功");
        //不能让程序结束
        System.in.read();

    }
}

消费者2代码：

public class Consumer2 {
    @Test
    public void receiveMessage() throws Exception {
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //设置交换机
        channel.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
        //从通道里面获取一个临时队列
        String queue = channel.queueDeclare().getQueue();
        /**
         * 把临时队列和交换机进行绑定
         *
         * 参数1：队列
         * 参数2：交换机
         * 参数3：路由key
         */
        channel.queueBind(queue,"logs","");
        //接收消息
        channel.basicConsume(queue,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));
            }
        });
        System.out.println("消费者【2】启动成功");
        //不能让程序结束
        System.in.read();

    }
}

结果：
在这里插入图片描述
在这里插入图片描述
4.路由模式
路由模式是可以根据路由键选择性给多个消费者发送消息的模式，它包括一个生产者、两个消费者、两个队列和一个交换机。两个消费者同时绑定到不同的不同的队列上去，两个队列通过路由键绑定到交换机上，生产者发送消息到交换机，交换机通过路由键转发到不同队列，队列绑定的消费者接受消息。
在这里插入图片描述
代码结构：
在这里插入图片描述
生产者代码：

public class Produce {
    @Test
    public void sendMessage() throws Exception{
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //设置交换机
        channel.exchangeDeclare("logs", BuiltinExchangeType.DIRECT);
        //向交换机发消息 打了四条消息，分别指定了路由key
        channel.basicPublish("logs","info",null,"我是一个routingKey-direct类型的消息-info".getBytes());
        channel.basicPublish("logs","warm",null,"我是一个routingKey-direct类型的消息-warm".getBytes());
        channel.basicPublish("logs","debug",null,"我是一个routingKey-direct类型的消息-debug".getBytes());
        channel.basicPublish("logs","error",null,"我是一个routingKey-direct类型的消息-error".getBytes());
        //关闭资源
        RabbitMQUtil.closeChannelAndConnection(connection,channel);

    }
}

消费者代码：

public class Consumer1 {
    @Test
    public void receiveMessage() throws Exception {
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //设置交换机
        channel.exchangeDeclare("logs", BuiltinExchangeType.DIRECT);
        //从通道里面获取一个临时队列
        String queue = channel.queueDeclare().getQueue();
        /**
         * 把临时队列和交换机进行绑定
         *
         * 参数1：队列
         * 参数2：交换机
         * 参数3：路由key
         */
        channel.queueBind(queue,"logs","info");
        channel.queueBind(queue,"logs","warm");
        //接收消息
        channel.basicConsume(queue,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者【info】接收到消息"+new String(body));
            }
        });
        System.out.println("消费者【info】启动成功");
        //不能让程序结束
        System.in.read();

    }
}

结果：
在这里插入图片描述
消费者值监听了绑定路由key的消息，其他消息并未被消费。
5.通配符模式
通配符模式是可以根据路由键匹配规则选择性给多个消费者发送消息的模式，它包含一个生产者、两个消费者、两个队列和一个交换机。两个消费者同时绑定到不同的队列上去，两个队列通过路由键匹配规则绑定到交换机上去，生产者发送消息到交换机，交换机通过路由键匹配规则转发到不同队列，队列绑定的消费者接收并消费消息。
在这里插入图片描述
代码结构
在这里插入图片描述
生产者代码

public class Produce {
    @Test
    public void sendMessage() throws Exception{
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //设置交换机
        channel.exchangeDeclare("topic", BuiltinExchangeType.TOPIC);
        //向交换机发消息 打了四条消息，分别指定了路由key
        channel.basicPublish("topic","com.mean",null,"我是一个routingKey-topic类型的消息mean".getBytes());
        channel.basicPublish("topic","com.mean.src",null,"我是一个routingKey-topic类型的消息mean.src".getBytes());
        //关闭资源
        RabbitMQUtil.closeChannelAndConnection(connection,channel);

    }
}

消费者*的代码：

public class Consumer1 {
    @Test
    public void receiveMessage() throws Exception {
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //设置交换机
        channel.exchangeDeclare("topic", BuiltinExchangeType.TOPIC);
        //从通道里面获取一个临时队列
        String queue = channel.queueDeclare().getQueue();
        /**
         * 把临时队列和交换机进行绑定
         *
         * 参数1：队列
         * 参数2：交换机
         * 参数3：路由key
         */
        channel.queueBind(queue,"topic","com.*");
        //接收消息
        channel.basicConsume(queue,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者【*】接收到消息"+new String(body));
            }
        });
        System.out.println("消费者【*】启动成功");
        //不能让程序结束
        System.in.read();

    }
}

消费者#的代码：

public class Consumer2 {
    @Test
    public void receiveMessage() throws Exception {
        Connection connection = RabbitMQUtil.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //设置交换机
        channel.exchangeDeclare("topic", BuiltinExchangeType.TOPIC);
        //从通道里面获取一个临时队列
        String queue = channel.queueDeclare().getQueue();
        /**
         * 把临时队列和交换机进行绑定
         *
         * 参数1：队列
         * 参数2：交换机
         * 参数3：路由key
         */
        channel.queueBind(queue,"topic","com.#");
        //接收消息
        channel.basicConsume(queue,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者【#】接收到消息"+new String(body));
            }
        });
        System.out.println("消费者【#】启动成功");
        //不能让程序结束
        System.in.read();

    }
}

运行结果：
在这里插入图片描述
在这里插入图片描述
由此可直观的看到#和 * 的区别，即符号“#”匹配路由键的一个或多个词，“*”符号匹配路由键的一个词。

BigGreySheep
关注
【SpringCloud】整合RabbitMQ六大模式应用（入门到精通）
qq_1801743621的博客
08-08 1297
【SpringCloud】整合RabbitMQ六大模式（入门到精通）。只有一个生产者（用于生产消息），一个队列 Queue（用于存储消息），一个消费者（用于接收消息）生产者将消息直接发送到指定队列，消费者通过监听该队列名称进行消费。注意：生产者与消费者消息模板类属性应该保证一致。简单模式也用到了交换机，使用的是默认的。.................................
java从入门到精通txt下载，你不懂还不学？
m0_56824583的博客
07-10 145
1、背景 首先，让我们简要地讨论下每个系统，以了解它们的高级设计和架构，看下每个系统所做的权衡。 Kafka 是一个开源的分布式事件流处理平台，也是 Apache 软件基金会下五个最活跃的项目之一。在其核心，Kafka 被设计成一个多副本的分布式持久化提交日志，用于支撑事件驱动的微服务或大规模流处理应用程序。客户端向代理集群提供事件或使用代理集群的事件，而代理会向底层文件系统写入或从底层文件系统读取事件，并自动在集群中同步或异步地复制事件，以实现容错性和高可用性。 Pulsar 是一个开源的分布式发布 /
mq的几种基本类型
weixin_73169334的博客
04-16 781
在此过程中，也可能出现延迟发送消息也出现问题，为了更深层次保证消息的可靠性，还需要一个定时检查服务，每隔一段时间，定时检查服务会把MDB中的消息和DB中的消息进行匹配（检查某个时间段的表，而不是全表扫面），如果MDB出现消息缺失，就会调用生产者重新发送消息。在这个过程中可能会出现异常或者网络波动，就会导致消息到不了回调检查服务，所以为了保证消息的可靠性，会让生产者延迟一段时间后，再发送一个相同的消息给MQ，这个消息会被MQ发送到回调检查服务。消息消费者，负责消费消息，一般是后台系统负责异步消费。
学习笔记之MQ的几种模式
weixin_30878501的博客
08-16 697
MQ的几种模式： Producer消息产生者，红色队列，Customer消息消费者，蓝色交换机exchange 简单模式：消息产生者产生消息，消息的消费者进行消费 工作模式：消息消...
RabbitMQ工作模式详解，以及Java实现
最新发布
qq_69331283的博客
07-10 1294
RabbitMQ共有六种工作模式：简单模式（Simple）、工作队列模式（Work Queue）、发布订阅模式（Publish/Subscribe）、路由模式（Routing）、通配符模式（Topics）、远程调用模式（RPC，不常用，不做讲解说明）
RabbitMQ从入门到精通【二】RabbitMQ安装
PowerfulQ的博客
09-30 249
一、RabbitMQ安装准备 二、Windows安装 三、Linux安装 四、集群部署
RabbitMq工作模式
@王某人
11-10 2481
rabbitMq工作模式 Work queues工作队列模式 模式说明 Work Queues 与入门程序的 简单模式 相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。 订阅模式概述 订阅模式示例图： 前面2个案例中，只有3个角色： P：生产者，也就是要发送消息的程序 C：消费者：消息的接受者，会一直等待消息到来。 queue：消息队列，图中红色部分 而在订阅模型中，多了一个exchange角色，而且过程略有变化
【详细】Linux下安装配置RabbitMQ教程
m0_37218227的博客
08-29 744
最近业务涉及到了数据的传输，因为涉及数据的持久化，因此接触到了RabbitMQ，这款消息队列工具，特此记录学习一下。 1. RabbitMQ简介 介绍RabbitMQ之前，需要先介绍一下什么是消息队列（Message Queue，简称MQ），从字面意思上看，本质是个队列，FIFO先入先出，只不过队列中存放的内容是message而已。 消息队列的主要用途...
RabbitMQ从入门到精通----编码与模式
秀秀的博客
12-12 2453
初始需求正如我们在使用RabbitMQ中，我们的初始需求并不是单纯的想要寻找一个消息队列，而我们的需求是解耦应用程序之间的耦合或者是将一个耗时的操作从应用中剥离出来，异或者整合不同的语言编写出来的应用程序，但是这些问题的本质就是解耦与操作。或者换种方法进行理解是我们可以把同步的应用程序转换为异步的操作，主程序进行其他操作时，我们可以将信息来发送到队列中，然后去做其他的事情，然后等待消息的返回，而不用
后端开发学习指南：从入门到精通的路径规划
04-28
### 后端开发学习指南：从入门到精通的路径规划 #### 一、基础编程语言 在后端开发中，选择合适的编程语言是至关重要的第一步。以下几种编程语言被广泛应用于后端开发： 1. **Java**：Java 是一种跨平台的面向...
Java开发自学教程！java从入门到精通txt下载
热门推荐
m0_57286518的博客
07-07 2万+
1、背景 首先，让我们简要地讨论下每个系统，以了解它们的高级设计和架构，看下每个系统所做的权衡。 Kafka 是一个开源的分布式事件流处理平台，也是 Apache 软件基金会下五个最活跃的项目之一。在其核心，Kafka 被设计成一个多副本的分布式持久化提交日志，用于支撑事件驱动的微服务或大规模流处理应用程序。客户端向代理集群提供事件或使用代理集群的事件，而代理会向底层文件系统写入或从底层文件系统读取事件，并自动在集群中同步或异步地复制事件，以实现容错性和高可用性。 Pulsar 是一个开源的分布式发布 /
java mq几种模式_RabbitMQ--其他几种模式
weixin_30653755的博客
02-27 205
本文是作者原创,版权归作者所有.若要转载,请注明出处.本文RabbitMQ版本为rabbitmq-server-3.7.17,erlang为erlang-22.0.7.请各位去官网查看版本匹配和下载,也可以留言,我发安装包首先我们看一下官网的图上篇文章中我们介绍了第一个简单模式,本文我们来介绍其他2-5的模式,开始吧Work queues工作队列模式Work Queues与入门程序的简单模式相比，...
java mq几种模式_RabbitMq的几种模式
weixin_34688479的博客
02-27 411
1.RabbitMq的队列的模式 2.RabbitMq的工作队列的模式 3.RabbitMq的发布订阅模式-Fanout模式 什么是发布订阅的fanout的模式？fanout模式又称广播模式即就是在交换机接收到消息后向队列中发送消息是没有任何的规则的，单纯的就是将消息交给后面的队列组进行处理即可;扇型交换机，这个交换机没有路由键概念，就算你绑了路由键也是无视的。 这个交换机在接收到消息后，会直接转...
RabbitMQ的几种模式(一)
Mensonge的博客
11-30 265
RabbitMQ存在6种实现 如下图（当前只研究前5种简单demo实现） HelloWorld 简单模式 如下图 简单模式就是一个生产者通过MQ Server对应一个消费者。 对于MQ服务器来说，无论是生产者还是消费者，都相当于客户端所以我们在pom中引入amqp-client客户端依赖<dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artif
RabbitMQ五大工作模式之简单模式、工作队列模式、发布订阅模式、路由模式、主题模式、RPC模式
lienze.tech
12-31 1652
前言 这几年一直在it行业里摸爬滚打，一路走来，不少总结了一些python行业里的高频面试，看到大部分初入行的新鲜血液，还在为各样的面试题答案或收录有各种困难问题 于是乎，我自己开发了一款面试宝典，希望能帮到大家，也希望有更多的Python新人真正加入从事到这个行业里，让python火不只是停留在广告上。 微信小程序搜索：Python面试宝典 或可关注原创个人博客：https://lienze.tech 也可关注微信公众号，不定时发送各类有趣猎奇的技术文章：Python编程学习 工作模式 通过与各种交换机搭
RabbitMQ二、RabbitMQ的六种模式
学习笔记
06-01 1787
主要了解rabbitmq的六种模式
RabbitMQ的几种模式(二)
Mensonge的博客
12-03 157
接着上篇 pubsub发布订阅模式 一个生产者通过交换机发布到队列中再分别传输给消费者。即生产者P发出的消息传输到交换机，交换机再分发给绑定在它身上的队列，再发送给消费者，C1和C2都会接收到。交换机类型为Fanout(广播型)。 建立一个Producer和多个Consumer 来模拟一个Producer发送天气信息 分别分发到消费端。 package com.orange.rabbitmq.pubsub; import com.orange.rabbitmq.utils.MQConstant; i
MQ的快速入门及RabbitMQ的五种工作模式
weixin_64133130的博客
08-11 3419
Mq消息中间件的基础知识，rabbitmq的工作模式，springboot集成rabbitmq
RabbitMQ学习（五）—五种模式
m0_59350665的博客
06-29 1277
一个消费者将消息首先发送到交换器，交换器绑定到多个队列，然后被监听该队列的消费者所接收并消费。生产者将消息发送到direct交换器，在绑定队列和交换器的时候有一个路由key，生产者发送的消息会指定一个路由key，那么消息只会发送到相应key相同的队列，接着监听该队列的消费者消费消息。交换器允许匹配 AMQP 消息的 header 而非路由键，除此之外，header 交换器和 direct 交换器完全一致，但是性能却差很多，因此基本上不会用到该交换器。与路由模式相似，但是，主题模式是一种模糊的匹配方式。
rabbitmq从入门到精通
05-04
下面是RabbitMQ从入门到精通的介绍： 1. RabbitMQ基础概念： - 消息：在RabbitMQ中，消息是指要传递的数据单元。 - 队列：消息在RabbitMQ中存储的地方，类似于一个邮箱。 - 交换机：接收生产者发送的消息，并将...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值