RabbitMQ-03（实战 、RabbitMQ 的六种消息模式）

已于 2022-08-10 17:26:38 修改
阅读量1.2k 收藏 3
点赞数 1
分类专栏： # RabbitMQ 文章标签： java-rabbitmq rabbitmq spring boot
于 2022-08-10 11:54:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52476654/article/details/126263757
版权

文章目录

七、实战 RabbitMQ 的六种消息模型

官方文档写的很详细：官网：RabbitMQ Tutorials — RabbitMQ

导入 amqp-client 依赖

<!--java原生依赖-->
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.10.0</version>
</dependency>

1. 基本消息模式

单个消费端情况

image-20220809172036438

  • P：生产者：发送消息
  • C：消费者：接收消息
  • queue：消息队列，图中红色部分。可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

新建一个连接工具类：

public class ConnectionUtil {

    public static Connection getConnection() throws IOException, TimeoutException {
        // 所以的中间件技术都是基于 tcp/ip 协议 或者 是在此协议基础之上构建新型的协议规范，rabbitmq 遵循的是 AMQP 协议
        // 既然都是以 tcp/ip 协议为基础的，那么都需要设置 ip 和端口port

        // 1：创建连接工厂 并配置信息
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //配置属性
        connectionFactory.setHost("xxxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("xxxx");
        connectionFactory.setVirtualHost("/");//将所有消息发到根目录节点
        Connection connection = connectionFactory.newConnection();
        return connection;
    }
}

生产者发送消息：

public class Send {
    public static final String QUEUE_NAME="simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.获取连接
        Connection connection = ConnectionUtil.getConnection();
        // 2.创建通道
        Channel channel = connection.createChannel();
        // 3.声明队列
        /**
         * 参数明细
         * 1、queue 队列名称
         * 2、durable 是否持久化，如果持久化，mq重启后队列还在
         * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
         * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
         * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        // 4.发送消息
        String message = "Hello Rabbit!";
        // 向指定的队列中发送消息
        channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
        // 5.关闭通道
        channel.close();
        // 6.关闭连接
        connection.close();
    }
}

image-20220809174029841

image-20220809174055416

消费者接收消息：

public class Recv {
    private final static String QUEUE_NAME = "simple_queue";

    public static void main(String[] argv) throws IOException, TimeoutException {
        // 1.获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 2.创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();
        // 3.声明队列
        //参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
        /**
         * 参数明细
         * 1、queue 队列名称
         * 2、durable 是否持久化，如果持久化，mq重启后队列还在
         * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
         * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
         * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
         */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 4.监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel){
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            /**
             * 当接收到消息后此方法将被调用
             * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
             * @param envelope 信封，通过envelope
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException, UnsupportedEncodingException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                // body 即消息体
                String msg = new String(body,"utf-8");
                System.out.println(" [x] received : " + msg + "!");
            }
        };

        // 监听队列，第二个参数：是否自动进行消息确认。
        //参数：String queue, boolean autoAck, Consumer callback
        /**
         * 参数明细：
         * 1、queue 队列名称
         * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为true表示会自动回复mq，如果设置为false要通过编程实现回复
         * 3、callback，消费方法，当消费者接收到消息要执行的方法
         */
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

消息被消耗了

image-20220809174627252

2.work消息模式

多个消费端情况

工作队列或者竞争消费者模式

image-20220809201837248

两个消费端竞争获取生产者发布的消息，假设有一个消费端处理速度较慢来模拟实际环境。

2.1 轮询模式

轮询模式：一个消费者一条，按均分配

生产者循环发送50条消息：

public class Send {
    public static final String QUEUE_NAME="simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        // 1.获取连接
        Connection connection = ConnectionUtil.getConnection();
        // 2.创建通道
        Channel channel = connection.createChannel();
        // 3.声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        for (int i = 0;i < 50;i++){
            // 4.发送消息
            String message = "Hello Rabbit!";
            // 向指定的队列中发送消息
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
            Thread.sleep(i * 2);
        }
        // 5.关闭通道
        channel.close();
        // 6.关闭连接
        connection.close();
    }
}

处理速度较慢的消费者：

public class Recv {
    private final static String QUEUE_NAME = "simple_queue";
    
    public final static int i = 0;

