深入浅出rabbitmq五大模型

最新推荐文章于 2024-06-27 10:30:09 发布
最新推荐文章于 2024-06-27 10:30:09 发布
阅读量172 收藏
点赞数
分类专栏： rabbitmq 文章标签： 交换机 队列 rabbitmq 五大模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48333563/article/details/114732260
版权

rabbitmq五大模型：

代码结构：

在这里插入图片描述

编写工具类生成连接：

package utils;

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

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

public class RabbitMqUtils {
    private static ConnectionFactory connectionFactory;
    static {
        connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/ems");
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("123");
    }
    public static Connection getConnection(){
        try {
            return connectionFactory.newConnection();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void closeConnectionAndChanel(Channel channel,Connection connection){
        if (channel != null) {
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1.直连模型

  • 生产者，也就是要发送消息的程序
  • 消费者：消息的接受者，会一直等待消息到来
  • queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息

在这里插入图片描述
例子：
生产者：

package helloword;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
import org.junit.Test;

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

public class Producer {
        @Test
        public void pro() throws IOException, TimeoutException {

            //创建连接工厂
            //创建连接mq的连接工厂对象
            ConnectionFactory factory = new ConnectionFactory();
            //设置连接rabbitmq主机
            factory.setHost("127.0.0.1");
            //设置端口号
            factory.setPort(5672);
            //设置访问虚拟主机的用户名和密码
            factory.setUsername("ems");
            factory.setPassword("123");
            //设置连接那个虚拟主机
            factory.setVirtualHost("/ems");

            //获取连接对象
            Connection connection = factory.newConnection();
            //获取连接中通道
            Channel channel = connection.createChannel();

            //通道绑定对应消息队列
            //参数1:  队列名称 如果队列不存在自动创建
            //参数2:  用来定义队列特性是否要持久化 true 持久化队列   false 不持久化
            //参数3:  exclusive 是否独占队列  true 独占队列   false  不独占
            //参数4:  autoDelete: 是否在消费完成后自动删除队列  true 自动删除  false 不自动删除
            //参数5:  额外附加参数
            channel.queueDeclare("hello", true, false, false, null);

            //发布消息
            //参数1: 交换机名称 参数2:队列名称  参数3:传递息额外设置  参数4:消息的具体内容
            channel.basicPublish("", "hello", MessageProperties.PERSISTENT_TEXT_PLAIN, "hello rabbitmq".getBytes());

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

}

消费者：

package helloword;

import com.rabbitmq.client.*;

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

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

        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/ems");
        factory.setUsername("ems");
        factory.setPassword("123");
        Connection connection = factory.newConnection();

        //创建通道
        Channel channel = connection.createChannel();

        //通道绑定队列：与生产端一致
        channel.queueDeclare("hello", true, false, false, null);

        //获取消息
        //参数1: 消费那个队列的消息 队列名称
        //参数2: 开始消息的自动确认机制[只要消费就从队列删除消息]
        //参数3: 消费时的回调接口
        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("取出消息:===>" + new String(body));
            }
        });
    }
}

效果：
在这里插入图片描述

2.work模型：

Work queues，也被称为（Task queues），任务模型。当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。此时就可以使用 work 模型：让多个消费者绑定到一个队列，共同消费队列中的消息。队列中的消息一旦消费，就会消失，因此任务是不会被重复执行的。
总的来说：生产者直接发送消息到队列，配置多个消费者
在这里插入图片描述

实例1：

生产者：

package workquene;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.MessageProperties;
import utils.RabbitMqUtils;

import java.io.IOException;

import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("work",true,false,false,null);
        for (int i=0 ; i<20; i++){
            channel.basicPublish("","work", MessageProperties.PERSISTENT_TEXT_PLAIN, "hello rabbitmq".getBytes());
        }
        RabbitMqUtils.closeConnectionAndChanel(channel,connection);
    }
}

消费者1：

package workquene;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;


