rabbitmq的七种常用模式连接idea使用

最新推荐文章于 2025-06-16 21:59:00 发布
最新推荐文章于 2025-06-16 21:59:00 发布
阅读量1.6k 收藏 5
点赞数
CC 4.0 BY-SA版权
分类专栏： rabbitmq 文章标签： rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56320090/article/details/115874434
本文详细介绍了RabbitMQ的五种常用消息传递模式，包括简单模式、工作者模式、发布订阅模式、路由模式和主题模式。每种模式通过实例展示了如何创建生产者和消费者，并解释了它们的工作原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

rabbitmq的五种常用模式

官方网址
https://www.rabbitmq.com/getstarted.html

在这里插入图片描述

创建idea的maven项目

因为五种方式的结构一样，这边我就创建一个项目作为演示
(1)创建一个大的maven项目当作父项目
在这里插入图片描述（2）选择安装路径
在这里插入图片描述（3）在父项目下创建连个子项目
创建步骤和父项目一样
在这里插入图片描述
（4）效果展示
在这里插入图片描述（5）引入依赖
maven项目有一个特性，子类工程可以继承父类工程引得依赖
在这里插入图片描述

（1）简单模式

在这里插入图片描述

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

生产者（往队列中加入信息）


public class Product {
    public static void main(String[] args)throws  Exception {
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        //虚拟机的IP
        factory.setHost("192.168.213.188");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        channel.queueDeclare("ban129_queue",true,false,false,null);
        //发生消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        String msg="holle！！！！！！！！！！！";
        channel.basicPublish("","ban129_queue",null,msg.getBytes());
    }
}

消费者（消费队列信息）



public class Consumer {
    public static void main(String[] args) throws Exception{
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.213.188");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受消息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer callback=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body 接受的信息
                System.out.println("消息的内容:"+new String(body));
            }
        };
        channel.basicConsume("ban129_queue",true,callback);

    }
}

测试

  • [1 ] 先运行生产者
    在这里插入图片描述
  • [2 ]运行消费者
    -

（2）工作者模式

在这里插入图片描述

特点:   
 1. 一个生产者   
 2. 由多个消费。   
 3. 统一个队列。 
 4. 这些消费者之间存在竞争关系。
 用处:    比如批量处理上. rabbitMQ里面积压了大量的消息。

生产者（往队列中加入信息）

public class Product {
    public static void main(String[] args)throws  Exception {
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.213.188");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        channel.queueDeclare("ban129_queue_work",true,false,false,null);
        //发生消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        for(int i=0;i<10;i++) {
            String msg = "冯昱凯真帅！！！！！！！！！！！"+i;
            channel.basicPublish("", "ban129_queue_work", null, msg.getBytes());
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        channel.close();
        connection.close();

    }
}

消费者01（消费队列信息）

public class Consumer01 {
    public static void main(String[] args) throws Exception{
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.213.188");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受消息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer callback=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body 接受的信息
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者01:"+new String(body));
            }
        };
        channel.basicConsume("ban129_queue_work",true,callback);

    }
}

消费者02（消费队列信息）

public class Consumer02 {
    public static void main(String[] args) throws Exception{
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.213.188");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受消息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer callback=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body 接受的信息
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者01:"+new String(body));
            }
        };
        channel.basicConsume("ban129_queue_work",true,callback);

    }
}

测试

  • [1 ] 先运行生产者
    在这里插入图片描述
  • [2 ]运行消费者01
    在这里插入图片描述
  • [3 ]运行消费者02
    在这里插入图片描述

总结

可以看到，在生产者往队列中加入100条信息后，消费者01（consumer1）和消费者02（consumer2）是采用交替处理的方式进行消费队列中的信息的

（3）发布订阅模式

在这里插入图片描述

特点:   
    1.一个生产者
    2.多个消费者
    3.多个队列。
    4.交换机 转发消息。

生产者（往队列中加入信息）

public class product1 {
    public static void main(String[] args) throws Exception{
        //创建工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.11.222");
        //获取对象
        Connection connection = connectionFactory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        /**
         * (String queue, 队列的名称
         * boolean durable, 是否持久化
         * boolean exclusive,   是否独占
         * boolean autoDelete,  是否自动销毁
         * Map<String, Object> arguments 额外参数 不用就给空 null
         */
        channel.queueDeclare("ban129_fanout01",true,false,false,null);
        channel.queueDeclare("ban129_fanout02",true,false,false,null);

        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        channel.exchangeDeclare("ban129_exchange", BuiltinExchangeType.FANOUT,true);
       //绑定交换机和队列
        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        channel.queueBind("ban129_fanout01","ban129_exchange","");
        channel.queueBind("ban129_fanout02","ban129_exchange","");
        //发生消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        for (int i = 0; i < 15; i++) {
            String msg = "刘亚飞真帅，好像没有见过他说话！！！！！！！！！！！"+i;
            channel.basicPublish("ban129_exchange","",null,msg.getBytes());
        }
    }
}