    public static void main(String[] argv) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException, UnsupportedEncodingException {
                String exchange = envelope.getExchange();
                long deliveryTag = envelope.getDeliveryTag();
                String msg = new String(body,"utf-8");
                System.out.println(" [消费者1] received : " + msg + "!"+"["+(i+1)+"]");
                try {
                    TimeUnit.SECONDS.sleep(1);// 增加耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

提前启动两个消费端，发现，两个消费端都是收到了25条消息。

image-20220809203506535

2.2 公平分发模式

公平分发：根据消费者的消费能力进行公平分发，处理快的处理的多，处理慢的处理的少；按劳分配

在生产者声明队列的时候，修改队列的参数：

channel.basicQos(1);//同一时刻，消费者只会推送一条消息给消费者

这里在消费端自动ACK 的情况下测试，发现依旧是轮询模式。

注意：只有在 消费端手动ACK 的情况下，公平分发模式才有效。

可以看到，高速度的消费端接收了46个消息。

image-20220809210701787

2.3 订阅模型分类

  1. 一个生产者，多个消费者
  2. 每个消费者独占一个队列，每个队列都需要绑定到交换机上
  3. 由生产者生产的消息发送给交换机
  4. 由交换机发送个队列，实现一个消息被多个消费者消费

交换机（Exchanges）：

  • 一方面：接收生产者发送的消息。
  • 另一方面：知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。

Exchange 交换机有以下几种类型（接下来三种消息模式分别使用以下前三种交换机）：

  • Fanout：广播，将消息交给所有绑定到交换机的队列

  • Direct：定向，把消息交给符合指定routing key 的队列

  • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

  • Header：header模式与routing不同的地方在于，header模式取消routingkey，使用header中的 key/value（键值对）匹配队列。

3.Publish/subscribe（交换机类型：Fanout，也称为广播 ）

image-20220809211830566

  • 生产者不声明队列，只声明交换机，将消息发送到交换机
  • 消费者声明队列，并将队列绑定到交换机，从而一个消费端对应一条队列

生产者：

public class Send {
    public static final String EXCHANGE_NAME="fanout_exchange";


    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        // 1.获取连接
        Connection connection = ConnectionUtil.getConnection();
        // 2.创建通道
        Channel channel = connection.createChannel();
        // 3.声明交互机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        // 4.发送消息
        String message = "fanout_exchange send 'hello rabbit！'";
        channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes());
        System.out.println("[生产者] send :"+ message);
        // 5.关闭通道
        channel.close();
        // 6.关闭连接
        connection.close();
    }
}

消费者1、2：

public class Recv {
    private final static String QUEUE_NAME = "fanout_queue_01";//消费者2 fanout_queue_02

    public static final String EXCHANGE_NAME="fanout_exchange";

    public static void main(String[] argv) throws IOException, TimeoutException {
        // 1.获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 2.创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();
        // 3.声明队列
        //参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
        /**
         * 参数明细
         * 1、queue 队列名称
         * 2、durable 是否持久化，如果持久化，mq重启后队列还在
         * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
         * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
         * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
         */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
        // 4.监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel){
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            /**
             * 当接收到消息后此方法将被调用
             * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
             * @param envelope 信封，通过envelope
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException, UnsupportedEncodingException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                // body 即消息体
                String msg = new String(body,"utf-8");
                System.out.println(" [消费者1] received : " + msg);
                channel.basicAck(envelope.getDeliveryTag(),false);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        // 监听队列，第二个参数：是否自动进行消息确认。
        //参数：String queue, boolean autoAck, Consumer callback
        /**
         * 参数明细：
         * 1、queue 队列名称
         * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为true表示会自动回复mq，如果设置为false要通过编程实现回复
         * 3、callback，消费方法，当消费者接收到消息要执行的方法
         */
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

先启动生产者，声明交换机

image-20220810094200116

此时再图形化界面查看交换机，发现并不是像队列一样可以获取到消息，猜测交换机收到的消息如果不能立即发送就会销毁。

image-20220810094930498

此时启动两个消费者，果然没有获取到消息，交换机显示已经绑定了两个队列：

image-20220810095020420

再次启动生产者，成功获取到消息：

image-20220810094623409

image-20220810094613349

Publish/subscribe 与 work消息模式的区别：

  • 一个面向交换机发送消息，一个面向队列发送消息（使用的默认交换机）

4.Routing 路由模型（交换机类型：direct）

image-20220810095524280

上一个模式中的交换机将所有消息广播给所有消费者。我们希望扩展它以允许根据消息的严重性过滤消息。

例如，我们可能希望将日志消息写入磁盘的脚本仅接收严重错误，而不会在警告或信息日志消息上浪费磁盘空间

  • 在发送消息的时候，加上 RoutingKey
  • 消费端可以绑定队列与交换机的时候，设置 RoutingKey ，只有与发送消息附带的 RoutingKey 相同的消费队列才会接收到消息

生产者：

public class Send {
    public static final String EXCHANGE_NAME="direct_exchange";


    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        // 1.获取连接
        Connection connection = ConnectionUtil.getConnection();
        // 2.创建通道
        Channel channel = connection.createChannel();
        // 3.声明交互机
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        // 4.发送消息
        String message = "direct_exchange send 'hello rabbit！'";
        //发送一条报错信息
        channel.basicPublish(EXCHANGE_NAME,"error",null,message.getBytes());
        System.out.println("[生产者] send :"+ message);
        // 5.关闭通道
        channel.close();
        // 6.关闭连接
        connection.close();
    }
}

消费者1（RoutingKey = log）：

public class Recv {
    private final static String QUEUE_NAME = "direct_queue_log";

