【RabbitMQ】工作模式

news2024/9/21 17:58:19

工作模式概述

简单模式

 简单模式中只存在一个生产者，只存在一个消费者。生产者生产消息，消费者消费消息。消息只能被消费一次，也称为点对点模式。

简单模式适合在消息只能被单个消费者处理的场景下存在。

工作队列模式（Work Queue）

工作队列模式中存在一个消费者，多个生产者。生产者生产消息，消息队列将生产的消息分发给不同的消费者，每个消费者接收到不同的消息后开始进行消费。简单来说，工作模式下，消息不会被重复消费，不同的消费者消费的是不同的消息。

工作模式适合在集群环境中做异步处理。

发布订阅模式

交换机（Exchange）

作用：生产者将消息发送到Broker中，会先经过交换机，由交换机将消息按照一定规则路由到一个或者多个消息队列中（在简单模式和工作队列模式下，由生产者直接将消息投递到队列中，这种情况在RabbitMQ中根本不会出现）。

RabbitMQ交换机有四种类型：fanout、direct、topic、headers。不同类型有着不同的路由策略。AMQP协议其实是有六种交换机类型的（除了上述四种，还有system和自定义），只不过RabbitMQ只使用了其四种而已。

1. Fanout：广播，交换机将从生产者中获取的消息交给与之绑定的全部队列（对应工作模式中的发布订阅模式）。

2. Direct：定向，交换机将从生产者中获取的消息交给与之绑定的符合RoutingKey的队列（对应工作模式中的路由模式）。具体RoutingKey是啥，后面会讲到。

3. Topic：通配符，交换机将从生产者中获取的消息交给与之绑定的符合RoutingKey的队列（对应工作模式中的通配符模式）。定向和通配符中的RoutingKey是略有不同的，具体到工作模式的路由模式和通配符模式就会明白。

4. headers：此类交换器并不依赖于RoutingKey的匹配规则来路由消息，而是根据发送的消息内容中的headers属性进行匹配。headers类型的交换器性能会很差，而且也不实用，基本看不到它的存在，了解即可。

Exchange只负责转化消息，并不负责存储消息。因此如果没有任何交换机和队列绑定，或者发送的消息没有符合路由规则的队列，消息就会丢失。

RoutingKey，路由键。生产者发送消息给Broker时，指定的一个字符串，用来告诉交换机应该如何处理这个消息。

BindingKey，绑定键。在声明交换机和队列之后，使用一个BindingKey将交换机和队列绑定起来。这样，当生产者将消息发送给Broker之后，交换机接收到消息就能根据消息中的RoutingKey和BindingKey进行对比，从而知道将消息路由到某个或者某几个队列中了。

本质上，BindingKey属于RoutingKey的一种。换句话说，两者的作用并没有什么差别。不同的是，路由键是生产者向Broker发送消息时使用的，绑定键则是交换机和队列绑定时进行绑定，然后再交换机给队列发送消息时使用。当生产者将一个绑定了RoutingKey的消息发送给交换机之后，交换机根据存在的BindingKey来将消息路由给队列。

发布订阅模式存在一个生产者，多个消费者。生产者生产消息，交换机将消息复制多份，每个队列都会接收到相同的消息，每个消费者接收到消息之后开始进行消费。简单来说，消费者发送的消息，所有与之关联的队列都会收到相同的消息。

发布订阅模式适合消费需要被多个消费者同时接收的场景，例如实时播报或者广播消息。

路由模式

 路由模式是发布订阅模式的变种，在发布订阅模式的基础上，增加了路由键。也就是说，消息到达交换机之后，不再是分发给所有关联的队列，而是根据绑定的路由规则来进行分发消息。

路由模式适合需要根据特定规则分发消息的场景。例如，系统日志打印，将不同级别的日志发送到不同的队列，最终输出到不同的文件。

通配符模式

通配符模式又是路由模式的变种，在路由模式的基础上，增加了通配符的功能，使消息分发更加灵活。

