RabbitMQ2/7--RabbitMQ支持的消息模型

最新推荐文章于 2023-05-18 20:14:37 发布
最新推荐文章于 2023-05-18 20:14:37 发布
阅读量172 收藏
点赞数
分类专栏： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42758288/article/details/119077554
版权

RabbitMQ支持的消息模型

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

第一种模型（直连）

概念

生产者和消费者之间是一对一的关系，通过队列进行消息的传输

结构图

在这里插入图片描述

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

代码演示之前，先创建新用户并指定虚拟主机！！

创建虚拟主机（必须以 / 开头）

在这里插入图片描述

创建新用户

在这里插入图片描述

用户指定虚拟机

在这里插入图片描述

选择要指定的虚拟主机，并设置

设置成功，返回查看
在这里插入图片描述

代码

引入依赖

<!--引入rabbitmq的相关依赖-->
<dependency>
  <groupId>com.rabbitmq</groupId>
  <artifactId>amqp-client</artifactId>
  <version>5.7.2</version>
</dependency>

生产者代码

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 Provider {

    //生产消息
    @Test
    public void testSendMessage() throws IOException, TimeoutException {

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

        //获取连接对象
       Connection connection = connectionFactory.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 utils.RabbitMQUtils;

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

public class Customer {

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

        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //连接主机
        connectionFactory.setHost("192.168.139.129");
        //连接端口号
        connectionFactory.setPort(5672);
        //虚拟主机
        connectionFactory.setVirtualHost("/ems");
        //用户名
        connectionFactory.setUsername("ems");
        //密码
        connectionFactory.setPassword("ems");

        //创建连接对象
        Connection connection = connectionFactory.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));
            }
        });
        //---通道和连接不关闭将一直监听消息队列
//        //关闭通道
//        channel.close();
//        //关闭连接
//        connection.close();
    }
}

消费之后
在这里插入图片描述

Tips

junit测试过程中，不支持多线程模型，如果以test方式运行，不支持监听，还未回调，主线程已经结束了，所以消费者要放在main函数中执行！！！

工程优化–工具类封装（连接对象封装成工具类）

工具类封装-RabbitMQUtils

package utils;


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

import java.util.Properties;

public class RabbitMQUtils {

    private static ConnectionFactory connectionFactory;
    private static Properties properties;
    static{
        //重量级资源  类加载执行之执行一次
        connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.139.129");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/ems");
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("ems");
    }

    //定义提供连接对象的方法
    public static Connection getConnection() {
        try {
            return connectionFactory.newConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    //关闭通道和关闭连接工具方法
    public static void closeConnectionAndChanel(Channel channel, Connection conn) {
        try {
            //空指针判断
            if(channel!=null) channel.close();
            if(conn!=null)   conn.close();
        } catch (Exception e) {
            e.printStackTrace();

        }
    }

}

生产者引用工具类

package helloword;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.MessageProperties;
import org.junit.Test;
import utils.RabbitMQUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Provider {

    //生产消息
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
//        //通过工具类获取连接对象
        Connection connection = RabbitMQUtils.getConnection();
//
       //获取连接中通道
       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());
//        //调用工具类
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

消费者引入工具类

package helloword;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Customer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //通过工具类获取连接
        Connection connection = RabbitMQUtils.getConnection();

        //创建通道
        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));
            }
        });
    }
}

设置消息队列持久化和消息持久化

在这里插入图片描述
说明：

  1. 队列持久化：b,设置为false，服务宕机重启后，队列消失，设置为true，队列持久化
  2. 消息持久化：MessageProperties，设置为PERSISTENT_TEXT_PLAIN，服务重启后，消息还在队列中，持久化存储，直到被消费掉
  3. 生产者和消费者的消息队列信息要保持一致
    在这里插入图片描述

总结

第一种模型（直连）helloworld的这种模型，适用于登录，短信发送这种场景，一对一，一个生产者对应一个消费者，每次只生产一条消息，消费者不中断的监听消息队列，只要队列中有消息，就进行消费

缺点
消息堆积，生产者不断生产消息到消息队列，消费者消费的速度跟不上生产的速度，会产生消息堆积

第二种模型（工作队列）

概念

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

结构

在这里插入图片描述

  • P：生产者：任务的发布者
  • C1：消费者-1，领取任务并且完成任务，假设完成速度较慢
  • C2：消费者-2：领取任务并完成任务，假设完成速度快

代码演示

生产者

