RabbitMQ的使用（二）：RabbitMQ中的五种通信模型

最新推荐文章于 2024-08-09 21:13:28 发布
最新推荐文章于 2024-08-09 21:13:28 发布
阅读量527 收藏
点赞数
文章标签： java rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuemmm/article/details/104828298
版权

文章目录

5.1、helloworld模型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d0LabZFw-1584019131982)(pic\1583822258266.png)]

意思是：生产者将消息发送到队列 然后队列将这个消息发送给消费者

5.1.1、导包
  <!--导入RabbitMQ的相关的包-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>4.5.0</version>
        </dependency>
5.1.2、生产者的写法
 //申明队列的名字
    private static final String QUEUE_NAME="nz1904-helloword";

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

        //第一步：获取连接
        Connection connection = ConnectionUtils.getConnection();
        //第二步：创建数据传输的通道
        Channel channel = connection.createChannel();
        //第三步：申明队列
        /**
         * 第一个参数：队列的名字
         * 第二个参数：是否持久化   比如现在发送到队列里面的消息 如果没有持久化 重启这个队列后数据会丢失(false) true：重启之后数据依然在
         * 第三个参数：是否排外
         *            1：连接关闭之后 这个队列是否自动删除
         *            2：是否允许其他通道来进行访问这个数据
         * 第四个参数：是否允许自动删除
         *            就是当最后一个连接断开的时候  这个时候是否允许自动删除这个队列
         * 第五个参数：申明队列的时候 要附带的一些参数
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //发送数据到队列

        /**
         * 第一个参数：exchange  交换机  没有就设置为"值就可以了"
         * 第二个参数：原本的意思是路由的key  现在没有key直接使用队列的名字
         * 第三个参数：发送数据到队列的时候 是否要带一些参数  没有带任何参数
         * 第四个参数：向队列中发送的数据
         */
        channel.basicPublish("",QUEUE_NAME,null,"我是小波波1111".getBytes());
        channel.close();
        connection.close();
    }
5.1.3、消费者的写法
 //申明队列的名字
    private static final String QUEUE_NAME="nz1904-helloword";

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

        //获取连接
        Connection connection = ConnectionUtils.getConnection();

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

        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);


        //消费者的申明
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            /**
             *
             * @param consumerTag：这个消息的唯一标记
             * @param envelope：信封(请求的消息属性的一个封装)
             * @param properties：前面队列带过来的值
             * @param body  ：接受到的消息
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接受到的消息是:"+new String(body));
                //进行手动应答
                /**
                 * 第一个参数：自动应答的这个消息标记
                 * 第二个参数：false 就相当于告诉队列受到消息了
                 */
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };

        //绑定这个消费者
        /**
         * 第一个参数：队列的名字
         * 第二个参数：是否自动应答
         * 第三个参数：消费者的申明
         */
        channel.basicConsume(QUEUE_NAME,false,defaultConsumer);
}
5.2、work模型的玩法

多个消费者消费的数据之和才是原来队列中的所有数据 适用于流量的消峰

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oba16bOM-1584019131983)(pic\1583827843958.png)]

5.2.1、生产者的编写
public class Producer {

    private static final String QUEUE_NAME="nz1904-work";

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

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //下面向队列中发送100条消息
        for (int i = 0; i <100 ; i++) {
            channel.basicPublish("",QUEUE_NAME,null,("我是工作模型:"+i).getBytes());
        }
        channel.close();
        connection.close();
    }

}
5.2.2、消费者1的编写
public class Consumer {

    //申明队列的名字
    private static final String QUEUE_NAME="nz1904-work";

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

        //获取连接
        Connection connection = ConnectionUtils.getConnection();

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

        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);


        //消费者的申明
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            /**
             *
             * @param consumerTag：这个消息的唯一标记
             * @param envelope：信封(请求的消息属性的一个封装)
             * @param properties：前面队列带过来的值
             * @param body  ：接受到的消息
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1接受到的消息是:"+new String(body));
                //进行手动应答
                /**
                 * 第一个参数：自动应答的这个消息标记
                 * 第二个参数：false 就相当于告诉队列受到消息了
                 */
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };

        //绑定这个消费者
        /**
         * 第一个参数：队列的名字
         * 第二个参数：是否自动应答
         * 第三个参数：消费者的申明
         */
        channel.basicConsume(QUEUE_NAME,false,defaultConsumer);

    }
}
5.2.3、消费者2的编写
public class Consumer1 {