总的来说，发布订阅模式是消息到达交换机之后，交换机无条件的将所有消息转发给队列。路由模式是消息到达交换机之后，交换机根据RoutingKey的规则，将数据筛选之后分发给不同的队列。通配符模式也是消息到达交换机之后，交换机根据RoutingKey的规则，将数据筛选之后分发给不同的队列，只不过该RoutingKey不再是一个确定的路由键，而是类似于正则表达式的方式来定义路由键。

通配符模式适合需要灵活匹配和过滤消息的场景。

RPC模式

 RPC模式没有生产者和消费者，比较类似于咋们的RPC远程调用，大概就是通过两个队列实现了一个可回调的过程。

1. 客户端发送消息到一个指定队列，并在消息属性中设置replyTo字段，这个字段指定了一个回调队列，用于接收服务器的响应，并且还设置了correctionId字段，用来确定响应是否为服务器所期望的。

2. 服务器接收到请求之后，处理请求并将响应消息发送到replyTo指定的回调队列中。

3. 客户端在回调队列上等待响应消息，一旦收到响应，客户端会检查消息的correctionId属性，以确定它是所期望的响应。

发布确认模式（Publisher Confirms）

发布确认模式是RabbitMQ提供的一种确保消息可靠发送到RabbitMQ服务器的机制。在这种模式下，生产者可以等待RabbitMQ服务器确认收到消息的通知，以确保消息已经被服务器所接收并进行了处理。

1. 生产者将channel设置为confirm模式（通过调用channel.confirmSelect()，发布的每一条消息都会获得一个唯一的ID，生产者可以将这些序列号与消息关联起来，以便跟踪消息的状态）。

2. 当消息被RabbitMQ接收并处理后，服务器会异步地向生产者发送一个确认（ACK）给生产者（内容包含了唯一ID），表示消息已经送达。

通过发布确认模式，生产者可以确保消息被RabbitMQ服务器接收并处理，从而避免了消息丢失的问题。

发布确认模式适合对数据安全性要求较高的场景，比如金融交易、订单处理。

SDK工作模式代码案例

简单模式

生产者代码

// 简单模式

public class Producer {

    public static void main(String[] args) throws IOException, TimeoutException {
        // TODO 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("43.138.108.125"); // IP
        connectionFactory.setPort(5672); // PORT
        connectionFactory.setUsername("admin"); // 用户名
        connectionFactory.setPassword("admin"); // 密码
        connectionFactory.setVirtualHost("mq-sdk-test"); // 虚拟主机

        // TODO 创建连接
        Connection connection = connectionFactory.newConnection();

        // TODO 获取信道
        Channel channel = connection.createChannel();

        // TODO 声明队列
        channel.queueDeclare(Constants.SIMPLE_QUEUE, true, false, false, null);

        // TODO 声明交换机，使用内置交换机，无需声明

        // TODO 发送消息
        String msg = "hello simple";
        channel.basicPublish("", Constants.SIMPLE_QUEUE, null, msg.getBytes());
        System.out.println("简单模式生产者发送消息！");

        // TODO 关闭资源
        channel.close();
        connection.close();

    }

}

上述代码运行之后，在RabbitMQ的开源界面和IDEA终端上会有如下结果：

 

消费者代码

public class Consumer {

    public static void main(String[] args) throws IOException, TimeoutException {
        // TODO 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("43.138.108.125"); // IP
        connectionFactory.setPort(5672); // PORT
        connectionFactory.setUsername("admin"); // 用户名
        connectionFactory.setPassword("admin"); // 密码
        connectionFactory.setVirtualHost("mq-sdk-test"); // 虚拟主机

        // TODO 创建连接
        Connection connection = connectionFactory.newConnection();

        // TODO 获取信道
        Channel channel = connection.createChannel();

        // TODO 声明队列
        channel.queueDeclare(Constants.SIMPLE_QUEUE, true, false, false, null);

        // TODO 声明交换机，使用内置交换机，无需声明

        // TODO 接收消息
        DefaultConsumer consumer = 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.basicConsume(Constants.SIMPLE_QUEUE, true, consumer);

        // TODO 关闭资源
        channel.close();
        connection.close();

    }

}

 上述代码运行之后，队列中的消息被该消费者接收，控制台输出下述内容：

