RabbitMQ支持的消息模型

最新推荐文章于 2024-06-27 10:30:09 发布
最新推荐文章于 2024-06-27 10:30:09 发布
阅读量929 收藏 8
点赞数 14
分类专栏： RabbitMQ成长之路 文章标签： rabbitmq spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc_138/article/details/139484010
版权

一、第一种模型(直连)

我们将用Java编写两个程序，发送单个消息的生成者和接收消息并打印出来的消费者。
在下图，“P”是生成者，“C”消费者。中间框是一个队列RabbitMQ保留的消息缓冲区 。

首先构建一个Maven项目，然后引入依赖。

<!-- 导入rabbitmq原生依赖-->
<dependency>
  <groupId>com.rabbitmq</groupId>
  <artifactId>amqp-client</artifactId>
  <version>5.10.0</version>
</dependency>
定义生产者
import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
* @author db
* @version 1.0
* @description Provider 生产者代码
* @since 2022/12/29
*/
public class Producer {

    public static void main(String[] args) throws IOException, TimeoutException {

        //        // 1.创建连接工厂
        //        ConnectionFactory connectionFactory = new ConnectionFactory();
        //        // 2.设置连接属性
        //        connectionFactory.setHost("192.168.137.120");
        //        connectionFactory.setPort(5672);
        //        connectionFactory.setVirtualHost("/");
        //        connectionFactory.setUsername("admin");
        //        connectionFactory.setPassword("123456");
        //        connectionFactory.setHandshakeTimeout(60000);
        //
        //        // 3.从连接工厂获得连接
        //        Connection connection = connectionFactory.newConnection();

        // 从工具类中获得连接
        Connection connection = RabbitMqUtil.getConnection();
        // 4.从连接中获得channel
        Channel channel = connection.createChannel();
        // 5.声明队列queue存储消息

        /**
         * 参数s：队列名称 如果队列不存在就自动创建
         * 参数b：用来定义队列特性是否要持久化 true 持久化队列  false 不持久化
         * 参数b1: exclusive 是否独占队列  true 独占队列 false 不独占
         * 参数b2：autoDelete 是否在消费完成后自动删除队列 true 自动删除 false 不自动删除
         * 参数5：额外附加参数
         *
         */
        channel.queueDeclare("hello",true,false,false,null);

        // 7.发送消息给中间件
        // 参数1：交换机名称 参数2：队列名称 参数3：传递消息的额外设置 参数4：
        channel.basicPublish("","hello", MessageProperties.PERSISTENT_TEXT_PLAIN,"hello rabbitmq".getBytes());

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


        //        // 8.关闭连接
        //        channel.close();
        //        connection.close();

        RabbitMqUtil.closeConnectionAndChannel(channel,connection);
    }
}

执行发送，这个时候可以在web控制台查看到这个队列queue的信息。

定义消费者

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author db
 * @version 1.0
 * @description Consumer  消费者
 * @since 2022/12/29
 */
public class Consumer {

    public static void main(String[] args) throws IOException, TimeoutException {
//        ConnectionFactory connectionFactory = new ConnectionFactory();
//        connectionFactory.setHost("192.168.137.120");
//        connectionFactory.setPort(5672);
//        connectionFactory.setVirtualHost("/");
//        connectionFactory.setUsername("admin");
//        connectionFactory.setPassword("123456");
//        connectionFactory.setHandshakeTimeout(60000);
//
//        // 创建连接
//        Connection connection = connectionFactory.newConnection();

        // 从工具类中获得连接
        Connection connection = RabbitMqUtil.getConnection();
        // 创建信道
        Channel channel = connection.createChannel();

        // 消费者成功消费时的回调
        DeliverCallback deliverCallback = (consumerTag,message) ->{
            System.out.println(new String(message.getBody()));
        };

        // 消费者取消消费时的回调
        CancelCallback callback = consumerTag ->{
            System.out.println("消费者取消消费接口的回调");
        };

        // 参数1：消费队列的名称
        // 参数2：消息的自动确认机制（已获得消息就通知MQ消息已被消费）true 打开 false 关闭
        // 参数3：
        channel.basicConsume("hello",true,deliverCallback,callback);

//        channel.close();
//        connection.close();
    }
}

工具类的包装

package com.duan.rabbitmq.utils;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * @author db
 * @version 1.0
 * @description RabbitMqUtil
 * @since 2023/1/2
 */
public class RabbitMqUtil {