    //申明队列的名字
    private static final String QUEUE_NAME="nz1904-work";

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

        //获取连接
        Connection connection = ConnectionUtils.getConnection();

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

        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);


        //消费者的申明
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            /**
             *
             * @param consumerTag：这个消息的唯一标记
             * @param envelope：信封(请求的消息属性的一个封装)
             * @param properties：前面队列带过来的值
             * @param body  ：接受到的消息
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2接受到的消息是:"+new String(body));
                //进行手动应答
                /**
                 * 第一个参数：自动应答的这个消息标记
                 * 第二个参数：false 就相当于告诉队列受到消息了
                 */
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };

        //绑定这个消费者
        /**
         * 第一个参数：队列的名字
         * 第二个参数：是否自动应答
         * 第三个参数：消费者的申明
         */
        channel.basicConsume(QUEUE_NAME,false,defaultConsumer);

    }
}
5.3、发布订阅模型

在这里插入图片描述

简单的说就是队列里面的消息会被几个消费者 同时接受到

模型 适合于做模块之间的异步通信

例子: 就可以使用这种模型 来发送日志信息 ------ 立马就会被log收集程序

收集到 直接写到咋们的文件里面

例子：springcloud的config组件里面通知配置自动更新

例子：缓存同步也可以使用这一个

例子：高并发下实现下单逻辑

5.3.1、编写生产者
public class Producer {

    //申明交换机的名字
    private static final String EXCHANGE_NAME="nz1904-fanout-01";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //申明交换机
        /**
         * 第一个参数：交换机的名字
         * 第二个参数：交换机的类型
         *    交换机的类型是不能乱写的   如果使用的是发布订阅模型  只能写 fanout
         */
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //发送消息到交换机了
        for (int i = 0; i <100 ; i++) {
            channel.basicPublish(EXCHANGE_NAME,"",null,("发布订阅模型的值:"+i).getBytes());
        }
        //关闭资源
        channel.close();
        connection.close();
    }

}
5.3.2、编写消费者
public class Consumer {
    //申明交换机的名字
    private static final String EXCHANGE_NAME="nz1904-fanout-01";
    //队列的名字
    private static final String QUEUE_NAME="nz1904-fanout-queue1";

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

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //申明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //将队列绑定到交换机
        /**
         * 第一个参数：队列的名字
         * 第二个参数：交换机的名字
         * 第三个参数：路由的key(现在没有用到这个路由的key)
         */
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");

        //申明消费者
        DefaultConsumer defaultConsumer = 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(QUEUE_NAME,true,defaultConsumer);
    }
}
5.3.2、编写消费者2
public class Consumer1 {

    //申明交换机的名字
    private static final String EXCHANGE_NAME="nz1904-fanout-01";
    //队列的名字
    private static final String QUEUE_NAME="nz1904-fanout-queue2";

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

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //申明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //将队列绑定到交换机
        /**
         * 第一个参数：队列的名字
         * 第二个参数：交换机的名字
         * 第三个参数：路由的key(现在没有用到这个路由的key)
         */
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");

        //申明消费者
        DefaultConsumer defaultConsumer = 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(QUEUE_NAME,true,defaultConsumer);
    }
}
5.4、路由模型

路由模式相当于是发布订阅模式的升级版

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zFRBJFPK-1584019131984)(pic\1583891119250.png)]

5.4.1、生产者的写法
public class Producer {
    private static final String EXCHANGE_NAME="nz1904-exchange-direct-01";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        /**
         * 如果玩的是路由模型 交换机的类型只能是  direct
         */
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        //发送信息到交换机
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                //这个路由的key是可以随便设置的
                channel.basicPublish(EXCHANGE_NAME,"xiaowangzi",null,("路由模型的值:"+i).getBytes());
            }else{
                //这个路由的key是可以随便设置的
                channel.basicPublish(EXCHANGE_NAME,"xiaobobo",null,("路由模型的值:"+i).getBytes());
            }
        }
        channel.close();
        connection.close();
    }
}
5.4.2、消费者1的写法
public class Cosnumer1 {