工作队列模式

由于在接下来的代码中，创建连接工厂，创建连接，开启信道，释放资源都要存在。因此为了简化开发，将这些步骤封装成方法，方便后续调用。

public class Common {

    private static Connection connection;
    private static Channel channel;

    // 获取信道
    public static Channel getChannel() throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("43.138.108.125"); // IP
        connectionFactory.setPort(5672); // PORT
        connectionFactory.setUsername("admin"); // 用户名
        connectionFactory.setPassword("admin"); // 密码
        connectionFactory.setVirtualHost("mq-sdk-test"); // 虚拟主机

        // TODO 创建连接
        connection = connectionFactory.newConnection();

        // TODO 获取信道
        channel = connection.createChannel();
        return channel;
    }

    // 释放资源
    public static void close() throws IOException, TimeoutException {
        channel.close();
        connection.close();
    }

}

生产者代码

public class Producer {

    public static void main(String[] args) throws IOException, TimeoutException {
        // TODO 获取信道
        Channel channel = Common.getChannel();

        // TODO 声明交换机，使用内置交换机，因此无需声明

        // TODO 声明队列
        channel.queueDeclare(Constants.WORK_QUEUE, true, false, false, null);

        // TODO 发送消息
        /**
         * 工作队列的模式是一个队列，多个消费者。
         * 当存在多个消息时，不同的消费者会接收不同的消息，消息并不会重复消费
         * 因此为了检验这个模式，发送多条消息
         */
        String msg = "hello work queue";
        for (int i = 0; i < 15; i++) {
            channel.basicPublish("", Constants.WORK_QUEUE, null, (msg + "：" + i).getBytes());
        }
        System.out.println("工作队列模式消息发送成功！");

        // TODO 释放资源
        Common.close();
    }

}

 消费者代码

public class Consumer1 {

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        // TODO 获取信道
        Channel channel = Common.getChannel();

        // TODO 声明交换机，使用内置交换机，因此无需声明

        // TODO 声明队列
        channel.queueDeclare(Constants.WORK_QUEUE, true, false, false, null);

        // TODO 接收消息
        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(Constants.WORK_QUEUE, true, consumer);

        // TODO 释放资源
//        Common.close();
    }

}
public class Consumer2 {

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        // TODO 获取信道
        Channel channel = Common.getChannel();

        // TODO 声明交换机，使用内置交换机，因此无需声明

        // TODO 声明队列
        channel.queueDeclare(Constants.WORK_QUEUE, true, false, false, null);

        // TODO 接收消息
        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(Constants.WORK_QUEUE, true, consumer);

        // TODO 释放资源
//        Common.close();
    }

}

 在上述代码中，不要释放资源。将生产者的代码重新启动一次之后，就会发现如下内容。从消费者消费消息的输出情况来看，很容易得到工作模式最主要的内容：消费者消费的消息都是不同的消息，消息并不会被重复消费。

发布订阅模式

生产者代码

public class Producer {

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = Common.getChannel();

        // TODO 声明交换机
        channel.exchangeDeclare(Constants.FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT, true);

        // TODO 声明队列
        channel.queueDeclare(Constants.FANOUT_QUEUE1, true, false, false, null);
        channel.queueDeclare(Constants.FANOUT_QUEUE2, true, false, false, null);

        // TODO 绑定交换机和队列
        channel.queueBind(Constants.FANOUT_QUEUE1, Constants.FANOUT_EXCHANGE, "");
        channel.queueBind(Constants.FANOUT_QUEUE2, Constants.FANOUT_EXCHANGE, "");

        // TODO 发送消息
        String msg = "hello 发布订阅模式";
        channel.basicPublish(Constants.FANOUT_EXCHANGE, "", null, msg.getBytes());
        System.out.println("发布订阅模式发送消息成功！");

