【尚硅谷 RabbitMQ 精髓】4、交换机概述、临时队列、绑定RoutingKey、交换机分类(Fanout、Direct、Topics)与比较

最新推荐文章于 2024-06-24 00:15:00 发布
最新推荐文章于 2024-06-24 00:15:00 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： RabbitMQ 文章标签： 消息队列 RabbitMQ Docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tu_wer/article/details/123751565
版权

1、概述

在这里插入图片描述

在这里插入图片描述

  • RabbitMQ消息传递模型的核心思想是：生产者的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递到了哪些队列中。

  • 生产者只能将消息发送到交换机(exchange)。交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。

  • 交换机必须确切知道如何处理收到的消息：是应该把这些消息放到特定队列，还是说把他们放到许多队列，还是说应该丢弃它们。这就的由交换机的类型来决定。总共有以下几个类型：

    • 直接（direct）
    • 主题（topic）
    • 标题（headers）
    • 扇出（fanout）

    在这里插入图片描述

  • 默认交换机：在没有指定交换机之前，能实现消息发送的原因，是因为使用的是默认交换机，通过空字符串进行标识。第一个参数是交换机的名称。空字符串表示默认或无名称交换机：消息能路由发送到队列中，其实是由routingKey(bindingkey)绑定key指定的，如果它存在的话；

channel.basiPublish("交换机","routingkey",消息属性props,"消息")；
  • 没有指定交换机时，routingkey可以是队列名称

2、临时队列

每当连接到RabbitMQ时，都需要一个全新的空队列，为此可以创建一个具有随机名称的队列，或者能让服务器为我们选择一个随机队列名称那就更好了。一旦断开了消费者的连接，临时队列将被自动删除

  • 创建临时队列的方式：channel.queueDeclare().getQueue()

在这里插入图片描述

3、Bindings

绑定binding 是 exchange 和 queue 之间的桥梁，它告诉exchange和那个队列进行了绑定关系。

比如：下面这张图就是×与Q1和Q2进行了绑定

在这里插入图片描述

  • 一个交换机可以通过不同的Routing Key与不同的队列绑定

在这里插入图片描述

4、Fanout

Fanout扇出：交换机将接收到的所有消息 广播 到所有队列中；

交换机的默认类型就是：fanout

扇出类型就是发布订阅模式式

在这里插入图片描述

实战

  • 消费者
package com.tuwer.rabbitmq.fanout;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.tuwer.utils.RabbitMqUtils;

import java.io.IOException;

/**
 * @author 土味儿
 * Date 2022/3/25
 * @version 1.0
 */
public class ReceiveLog01 {
    /**
     * 交换机名称
     */
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException {
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 得到通道
        Channel channel = mqUtils.getChannel(
                "192.168.19.101",
                5672,
                "admin",
                "admin",
                "/",
                "消费者01(获取日志)");
        // 声明交换机：交换机的默认类型就是fanout，可以省略声明
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        // 获取随机队列
        String queueName = channel.queueDeclare().getQueue();
        // 队列绑定交换机：由于交换机类型为fanout，可以广播到所有队列，所以不需要routingKey
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        System.out.println("消费者01开始接收日志...");

        // 确认接收
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("接收到的消息：" + new String(message.getBody()));
        };
        // 未确认接收
        CancelCallback cancelCallback = consumerTag -> {
            System.out.println("消息" + consumerTag + "接收失败！");
        };
        // 接收消息
        channel.basicConsume(queueName, false, deliverCallback, cancelCallback);
    }
}
  • 生产者
package com.tuwer.rabbitmq.fanout;

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

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

/**
 * @author 土味儿
 * Date 2022/3/25
 * @version 1.0
 */