public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.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("取出消息:===>" + new String(body));
            }
        });
    }
}

消费者2：

package workquene;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;


public class Consumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.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 (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("取出消息:===>" + new String(body));
            }
        });
    }
}

效果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实例2：

但使用这种模型有两个个缺陷，在消息平均分配给绑定该队列的多个消费者的基础上，其一：消费者的消费速度可能不一样，其二：所有消费者拿到消息以后还没有消费就进行了确认使得队列没有再保存消息了。倘若有消费者消息没消费完就宕机了，那么没有消费的消息就丢失了，这是绝不允许的，因此就出现了下面这种对rabbitmq的消息确认机制进行配置解决办法：
1.消费者每次只从消息队列取一条消息：

channel.basicQos(1);

2.关闭消息自动确认

 //使用手动确认就要取消自动确认，第二参数设置为false
 channel.basicConsume("work", false, new DefaultConsumer(channel)

3.手动确认消息:

channel.basicAck(envelope.getDeliveryTag(), false);

生产者：

package workquene2;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.MessageProperties;
import utils.RabbitMqUtils;

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

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("work",true,false,false,null);
        for (int i=0 ; i<20; i++){
            channel.basicPublish("","work", MessageProperties.PERSISTENT_TEXT_PLAIN, "hello rabbitmq".getBytes());
        }
        RabbitMqUtils.closeConnectionAndChanel(channel,connection);
    }
}

消费者1：

package workquene2;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;


public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("work", true, false, false, null);
        //每次接收一个消息
        channel.basicQos(1);
        //使用手动确认就要取消自动确认，第二参数设置为false
        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("取出消息:===>" + new String(body));
                //手动确认
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

消费者2：

package workquene2;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;


public class Consumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("work", true, false, false, null);
        channel.basicQos(1);
        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 (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("取出消息:===>" + new String(body));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

效果：
消费者1：
在这里插入图片描述
消费者2：
在这里插入图片描述

3.fanout模型（广播）

在这里插入图片描述

  • 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。
  • 消费者将临时队列和交换机绑定，整个生产消费模型就连通了
  • 交换机把消息发送给绑定过的所有队列
  • 队列的消费者都能拿到消息。实现一条消息被多个消费者消费
    例子：
    生产者：
public class Producer {
    @Test
    public void pro() throws IOException {

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

        //声明交换机 [ 参数一:交换机名字,参数2:交换机类型:fanout(广播模式) 固定]
        channel.exchangeDeclare("register", "fanout");

        //发布消息[参数1:交换机名字,参数2:路由,参数3:消息持久化,参数4:消息内容]
        channel.basicPublish("register", "", null, "fanout...".getBytes());
        //关闭
        RabbitMQUtils.closeConnection(channel, connection);
    }
}

消费者1：

package fanoutquene;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;

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

            //声明交换机
            channel.exchangeDeclare("register", "fanout");
            //创建临时队列
            String queue = channel.queueDeclare().getQueue();

            //[绑定]=>临时队列和交换机 [参数1:临时队列,参数2:交换机,参数3:路由]
            channel.queueBind(queue, "register", "");

            //消费消息
            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 fanoutquene;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;

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

            //声明交换机
            channel.exchangeDeclare("register", "fanout");
            //创建临时队列
            String queue = channel.queueDeclare().getQueue();

            //绑定临时队列和交换机 [参数1:临时队列,参数2:交换机,参数3:路由]
            channel.queueBind(queue, "register", "");

            //消费消息
            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 fanoutquene;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;

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

            //声明交换机
            channel.exchangeDeclare("register", "fanout");
            //创建临时队列
            String queue = channel.queueDeclare().getQueue();

            //绑定临时队列和交换机 [参数1:临时队列,参数2:交换机,参数3:路由]
            channel.queueBind(queue, "register", "");

            //消费消息
            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));
                }
            });

        }
}