    public static final String EXCHANGE_NAME="direct_exchange";

    public static void main(String[] argv) throws IOException, TimeoutException {
        // 1.获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 2.创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();
        // 3.声明队列
        //参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
        /**
         * 参数明细
         * 1、queue 队列名称
         * 2、durable 是否持久化，如果持久化，mq重启后队列还在
         * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
         * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
         * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
         */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"log");
        // 4.监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel){
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            /**
             * 当接收到消息后此方法将被调用
             * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
             * @param envelope 信封，通过envelope
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException, UnsupportedEncodingException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                // body 即消息体
                String msg = new String(body,"utf-8");
                System.out.println(" [log] received : " + msg);
                channel.basicAck(envelope.getDeliveryTag(),false);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        // 监听队列，第二个参数：是否自动进行消息确认。
        //参数：String queue, boolean autoAck, Consumer callback
        /**
         * 参数明细：
         * 1、queue 队列名称
         * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为true表示会自动回复mq，如果设置为false要通过编程实现回复
         * 3、callback，消费方法，当消费者接收到消息要执行的方法
         */
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

消费者2（RoutingKey = error）：

public class Recv2 {
    private final static String QUEUE_NAME = "direct_queue_error";

    public static final String EXCHANGE_NAME="direct_exchange";

    public static void main(String[] argv) throws IOException, TimeoutException {
        // 1.获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 2.创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();
        // 3.声明队列
        //参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
        /**
         * 参数明细
         * 1、queue 队列名称
         * 2、durable 是否持久化，如果持久化，mq重启后队列还在
         * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
         * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
         * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
         */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"error");
        // 4.监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel){
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            /**
             * 当接收到消息后此方法将被调用
             * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
             * @param envelope 信封，通过envelope
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException, UnsupportedEncodingException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                // body 即消息体
                String msg = new String(body,"utf-8");
                System.out.println(" [error] received : " + msg);
                channel.basicAck(envelope.getDeliveryTag(),false);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        // 监听队列，第二个参数：是否自动进行消息确认。
        //参数：String queue, boolean autoAck, Consumer callback
        /**
         * 参数明细：
         * 1、queue 队列名称
         * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为true表示会自动回复mq，如果设置为false要通过编程实现回复
         * 3、callback，消费方法，当消费者接收到消息要执行的方法
         */
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

启动生产者 声明交换机：

image-20220810100229585

启动消费者等待消息，显示交换机绑定的队列，同时有 RoutingKey：

image-20220810100427173

再次启动生产者，只有 error 消费端接收到了消息：

image-20220810100724447

image-20220810100730658

5.Topics 通配符模式（交换机类型：topics）

image-20220810101034522

上一个模式的 RoutingKey 并不能满足我们的需求，于是我们在 topics 模式中加入了*、#等通配符。

发送到主题交换的消息不能具有任意routing_key - 它必须是单词列表，由点分隔。这些单词可以是任何内容，但通常它们指定与消息相关的一些功能。一些有效的路由关键示例：“stock.usd.nyse”，“nyse.vmw”，“quick.orange.rabbit”。路由密钥中可以有任意数量的单词，最大限制为 255 个字节。

绑定键也必须采用相同的形式。主题交换背后的逻辑类似于直接交换 - 使用特定路由键发送的消息将被传递到使用匹配绑定键绑定的所有队列。但是，绑定键有两种重要的特殊情况：