    // 定义提供连接对象的方法
    public static Connection getConnection(){
        try{
            // 1.创建连接工厂
            ConnectionFactory connectionFactory = new ConnectionFactory();
            // 2.设置连接属性
            connectionFactory.setHost("192.168.137.120");
            connectionFactory.setPort(5672);
            connectionFactory.setVirtualHost("/");
            connectionFactory.setUsername("admin");
            connectionFactory.setPassword("123456");

            connectionFactory.setHandshakeTimeout(60000);
            return connectionFactory.newConnection();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

    // 关闭连接通道和关闭连接的工具方法
    public static void closeConnectionAndChannel(Channel channel,Connection connection){
        try{
            if(channel !=null){
                channel.close();
            }
            if(connection != null){
                connection.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

报连接超时错误

**解决方案：**原因是连接超时，加超时时间。

maevn项目设置超时时间：factory.setHandshakeTimeout\(60000\)

二、第二种模型(work quene)

work queues被称为任务队列（Task queues）。当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。此时就可以使用work 模型： 让多个消费者绑定到一个队列，共同消费队列中的消息。 队列中的消息一旦消费，就会消失，因此任务是不会被重复执行的。

  • P：生产者
  • C1：消费者1
  • C2：消费者2
定义生成者
package com.duan.rabbitmq.work;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Producer
 * @since 2023/3/24
 */
public class Producer {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();
        /**
         * 声明队列queue存储信息
         * 参数1： 队列名称
         * 参数2： 用来定义队列是否要持久化
         * 参数3： exclusion 是否是独占队列
         * 参数4： autoDelete 是否再消费完成后自动删除队列
         * 参数5： 额外附加参数
         */
        channel.queueDeclare("work",true,false,false,null);

        for(int i = 0; i<10; i++){
            // 参数1：交换机名称 参数2：队列名称 参数3：消息传递的额外设置
            channel.basicPublish("","work",null,(i+"work").getBytes());
        }
        RabbitMqUtil.closeConnectionAndChannel(channel,connection);
    }
}
定义消费者1
package com.duan.rabbitmq.work;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Consumer1
 * @since 2023/3/24
 */
public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtil.getConnection();
        // 创建信道
        Channel channel = connection.createChannel();

        // 消费者消费成功时的回调
        channel.queueDeclare("work",true,false,false,null);
        channel.basicConsume("work",true,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));
            }
        });
        RabbitMqUtil.closeConnectionAndChannel(channel,connection);
    }
}
定义消费者2
package com.duan.rabbitmq.work;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Consumer1
 * @since 2023/3/24
 */
public class Consumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtil.getConnection();
        // 创建信道
        Channel channel = connection.createChannel();

        // 消费者消费成功时的回调
        channel.queueDeclare("work",true,false,false,null);
        channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException{
                try{
                    Thread.sleep(2000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("消费者2： "+new String(body));
            }
        });
        RabbitMqUtil.closeConnectionAndChannel(channel,connection);
    }
}

rabbitMQ讲按照顺序将每个消息发给下一个使用者，每个消费者都会收到相同数量的消息。
测试结果

消息确认机制

前面看到的是所有的消费者均分消息，会有一个问题，如果一个消费者宕机了，会出现消息丢失现场，希望当出现消费者宕机时，消息被另一个消费者消费，也就是多劳多得生产者代码。

package com.duan.rabbitmq.work;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Producer
 * @since 2023/3/24
 */
public class Producer {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();
        /**
         * 声明队列queue存储信息
         * 参数1： 队列名称
         * 参数2： 用来定义队列是否要持久化
         * 参数3： exclusion 是否是独占队列
         * 参数4： autoDelete 是否再消费完成后自动删除队列
         * 参数5： 额外附加参数
         */
        channel.queueDeclare("work",true,false,false,null);

        for(int i = 0; i<20; i++){
            // 参数1：交换机名称 参数2：队列名称 参数3：消息传递的额外设置
            channel.basicPublish("","work",null,(i+"work").getBytes());
        }

        RabbitMqUtil.closeConnectionAndChannel(channel,connection);

    }
}

生成者1

package com.duan.rabbitmq.work;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Consumer3
 * @since 2023/11/27
 */
public class Consumer3 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtil.getConnection();
        // 创建信道
        Channel channel = connection.createChannel();

        channel.basicQos(1); // 每次只消费一个消息
        // 消费者消费成功时的回调
        channel.queueDeclare("work",true,false,false,null);
        channel.basicConsume("work",false,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));

                // 手动确认，参数1：消息标识  参数2：每次确认1个
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });

    }
}

生成者2