    private static final String QUEUE_NAME="nz1904-direct-queue-01";
    private static final String EXCHANGE_NAME="nz1904-exchange-direct-01";

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

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //申明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        //绑定队列到交换机
        //第三个参数：表示的是路由key
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"xiaobobo");
        //申明消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
               //这里就是接受消息的地方
                System.out.println("路由key是xiaobobo的这个队列接受到数据:"+new String(body));
            }
        };
        //绑定消费者
        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);
    }
}
5.4.3、消费者2的写法
public class Consumer2 {
    private static final String QUEUE_NAME="nz1904-direct-queue-02";
    private static final String EXCHANGE_NAME="nz1904-exchange-direct-01";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //申明队列
      channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //申明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        //绑定队列到交换机
        //第三个参数：表示的是路由key
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"xiaowangzi");
        //申明消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //这里就是接受消息的地方
                System.out.println("路由key是xiaowangzi的这个队列接受到数据:"+new String(body));
            }
        };
        //绑定消费者
        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);
    }
}
5.5、topic模式

说明：topic模式相当于是对 路由模式的一个升级 topic模式主要就是在匹配的规则上可以实现模糊匹配

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i4qeGTH7-1584019131985)(pic\1583892955712.png)]

5.5.1、生产者的写法
public class Producer {
    private static final String EXCHANGE_NAME = "nz1904-exchange-topic-01";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        /**
         * 如果玩的是路由模型 交换机的类型只能是  direct
         */
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //发送信息到交换机
        for (int i = 0; i < 100; i++) {
            //这个路由的key是可以随便设置的
            //topic在路由基础上只有 路由的key发生改变  其余的都不变
            channel.basicPublish(EXCHANGE_NAME, "xiaowangzi.xiaowangzi.xiaowangzi", null, ("路由模型的值:" + i).getBytes());
        }
        channel.close();
        connection.close();
    }
}
5.5.3、消费者1的写法
public class Cosnumer1 {

    private static final String QUEUE_NAME="nz1904-topic-queue-01";
    private static final String EXCHANGE_NAME="nz1904-exchange-topic-01";

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

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //申明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");
        //绑定队列到交换机
        //第三个参数：表示的是路由key
        /**
         *    注意  * ：只是代表一个单词
         *         # ：这个才代表  一个或者多个单词
         *         记住如果有多个单词组成的路由key  那么多个单词之间使用 . 好连接
         *
         *
         */
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"xiaobobo.*");
        //申明消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
               //这里就是接受消息的地方
                System.out.println("路由key是xiaobobo的这个队列接受到数据:"+new String(body));
            }
        };
        //绑定消费者
        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);
    }
}
5.5.3、消费者2的写法
public class Consumer2 {
    private static final String QUEUE_NAME="nz1904-topic-queue-02";
    private static final String EXCHANGE_NAME="nz1904-exchange-topic-01";

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

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //申明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");
        //绑定队列到交换机
        //第三个参数：表示的是路由key
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"xiaowangzi.#");
        //申明消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //这里就是接受消息的地方
                System.out.println("路由key是xiaowangzi的这个队列接受到数据:"+new String(body));
            }
        };
        //绑定消费者
        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);
    }
}

备注：使用了交换机发送了数据 如果没有消费者的话那么这个数据会发生丢失 通过设置这样的属性来解决这个问题

channel.basicPublish(EXCHANGE_NAME, "xiaowangzi.xiaowangzi.xiaowangzi", MessageProperties.PERSISTENT_TEXT_PLAIN, ("路由模型的值:" + i).getBytes());

备注2：通道的问题

原本没有通道我们也可以完成这个请求 RabbitMQ官方考虑到一个问题生产者 和 消费者 实际上 Connection 引入这个通道这个概念 是为了降低TCP连接的这样一个消耗 相当于是为了 TCP的复用 还有一个目的 就是为了线程隐私 相当于每一个线程都给你创建了一个通道

希望大家关注我一波,防止以后迷路,有需要的可以加我Q讨论互相学习java ,学习路线探讨,经验分享与java Q:2415773436

