RabbitMQ基础入门

news2024/11/23 23:23:27

初识MQ

微服务间通讯有同步和异步两种方式：

  • 同步通讯：就像打电话，需要实时响应。

  • 异步通讯：就像发邮件，不需要马上回复。

两种方式各有优劣，打电话可以立即得到响应，但是你却不能跟多个人同时通话。发送邮件可以同时与多个人收发邮件，但是往往响应会有延迟。

同步通讯

微服务间基于Feign的调用就属于同步方式，它的优点是时效性较强，可以立即得到结果；同时也存在一些问题：

  1. 耦合度高

    每次加入新的需求，都要修改原来的代码。

  2. 性能下降

    调用者需要等待服务提供者响应，如果调用链过长则响应时间等于每次调用的时间之和。

  3. 资源浪费

    调用链中的每个服务在等待响应过程中，不能释放请求占用的资源，高并发场景下会极度浪费系统资源。

  4. 级联失败

    如果服务提供者出现问题，所有调用方都会跟着出问题，如同多米诺骨牌一样，迅速导致整个微服务群故障。

image-20240112094204261

异步通讯

异步调用则可以避免上述问题：

我们以购买商品为例，用户支付后需要调用订单服务完成订单状态修改，调用物流服务，从仓库分配响应的库存并准备发货。

在事件模式中，支付服务是事件发布者（publisher），在支付完成后只需要发布一个支付成功的事件（event），事件中带上订单id。

订单服务和物流服务是事件订阅者（Consumer），订阅支付成功的事件，监听到事件后完成自己业务即可。

为了解除事件发布者与订阅者之间的耦合，两者并不是直接通信，而是有一个中间人（Broker）。发布者发布事件到Broker，不关心谁来订阅事件。订阅者从Broker订阅事件，不关心谁发来的消息。

image-20240112095857597

Broker 是一个像数据总线一样的东西，所有的服务要接收数据和发送数据都发到这个总线上，这个总线就像协议一样，让服务间的通讯变得标准和可控。

优点：

  • 吞吐量提升：无需等待订阅者处理完成，响应更快速；
  • 故障隔离：服务没有直接调用，不存在级联失败问题；
  • 调用间没有阻塞，不会造成无效的资源占用；
  • 耦合度极低：每个服务都可以灵活插拔，可替换；
  • 流量削峰：不管发布事件的流量波动多大，都由Broker接收，订阅者可以按照自己的速度去处理事件。

缺点：

  • 架构复杂了，业务没有明显的流程线，不好管理
  • 需要依赖于Broker的可靠、安全、性能

现在开源软件或云平台上 Broker 的软件是非常成熟的，比较常见的一种就是MQ技术。

MQ常见框架

MQ，中文是消息队列（MessageQueue），字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。

比较常见的MQ实现：

  • ActiveMQ
  • RabbitMQ
  • RocketMQ
  • Kafka

几种常见MQ的对比：

RabbitMQActiveMQRocketMQKafka
公司/社区RabbitApache阿里Apache
开发语言ErlangJavaJavaScala&Java
协议支持AMQP，XMPP，SMTP，STOMPOpenWire,STOMP，REST,XMPP,AMQP自定义协议自定义协议
可用性高一般高高
单机吞吐量一般差高非常高
消息延迟微秒级毫秒级毫秒级毫秒以内
消息可靠性高一般高一般

追求可用性：Kafka、 RocketMQ 、RabbitMQ

追求可靠性：RabbitMQ、RocketMQ

追求**吞吐能力：**RocketMQ、Kafka

追求消息低延迟：RabbitMQ、Kafka

RabbitMQ快速入门

安装RabbitMQ

拉取镜像

docker pull rabbitmq

创建容器

docker run \
--name mq \
#配置主机名
--hostname mq1 \
#管理平台的端口
-p 15672:15672 \
#消息通信端口
-p 5672:5672 \
-e RABBITMQ_DEFAULT_USER=admin \
-e RABBITMQ_DEFAULT_PASS=123456 \
-d \
rabbitmq

image-20240112103537261