package com.duan.rabbitmq.work;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Consumer4
 * @since 2023/11/27
 */
public class Consumer4 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtil.getConnection();
        // 创建信道
        Channel channel = connection.createChannel();

        channel.basicQos(1);  // 每次消费一个消息
        // 消费者消费成功时的回调
        channel.queueDeclare("work",true,false,false,null);
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException{
                try{
                    Thread.sleep(2000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("消费者2： "+new String(body));
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });


    }
}

测试结果

三、第三种模型（Fanout）

广播模式下：发送消息流程是可以有多个消费者每个消费者都有自己的队列（queue）每个队列都要绑定交换机（exchange）生成者发送消息，只能发送到交换机，交换机决定把消息发给哪个队列，生成者无法决定交换机把消息发给绑定过的所有队列，队列的消费者都能拿到消息，一条消息可以被多个消费者消费。

生产者
package com.duan.rabbitmq.fanout;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Provider
 * @since 2023/11/28
 */
public class Provider {
    public static void main(String[] args) throws IOException {

        // 获取连接对象
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();

        // 将通道声明交换机  参数1：交换机名称 参数2：交换机类型
        channel.exchangeDeclare("logs","fanout");

        // 发送消息
        channel.basicPublish("logs","",null,"fanout type message".getBytes());

        // 释放资源
        RabbitMqUtil.closeConnectionAndChannel(channel,connection);

    }
}
消费者1
package com.duan.rabbitmq.fanout;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Customer1
 * @since 2023/11/28
 */
public class Customer1 {
    public static void main(String[] args) throws IOException {
        // 获得连接对象
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();

        // 通道绑定交换机
        channel.exchangeDeclare("logs","fanout");

        // 绑定临时队列
        String queue = channel.queueDeclare().getQueue();

        // 绑定交换机和队列
        channel.queueBind(queue,"logs","");

        // 消费消息
        channel.basicConsume(queue,true,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));
            }
        });
    }
}
消费者2
package com.duan.rabbitmq.fanout;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Customer1
 * @since 2023/11/28
 */
public class Customer2 {
    public static void main(String[] args) throws IOException {
        // 获得连接对象
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();

        // 通道绑定交换机
        channel.exchangeDeclare("logs","fanout");

        // 绑定临时队列
        String queue = channel.queueDeclare().getQueue();

        // 绑定交换机和队列
        channel.queueBind(queue,"logs","");

        // 消费消息
        channel.basicConsume(queue,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));
            }
        });
    }
}
消费者3
package com.duan.rabbitmq.fanout;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Customer1
 * @since 2023/11/28
 */
public class Customer3 {
    public static void main(String[] args) throws IOException {
        // 获得连接对象
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();

        // 通道绑定交换机
        channel.exchangeDeclare("logs","fanout");

        // 绑定临时队列
        String queue = channel.queueDeclare().getQueue();

        // 绑定交换机和队列
        channel.queueBind(queue,"logs","");

        // 消费消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者3: "+new String(body));
            }
        });
    }
}
测试结果

四、第四种模型（Routing）

在fanout模式中，一条消息，会被所有绑定的队列都能消费，但是，在某些场景下，希望不同的消息被不同的队列消费，就需要Direct类型的exchange。

在Direct模型下：队列与交换机的绑定，不是任意绑定的，而是要指定一个RoutingKey（路由key）消息的发送方在向Exchange发送消息时，也必须指定消息的 RoutingKey。Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息。

生产者
package com.duan.rabbitmq.direct;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Provider
 * @since 2023/11/28
 */
public class Provider {
    public static void main(String[] args) throws IOException {
        // 建立连接
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare("logs_direct","direct");

        String routingKey = "error";
        channel.basicPublish("logs_direct",routingKey,null,("这是direct模型发布的基于route key: ["+routingKey+"] 发送的消息").getBytes());

        RabbitMqUtil.closeConnectionAndChannel(channel,connection);
    }
}
消费者1
package com.duan.rabbitmq.direct;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Consumer1
 * @since 2023/11/28
 */
public class Consumer1 {
    public static void main(String[] args) throws IOException {
        // 获得连接对象
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();

        // 通道绑定交换机
        channel.exchangeDeclare("logs_direct","direct");

        // 绑定临时队列
        String queue = channel.queueDeclare().getQueue();

        // 绑定交换机和队列
        channel.queueBind(queue,"logs_direct","error");

        // 消费消息
        channel.basicConsume(queue,true,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));
            }
        });
    }
}
消费者2
package com.duan.rabbitmq.direct;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Consumer1
 * @since 2023/11/28
 */