  • *（星号）可以正好代替一个词。
  • #（哈希）可以代替零个或多个单词。

主题交换功能强大，可以像其他交换一样运行。

当队列绑定“#”（哈希）绑定键时 - 它将接收所有消息，而不管路由键如何 - 就像在扇出交换中一样。

当绑定中不使用特殊字符“*”（星号）和“#”（哈希）时，主题交换的行为将类似于直接交换。

在二号队列绑定了两个 RoutingKey：

image-20220810102456938

消费者1 收到了，消费者2没有收到：

image-20220810102548625

修改消息：发送：hot.orange.cat

channel.basicPublish(EXCHANGE_NAME,"hot.orange.cat",null,message.getBytes());

两个都获取到了：

image-20220810102707955

image-20220810102715017

6.RPC

RPC 框架很出名，但是 RabbitMQ 实现的 RPC 模式很少用到，这里简单介绍一下。

image-20220810102928171

我们的 RPC 将按如下方式工作：

  • 当客户端启动时，它会创建一个匿名独占回调队列。
  • 对于 RPC 请求，客户端发送一条具有两个属性的消息：reply_to（设置为回调队列）和correlation_id（设置为每个请求的唯一值）。
  • 请求将发送到rpc_queue队列。
  • RPC 工作线程（也称为：服务器）正在等待该队列上的请求。当出现请求时，它会执行作业，并使用reply_to 字段中的队列将包含结果的消息发送回客户端。
  • 客户端等待回调队列上的数据。当出现一条消息时，它会检查correlation_id属性。如果它与请求中的值匹配，则会将响应返回到应用程序。
HotRabbit.
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RabbitMQ实战指南-rabbitmq-action.zip
11-07
**六、RabbitMQ实战应用** 1. **微服务通信**: 在微服务架构中，RabbitMQ可作为服务间的通信桥梁，实现服务解耦和异步处理。 2. **批量处理**: 处理大量数据时，可以将任务放入队列，由后台服务按需处理。 3. **...
rabbitMQ实战java版-rabbitMQ-demo.zip
11-07
《RabbitMQ实战Java版——基于rabbitMQ-demo.zip的详解》 在当今的分布式系统中，消息队列作为异步处理、解耦组件的关键技术，得到了广泛应用。RabbitMQ作为一款开源的消息代理和队列服务器，以其稳定性和易用性...
RabbitMQ：消息模型
栗筝i的博客
12-12 2398
RabbitMQ 提供了 6 种消息模型，分别为：单生产单消费模型（Hello World）、消息分发模型（Work queues）、Fanout 消息订阅模式（Publish/Subscribe）、Direct 路由模式（Routing）、Topic 匹配模式（Topic）、RPC 模式（RPC）。 本篇内容包括：RabbitMQ 6 种消息模型、RabbitMQ 6 种消息模型介绍
5.RabbitMQ消息队列类型（7个）详细使用
相互学习 共同进步
05-22 2393
RabbitMQ是消息代理：接受并转发消息。可以将其视为邮局 将要发布的邮件放在邮箱中时，可以确保邮递员最终将邮件传递给收件人。以此类推，RabbitMQ是一个邮箱、一个邮局和一个邮递员 RabbitMQ与邮局之间的主要区别在于，它不处理纸张。只是做接收、存储和转发数据消息的二进制码 AMQP（Advanced Message Queuing Protocol，高级消息队列协议） 应用层协议的一个开放标准，为面向消息的中间件设计。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性
RabbitMQ 的七种消息传递形式
最新发布
2401_84831774的博客
05-13 317
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
RabbitMQ之五种消息模型
qq_57907966的博客
02-11 1675
虚拟主机：类似于mysql中的database。他们都是以“/”开头。
RabbitMQ3-RabbitMQ消息类型
bobshute的专栏
05-20 5798
1.1 概述 http://www.rabbitmq.com/getstarted.html 1.2 simplest(简单队列) 1.2.1.概述 The simplest thing that does something - 简单队列 生产消费一一对应,耦合性高. - 生产消息快,消费消息慢.如果很多容易堵塞 P:消息生产者;红色的:队列;C:消费者. 1.2...
RabbitMQ五种消息模式
qq_43390704的博客
12-21 3473
1，简单模式 工作的流程: 当生产者生产消息后,将消息发往队列. 当队列中有消息时,消费者会实时的监听队列中的消息.如果有消息则会执行消息 2，工作模式 默认的传统队列是为均摊消费，存在不公平性；如果每个消费者速度不一样的情况下，均摊消费是不公平的，应该是能者多劳。 采用工作队列 在通道中只需要设置basicQos为1即可，表示MQ服务器每次只会给消费者推送1条消息必须手动ack确认之后才会继续发送。channel.basicQos(1); public class ...
rabbitmq实战-rabbitmq-action.zip
11-06
《RabbitMQ实战》 RabbitMQ是一种广泛使用的开源消息队列系统，它基于AMQP（Advanced Message Queuing Protocol）协议，提供可靠、灵活的消息传递服务。本实战指南将深入探讨RabbitMQ的核心概念、安装配置、使用...
rabbitmq 实战练习-rabbitmq-actual.zip
11-07
本实战练习将深入探讨RabbitMQ的核心概念和实际应用，帮助你掌握其核心功能。 1. **RabbitMQ基本概念** - **消息**：消息是RabbitMQ中的基本单元，它包含了一段数据，由生产者发送，通过中间件传递，最终被消费者...
RabbitMQ实战演练-RabbitMQ-Action.zip
11-07
RabbitMQ是一款开源的消息队列系统，基于AMQP（Advanced Message Queuing Protocol）协议实现，广泛应用于分布式系统中，用于处理异步任务、解耦组件以及实现消息传递。本实战演练将带你深入理解RabbitMQ的核心概念...
RabbitMQ详解（三）：消息模式（fanout、direct、topic、work）
weixin_45181611的博客
05-10 3172
消息模式详解
RabbitMQ的5种消息队列
YIYIYI
08-16 3278
RabbitMQ的5种消息队列
谈谈RabbitMQ的五种消息模型以及SpringAMQP的使用
qq_51938362的博客
11-18 685
RabbitMQ的五种模型讲解，以及使用SpringAMQP完成示例代码。
rabbitmq五种消息模型和消息持久化
孟斌斌的博客
03-22 955
当你运行许多消费者时，任务将在他们之间共享，但是一个消息只能被一个消费者获取。Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。在Direct模型下，队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）在某些场景下，我们希望不同的消息被不同的队列消费。消息的发送方在向Exchange发送消息时，也必须指定消息的routing key。​ 5、生产者发送的消息，经过交换机到达队列，实现一个消息被多个消费者获取的目的。
RabbitMQ
私は悪い人ですか的博客
02-04 130
RabbitMQ RabbitMQ是基于AMQP的一款消息管理系统 官网： http://www.rabbitmq.com/ 官方教程：http://www.rabbitmq.com/getstarted.html 安装 下载镜像：docker pull rabbitmq:management 创建实例并启动： docker run -d --name rabbitmq --publish 567...
MQ如何处理消费者的故障和重启问题？MQ的消息格式是怎样的？MQ的消息压缩机制有哪些？MQ的消息的安全性如何保证？
luoluoal的博客
07-25 788
数据完整性校验：可以使用哈希算法对消息进行摘要计算，然后将摘要与消息一起发送，接收端在接收到消息后再次计算摘要，比对发送方计算的摘要与接收到的摘要是否一致，以确保消息在传输过程中没有被篡改。消息头包含了一些元数据信息，如消息的唯一标识符、消息的优先级、消息的发送时间等。在MQ（消息队列）系统中，消息的压缩机制可以通过减小消息的大小来降低网络传输的开销，提高系统的性能和效率。在一些MQ系统中，还可以在消息中添加一些自定义的属性，用于标记和分类消息，以方便消费者根据属性进行消息过滤或路由。
RocketMQ 消息结构和消息类型
jiaomubai的博客
05-27 3052
生产者 Producer 概述和消息结构与消息类型
RabbitMQ的使用及其支持的消息类型
qq_34896730的博客
08-04 4051
RabbitMQ的使用及其支持的消息类型1、RabbitMQ的初使用1.1、创建一个用户1.2、创建虚拟主机1.3、绑定虚拟主机和用户2、RabbitMQ支持的消息模式2.1、AMQP协议的回顾2.2、官方RabbitMQ所支持的消息模式2.3、 在使用RabbitMQ时，我们会先创建一个用户，然后创建一个虚拟主机，给用户添加权限。 1、RabbitMQ的初使用 1.1、创建一个用户 上面的Tags选项，其实是指定用户的角色，可选的有以下几个： 超级管理员(administrator) 可登陆管理控制
rabbitMQ实战
07-30
RabbitMQ是一款基于AMQP协议使用Erlang语言开发的消息队列产品。它提供了6种工作模式，我们通常学习其中的5种。...[1] ...希望这些信息对你的RabbitMQ实战有所帮助。如果你有任何其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HotRabbit.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值