package workquene;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

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

        //通过通道声明队列
        channel.queueDeclare("work", true, false, false, null);

        for (int i = 1; i <=20; i++) {
            //生产消息
            channel.basicPublish("", "work", null, (i + "hello work quene").getBytes());
        }

        //关闭资源
        RabbitMQUtils.closeConnectionAndChanel(channel, connection);

    }
}

消费者-1

package workquene;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;
import java.io.IOException;

public class Customer1 {
    public static void main(String[] args) throws IOException {
        //调用工具类获取连接
        Connection connection = RabbitMQUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare("work",true,false,false,null);
        //参数1:队列名称  参数2:消息自动确认 true  消费者自动向rabbitmq确认消息消费  false 不会自动确认消息
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try{
                    //休眠2秒，测试是否平均消费
                    Thread.sleep(2000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("消费者-1: "+new String(body));
            }
        });
    }
}

消费者-2

package workquene;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;
import java.io.IOException;

public class Customer2 {
    public static void main(String[] args) throws IOException {
        //调用工具类，获取连接
        Connection connection = RabbitMQUtils.getConnection();
        final Channel channel = connection.createChannel();
        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("消费者-2: "+new String(body));
            }
        });
    }
}

运行结果

消费前

在这里插入图片描述

消费后

在这里插入图片描述

消费者-1

在这里插入图片描述

消费者-2

在这里插入图片描述

存再的问题-循环

消费者-1，和消费者-2平均消费消息队列中的消息，这种经过，经过多次测试，加上线程休眠，结果还是平均消费，官方称为循环。

默认循环机制存在的缺点

一个消费的快，另一个消费的慢，依旧会存在消息堆积的现象

优化–消息确认机制（能者多劳模式）

如何开启消息确认
在消费者端channel.basicConsume()方法的第二个参数设置为true
在这里插入图片描述

消息自动确认带来的问题

如果两个消费者平均分配消息，假如一个消费已经从队列中拿到了5个消息，在消费到第3个消息的时候宕机了，后面的消息将会丢失
在这里插入图片描述

消息确认机制的优化

1.关闭消息确认机制，设置第二个参数为false
2.设置每次只能消费一个消息
3.设置消息消费完毕后进行手动确认

优化后的代码（消费者端）

在这里插入图片描述

结果

能者多劳，保证不会丢失消息

第三种模型（广播模型）

概念

工作队列的变体，生产者负责把消息放入交换机中，由交换机负责分发消息到队列中

结构图

在这里插入图片描述

  • 可以有多个消费者 每个消费者有自己的queue（队列）
  • 每个队列都要绑定到Exchange（交换机）
  • 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。
  • 交换机把消息发送给绑定过的所有队列
  • 队列的消费者都能拿到消息。实现一条消息被多个消费者消费

默认的交换机类型

在这里插入图片描述

代码演示

生产者

package fanout;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Provider {

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

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

        //发送消息
        参数1：交换机名字
        参数2：路由key
        参数3：消息持久化特性
        参数4：消息内容
        channel.basicPublish("logs","",null,"fanout type message".getBytes());

        //释放资源
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

生产者指定的交换机不存在，运行后则创建一个交换机
在这里插入图片描述

消费者（三个消费者，代码同）

package fanout;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;
import java.io.IOException;

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

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

        //临时队列
        String queueName = channel.queueDeclare().getQueue();

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

        //消费消息
        channel.basicConsume(queueName,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));
            }
        });
    }
}

运行结果

在这里插入图片描述

总结

多个消费者同时接收到生产者发出的消息
消费者所绑定的队列，称为临时队列

适用场景

注册，用户注册成功后，可通过多种途径通知客户，如邮件，手机短信，微信公众号推送,一条广播消息，多个接受途径

第四种模型（路由）

Routing 之订阅模型-Direct(直连)

在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

在Direct模型下：

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

简言之，就是生产者与消费者之间通过路由key进行绑定，路由key匹配成功才能接受消息，不成功的接收不到消息
在这里插入图片描述

结构

在这里插入图片描述

  • P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。
  • X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列
  • C1：消费者，其所在队列指定了需要routing key 为 error 的消息
  • C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消

代码演示

生产者代码

package direct;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;
import java.io.IOException;