yuemmm
关注
商城-RabbitMQ及消息同步-五种消息模型
shenzhen_zsw的专栏
06-17 1794
商城-RabbitMQ及消息同步-五种消息模型2.五种消息模型2.1.基本消息模型2.1.1.生产者发送消息2.1.2.管理工具中查看消息2.1.3.消费者获取消息2.1.4.消息确认机制（ACK）2.1.4.1.自动ACK存在的问题2.1.4.2.演示手动ACK2.2.work消息模型2.2.1.生产者2.2.2.消费者12.2.3.消费者22.2.4.能者多劳2.3.订阅模型分类2.4.订阅模...
分布式消息通讯RabbitMQ工作模型
须臾-code
04-19 425
本章重点： 1.三种主要的交换机介绍 2.SpringBoot整合RabbitMQ三种交换机 3.死信队列 4.优先级队列和消息 5.服务端流控 6.消费端限流 RabbitMQ的特性 RabbitMQ使用Erlang语言编写，使用Mnesia数据库存储消息。 1.可靠性（Reliability） RabbitMQ 使用一些机制来保证可靠性，如持久化、传输确认、发布确认...
五大消息模型介绍（RabbitMQ 详细注释版）
最新发布
2301_79932106的博客
08-09 2061
1.simple消息模型一个生产者 一个队列 一个消费者在此种消费模型下，若消费者对消息的处理速度较慢。那么当生产者不断向队列发送消息时，便会造成堵塞。2.work消息模型一个生产者 一个队列 多个消费者由此模型衍生的 -> 能者多劳：消费者性能高的可以多消费消息3. fanout消息模型一个生产者 一个交换机 多个队列 多个消费者这种模型下，生产着会将消息发送至交换机。再由交换机以广播的形式发送给所有消费者，由消费者在自己相应的队列获取消息。
RabbitMQ之五种消息模型
热门推荐
qq_43243541的博客
10-28 3万+
首先什么是MQ MQ全称是Message Queue,即消息对列！消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。 RabbitMQ 基于AMQP协议，erlang语言开发，稳定性好！基于AMQP的一款消息管理系统 官网： http:...
RabbitMQ的整合以及5种通讯模型
weixin_46403305的博客
07-28 1040
RabbitMQ的使用 1、MQ是什么 MQ：Message Queue ：消息队列 队列：简单的是就是一种数据结构 先进先出 消息队列：就是用来进行消息传输的 消息中间件：就是用来传输消息的中间载体 编程中 有点类似咋们的 协议 中间件 他只有一个作用：就是将你的信息发送到接受方 他并不关心 你发送的数据长啥样? 就类似于咋们生成中一个快递员的职责 RabbitMQ就是消息中间件 2、使用这个MQ能干什么 2.1、流量消峰(解决高并发) 2.2、模块之间的异步通信 3、消息队列的中间件有哪些
RabbitMQ的六种通讯模式详解
最爱嫣夜来
03-04 911
1、官方文档的学习地址 官方介绍文档地址： https://www.rabbitmq.com/getstarted.html 官网提供的文档已经很详细了，每一种模式都提供了配图和各种编程语言的code实现。 2、RabbitMQ的六种通讯模式 2.1 Simple简单模式 2.2 workqueues模式 2.3 Publish/Subscribe模式 2.4 Routing模式 2.5 Topic模式 2.6 RPC模式 3、六种模式的演示代码示例 ...
rabbitmq-test:rabbitmq测试
03-26
在Java开发中，RabbitMQ主要被用来实现异步处理、解耦系统组件以及提供可靠的通信机制。下面将详细讲解RabbitMQ的核心概念、Java API的使用以及如何进行测试。 1. **核心概念** - **消息**：在RabbitMQ中，信息...
rabbitmq-chat:rabbitmq 和基于节点的聊天系统
06-18
3. **发布/订阅模式**：在 RabbitMQ 中，发布/订阅模式是一种常见的消息模型。在这个模式下，生产者（发送者）发布消息到一个主题，而多个消费者（接收者）可以订阅这个主题，接收并处理这些消息。在聊天系统中，每...
Springboo整合RabbitMQ并测试五种模型
12-02
在本文中，我们将深入探讨如何将Spring Boot与RabbitMQ集成，并通过实践了解五种不同的消息模型。首先，让我们简要介绍一下Spring Boot和RabbitMQ。 Spring Boot是Spring框架的一个微服务开发工具，它简化了配置，...
RabbitMQ五种模式
07-01
**基本模型： 消息发布者 --> 消息中间件 ---> 消息消费者** 同步调用是 A调用B后阻塞等待，此时A的后续操作是不能进行。异步调用的一种实现方式是引入MQ，A将调用信息发到消息中间件，然后B从消息中间件获取到消息...
rabbitmq-producer:Rabbit MQ-ConsumerProducer消息队列
03-06
本篇文章将深入探讨RabbitMQ的Producer（生产者）和Consumer（消费者）模型，以及如何在C#环境中使用它们。 首先，RabbitMQ的Producer是发送消息的应用程序部分，它的主要任务是创建消息并将其发送到消息队列。在C#...
RabbitMQ常用五种模型
weixin_38635565的博客
04-24 939
1、引入rabbitmq的客户端jar包 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.6.0</version> </dependency> 2、rabbitmq的模型 第一种模型直连（直连） P:生产者，发送消息的程序； C：消费者，消...
RabbitMQ的通信模型与基本使用
执笔画红颜丶的博客
01-09 860
一、RabbitMQ的七大通信模型 RabiitMQ 目前有七大通信模型，分别是： Hello World 模型（最简单的模型，点对点通过队列直接通信） Work Queues 工作队列模型（在多个工人之间分配消息，竞争消费消息，能者多劳，消费快的工人能够消费更多的消息） Publish / Subscribe 发布与订阅模型（Fanout 广播模式，一条消息可以被多个消费者消费） Route 路由模型（Direct模式，根据消息类型，有选择性的消费消息） Topic 动态路由模型（与Route路由模型类
Rabbitmq五种消息模型---1
xiao-啸
06-28 312
五种消息模型 RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。 但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。 我们通过一个demo工程来了解下RabbitMQ的工作方式： 依赖： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocati
rabbitMQ--五种消息模型
山海可平的博客
08-13 630
基本消息模型 生产者发送一条消息给消息队列，消费者被动接收消息 代码： 生产者 public class Producer { public static void main(String[] args) { /*** * 1 创建连接工程 * 2 创建连接Connection * 3 通过连接获取通道 * 4 通过连接创建交换机，申明队列，绑定关系，路由可以，发送消息和接收消息 * 5
【rabbitMQ】五种消息模型
丢失了名字的琥珀川
01-07 3025
高效能人士的七个习惯 这本书不是一本普通的成功学之作，而是一本能够付诸实践的处世方法论，它让我们可以静下心来反思自己的态度。 一. 积极主动：个人愿景的原则 积极主动的人在生活中更多讲“我可以……”、“我愿意……”、“我能够……”，而不是“但愿……”、“如果……就好了”，也就是把精力放在能够控制的事情上，主动创造有利于自己发展的环境，而不是怨天尤人，处处找借口。 二. 以终为始：自我领...
RabbitMQ的5种消息模型
qq_43640120的博客
08-22 682
MQ官方教程地址：http://www.rabbitmq.com/getstarted.html 什么是MQ `MQ`(Message Quene) : 翻译为 `消息队列`,通过典型的 `生产者`和`消费者`模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。别名为 `消息中间件` 通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。基于AMQP协
RabbitMQ的五种消息模型
weixin_42492504的博客
09-04 2959
RabbitMQ的五种消息模型RabbitMQ的五种消息模型1.简单工作模型2.工作模型3.订阅模式-----Fanout（广播）4.订阅模式 ---- Direct（路由）5.订阅模式 ---- topic（通配符） RabbitMQ的五种消息模型 1.简单工作模型 一个生产者，一个队列 ，一个消费者 2.工作模型 一个生产者 ==> 一个队列 ==> 多个消费者。 一个消息只能被消费一次。 3.订阅模式-----Fanout（广播） 一个生产者 ==> 一个交换机 ==> 多个列
RabbitMQ入门指南：构建消息队列与通信模型
RabbitMQ的核心概念基于消息队列（Message Queue）模型，它是分布式应用间通信的一种高效解决方案，遵循消费-生产者（Consumer-Producer）架构模式。 消息队列在RabbitMQ中扮演着关键角色，它提供了First-In-First-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值