如果运行容器后还是打不开https://172.21.240.43:15672（这里的172.21.240.43是我的虚拟机的ip）出现HTTP ERROR 502错误，进行一下操作：

  1. docker ps查看容器的id
  2. docker exec -it [id] /bin/bash 进到rabbitmq容器内部
  3. 然后执行rabbitmq-plugins enable rabbitmq_management

image-20240112152833229

此时再访问就可以了。

MQ的基本结构

image-20240112105019448

RabbitMQ中的角色
  • publisher：生产者
  • consumer：消费者
  • exchange个：交换机，负责消息路由
  • queue：队列，存储消息
  • virtualHost：虚拟主机，隔离不同租户的exchange、queue、消息的隔离
RabbitMQ消息模型

RabbitMQ官方提供了5个不同的Demo示例，对应了不同的消息模型：

  • 基本消息队列(BasicQueue)

    官方的HelloWorld是基于最基础的消息队列模型来实现的，只包括三个角色：

    • publisher：消息发布者，将消息发送到队列queue
    • queue：消息队列，负责接受并缓存消息
    • consumer：订阅队列，处理队列中的消息

    image-20240112105516705

  • 工作消息队列(WorkQueue)

    image-20240112105524279

  • 发布订阅(Publish、Subscribe)，又根据交换机类型不同分为三种：

    • Fanout Exchange 广播

      image-20240112105543944

    • Direct Exchange 路由

      image-20240112105553273

    • Topic Exchange 主题

      image-20240112105603172

入门案例
publisher实现思路
  • 建立连接
  • 创建Channel
  • 声明队列
  • 发送消息
  • 关闭连接和channel

代码实现：

package cn.itcast.mq.helloworld;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.Test;

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

public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("172.21.240.43");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("admin");
        factory.setPassword("123456");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

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

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }
}
consumer实现思路
  • 建立连接
  • 创建Channel
  • 声明队列
  • 订阅消息

代码实现：

package cn.itcast.mq.helloworld;

import com.rabbitmq.client.*;

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

public class ConsumerTest {

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("172.21.240.43");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("admin");
        factory.setPassword("123456");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

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

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
}

image-20240112235724541

image-20240112235745580

总结

基本消息队列的消息发送流程：

  1. 建立connection
  2. 创建channel
  3. 利用channel声明队列
  4. 利用channel向队列发送消息

基本消息队列的消息接收流程：

  1. 建立connection
  2. 创建channel
  3. 利用channel声明队列
  4. 定义consumer的消费行为handleDelivery()
  5. 利用channel将消费者与队列绑定

SpringAMQP

SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。SpringAmqp的官方地址：https://spring.io/projects/spring-amqp

AMQP，即Advanced Message Queuing Protocol，是用于在应用程序之间传递业务消息的一种协议。与语言和平台无关，更符合微服务中独立性的要求。

Spring AMQP是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息。包含两部分，其中spring-amqp是基础抽象，spring-rabbit是底层的默认实现。

SpringAMQP提供了三个功能：

  • 自动声明队列、交换机及其绑定关系
  • 基于注解的监听器模式，异步接收消息
  • 封装了RabbitTemplate工具，用于发送消息
SpringAMQP如何发送消息？
  1. 引入amqp的starter依赖
  2. 配置RabbitMQ地址
  3. 利用RabbitTemplate的convertAndSend方法
SpringAMQP如何接收消息？
  1. 引入amqp的starter依赖
  2. 配置RabbitMQ地址
  3. 定义RabbitListener类，并添加@Component注解
  4. 类方法添加@RabbitListener注解，方法的参数就是消息

注意：消息一旦消费就会从队列删除，RabbitMQ没有消息回溯功能

Basic Queue简单队列模型

在pom.xml中引入依赖

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
消息发送

首先配置MQ地址，在publisher服务的application.yml中添加配置：

spring:
  rabbitmq:
    host: 172.21.240.43 # rabbitMQ的ip地址
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: admin # 用户名
    password: 123456 # 密码

然后在publisher服务中编写测试类SpringAmqpTest，并利用RabbitTemplate实现消息发送：

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, spring amqp!";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}
消息接收

首先配置MQ地址，在consumer服务的application.yml中添加配置：

spring:
  rabbitmq:
    host: 172.21.240.43 # rabbitMQ的ip地址
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: admin # 用户名
    password: 123456 # 密码