public class Provider {
    public static void main(String[] args) throws IOException {
        //获取连接对象
        Connection connection = RabbitMQUtils.getConnection();
        //获取连接通道对象
        Channel channel = connection.createChannel();
        String exchangeName = "logs_direct";
        //通过通道声明交换机  参数1:交换机名称  参数2:direct  路由模式
        channel.exchangeDeclare(exchangeName,"direct");
        //发送消息
        String routingkey = "warning";
        channel.basicPublish(exchangeName,routingkey,null,("这是direct模型发布的基于route key: ["+routingkey+"] 发送的消息").getBytes());
        //关闭资源
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

消费者1

package direct;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;
import java.io.IOException;

public class Customer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        String exchangeName = "logs_direct";

        //通道声明交换机以及交换的类型
        channel.exchangeDeclare(exchangeName,"direct");

        //创建一个临时队列
        String queue = channel.queueDeclare().getQueue();

        //基于route key绑定队列和交换机和接受的路由key
        channel.queueBind(queue,exchangeName,"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 direct;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;
import java.io.IOException;

public class Customer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        String exchangeName = "logs_direct";

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

        //创建一个临时队列
        String queue = channel.queueDeclare().getQueue();

        //临时队列和交换机绑定，路由key的绑定
        channel.queueBind(queue,exchangeName,"info");
        channel.queueBind(queue,exchangeName,"error");
        channel.queueBind(queue,exchangeName,"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("消费者2: "+new String(body));
            }
        });
    }
}

运行结果

消费者1和消费者2绑定的路由key不同，能接收的消息也就不同
在这里插入图片描述

第五种模型（通配符）

Routing 之订阅模型-Topic

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

结构

在这里插入图片描述

通配符说明

* (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

在这里插入图片描述

代码演示

生产者

package topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;
import java.io.IOException;

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

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

        //发布消息，路由key
        String routekey = "save.user.delete";

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

        //关闭资源
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);

    }
}

消费者1

package topic;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;
import java.io.IOException;

public class Customer1 {
    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();
        //绑定队列和交换机  动态统配符形式route key
        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 topic;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;
import java.io.IOException;

public class Customer2 {
    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();
        //绑定队列和交换机  动态统配符形式route key
        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("消费者2: "+ new String(body));
            }
        });
    }
}

运行结果

在这里插入图片描述