public class EmitLog {
    /**
     * 交换机名称
     */
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) {
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 得到通道
        Channel channel = mqUtils.getChannel(
                "192.168.19.101",
                5672,
                "admin",
                "admin",
                "/",
                "生产者(发送日志)");

        try {
            // 声明交换机：交换机的默认类型就是fanout，可以省略声明
            //channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
            // 发送消息
            // 消息
            String message = "";
            // 循环发送消息
            for (int i = 1; i < 11; i++) {
                message = "Hello World! " + i;
                // fanout类型，不需要routingKey
                channel.basicPublish(
                        EXCHANGE_NAME,
                        "",
                        null,
                        message.getBytes());
                System.out.println("第" + i + "条消息已发送！");
                try {
                    // 休眠1秒
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            // 关闭
            mqUtils.close();
        }
    }
}
  • 测试

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

5、Direct

Direct：路由模式；交换机根据RoutingKey向特定队列发送消息

交换机的声明只需要在生产者或消费者一方就可以，适用于其它类型，建议两端都声明，如果先启动的一方中没有声明，将会用默认交换机类型

在这里插入图片描述

  • 消费者
// 接收控制台console队列消息：info和warning
public class ReceiveLogDirect01 {
    /**
     * 交换机名称
     */
    private static final String EXCHANGE_NAME = "direct_logs";

    /**
     * 队列名称
     */
    private static final String QUEUE_NAME = "console";

    public static void main(String[] args) throws IOException {
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 得到通道
        Channel channel = mqUtils.getChannel(
                "192.168.19.101",
                5672,
                "admin",
                "admin",
                "/",
                "控制台获取日志");
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 声明队列：可以省略，也可获取随机队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 队列绑定交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "info");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "warning");
        System.out.println("控制台开始接收日志...");

        // 确认接收
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("接收到的消息：" + new String(message.getBody()));
        };
        // 未确认接收
        CancelCallback cancelCallback = consumerTag -> {
            System.out.println("消息" + consumerTag + "接收失败！");
        };
        // 接收消息
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
    }
}

// 接收磁盘disk队列消息：error
public class ReceiveLogDirect02 {
    /**
     * 交换机名称
     */
    private static final String EXCHANGE_NAME = "direct_logs";

    /**
     * 队列名称
     */
    private static final String QUEUE_NAME = "disk";

    public static void main(String[] args) throws IOException {
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 得到通道
        Channel channel = mqUtils.getChannel(
                "192.168.19.101",
                5672,
                "admin",
                "admin",
                "/",
                "磁盘获取日志");
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 队列绑定交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "error");
        System.out.println("磁盘开始接收日志...");

        // 确认接收
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("接收到的消息：" + new String(message.getBody()));
        };
        // 未确认接收
        CancelCallback cancelCallback = consumerTag -> {
            System.out.println("消息" + consumerTag + "接收失败！");
        };
        // 接收消息
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
    }
}
  • 生产者：可以向指定的routingkey中发消息
package com.tuwer.rabbitmq.exchange.direct;

import com.rabbitmq.client.Channel;
import com.tuwer.utils.RabbitMqUtils;

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

/**
 * @author 土味儿
 * Date 2022/3/25
 * @version 1.0
 */
public class EmitLog {
    /**
     * 交换机名称
     */
    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) {
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 得到通道
        Channel channel = mqUtils.getChannel(
                "192.168.19.101",
                5672,
                "admin",
                "admin",
                "/",
                "生产者(发送日志)");

        try {
            // 声明交换机
            //channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
            // 发送消息
            // 消息
            String message = "";
            // 循环发送消息
            for (int i = 1; i < 11; i++) {
                message = "Hello World! " + i;
                channel.basicPublish(
                        EXCHANGE_NAME,
                        "error",
                        null,
                        message.getBytes());
                System.out.println("第" + i + "条消息已发送！");
                try {
                    // 休眠1秒
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            // 关闭
            mqUtils.close();
        }
    }
}
  • 测试

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

6、Topics

Topics：主题类型

发送到类型是Topics交换机的消息的RoutingKey不能随意写，必须满足一定的要求，它必须是一个 单词列表，以 点号 分隔开，这些单词可以是任意单词。

比如：“stock.usd.nyse” ， “nyse.vmw”，"quick.orange.rabbit"这种类型的。

单词列表最多不能超过255个字节。

在这个规则列表中，其中有两个替换符：

  • * 代替一个单词 1
  • # 代替零个或多个单词 >=0

2）案例解析

在这里插入图片描述

Q1绑定的是：中间带orange的三个单词的字符串：*.orange.*

Q2绑定的是：最后一个单词是rabbit的单个单词：*.*.rabbit，第一个单词是lazy的多个单词：lazy.#

数据接收情况如下：

  • quick.orange.rabbit：被队列Q1、Q2接收到
  • quick.orange.fox：被队列Q1接收到
  • lazy.brown.fox：被队列Q2接收到
  • lazy.pink.rabbit：虽然满足队列Q2的两个绑定，但是只会被接收一次
  • quick.orange.male.rabbit：四个单词不匹配任何绑定，会被丢弃
  • lazy.orange.male.rabbit：被队列Q2接收到

3）总结

交换机类型是 Topics 的情况下：

  • 当队列绑定键RoutingKey是 #，那么这个队列将接收所有数据，就有点像Fanout了（广播）
  • 当队列绑定键RoutingKey当中没有 # 和 * 出现，那么该队列绑定类型就是Direct了（完全匹配）

4）实战

  • 消费者
package com.tuwer.rabbitmq.exchange.topics;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.tuwer.utils.RabbitMqUtils;

import java.io.IOException;

/**
 * @author 土味儿
 * Date 2022/3/25
 * @version 1.0
 */
public class ReceiveLogTopics01 {
    /**
     * 交换机名称
     */
    private static final String EXCHANGE_NAME = "topics_logs";

    /**
     * 队列名称
     */
    private static final String QUEUE_NAME = "q1";

    public static void main(String[] args) throws IOException {
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 得到通道
        Channel channel = mqUtils.getChannel(
                "192.168.19.101",
                5672,
                "admin",
                "admin",
                "/",
                "消费者（主题|Q1）");
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        // 声明队列：可以省略，也可获取随机队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 队列绑定交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "*.orange.*");
        System.out.println("消费者01开始接收Q1队列消息...");

        // 确认接收
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("接收到的消息【" + new String(message.getBody())
                    + "】 RoutingKey【" + message.getEnvelope().getRoutingKey() + "】");
        };
        // 未确认接收
        CancelCallback cancelCallback = consumerTag -> {
            System.out.println("消息" + consumerTag + "接收失败！");
        };
        // 接收消息
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
    }
}