然后在consumer服务中通过类SpringRabbitListener实现消息接收

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
}

启动consumer服务，然后在publisher服务中运行测试代码，发送MQ消息

Work Queue工作队列模型

Work queues，也被称为（Task queues），任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息。image-20240113100846671

当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。

此时就可以使用 work 模型，多个消费者共同处理消息处理，速度就能大大提高了。

消息发送

这次我们循环发送，模拟大量消息堆积现象。

在publisher服务中的SpringAmqpTest类中添加一个测试方法：

/**
 * workQueue
 * 向队列中不停发送消息，模拟消息堆积。
 */
@Test
public void testWorkQueue() throws InterruptedException {
    // 队列名称
    String queueName = "simple.queue";
    // 消息
    String message = "hello, message_";
    for (int i = 0; i < 50; i++) {
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message + i);
        Thread.sleep(20);
    }
}
消息接收

要模拟多个消费者绑定同一个队列，我们在consumer服务的SpringRabbitListener中添加2个新的方法：

@RabbitListener(queues = "simple.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
    System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(20);
}

@RabbitListener(queues = "simple.queue")
public void listenWorkQueue2(String msg) throws InterruptedException {
    System.err.println("消费者2........接收到消息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(200);
}

注意到这个消费者sleep了，模拟任务耗时。

启动ConsumerApplication后，在执行publisher服务中刚刚编写的发送测试方法testWorkQueue。

image-20240113102327712

可以看到消费者1很快完成了自己的25条消息。消费者2却在缓慢的处理自己的25条消息。

也就是说消息是平均分配给每个消费者，并没有考虑到消费者的处理能力。

这是默认的消费预取机制导致的，可以通过修改application.yml文件，设置preFetch这个值，控制预取消息的上限：

spring:
  rabbitmq:
    host: 172.21.240.43 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: admin
    password: 123456
    virtual-host: /
    listener:
      simple:
        prefetch: 1 #每次只能取一条数据，处理完了再去取下一条

修改之后可以看到两个消费者处于能者多劳的状态在处理消息

image-20240113102738090

总结

Work模型的使用：

  • 多个消费者绑定到一个队列，同一条消息只会被一个消费者处理
  • 通过设置prefetch来控制消费者预取的消息数量
发布Publish/订阅Subscribe

发布订阅模式与之前案例的区别就是允许将同一消息发送给多个消费者。实现方式是加入了exchange（交换机）。

发布订阅的模型如图：

image-20240113103021783

可以看到，在订阅模型中，多了一个exchange角色，而且过程略有变化：

  • Publisher：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给exchange
  • Exchange：交换机。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有以下3种类型：
    • Fanout：将消息交给所有绑定到交换机的队列
    • Direct：把消息交给符合routing key 的队列
    • Topic：把消息交给符合routing pattern（路由模式） 的队列
  • Consumer：消费者，与以前一样，订阅队列，没有变化
  • Queue：消息队列也与以前一样，接收消息、缓存消息。

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

Fanout Exchange

Fanout Exchange会将接收到的消息广播到每一个跟其绑定的queue。

image-20240113103708405

在Fanout 模式下，消息发送流程是这样的：

  • 可以有多个队列
  • 每个队列都要绑定到Exchange
  • 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
  • 交换机把消息发送给绑定过的所有队列
  • 订阅队列的消费者都能拿到消息

SpringAMQP提供了声明交换机、队列、 绑定关系的API：

image-20240113103846749

在consumer中创建一个类，声明队列和交换机：

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutConfig {
    /**
     * 声明交换机
     * @return Fanout类型交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("my.fanout");
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

    /**
     * 第2个队列
     */
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}
消息发送

在publisher服务的SpringAmqpTest类中添加测试方法：

@Test
public void testFanoutExchange() {
    // 队列名称
    String exchangeName = "my.fanout";
    // 消息
    String message = "hello, everyone!";
    rabbitTemplate.convertAndSend(exchangeName, "", message);
}
消息接收

在consumer服务的SpringRabbitListener中添加两个方法，作为消费者：

@RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) {
    System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
}

@RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) {
    System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
}

image-20240113111604531

总结