消费者01（消费队列信息）

public class Consumer1 {
    public static void main(String[] args) throws Exception{
        //创建 连接对象
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.11.222");
        Connection connection = factory.newConnection();

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

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer consumer= new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("ababab1"+new String(body));
            }
        };
    channel.basicConsume("ban129_fanout01",true,consumer);

    }
}

消费者02（消费队列信息）

public class Consumer2 {
    public static void main(String[] args) throws Exception{
        //创建 连接对象
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.11.222");
        Connection connection = factory.newConnection();

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

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer consumer= new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("ababab2"+new String(body));
            }
        };
    channel.basicConsume("ban129_fanout02",true,consumer);

    }
}

测试

  • [1 ] 先运行生产者
    在这里插入图片描述
  • [2 ]运行消费者01
    在这里插入图片描述
  • [3 ]运行消费者02
    在这里插入图片描述

总结

可以看到，在生产者往队列中加入15条信息后，队列1和队列2都接收到信息并存储信息，消费者01（consumer1）和消费者02（consumer2）对应不同的队列，都可以消费生产者发布的信息

（4）路由模式

在这里插入图片描述

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

生产者（往队列中加入信息）

public class Product1 {
    public static void main(String[] args) throws Exception{
        //创建连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.11.222");
        //获得对象
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        /**
         * String queue,队列的名称
         * boolean durable,是否持久化
         * boolean exclusive, 是否独占
         * boolean autoDelete, 是否自动删除
         * Map<String, Object> arguments 额外参数
         */
        channel.queueDeclare("ban129_queue_direct01",true,false,false,null);
        channel.queueDeclare("ban129_queue_direct02",true,false,false,null);

        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        channel.exchangeDeclare("ban129_exchange_direct", BuiltinExchangeType.DIRECT,true);

        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        //绑定队列的路由key
        channel.queueBind("ban129_queue_direct01","ban129_exchange_direct","error");
        channel.queueBind("ban129_queue_direct02","ban129_exchange_direct","error");
        channel.queueBind("ban129_queue_direct02","ban129_exchange_direct","info");
        channel.queueBind("ban129_queue_direct02","ban129_exchange_direct","wange");

        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        //发送消息
        for (int i = 0; i < 20; i++) {
            String msg= "加油"+i;
            channel.basicPublish("ban129_exchange_direct","error",null,msg.getBytes());
            channel.basicPublish("ban129_exchange_direct","info",null,msg.getBytes());
//            channel.basicPublish("ban129_exchange_direct","error",null,msg.getBytes());

        }
    }
}

消费者01（消费队列信息）

public class Consumer1 {
    public static void main(String[] args) throws Exception{
        //创建连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.11.222");
        //获得对象
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接收信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer consumer= 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));
            }
        };
        channel.basicConsume("ban129_queue_direct01",true,consumer);
    }
}

消费者02（消费队列信息）

public class Consumer2 {
    public static void main(String[] args) throws Exception{
        //创建连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.11.222");
        //获得对象
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接收信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer consumer= 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));
            }
        };
        channel.basicConsume("ban129_queue_direct02",true,consumer);
    }
}

测试

  • [1 ] 先运行生产者
    在这里插入图片描述

  • [2 ]运行消费者01
    在这里插入图片描述

  • [3 ]运行消费者02
    在这里插入图片描述

总结

可以看到，在生产者代码中给两个队列绑定了不同的路由key，在交换机往队列发信息时带了不同的路由key，只有队列绑定了此key才能成功往此队列发送信息。

（5）topic主体模式

整体代码于路由模式基本一样，只是交换机在绑定路由key时使用了通配符
在这里插入图片描述

1. 绑定按照通配符的模式。
     *: 统配一个单词。
     #: 统配n个单词

生产者

public class Product {
    public static void main(String[] args)throws  Exception {
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.213.188");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        channel.queueDeclare("ban129_queue_topic01",true,false,false,null);
        channel.queueDeclare("ban129_queue_topic02",true,false,false,null);

        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        channel.exchangeDeclare("ban129_exchange_topic", BuiltinExchangeType.TOPIC,true);
        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        
//在绑定路由key时使用通配符 # 和 *         
channel.queueBind("ban129_queue_topic01","ban129_exchange_topic","*.orange.*");
              channel.queueBind("ban129_queue_topic02","ban129_exchange_topic","*.*.rabbit");
        channel.queueBind("ban129_queue_topic02","ban129_exchange_topic","lazy.#");

        //发生消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        for(int i=0;i<10;i++) {
            String msg = "你们有没有打疫苗！！！！！！！！！！！"+i;
            channel.basicPublish("ban129_exchange_topic", "lazy.orange.rabbit", null, msg.getBytes());
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        channel.close();
        connection.close();

    }
}