        // TODO 释放资源
        Common.close();
    }

}

当上述代码启动之后，在开源界面中发生了如下变化。队列列表中新增了两个队列，交换机列表中新增了一条声明的交换机。

消费者代码

public class Consumer1 {

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = Common.getChannel();

        // TODO 声明交换机
        channel.exchangeDeclare(Constants.FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT, true);

        // TODO 声明队列
        channel.queueDeclare(Constants.FANOUT_QUEUE1, true, false, false, null);

        // TODO 绑定交换机和队列
        channel.queueBind(Constants.FANOUT_QUEUE1, Constants.FANOUT_EXCHANGE, "");

        // TODO 接收消息
        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(Constants.FANOUT_QUEUE1, true, consumer);

        // TODO 释放资源
        Common.close();
    }

}
public class Consumer2 {

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = Common.getChannel();

        // TODO 声明交换机
        channel.exchangeDeclare(Constants.FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT, true);

        // TODO 声明队列
        channel.queueDeclare(Constants.FANOUT_QUEUE2, true, false, false, null);

        // TODO 绑定交换机和队列
        channel.queueBind(Constants.FANOUT_QUEUE2, Constants.FANOUT_EXCHANGE, "");

        // TODO 接收消息
        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(Constants.FANOUT_QUEUE2, true, consumer);

        // TODO 释放资源
        Common.close();
    }

}

路由模式

路由模式实现的代码案例按照此图的需求来做。根据此图可以看出，当生产者发送消息时的路由键为error时，两个队列都能收到消息；但是当生产者发送消息时的路由键为info或者warn时，只有队列二可以收到消息。

生产者代码

public class Producer {

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = Common.getChannel();

        // TODO 声明交换机
        channel.exchangeDeclare(Constants.DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT, true);

        // TODO 声明队列
        channel.queueDeclare(Constants.DIRECT_QUEUE1, true, false, false, null);
        channel.queueDeclare(Constants.DIRECT_QUEUE2, true, false, false, null);

        // TODO 绑定交换机和队列
        channel.queueBind(Constants.DIRECT_QUEUE1, Constants.DIRECT_EXCHANGE, "error");
        channel.queueBind(Constants.DIRECT_QUEUE2, Constants.DIRECT_EXCHANGE, "info");
        channel.queueBind(Constants.DIRECT_QUEUE2, Constants.DIRECT_EXCHANGE, "warn");
        channel.queueBind(Constants.DIRECT_QUEUE2, Constants.DIRECT_EXCHANGE, "error");

        // TODO 发送消息
        // error的消息进入两个队列
        // info和warn只会进入队列2
        String[] msg = {"info", "error", "warn"};
        for (String s : msg) {
            channel.basicPublish(Constants.DIRECT_EXCHANGE, s, null, s.getBytes());
        }
        System.out.println("路由模式发送消息成功！");

        // TODO 释放资源
        Common.close();

    }

}

 当运行上述代码之后，发现队列中的结果和预想结果一致。

消费者代码

public class Consumer1 {

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Channel channel = Common.getChannel();

        // TODO 声明交换机
        channel.exchangeDeclare(Constants.DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT, true);

        // TODO 声明队列
        channel.queueDeclare(Constants.DIRECT_QUEUE1, true, false, false, null);

        // TODO 绑定交换机和队列
        channel.queueBind(Constants.DIRECT_QUEUE1, Constants.DIRECT_EXCHANGE, "error");

        // TODO 接收消息
        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(Constants.DIRECT_QUEUE1, true, consumer);
        Thread.sleep(20000); // 阻塞等待消息接收完成

        // TODO 释放资源
        Common.close();
    }

}
public class Consumer2 {

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Channel channel = Common.getChannel();

        // TODO 声明交换机
        channel.exchangeDeclare(Constants.DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT, true);