细节：

  • 临时队列在关闭消费者运行后自动删除，运行期间无法删除
  • 先运行生产者发布消息再运行消费者是不行的， 先运行生产者交换机没有绑定队列可能自动丢弃了消息

效果：
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.Routing模型

有时候我们并不希望所有种类信息都发给绑定同一个交换机的队列，我们更希望绑定同一个交换机的队列能够接受特定种类的消息，当然，每条队列不只能够接受一种特定消息。Routing模型很好地满足了这种需求。
在这里插入图片描述

实例1：

生产者：

package routingquene;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import org.junit.Test;
import utils.RabbitMqUtils;

import java.io.IOException;

public class Producer {
        @Test
        public void pro() throws IOException {
            //获取连接
            Connection connection = RabbitMqUtils.getConnection();
            //创建通道
            Channel channel = connection.createChannel();

            //声明交换机[参数1：交换机名字, 参数2:交换机类型,direct路由模式]=>基于指令的 Routing key 转发
            channel.exchangeDeclare("logs_direct", "direct");

            //发布的路由名称==>根据路由key的不同发送到不同的绑定队列中
            String key = "error";

            //发布消息[参数1:交换机名字,参数2:路由名字,参数3:消息内容]
            channel.basicPublish("logs_direct", key, null, ("发送给指定路由" + key + "的消息").getBytes());

            //关闭连接
            RabbitMqUtils.closeConnectionAndChanel(channel, connection);
        }
}

消费者1：

package routingquene;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;

public class Consumer1 {
        public static void main(String[] args) throws IOException {
            //获取连接
            Connection connection = RabbitMqUtils.getConnection();
            //创建通道
            Channel channel = connection.createChannel();

            //声明交换机[参数1：交换机名字, 参数2:交换机类型,direct路由模式]
            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", "warn");

            //消费消息
            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 routingquene;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;

public class Consumer2 {
        public static void main(String[] args) throws IOException {
            //获取连接
            Connection connection = RabbitMqUtils.getConnection();
            //创建通道
            Channel channel = connection.createChannel();

            //声明交换机[参数1：交换机名字, 参数2:交换机类型,direct路由模式]
            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("消费者2号:==>" + new String(body));
                }
            });

        }

}

效果：
在这里插入图片描述
在这里插入图片描述

实例2：

修改生产者路由规则代码：

 String key = "info";

效果：
在这里插入图片描述
在这里插入图片描述

  • 交换机根据每条消息附带的路由规则key发送到队列名与路由规则key值相同的队列。
  • 路由规则key在前三种模型中指的是队列

5.Topic模型

在Routing模型的基础上增加了通配符

  • #匹配多个单词
  • *匹配一个单词
# 统配符

*(star) can substitute for exactly one word.    匹配不多不少恰好1个词
#(hash) can substitute for zero or more words.  匹配一个或多个词
 
# 如:
audit.#    匹配audit.irs.corporate或者 audit.irs 等
audit.*   只能匹配 audit.irs

实例1：

生产者：

package topicquene;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import org.junit.Test;
import utils.RabbitMqUtils;

import java.io.IOException;

public class Producer {
        @Test
        public void pro() throws IOException {
            //创建连接
            Connection connection = RabbitMqUtils.getConnection();
            Channel channel = connection.createChannel();

            //声明交换机[交换机名字+交换机类型]
            channel.exchangeDeclare("topics", "topic");

            //发布消息==>使用动态路由(通配符方式)
            String key = "user.update"; //指定发布的路由key
            channel.basicPublish("topics", key, null, ("发送消息给指定的路由key" + key).getBytes());

            //关闭连接
            RabbitMqUtils.closeConnectionAndChanel(channel, connection);
        }
}

消费者1：

package topicquene;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;