// 消费者2和消费者1中只有名称和RoutingKey不同
public class ReceiveLogTopics02 {
    // ...

    /**
     * 队列名称
     */
    private static final String QUEUE_NAME = "q2";

    public static void main(String[] args) throws IOException {
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 得到通道
        Channel channel = mqUtils.getChannel(
                "192.168.19.101",
                5672,
                "admin",
                "admin",
                "/",
                "消费者（主题|Q2）");
        // ...
        // 队列绑定交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "*.*.rabbit");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "lazy.#");
        System.out.println("消费者02开始接收Q2队列消息...");

        // ...
    }
}
  • 生产者
package com.tuwer.rabbitmq.exchange.topics;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.tuwer.utils.RabbitMqUtils;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @author 土味儿
 * Date 2022/3/25
 * @version 1.0
 */
public class EmitLogTopics {
    /**
     * 交换机名称
     */
    private static final String EXCHANGE_NAME = "topics_logs";

    public static void main(String[] args) {
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 得到通道
        Channel channel = mqUtils.getChannel(
                "192.168.19.101",
                5672,
                "admin",
                "admin",
                "/",
                "生产者(Topic|发送日志)");

        // 要发送的消息及RoutingKey
        Map<String, String> map = new HashMap<>();
        map.put("quick.orange.rabbit", "被队列Q1、Q2接收到");
        map.put("quick.orange.fox", "被队列Q1接收到");
        map.put("lazy.brown.fox", "被队列Q2接收到 ");
        map.put("lazy.pink.rabbit", "虽然满足队列Q2的两个绑定，但是只会被接收一次");
        map.put("quick.orange.male.rabbit", "四个单词不匹配任何绑定会被丢弃");
        map.put("lazy.orange.male.rabbit", "被队列Q2接收到");

        try {
            // 声明交换机
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

            String routingKey = "";
            String message = "";
            for (String s : map.keySet()) {
                routingKey = s;
                message = map.get(s);

                // 发消息
                channel.basicPublish(
                        EXCHANGE_NAME,
                        routingKey,
                        null,
                        message.getBytes());
                System.out.println("【" + message + "】已发送！");

                // 休眠1秒
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭
            mqUtils.close();
        }
    }
}
  • 测试

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

7、类型区别

交换机类型匹配RoutingKey特点
扇出 Fanout不需要匹配；广播转发，可以发送到所有队列不需要匹配
直接 Direct完全匹配；只发到特定的队列完全匹配
主题 Topic选择匹配；按通配符发送到特定的队列选择匹配
土味儿~
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
RabbitMQ-交换机（Fanout ，Direct ，Topics ）血战
weixin_66314634的博客
10-14 755
1.RabbitMq消息队列如何保证消息不丢失： 1.Ack确认应答机制（消费者） 2.Comfirm确认机制（生产者） 3.持久化机制（交换机） 2.交换机的三种模式：FanoutDirectTopics Fanout:分裂交换机扇出交换机 Direct：直连交换机 路由键（一对一） Topics：主题路由键更加复杂，更加适用于多套场景
批量删除rabbitmq的队列或交换机
06-29
采用python编写的批量删除rabbitmq的队列或交换机。 1.修改rabbitmq_delete.py中rabbitmq的配置； 2.执行以下命令： 删除队列: python3 rabbitmq_delete.py -k ‘udata.climb’ -d 1 删除交换机: python3 rabbitmq_...
RabbitMQ的临时队列
weixin_44672916的博客
07-24 140
什么是RabbitMQ的临时队列~~是指当RabbitMQ服务重启后队列是否还存在，如果不存在即为临时队列。图片中的说法不完全正确的，不要被网上的视频骗了！
RabbitMQ实践——临时队列
方亮的专栏
06-24 433
临时队列是一种自动删除队列。当这个队列被创建后，如果没有消费者监听，则会一直存在，还可以不断向其发布消息。但是一旦的消费者开始监听，然后断开监听后，它就会被自动删除。
RabbitMQ学习教程二（交换机，死信队列）
qq_51269815的博客
08-31 852
RabbitMQ学习教程二（交换机，死信队列）
RabbitMQ-交换机（发布订阅模式/fanout/direct/topics）
萌萌虎的博客
08-13 507
在中，我们创建了一个工作队列。我们假设的是工作队列背后，每个任务都恰好交付给一个消费者(工作进程)。在这一部分中，我们将做一些完全不同的事情-我们将消息传达给多个消费者。这种模式称为 ”发布/订阅模式”.......
RabbitMQ学习（中）——交换机、死信队列和延迟队列
weixin_44630656的博客
08-05 444
RabbitMQ学习总结（中）——发布确认、交换机和死信队列一、发布确认1.1 单个确认发布1.2 批量确认发布1.3 异步确认发布二、交换机2.1 Fanout exchange（发布/订阅模式）2.2 Direct exchange（路由模式）2.3 Topics 模式三、死信队列3.1 死信之TTl3.2 死信之最大长度3.3 死信之消息被拒 一、发布确认 生产者将信道设置成 confirm 模式，一旦信道进入 confirm 模式，所有在该信道上面发布的消息都将会被指派一个唯一的 ID(从 1 开始
RabbitMQ_交换机
Mudrock__的博客
11-19 832
交换机在RabbitMQ中扮演消息系统中枢，将从处收集的消息转发至处，等待消费者消费消息队列被绑定至交换机，交换机根据routing key标识并分类消息队列
RabbitMq 七大发布消息之 Routing 路由模式 中的 direct 和 topics 形式
Ai_Ting_Java的博客
03-25 405
RabbitMq 七大发布消息之helloword最简单的发布和消费消息 RabbitMq 七大发布消息之Work queues模式 RabbitMq 七大发布消息之Publish/Subscribe 发布/订阅，广播模式 一、概述 Routing 路由模式共有两种类型direct和Topics，direct可以直接绑定一个确定的routing-key，而topics则可以实现模糊动态的绑...
RabbitMQ：交换机
qq_49896962的博客
07-07 135
交换机在使用前都需要绑定(bindings)队列，什么是 binding 呢，binding 其实是 exchange 和 queue 之间的桥梁，它告诉我们 exchange 和哪个队列进行了绑定关系。 绑定关系介绍： 一、Fanout（扇出交换机） Fanout 这种类型非常简单。它将接收到的所有消息广播到它知道的所有队列中（RoutingKey一致的情况下）。通俗点说，使用了扇出（Fanout）类型的交换机可以将消息转发到所有它绑定的队列中，每一个队列都可接收到消息。 代码： 生产者： package
RabbitMQ之交换机、临时队列、Bindings、Fanout、Direct、Topics
花&败
05-17 408
一、交换机简介 RabbitMQ消息传递模型的核心思想是：生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。 相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。 总共有以下几个类型：直接（direct）、主
Python通过RabbitMQ服务器实现交换机功能的实例教程
12-24
好了，接下来我们先看交换机的工作原理：消息发送端先将消息发送给交换机，交换机再将消息发送到绑定的消息队列，而后每个接收端都能从各自的消息队列里接收到信息。 下面用send.py和receive.py来模拟实现交换机的...
rabbitmq延时队列和四种交换机模式下队列的简单实现
08-06
- `binding:` 配置队列与交换机的绑定关系，包括路由键（对于Direct和Topic模式）或headers（对于Headers模式）。 在实际应用中，你可以根据业务需求选择合适的交换机模式和创建延时队列，通过RabbitMQ实现高效的...
rabbitmq队列和交换机的实现
02-20
1. **直连交换机（Direct Exchange）**：直连交换机是最简单的交换机类型，它使用完全匹配的路由键（binding key）来将消息路由到特定的队列。生产者发送消息时指定一个路由键，如果该键与队列绑定的键完全相同，...
基于Springboot和Vue的图书借还管理系统源码 图书借还管理系统代码（高分毕设）
07-28
图书借还管理系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
C语言内存管理：静态与动态分配的较量
07-28
C语言是一种通用的编程语言，由丹尼斯·里奇（Dennis Ritchie）在20世纪70年代早期于美国电话电报公司（AT&T）的贝尔实验室开发。C语言以其高效性、灵活性和可移植性而闻名，它是一种过程式编程语言，提供了对底层硬件的直接访问能力。 C语言的特点包括： 1. **简洁高效**：C语言的语法简洁，执行效率高，适合编写系统软件。 2. **接近硬件**：C语言提供了对内存地址和位操作的直接控制，使其非常适合硬件级编程。 3. **可移植性**：C语言编写的程序可以在不同的操作系统和硬件平台上编译和运行，具有很好的可移植性。 4. **丰富的库支持**：C语言拥有大量的标准库，如标准输入输出库（stdio.h）、数学库（math.h）等。 5. **结构化编程**：C语言支持结构化编程，允许使用循环、条件判断和函数等控制结构。 6. **指针**：C语言的指针功能强大，可以操作内存地址，实现复杂的数据结构和算法。 7. **编译型语言**：C语言是一种编译型语言，源代码需要通过编译器转换成机器码才能运行。 C语言广泛应用于操作系统（如Unix和Linux）、嵌入式系统、高性能
通讯协议规范-命令包格式
07-28
提供一份通讯协议规范，包含命令包、格式等，在上下位机调试的时候可参考该文档，制定对应的通讯协议。
四足宠物机器狗动态步行规划与仿真.pdf
最新发布
07-28
四足宠物机器狗动态步行规划与仿真
RabbitMQ新建交换机、队列、交换机和队列绑定
05-17
在 RabbitMQ 中，新建交换机、队列和绑定它们之间的关系非常简单。 首先，需要连接到 RabbitMQ 服务器，并创建一个通道： ```python import pika # 连接到 RabbitMQ 服务器 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() ``` 然后，可以使用 `channel.exchange_declare()` 方法创建一个新的交换机。该方法有四个参数： - `exchange`: 交换机名称 - `exchange_type`: 交换机类型，可以是 `direct`、`fanout`、`topic` 或 `headers` - `durable`: 是否持久化，如果为 `True`，则交换机会在 RabbitMQ 服务器重启后仍然存在 - `auto_delete`: 是否自动删除，如果为 `True`，则交换机在不再被使用时会自动删除 例如，创建一个名为 `my_exchange` 的 `fanout` 类型的交换机，可以使用以下代码： ```python channel.exchange_declare(exchange='my_exchange', exchange_type='fanout', durable=True, auto_delete=False) ``` 接下来，可以使用 `channel.queue_declare()` 方法创建一个新的队列。该方法有三个参数： - `queue`: 队列名称，如果未指定，则会自动生成一个随机名称的队列 - `durable`: 是否持久化，如果为 `True`，则队列会在 RabbitMQ 服务器重启后仍然存在 - `auto_delete`: 是否自动删除，如果为 `True`，则队列在不再被使用时会自动删除 例如，创建一个名为 `my_queue` 的队列，可以使用以下代码： ```python channel.queue_declare(queue='my_queue', durable=True, auto_delete=False) ``` 最后，可以使用 `channel.queue_bind()` 方法将交换机和队列绑定在一起。该方法有三个参数： - `queue`: 队列名称 - `exchange`: 交换机名称 - `routing_key`: 路由键，用于将消息发送到特定的队列。对于 `fanout` 类型的交换机，该参数可以为空字符串。 例如，将名为 `my_queue` 的队列绑定到名为 `my_exchange` 的交换机上，可以使用以下代码： ```python channel.queue_bind(queue='my_queue', exchange='my_exchange', routing_key='') ``` 以上就是 RabbitMQ 中新建交换机、队列和绑定它们之间关系的基本流程。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

土味儿~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值