        // TODO 声明队列
        channel.queueDeclare(Constants.DIRECT_QUEUE2, true, false, false, null);

        // TODO 绑定交换机和队列
        channel.queueBind(Constants.DIRECT_QUEUE2, Constants. DIRECT_EXCHANGE, "error");
        channel.queueBind(Constants.DIRECT_QUEUE2, Constants. DIRECT_EXCHANGE, "info");
        channel.queueBind(Constants.DIRECT_QUEUE2, Constants. DIRECT_EXCHANGE, "warn");

        // TODO 接收消息
        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(Constants.DIRECT_QUEUE2, true, consumer);
        Thread.sleep(20000); // 阻塞等待消息接收完成

        // TODO 释放资源
        Common.close();
    }

}

 上述代码启动之后，在控制台输出消息如下：

 

在该文章中，介绍了MQ的七大工作模式，并且对其中的前四种工作模式的SDK写法进行了代码示例，在下一篇文章中，将对剩下的三种SDK代码以及SpringBoot代码进行示例操作。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2127420.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

计算机毕业设计Django+Vue.js考研分数线预测 考研院校推荐系统 考研推荐系统 考研爬虫 考研大数据 Hadoop 大数据毕设 机器学习 深度学习

计算机毕业设计Django+Vue.js考研分数线预测 考研院校推荐系统 考研推荐系统 考研爬虫 考研大数据 Hadoop 大数据毕设 机器学习 深度学习

考研推荐系统— 项目概述 考研&#xff08;研究生入学考试&#xff09;是许多大学毕业生追求深造的一种途径。为了帮助考生更好地选择适合自己的研究生专业和院校&#xff0c;开发一个考研推荐系统可以为考生提供个性化的建议。该项目旨在通过数据分析和可视化技术&#xff0…
阅读更多...
[晕事]今天做了件晕事44 wireshark 首选项IPv4：Reassemble Fragented IPv4 datagrams

[晕事]今天做了件晕事44 wireshark 首选项IPv4：Reassemble Fragented IPv4 datagrams

不知不觉&#xff0c;已经来到了晕事系列的第四十四个晕事。今天办的晕事和Wireshark查看网络包相关。说&#xff0c;在Wireshark的编辑-首选项协议里的IPv4协议&#xff0c;有一个参数设置是&#xff1a;Reassemble Fragented IPv4 datagrams。 这个参数的含义是指定Wireshar…
阅读更多...
第 7 篇 Helm 部署 Nacos【详细步骤】

第 7 篇 Helm 部署 Nacos【详细步骤】

文章目录 安装 Chart准备工作单机 MySQL 模式第 1 步&#xff1a;自定义配置第 2 步&#xff1a;安装 chart第 3 步&#xff1a;查看状态查看 Pod 运行状态查看 Pod 信息 第 4 步&#xff1a;访问 Nacos集群外访问集群内访问 集群 MySQL 模式第 1 步&#xff1a;自定义配置文…
阅读更多...
Java 入门指南：Java 并发编程 —— 同步工具类 Phaser（相位器）

Java 入门指南：Java 并发编程 —— 同步工具类 Phaser（相位器）

文章目录 同步工具类Phaser主要特点核心方法使用步骤适用场景使用示例 同步工具类 JUC&#xff08;Java.util.concurrent&#xff09;是 Java 提供的用于并发编程的工具类库&#xff0c;其中包含了一些通信工具类&#xff0c;用于在多个线程之间进行协调和通信&#xff0c;特别…
阅读更多...
Ton链历险记（一）

Ton链历险记（一）

系列文章目录 文章目录 系列文章目录前言第一天、FunC环境安装总结 前言 欢迎来到神秘的web3小镇&#xff0c;这里是充满未知和魔法的土地&#xff0c;神兽出没&#xff0c;超能力攻击&#xff0c;卡牌收集。。。 穷困却又励志的无天赋法师木森。因为没有交够保护费&#xff…
阅读更多...
Spring和Spring FrameWork有什么关系?两者是同一个东西吗?