詹姆斯东
关注
专栏目录
RabbitMQ常用的几种消息模型
编程小白养成手记
07-21 902
RabbitMQ常用的几种消息模型你知道哪些？Fanout，Topics，Direct，Routing，Work？对不对呢
Go 使用 RabbitMQ---------------之一
最新发布
qq_39335595的博客
05-27 1230
RabbitMQ 是一种消息代理。消息代理的主要目的是接收、存储并转发消息。在复杂的系统设计和微服务架构中，RabbitMQ 经常被用作中间件来处理和转发系统之间的消息，以确保数据的一致性和可靠性。正是因为提供了可靠的消息机制、跟踪机制和灵活的消息路由，常常被用于排队算法、秒杀活动、消息分发、异步处理、耗时任务等场景。
【SpringBoot学习】13、SpringBoot 整合 RabbitMQ 实现五种消息模型案例
Tellsea
04-21 1346
SpringBoot整合RabbitMQ实现五种消息模型 RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。 simple消息模型：生产者–>队列–>消费者 work消息模型：生产者–>队列–>多个消费者共同消费 fanout消息模型：广播，将消息交给所有绑定到交换机的队列，每个消费者都会收到同一条消息 direct消...
RabbitMQ支持的消息模型
Ciel_Y的博客
08-07 2487
目录 1.什么是MQ 1.2 MQ有哪些 1.3不同MQ特点 2 RabbitMQ AMQP协议 1 RabbitMQ支持的消息模型 4.2引入依赖 4.3第一种模型(直连) 1.开发生产者 2.开发消费者 4.4RabbitMQ中连接工具类封装 4.5细节 4.6第二种模型(work quene) 1.定义： 2.角色: 3.生产者： 4.消费者 创建2个： // 区别是是否带下面这个线程休眠代码 5.总结: 6.缺点： 5.第三种模型(fanout| 广播) 1
RabbitMQ消息模型
tian830937的专栏
11-21 820
RabbitMQ提供了5种消息模型
RabbitMQ：消息模型
栗筝i的博客
12-12 3942
RabbitMQ 提供了 6 种消息模型，分别为：单生产单消费模型（Hello World）、消息分发模型（Work queues）、Fanout 消息订阅模式（Publish/Subscribe）、Direct 路由模式（Routing）、Topic 匹配模式（Topic）、RPC 模式（RPC）。 本篇内容包括：RabbitMQ 6 种消息模型、RabbitMQ 6 种消息模型介绍
rabbitmq-server-windows-3.6.10.zip
06-24
7. **消息模型**：RabbitMQ支持多种消息模型，如Direct、Fanout、Topic和Header，可以根据你的应用场景选择合适的模型。 8. **监控与日志**：RabbitMQ提供了丰富的监控工具和日志记录，可以帮助你了解系统的运行...
rabbitmq3.8.16-linux-centos7.x
04-05
2. **RabbitMQ核心概念**：如节点、队列、通道、消费者和生产者等，以及它们在消息传递中的角色。 3. **Erlang OTP**：Erlang的开放电信平台（OTP）框架提供了构建分布式、容错系统的基础，理解其并发模型和错误...
rabbitmq-java (2).zip
01-11
RabbitMQ是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，被广泛用于处理分布式系统中的异步任务和消息传递。在这个名为"rabbitmq-java (2).zip"的压缩包中，我们可以看到...
rabbitmq-server-generic-unix-3.7.7.tar
08-16
RabbitMQ是一个开源的消息代理和队列服务器，它实现了Advanced Message Queuing Protocol（AMQP），用于在分布式系统中高效地处理消息传递。 描述中的内容与标题相同，暗示这个压缩包可能包含了RabbitMQ服务器的...
中间件_RabbitMQ五种消息模型
故常无，欲以观其妙；常有，欲以观其徼；
05-18 3458
RabbitMQ 提供了5种常用消息模型。但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。
【RabbitMQ】常用消息模型详解
十八岁讨厌编程的博客
11-10 3467
本文涉及AMQP协议的回顾、RabbitMQ支持的消息模型概述、以及其中Direct模型、WorkQueue模型、Fanout模型、Routing模型、Topic模型的详细介绍与使用
消息中间件rabbitMQ之第一种消息模型(直连)
helloworld工程师的博客
01-14 753
AMQP协议的回顾 RabbitMQ支持的消息模型 引入依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.7.2</version> </dependency> 第一种模型(直连) 在上图的模型中，有以下概..
spring boot整合rabbitmq(5种)
cxxx45的博客
06-19 222
原文：https://blog.csdn.net/qq_38762237/article/details/89433506 依赖 ​ org.springframework.boot ​ spring-boot-starter-amqp application.yml spring: rabbitmq: ​ host: 127.0.0.1 ​ username: tel...
MQ2和MQ7浓度测量
qq_43313535的博客
04-29 1万+
最近在用32做一个测量气体的课设项目，用到了MQ2和MQ7两个传感器，收了将近两个小时的资料 这两篇文章写的很直接，就算你看不懂也没关系，博主的代码可以直接用 MQ2烟雾传感器 https://blog.csdn.net/qq_41422043/article/details/89138213?utm_medium=distribute.pc_relevant.none-task-blog-Blo...
消息中间件概述
weixin_33805992的博客
04-22 4663
1 消息中间件概述 消息队列已经逐渐成为企业IT系统内部通信的核心手段。它具有低耦合、可靠投递、广播、流量控制、最终一致性等一系列功能，成为异步RPC的主要手段之一。当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、RabbitMQ，炙手可热的Kafka，阿里巴巴自主开发RocketMQ等。 2 消息中间件的组成 2.1 Broker 消息服务器，作为server提供消息核心服务 2.2...
MQ7一氧化碳传感器
飘飘仙儿__的博客
04-08 4万+
1、MQ-7气体传感器所使用的气敏材料是在清洁空气中电导率较低的二氧化锡（SnO2）。采用高低温循环检测方式低温（1.5v加热）检测一氧化碳，传感器的电导率随空气中一氧化碳气体浓度增加而增加，高温（5.0v加热）清洗低温时吸附的杂散气体。使用简单的电路即可将电导率的变化，转换为与该气体浓度相对应的输出信号。 2、MQ-7气体传感器对一氧化碳的灵敏度高，这种传感器可检测多种含一氧化碳的气体，是一款...
MQ-2烟雾传感器模块功能实现（STM32）
热门推荐
nazonomaster的博客
03-03 6万+
使用STM32F407ze获取MQ-2烟雾传感器模块的测量值
小程序基本命令
aiven1637的博客
10-30 3314
onLoad: function () { // 生命周期函数--监听页面加载 onReady: function () { // 生命周期函数--监听页面初次渲染完成 }, onShow: function () { // 生命周期函数--监听页面显示 }, onHide: function () { // 生命周期函数--监...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值