交换机的作用是什么？

  • 接收publisher发送的消息
  • 将消息按照规则路由到与之绑定的队列
  • 不能缓存消息，路由失败，消息丢失
  • FanoutExchange的会将消息路由到每个绑定的队列

声明队列、交换机、绑定关系的Bean是什么？

  • Queue
  • FanoutExchange
  • Binding
Direct Exchange

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

在Direct模型下：

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

image-20240113112029319

基于注解声明队列和交换机

基于@Bean的方式声明队列和交换机比较麻烦，Spring还提供了基于注解方式来声明。

在consumer的SpringRabbitListener中添加两个消费者，同时基于注解来声明队列和交换机：

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue1"),
    exchange = @Exchange(name = "my.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
    System.out.println("消费者接收到direct.queue1的消息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue2"),
    exchange = @Exchange(name = "my.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){
    System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
}
消息发送

在publisher服务的SpringAmqpTest类中添加测试方法：

@Test
public void testSendDirectExchange() {
    // 交换机名称
    String exchangeName = "my.direct";
    // 消息
    String message = "红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "red", message);
}
总结

描述下Direct交换机与Fanout交换机的差异？

  • Fanout交换机将消息路由给每一个与之绑定的队列
  • Direct交换机根据RoutingKey判断路由给哪个队列
  • 如果多个队列具有相同的RoutingKey，则与Fanout功能类似

基于@RabbitListener注解声明队列和交换机有哪些常见注解？

  • @Queue
  • @Exchange
Topic Exchange

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好1个词

举例：

item.#`：能够匹配`item.spu.insert` 或者 `item.spu
item.*`：只能匹配`item.spu

image-20240113121219618

解释：

  • Queue1：绑定的是china.# ，因此凡是以 china.开头的routing key 都会被匹配到。包括china.news和china.weather
  • Queue4：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配。包括china.news和japan.news
消息发送

在publisher服务的SpringAmqpTest类中添加测试方法：

@Test
public void testSendTopicExchange() {
    // 交换机名称
    String exchangeName = "my.topic";
    // 消息
    String message = "今天天气不错!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "china.weather", message);
}
消息接收

在consumer服务的SpringRabbitListener中添加方法：

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue1"),
    exchange = @Exchange(name = "my.topic", type = ExchangeTypes.TOPIC),
    key = "china.#"
))
public void listenTopicQueue1(String msg){
    System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue2"),
    exchange = @Exchange(name = "my.topic", type = ExchangeTypes.TOPIC),
    key = "#.news"
))
public void listenTopicQueue2(String msg){
    System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
}

可以看到这个exchange的队列绑定关系如下：

image-20240113121923815

总结

描述下Direct交换机与Topic交换机的差异？

  • Topic交换机接收的消息RoutingKey必须是多个单词，以 . 分割
  • Topic交换机与队列绑定时的bindingKey可以指定通配符
  • #：代表0个或多个词
  • *：代表1个词

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

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

相关文章

Python自动化下载指定公开页面文件

Python自动化下载指定公开页面文件

示例代码如下&#xff0c;但你拿到本地之需要做两件事才能运行 from selenium import webdriver from selenium.webdriver.chrome.service import Service from selenium.webdriver.common.by import By from selenium.webdriver.common.keys import Keys import time# 设置Se…
阅读更多...
【电路笔记】-Twin-T振荡器

【电路笔记】-Twin-T振荡器

Twin-T振荡器 文章目录 Twin-T振荡器1、概述2、Twin-T振荡器3、Twin-T放大4、Twin-T 振荡器示例5、总结Twin-T 振荡器是另一种 RC 振荡器电路，它使用两个并联的 RC 网络来产生单一频率的正弦输出波形。 1、概述 Twin-T 振荡器是另一种类型的 RC 振荡器，它产生正弦波输出，用…
阅读更多...
已经安装tensorflow，仍报错No module named ‘tensorflow‘

已经安装tensorflow，仍报错No module named ‘tensorflow‘

在安装某些python虚拟环境的教程文章中&#xff0c;经常看到有评论区说安装了但是调用显示无模块&#xff0c;例如pytorch和tensorflow等等。 其实跟之前我写过的一篇文章解决方法类似&#xff0c;就是python项目中需要应用哪个虚拟环境&#xff0c;这个项目的python解释器就选…
阅读更多...
LCD驱动IC-抗干扰液晶段码显示屏驱动芯片,液晶显示驱动原厂-VK2C23A/B LQFP64/48