public class Consumer1 {
        public static void main(String[] args) throws IOException {
            //创建连接
            Connection connection = RabbitMqUtils.getConnection();
            Channel channel = connection.createChannel();

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

            //声明临时队列
            String queue = channel.queueDeclare().getQueue();

            //绑定临时队列与交换机并设置获取交换机中动态路由
            String key = "user.*";//使用通配符指定路由key
            channel.queueBind(queue, "topics", key);

            //消费消息
            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 topicquene;

import com.rabbitmq.client.*;
import utils.RabbitMqUtils;

import java.io.IOException;

public class Consumer2 {
        public static void main(String[] args) throws IOException {
            //创建连接
            Connection connection = RabbitMqUtils.getConnection();
            Channel channel = connection.createChannel();

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

            //声明临时队列
            String queue = channel.queueDeclare().getQueue();

            //绑定临时队列与交换机
            String key = "user.#";//使用通配符指定路由key
            channel.queueBind(queue, "topics", key);

            //消费消息
            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));
                }
            });
        }
}

效果：
在这里插入图片描述
在这里插入图片描述

实例2：

修改生产者路由规则key：

 String key = "user.update.test";

效果：
在这里插入图片描述

在这里插入图片描述

Fire king
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RabbitMQ工作模型及Java编程
长沙老码农
01-29 432
目录 . 学习目标 1. 消息中间件概述 1.1. 什么是消息中间件 1.2. AMQP 和 JMS 1.2.1. AMQP 1.2.2. JMS 1.2.3. AMQP 与 JMS 区别 1.3. 消息队列产品 1.4. RabbitMQ 2. 安装及配置RabbitMQ 2.1. 安装依赖环境 2.2. 安装Erlang 2.3. 安装RabbitMQ 2.4. 开启管理界面及配置 2.5. 启动 2.6. 配置虚拟主机及用户 2.6.1. 用户角色 2.6.2. V
RabbitMq工作模型
weixin_35720385的博客
11-26 2228
RabbitMq工作模型欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用M
RabbitMq的五大消息模型及Java代码演示
最新发布
Aa5107033的博客
06-27 1461
主要介绍RabbitMq的五大消息模型，并通过代码实现各个订阅模型的使用
RabbitMQ学习（五）—五种模式
m0_59350665的博客
06-29 1220
一个消费者将消息首先发送到交换器，交换器绑定到多个队列，然后被监听该队列的消费者所接收并消费。生产者将消息发送到direct交换器，在绑定队列和交换器的时候有一个路由key，生产者发送的消息会指定一个路由key，那么消息只会发送到相应key相同的队列，接着监听该队列的消费者消费消息。交换器允许匹配 AMQP 消息的 header 而非路由键，除此之外，header 交换器和 direct 交换器完全一致，但是性能却差很多，因此基本上不会用到该交换器。与路由模式相似，但是，主题模式是一种模糊的匹配方式。
rabbitmq消息队列原理
明耀的博客
09-26 1423
转载：rabbitmq消息队列原理 一、rabbitmq架构 RabbitMQ是一个流行的开源消息队列系统，是AMQP（高级消息队列协议）标准的实现，由以高性能、健壮、可伸缩性出名的Erlang语言开发，并继承了这些优点。rabbitmq简单架构如下： 上图简单展示了rabb
RabbitMQ消息模型
tian830937的专栏
11-21 799
RabbitMQ提供了5种消息模型
深入浅出RabbitMQ
01-07
RabbitMQ遵循AMQP协议，AMQP的模型如下：  相关概念如下：1、Producer：消息生产者；2、Broker：即RabbitMQ serveice提供者；3、Virtual Host：RabbitMQ是多租户系统，一个Broker支持多个Virtual Host，这些...
资料-RabbitMQ深入浅出资料.zip
10-26
**RabbitMQ 深入浅出：理解与实践** RabbitMQ 是一款广泛应用的消息中间件，基于 AMQP（Advanced Message Queuing Protocol）协议，它允许应用程序之间进行异步通信，提高了系统的可扩展性和可靠性。在本文中，我们...
Springboo整合RabbitMQ并测试五种模型
12-02
在本文中，我们将深入探讨如何将Spring Boot与RabbitMQ集成，并通过实践了解五种不同的消息模型。首先，让我们简要介绍一下Spring Boot和RabbitMQ。 Spring Boot是Spring框架的一个微服务开发工具，它简化了配置，...
rabbitMq 5种消息模型测试代码
07-18
rabbitMq 5种消息模型测试代码
Python实现RabbitMQ6种消息模型的示例代码
09-17
### Python 实现 RabbitMQ 六种消息模型的深入解析 #### 一、引言 RabbitMQ 是一种基于 AMQP（Advanced Message Queuing Protocol）标准的开源消息中间件，广泛应用于分布式系统中作为消息传递的媒介。在实际开发...
RabbitMQ的5种消息队列
YIYIYI
08-16 3390
RabbitMQ的5种消息队列
RabbitMQ常用五种模型
weixin_38635565的博客
04-24 910
1、引入rabbitmq的客户端jar包 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.6.0</version> </dependency> 2、rabbitmq的模型 第一种模型直连（直连） P:生产者，发送消息的程序； C：消费者，消...
RabbitMQ 的五种消息队列
weixin_53106424的博客
06-05 1262
1.简单模式   一个生产者发送消息到一个队列，一个消费者从队列中取消息 RabbitMQ 工具类 public class MQUtils { public static final String QUEUE01 ="queue01"; public static final String QUEUE02 ="queue02"; public static final String EXCHANGE01="exchange01"; public static fin
8. 微服务之消息队列RabbitMQ以及五种消息队列模式
qq_46656580的博客
11-21 3666
即客户端并不是直接向服务端发起请求，而是会通过一个消息队列，客户端发起请求放入消息队列后就不会去等待服务端的执行结果，而是交给消息队列去下发请求做后台处理，客户端察觉不到。再创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息。创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息。创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息。
rabbitmq常用的五种模型
weixin_45967375的博客
04-09 8053
第一种：Hello World 第二种：Work queues 第三种：Publish/Subscribe 第四种：Routing 第五种：Topics
RabbitMq(一) RabbitMq工作模型
heyanfeng22的专栏
05-12 354
RabbitMq工作模型Mq基础RbbitMq工作模型RabbitMq基本使用原生apiSpring集成Springboot集成总结 Mq基础 message queue 消息队列 特点： 1、独立部署，解耦 2、数据结构是队列，FIFO 3、具有发布订阅模型 为什么使用MQ： 1、异步 2、解耦 3、削峰 4、能广播通信 带来的问题： 1、增加运维成本 2、系统可用性降低 3、系统复杂性提高 AMQP AMQP协议,所有的MQ都遵循这个协议 RbbitMq工作模型 Broker Connecti
RabbitMQ消息模型详解
热门推荐
小小张自由—>张有博
04-06 1万+
RabbitMQ消息模型详解，原理详解，代码展示。其中包括简单消息模型，工作模型，订阅发布模型，订阅模型-Fanout，订阅模型-Direct。
RabbitMQ之七种消息模型
Java追求者的博客
08-11 1287
该笔记大部分搬运B站编程不良人的RabbitMQ，顺便把图文合并记录，便于回顾，仅用于学习！ 视频地址：https://www.bilibili.com/video/BV1dE411K7MG 作者真的非常好，别白嫖，记得三连 如有侵权，请联系删除！ 1.AMQP协议 2. RabbitMQ七种消息模型 七种消息模型：https://www.rabbitmq.com/getstarted.html 3. RabbitMQ第一个程序 3.1 第一种模式(直连) 在上图的模型中，有以下概念： P：.
RabbitMq五大消息模型
09-23
RabbitMQ的五大消息模型分别为： 1. 简单模式(Simplest Model) 2. 工作队列模式(Work Queues Model) 3. 发布/订阅模式(Publish/Subscribe Model) 4. 路由模式(Routing Model) 5. 主题模式(Topic Model) 这些模型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Fire king

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

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

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

打赏作者

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

抵扣说明：

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

余额充值