总结

在生产者代码中使用通配符给两个队列绑定了不同的路由key，在交换机往队列发信息时带了不同的路由key，只有队列绑定了此key才能成功往此队列发送信息。

Spring Boot进阶(05)：Spring Boot与RabbitMQ完美融合，打造高效消息队列服务！
**My Coding Family**
06-07 2188
Springboot如何整合RabbitMq，若不会，我便手把手教你，超级详细
RabbitMQ——01
xiaowanziddd的博客
08-20 717
AMQP，即(高级消息队列协议)，是一个网络协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。2006年，AMQP规范发布。类比HTTP。2007年，Rabbit 技术公司基于AMQP标准开发的RabbitMQ 1.0发布。RabbitMQ采用Erlang 语言开发。Erlang 语言由Ericson设计，专门为开发高并发和分布式系统的一种语言，在电信领域使用广泛。
用idea操作RabbitMQ
qq_45595142的博客
06-01 1758
第一步 确保你的端口都开放了，浏览器可以访问得到。在配置文件中 第二步 注入RabbitTemplete 第三部操作 这是发消息的操作，需要指定交换器以及路由键。若传过去的是对象。则需要配置默认序列化。 获取队列中的消息： 创建一个交换器和队列，并绑定 ...
在Idea上实践RabbitMQ(一)
qq_58348395的博客
10-01 1062
基础操作之简单的收发消息以及转换器与队列的绑定
RabbitMQ在idea使用（项目举例）
最新发布
2301_79201170的博客
06-16 1139
在访问量剧增的情况下, 应⽤仍然需要继续发挥作⽤, 但是是这样的突发流量并不常⻅. 如果以能处理这类峰值为标准⽽投⼊资源,⽆疑是巨⼤的浪费. 使⽤MQ能够使关键组件⽀撑突发访问压⼒, 不会因为突发流量⽽崩溃. ⽐如秒杀或者促销活动, 可以使⽤MQ来控制流量, 将请求排队, 然后系统根据⾃⼰的处理能⼒逐步处理这些请求.要注意的是，当项⽬启动时，死信队列会实时消费。: 在很多时候应⽤不需要⽴即处理消息, MQ提供了异步处理机制, 允许应⽤把⼀些消息放⼊MQ中, 但并不⽴即处理它,在需要的时候再慢慢处理.
【rabbitMQ】五种消息模型
丢失了名字的琥珀川
01-07 3204
高效能人士的七个习惯 这本书不是一本普通的成功学之作，而是一本能够付诸实践的处世方法论，它让我们可以静下心来反思自己的态度。 一. 积极主动：个人愿景的原则 积极主动的人在生活中更多讲“我可以……”、“我愿意……”、“我能够……”，而不是“但愿……”、“如果……就好了”，也就是把精力放在能够控制的事情上，主动创造有利于自己发展的环境，而不是怨天尤人，处处找借口。 二. 以终为始：自我领...
Idea：RabbitMQ六种模式队列
XIATWO
10-10 855
前言 术语 1. Producing Producing意思不仅仅是发送消息。发送消息的程序叫做producer生产者。 2. Queue Queue是一个消息盒子的名称。它存活在 RabbitMQ 里。虽然消息流经 RabbitMQ 和你的应用程序，但是他们只能在 Queue 里才能被保存。Queue 没有任何边界的限制，你想存多少消息都可以，它本质上是一个无限的缓存。许多生产者都可以向一个 Queue 里发送消息，许多消费者都可以从一个 Queue 里接收消息。...
学习RabbitMQ（idea）
qq_47285211的博客
02-07 584
2、queue（队列）：队列是RabbitMQ中邮箱的名称，尽管消息流经RabbitMQ和你的应用程序，但它只能存储在队列中，队列仅受主机内存和磁盘限制的约束，它本质上是一个大型的消息缓冲区，许多生产者可以发送到一个队列的消息，许多使用者可以尝试从一个队列接收数据，这就是我们表示队列的方式。RabbitMQ本质上是队列，遵循FIFO(先进先出)，在队列中存放的是message，是一种跨进程的通信机制，用于上下游传递消息。1、producer（生产者）：生产只意味着发送，发送消息的程序就是生产者。
Rabbitmq消息中间件初步学习——第二节七种模型分析
Burnup_110的博客
01-28 648
前言 Rabbitmq应用场景 1.RabbitMQ的消息应当尽可能的小，并且只用来处理实时且要高可靠性的消息。 2.消费者和生产者的能力尽量对等，否则消息堆积会严重影响RabbitMQ的性能。 3.集群部署，使用热备，保证消息的可靠性。 ...
乐行学院RabbitMQ学习教程 第一章 RabbitMQ介绍(可供技术选型时使用)
乐行人生
04-30 1372
乐行学院RabbitMQ学习教程 第一章 RabbitMQ介绍 RabbitMQ介绍1.RabbitMQ技术简介2.RabbitMQ其他扩展插件2.1监控工具rabbitmq-management (官方提供)2.2学习手册 RabbitMQ Tutorials(官方提供)2.3Java语言客户端 rabbitmq-java-client(官方提供)3 RabbitMQ基本概念讲解3.1 Rabb...
RabbitMQ客户端连接池实现代码可直接复制项目中使用
12-19
RabbitMQ客户端连接池实现代码可直接复制项目中使用,内含MQhelper getMessage sendMessage
使用IDEA开发RabbitMQ教程系列（五）RabbitMQ可靠性投递生产者确认机制
热门推荐
Micro麦可乐的博客
03-01 1万+
1、前言 上一篇文章我们详细介绍了Queue队列和Message消息，本章节我们主要聊一聊RabbitMQ使用必须考虑的问题，就是消息可靠性！在生产环境下如何确保消息的可靠性投递，我们首先需要考虑两个问题 1、生产者发送消息，是否发送成功? 2、消费者接收消息如何确认以及拒绝？ 当然我们所说的可靠并非一个绝对的概念，因网络、硬件、不可抗因素等；可靠性是一个相对的概念，在条件合理的范围内系统所能确保...
初识Rabbit MQ用idea实现简单消息发送与读取的操作
qq_35524008的博客
08-13 542
1、首先在idea中创建Spring Boot项目 2、在pom文件中导入Rabbit MQ 的核心依赖 3、创建生产者 | public static void main(String[] args) throws IOException, TimeoutException { //1、创建连接工厂 ConnectionFactory factory = new ConnectionFact...
Windows下RabbitMQ安装及配置
明耀的博客
03-30 213
转载：Windows下RabbitMQ安装及配置 rabbitMQ是一个在AMQP协议标准基础上完整的，可服用的企业消息系统。它遵循Mozilla Public License开源协议，采用 ...
使用IDEA搭建 SpringBoot集成RabbitMQ系列（一）：RabbitMQ的简单使用
luck_sheng的博客
06-21 2075
标题
如何在idea使用RabbitMQ
qq_67576286的博客
09-25 1530
去rabbitMQ网站去看看，准备中（Ready）的消息变成两个了，然后我们点击进入helloworld-queue 队列里。然后在你的自己建立的启动类里添加@EnableRabbit注解来启动RabbitMQ。再去rabbitMQ网页，发现多了helloworld这个交换机，说明创建成功。然后再去rabbitMQ网站看看，之前准备的（Ready）的消息全没了。在你之前创建的test测试类RabbitMqTest 写入下面的代码。5672端口号是项目程序访问的端口，15672是web访问的端口。
RabbitMQ Linux安装以及IDEA使用
weixin_49194846的博客
09-01 467
一.在linux上安装插件 1.加载插件 输入命令 yum -y install epel-release 加载插件 yum -y install socat 2.在/usr/src下创建一个RabbitMQ目录,将MQ下载在这个目录下 3.安装erlang环境 在/usr/src/RabbitMQ 目录下将MQ需要的两个安装包放进去,进行安装命令,在linux粘贴: insert + shift yum install -y esl-erlang_22.1.8-1_centos_7_amd6
Idea+maven+springboot项目搭建系列--2 整合Rabbitmq完成客户端&服务器端消息收发
拽着尾巴的鱼儿的博客
06-14 1778
Direct Exchange 是最简单的交换机类型，交换机直接与队列完成绑定,它根据消息携带的 Routing Key 和队列与 Exchange 绑定时指定的 Routing Key 精准匹配,然后路由消息到指定队列中。因此，在选择队列类型时，需要结合具体的业务情况和系统限制，选择采用 classic、quorum 还是 stream 队列，以达到最优的性能和可用性。这里分别测试了单条消息，多条消息，延迟消息，事务消息的发送，将其封装为MsgDto对象，在发送时将其转为json 字符串；
使用IDEA开发基于SSM的Web项目
- **数据库连接池技术**：常用的数据库连接池有HikariCP、Apache DBCP等，它们能够有效提高数据库连接的复用率，提升应用性能。 - **缓存技术**：为了提升应用性能，可以在SSM项目中集成缓存技术，比如使用EhCache...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值