LCD驱动IC-抗干扰液晶段码显示屏驱动芯片,液晶显示驱动原厂-VK2C23A/B LQFP64/48

产品品牌&#xff1a;永嘉微电/VINKA 产品型号&#xff1a;VK2C23A/B 封装形式&#xff1a;LQFP64/48 概述 VK2C23是一个点阵式存储映射的LCD驱动器&#xff0c;可支持最大224点&#xff08;56SEGx4COM&#xff09; 或者最大416点&#xff08;52SEGx8COM&#xff09;的LCD屏。…
阅读更多...
API开发的必备神器：华为云CodeArts API实用体验入门篇

API开发的必备神器：华为云CodeArts API实用体验入门篇

今天我想给大家推荐一款API全生命周期研发与管理工具&#xff1a;华为云CodeArts API。 作为互联网软件的开发者&#xff0c;在软件研发的过程中&#xff0c;API的开发、调试、测试是必不可少的。之前我使用的是Postman这类工具来辅助开发&#xff0c; Postman在接口调试方面确…
阅读更多...
第 8 章 电机调速(自学二刷笔记)

第 8 章 电机调速(自学二刷笔记)

重要参考&#xff1a; 课程链接:https://www.bilibili.com/video/BV1Ci4y1L7ZZ 讲义链接:Introduction Autolabor-ROS机器人入门课程《ROS理论与实践》零基础教程 8.3.5 电机调速01_PID控制理论 场景&#xff1a; 速度信息可以以m/s为单位&#xff0c;或者也可以转换成转速 …
阅读更多...
第18讲：Ceph集群CrushMap的核心概念、默认规则与完整定义

第18讲：Ceph集群CrushMap的核心概念、默认规则与完整定义

文章目录 1.CrushMap核心概念2.集群默认的CrushMap规则剖析2.1.CrushMap列表显示内容剖析2.2.对默认的CrushMap规则进行深度的剖析2.3.完整的CrushMap定义信息 1.CrushMap核心概念 CrushMap官方文档&#xff1a;https://docs.ceph.com/en/pacific/rados/operations/crush-map/…
阅读更多...
【Alluxio】文件系统锁模型之InodeLockList

【Alluxio】文件系统锁模型之InodeLockList

InodeLockList接口，表示在inode tree里一个加了锁的路径。 沿着path，inodes和edges都被加锁了。path可能从edge或inode任意一个开始。 锁列表总是包含了一定数量的读锁（0个或多个），随后跟随着一些数量的写锁（0个或多个）。 举个例子： 对 /a/b/c/d 进行加锁，c->d这…
阅读更多...
QGraphicsItem的prepareGeometryChange 和 update方法区别

QGraphicsItem的prepareGeometryChange 和 update方法区别

prepareGeometryChange 这个函数用于为图形的几何形状变化做准备。在改变一个项目的边界矩形之前调用此函数&#xff0c;以保持 QGraphicsScene 的索引是最新的。如果必要的话&#xff0c;prepareGeometryChange() 会调用 update()。QGraphicsScene认为所有图元的boundingRect…
阅读更多...
ReactFlow的ReactFlow实例事件传参undefined处理状态切换

ReactFlow的ReactFlow实例事件传参undefined处理状态切换

1.问题 ReactFlow的ReactFlow实例有些事件我们在不同的状态下并不需要&#xff0c;而且有时候传参会出现其它渲染效果&#xff0c;比如只读状态下我们不想要拖拉拽onEdgesChange连线重连或删除的功能。 2.思路 事件名称类型默认值onEdgesChange(changes: EdgeChange[]) >…
阅读更多...
.NET邮箱API发送邮件的步骤？怎么配置API？

.NET邮箱API发送邮件的步骤？怎么配置API？

.NET邮箱API发送邮件需要注意哪些&#xff1f;如何使用API发信&#xff1f; 在.NET环境中&#xff0c;使用邮箱API发送邮件是一个常见的需求。无论是企业级的邮件通知&#xff0c;还是个人项目中的邮件验证&#xff0c;都少不了.NET邮箱API的帮助。下面&#xff0c;AokSend将详…
阅读更多...
MT3033 新的表达式