public class Consumer2 {
    public static void main(String[] args) throws IOException {
        // 获得连接对象
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();

        // 通道绑定交换机
        channel.exchangeDeclare("logs_direct","direct");

        // 绑定临时队列
        String queue = channel.queueDeclare().getQueue();

        // 绑定交换机和队列
        channel.queueBind(queue,"logs_direct","info");
        channel.queueBind(queue,"logs_direct","error");
        channel.queueBind(queue,"logs_direct","warning");

        // 消费消息
        channel.basicConsume(queue,true,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));
            }
        });
    }
}
测试结果

当routingKey为info时，消费者1和消费者2结果如下：

当routingKey为error时，消费者1和消费者2结果如下：

五、第五种模型（topic）

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定BindingKey 的时候使用通配符！BindingKey 一般都是有一个或多个单词组成，多个单词之间以.分割，例如： item.insert通配符规则：

  • #：匹配一个或多个词
  • *：匹配不多不少恰好1个词

举例：

  • item.#：能够匹配item.spu.insert 或者 item.spu
  • item.*：只能匹配item.spu
生产者
package com.duan.rabbitmq.topic;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Provider
 * @since 2023/11/30
 */
public class Provider {

    public static void main(String[] args) throws IOException {
        //获取连接对象
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();

        //声明交换机以及交换机类型 topic
        channel.exchangeDeclare("topics","topic");

        //发布消息
        String routekey = "save.user.delete";

        channel.basicPublish("topics",routekey,null,("这里是topic动态路由模型,routekey: ["+routekey+"]").getBytes());

        //关闭资源
        RabbitMqUtil.closeConnectionAndChannel(channel,connection);

    }


}
消费者1
package com.duan.rabbitmq.topic;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Customer1
 * @since 2023/11/30
 */
public class Customer1 {
    public static void main(String[] args) throws IOException {
        // 获得连接对象
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();

        // 通道绑定交换机
        channel.exchangeDeclare("topics","topic");

        // 绑定临时队列
        String queue = channel.queueDeclare().getQueue();

        // 绑定交换机和队列
        channel.queueBind(queue,"topics","*.user.*");

        // 消费消息
        channel.basicConsume(queue,true,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));
            }
        });
    }
}
消费者2
package com.duan.rabbitmq.topic;

import com.duan.rabbitmq.utils.RabbitMqUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author db
 * @version 1.0
 * @description Customer1
 * @since 2023/11/30
 */
public class Customer2 {
    public static void main(String[] args) throws IOException {
        // 获得连接对象
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();

        // 通道绑定交换机
        channel.exchangeDeclare("topics","topic");

        // 绑定临时队列
        String queue = channel.queueDeclare().getQueue();

        // 绑定交换机和队列
        channel.queueBind(queue,"topics","*.user.#");

        // 消费消息
        channel.basicConsume(queue,true,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));
            }
        });
    }
}
测试结果

代码地址：https://gitee.com/duan138/practice-code/tree/dev/rabbitmq-java

六、总结

以上就是rabbitMQ中常见的几种模式，这些模型通过交换机（Exchange）和队列（Queue）的不同组合与绑定方式实现。本文只是初步了解RabbitMQ相关知识。后续会讲解怎么在SpringBoot中应用。

改变你能改变的，接受你不能改变的，关注公众号：程序员康康，一起成长，共同进步。