Spring和Spring FrameWork有什么关系?两者是同一个东西吗?

Spring和Spring Framework之间的关系可以归结为以下几点&#xff1a; 广义与狭义的理解 广义上的Spring&#xff1a; 广义上的Spring泛指以Spring Framework为基础的整个Spring技术栈。Spring已经发展成为一个由多个不同子项目&#xff08;模块&#xff09;组成的成熟技术体系…
阅读更多...
R语言统计分析——功效分析2（t检验，ANOVA）

R语言统计分析——功效分析2（t检验，ANOVA）

参考资料&#xff1a;R语言实战【第2版】 1、t检验 对于t检验&#xff0c;pwr.t.test()函数提供了许多有用的功效分析选项&#xff0c;如下&#xff1a; pwr.t.test(n,d,sig.level,power,type,alternative) 其中&#xff0c;n为样本大小&#xff1b; d为效应值&#xff0c;即…
阅读更多...
【每日一题】LeetCode 98.验证二叉搜索树（树、深度优先搜索、二叉搜索树、二叉树）

【每日一题】LeetCode 98.验证二叉搜索树（树、深度优先搜索、二叉搜索树、二叉树）

【每日一题】LeetCode 98.验证二叉搜索树&#xff08;树、深度优先搜索、二叉搜索树、二叉树&#xff09; 题目描述 给定一个二叉树的根节点 root&#xff0c;判断该二叉树是否是一个有效的二叉搜索树&#xff08;BST&#xff09;。有效的二叉搜索树需要满足以下条件&#xf…
阅读更多...
R语言xlsx，txt文件处理：以《书摘》00年-10年资源合集整理为例

R语言xlsx，txt文件处理：以《书摘》00年-10年资源合集整理为例

偶然间读到一篇文章&#xff0c;分享06年《书摘》的内容&#xff0c;今天来看都不过时&#xff0c;所以起了找下这本老杂志合集的心思。 傅佩荣先生《哲学与人生》选段 “如果有人觉得活着很辛苦&#xff0c;面对自己又感觉无聊乏味&#xff0c;那么他应该多接触自然界。我有个…
阅读更多...
9.11.

9.11.