MT3033 新的表达式

代码&#xff1a; #include <bits/stdc.h> using namespace std; bool is_op(char c) {return c & || c |; } int priority(char op) { // 运算优先级。如果有-*/等别的运算符&#xff0c;则这个函数很有必要if (op & || op |){return 1;}return -1; } voi…
阅读更多...
内网渗透（二）

内网渗透（二）

预备知识 什么是域&#xff1f; 域是若干台计算机组成的集合&#xff0c;一个电脑也是。域中的电脑是分等级的&#xff0c;分为域控和成员机。 如何安装域&#xff1f; 在服务器管理中添加服务器角色&#xff0c;添加域服务 如何加入域? 首先一定要修改DNS服务器 ip为域…
阅读更多...
Davinci工程CAN模块讲解

Davinci工程CAN模块讲解

CAN模块是用来配置CAN Driver的&#xff0c;里面有CanConfigSet是用来配置驱动内容的&#xff0c;CanGeneral配置参数。涉及四个文件Can_Lcfg.c/Can_Lcfg.h/Can_Cfg.c/Can_Cfg.h CanConfigSet CanControllers CAN控制器&#xff0c;我们这里的CAN控制器只有一个&#xff0c;名…
阅读更多...
Gradle报错Cause: zip END header not found，构建问题解决

Gradle报错Cause: zip END header not found，构建问题解决

问题描述 构建报错&#xff1a;Cause: zip END header not found 解决办法 File>>setting>>Build,Execution,Deployment>>Gradle 选择你本地的Gradke路径 问题解决
阅读更多...
探索Java的未来

探索Java的未来

探索 Java 的未来是一个非常有趣的话题。Java 是一种广泛使用的编程语言&#xff0c;自 1995 年诞生以来&#xff0c;它已经在软件开发领域占据了重要的地位。尽管有些人担心 Java 可能会因为新技术的出现而变得不再相关&#xff0c;但实际情况并非如此。让我们来看看一些关于 …
阅读更多...
MySQL 依据扫码记录统计人员进出区域的时间

MySQL 依据扫码记录统计人员进出区域的时间

解决这样一个问题&#xff1a; 如下图人员在区域的扫码记录&#xff0c;进出区域的时候都必须扫码&#xff0c;中间扫码的不算&#xff0c;统计每个人员进入区域、出区域的时间。 有了人员在区域停留的组号&#xff0c;还差一步group by&#xff08;在最后&#xff09;&#xf…
阅读更多...
淘宝订单详情与物流电子面单API接口：提升电商物流效率的利器

淘宝订单详情与物流电子面单API接口：提升电商物流效率的利器

前言 在电子商务蓬勃发展的今天&#xff0c;物流作为电商交易的重要环节&#xff0c;其效率和准确性直接关系到消费者的购物体验和商家的运营效率。淘宝作为中国最大的电商平台之一&#xff0c;一直致力于提升物流效率和服务质量。其中&#xff0c;淘宝订单详情与物流电子面单A…
阅读更多...
Flutter-Statewidget 创建State过程State＜XXXX＞ createState() =＞ _XXXXState()的解释

Flutter-Statewidget 创建State过程State＜XXXX＞ createState() =＞ _XXXXState()的解释

文章目录 创建widget 的状态对象示例代码解析 完整的代码示例总结 创建widget 的状态对象 今天有个同学问了我下State createState() > _XXXXState()时什么意思。这个代码在flutter开发中一直看到&#xff0c;很多人都不关心这个&#xff0c;直接当模板使用。今天来介绍下这…
阅读更多...
运维自动化工具：Ansible 概念与模块详解

运维自动化工具：Ansible 概念与模块详解

目录 前言 一、运维自动化工具有哪些 二、Ansible 概述 1、Ansible 概念 2、Ansible 特点 3、Ansible 工作流程 4、Ansible 架构 4.1 Ansible 组成 4.2 Ansible 命令执行来源 5、Ansible 的优缺点 三、Ansible 安装部署 1、环境部署 2、管理节点安装 Ansible 3、…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023