cxykk1217
关注
  • 14
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RabbitMQ的消息模型(看一看，说不定有你想要的呢~~)
杨杨杨~~的博客
04-21 231
文章目录前言纯干货-详解RabbitMQ的消息模型(看一看，说不一定有你想要的呢~~)一、RabbitMQ在应用开发过程中涉及的核心基础组件概念二、消息投递到队列的整个过程三、交换机 (Exchange)的种类1、【Direct交换机】2、【Topic交换机】3、【Fanout交换机】四、消息模型实战1、基于DirectExchange的消息模型实战2、基于TopicExchange的消息模型实战3、基于FanouExchange的消息模型实战 前言   如果您觉得有用的话，记得给博主点个赞，评论，收藏一键
rabbitmq 实现消息插队
10-29
RabbitMQ支持多消费者模型，同一消息队列中的消息可以被多个消费者公平地消费，或者根据预设的策略分配给消费者。 - 使用RabbitMQ的集群功能，可以进一步提高系统的可用性和扩展性，确保在任何节点故障时，消息队列...
RabbitMQ：消息模型
栗筝i的博客
12-12 2735
RabbitMQ 提供了 6 种消息模型，分别为：单生产单消费模型（Hello World）、消息分发模型（Work queues）、Fanout 消息订阅模式（Publish/Subscribe）、Direct 路由模式（Routing）、Topic 匹配模式（Topic）、RPC 模式（RPC）。 本篇内容包括：RabbitMQ 6 种消息模型、RabbitMQ 6 种消息模型介绍
RabbitMq的五大消息模型及Java代码演示
最新发布
Aa5107033的博客
06-27 1358
主要介绍RabbitMq的五大消息模型，并通过代码实现各个订阅模型的使用
RabbitMQ-消息模型
kiki的博客
10-27 945
rabbitmq学习
RabbitMQ消息模型
tian830937的专栏
11-21 799
RabbitMQ提供了5种消息模型
RabbitMq消息队列指南.docx
07-05
RabbitMQ支持多种操作系统，如Linux、Windows和MacOS，并且兼容多种编程语言，如Java、Python、Ruby、.NET、PHP、C/C++以及node.js。 RabbitMQ的核心组件包括： 1. **Broker**：这是RabbitMQ服务进程，它包含两个...
rabbitMQ 消息队列 Demo
10-18
在发布/订阅模型中，生产者发布消息到一个主题（topic），而多个消费者可以订阅该主题。消费者通过指定过滤规则（通配符）来决定接收哪些消息。这允许消费者选择性地接收感兴趣的信息，同时保持解耦，因为生产者并...
Erlang和RabbitMQ 消息队列
04-21
4. **多种客户端库**：RabbitMQ支持多种编程语言的客户端库，如Java、Python、Ruby、Node.js等，方便开发者在不同项目中使用。 5. **管理界面**：RabbitMQ提供了一个Web管理界面，用于查看和管理队列、交换器、绑定...
springboot整合stream使用rabbitmq作为消息中间件
12-13
- **Message Conversion**: Spring Cloud Stream支持多种消息格式转换，如JSON、XML等。 - **Retry and DLQ**: 可以配置重试策略和死信队列，提高系统的容错性。 - **Binding和Destination**: 可以动态绑定，根据...
RabbitMQ 消息模型
weixin_42128977的博客
09-04 190
一.首先什么是MQ MQ全称是Message Queue,即消息对列！消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。 二.RabbitMQ 基于AMQP协议，erlang语言开发，稳定性好！基于AMQP的一款消息管理系统 三.RabbitMQ消息模型 3.1基本消息模型 RabbitMQ是一个消息代理。它的工作就是接收和...
RabbitMQ的消息模型
qq_37457564的博客
12-18 249
1.消息队列（MQ，MessageQueue） 消息队列里可以存放大量消息，这些消息由生产者生成放到队列里，等待消费者获取并处理。使用消息队列可以提升系统的性能，降低系统耦合性。 比如说，一个发短信的系统。如果不用消息队列，每发送一条短信都要经过----- 需求产生、发送短信。两个步骤。而发送短信这个步骤相对很慢。这样系统性能就会被拖慢。如果把这两个步骤分开，就会极大地提高性能。而消息队列...
RabbitMQ
私は悪い人ですか的博客
02-04 139
RabbitMQ RabbitMQ是基于AMQP的一款消息管理系统 官网： http://www.rabbitmq.com/ 官方教程：http://www.rabbitmq.com/getstarted.html 安装 下载镜像：docker pull rabbitmq:management 创建实例并启动： docker run -d --name rabbitmq --publish 567...
RabbitMQ 常见的消息模型：基本消息队列、工作消息队列、发布订阅
qq_52889347的博客
03-17 679
RabbitMQ 常见的消息模型：基本消息队列、工作消息队列、发布订阅
RabbitMQ：消息模型_rabbitmq消息模型，2024年最新字节跳动面试官
2401_84160272的博客
04-17 428
单生产单消费模型，即基本消息模型或简单消费模型，即完成基本的一对一消息转发。
RabbitMQ之基本消息模型
gloamer的博客
07-03 399
介绍： RabbitMQ提供了6中消息模型 但第6种其实是RPC（远程过程调用）并不是MQ (message queue 消息队列) 所以暂时咱还不研究 如果想去了解RPC的话可以去学习一下dubbo 它就是一个轻量级的开源 RPC框架,今天咱们学习第一种 RrabbitMQ消息模型——基本消息模型 如图所示 基本消息模型就是生产者------->消息队列------>消费者，消息生产者对应一个消息消费者： 搭建示例工程： 项目目录结构： ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值