Widget::Widget(QWidget *parent): QWidget(parent), ui(new Ui::Widget), speecher(new QTextToSpeech(this)) {//设置时钟ui->setupUi(this);startTimer(1000);//文本框label居中对齐ui->label_2->setAlignment(Qt::AlignCenter);connect(this,&Widget::my_sign…
阅读更多...
QT：音视频播放器

QT：音视频播放器

目录 一.播放器设计 二.需要使用的控件 三.选择视频 四.播放视频 五.暂停视频 六.关闭视频 七.播放状态设置 八.切换视频(上一首) 九.切换视频(下一首) 十.设置视频滑块 十一.更新滑块显示 十二.实现效果 十三.代码设计 1.mainwindow.h 2.mainwindow.cpp 一.播放…
阅读更多...
国产视频转换HDMI1.4转单/双MIPI DSI/CSI LT6911C芯片方案，带音频输出，QFN64封装 Lontium

国产视频转换HDMI1.4转单/双MIPI DSI/CSI LT6911C芯片方案，带音频输出，QFN64封装 Lontium

LT6911C:HDMI 1.4 TO MIPI DSI/CSI 芯片简介&#xff1a; LT6911C是一款高性能的HDMI1.4转换器MIPI DSI/CSI芯片用于VR/智能手机/显示应用。对于MIPI DSI/CSI输出&#xff0c;LT6911C功能可配置单端口或双端口MIPIDSI/CSI 1高速时钟通道和1~4个高速数据通道最大1.5Gb/s/lane&am…
阅读更多...
SSHamble：一款针对SSH技术安全的研究与分析工具

SSHamble：一款针对SSH技术安全的研究与分析工具

关于SSHamble SSHamble是一款功能强大的SSH技术安全分析与研究工具&#xff0c;该工具基于Go语言开发&#xff0c;可以帮助广大研究人员更好地分析SSH相关的安全技术与缺陷问题。 功能介绍 SSHamble 是用于 SSH 实现的研究工具&#xff0c;其中包含下列功能&#xff1a; 1、针…
阅读更多...
【算法思想·二叉搜索树】特性篇

【算法思想·二叉搜索树】特性篇

本文参考labuladong算法笔记[二叉搜索树心法&#xff08;特性篇&#xff09; | labuladong 的算法笔记] 1、概述 首先&#xff0c;BST&#xff08;binary search tree&#xff09; 的特性大家应该都很熟悉了&#xff08;详见基础知识章节的 二叉树基础&#xff09;&#xff1a…
阅读更多...
【QGC】把QGroundControl地面站添加到Ubuntu侧边菜单栏启动

【QGC】把QGroundControl地面站添加到Ubuntu侧边菜单栏启动

把QGroundControl地面站添加到Ubuntu侧边菜单栏启动 简介准备工作步骤 1: 创建 Desktop Entry 文件步骤 2: 编辑 Desktop Entry 文件步骤 3: 刷新应用程序菜单步骤 4: 将 QGroundControl 固定到侧边栏 环境&#xff1a; Ubuntu &#xff1a;20.04 LTS 简介 QGroundControl 是…
阅读更多...
[综述笔记]Federated learning for medical image analysis: A survey

[综述笔记]Federated learning for medical image analysis: A survey

论文网址&#xff1a;Federated learning for medical image analysis: A survey - ScienceDirect 英文是纯手打的&#xff01;论文原文的summarizing and paraphrasing。可能会出现难以避免的拼写错误和语法错误&#xff0c;若有发现欢迎评论指正&#xff01;文章偏向于笔记&…
阅读更多...
C++ Primer Plus(速记版)-基本语言

C++ Primer Plus(速记版)-基本语言

序章 快速入门 初窥输入/输出 C 并没有直接定义进行输入或输出(I/O)的任何语句&#xff0c;这种功能是由标准库提供的。 本书的大多数例子都使用了处理格式化输入和输出的 iostream 库。 iostream 库的基础是两种命名为 istream 和 ostream 的类型&#xff0c;分别表示输入流和…
阅读更多...
卷积神经网络-经典分类网络结构(LetNet-5,AlexNet)

卷积神经网络-经典分类网络结构(LetNet-5,AlexNet)

目录 一&#xff1a;LeNet-5解析 1.网络结构 输入层&#xff1a; 1.conv1&#xff1a; 2.pool1层&#xff1a; 3.conv2&#xff1a; 4.pool2&#xff1a; 5.fc3&#xff0c;fc4&#xff1a; 6.output层: 2.参数形状 二&#xff1a;AlexNet 1层&#xff1a; 2层&am…
阅读更多...
招生管理|基于Java+vue的招生管理系统(源码+数据库+文档)

招生管理|基于Java+vue的招生管理系统(源码+数据库+文档)

招生管理|学生管理系统|高校招生管理 目录 基于Javavue的招生管理系统 一、前言 二、系统设计 三、系统功能设计 系统功能模块 四、数据库设计 五、核心代码 六、论文参考 七、最新计算机毕设选题推荐 八、源码获取&#xff1a; 博主介绍&#xff1a;✌️大厂码农|…
阅读更多...
什么是OAuth 2.0？OAuth 2.0的工作流程是什么？与OAuth 1.0有哪些区别？

什么是OAuth 2.0？OAuth 2.0的工作流程是什么？与OAuth 1.0有哪些区别？

在浏览网页时&#xff0c;你肯定会遇到允许你使用社交媒体账户登录的网站。此功能一般是使用流行的OAuth 2.0框架构建的。OAuth 2.0是对OAuth 1.0的彻底重写&#xff0c;OAuth 2.0与OAuth 1.0或1.1不向后兼容。 1. OAuth产生背景 为了更好的理解OAuth&#xff0c;我们假设有如…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023