RabbitMq 基础

文章目录

  • 一、初识 MQ
    • 1.1 同步调用：
    • 1.2 异步调用：
  • 二、RabbitMQ
  • 三、SpringAMQP
    • 3.1 依赖和配置文件
    • 3.2 消息发送和接收：
      • 3.2.1 消息发送：
      • 3.2.2 消息接收：
    • 3.3 WorkQueues 模型：
    • 3.4 交换机类型：
      • 3.4.1 Fanout 交换机：
      • 3.4.2 Direct 交换机：
      • 3.4.3 Topic 交换机：
    • 3.5 声明交换机和队列：
      • 3.5.1 使用 API：
        • 3.5.1.1 fanout 示例：
        • 3.5.1.2 direct 示例：
      • 3.5.2 使用注解：
        • 3.5.2.1 fanout 示例:
        • 3.5.2.2 direct 示例：
    • 3.6 消息转化器：

一、初识 MQ

1.1 同步调用：

我们观察下，下面这个余额支付功能的流程图：

image-20241128143225761

如果我们采用的是基于 OpenFeign 的同步调用，也就是说业务执行流程是这样的：

  • 支付服务需要先调用用户服务完成余额扣减。
  • 然后支付服务自己要更新支付流水单的状态。
  • 然后支付服务调用交易服务，更新业务订单状态为已支付。

三个步骤依次执行。

这其中就存在3个问题：

  1. 拓展性差：

我们目前的业务相对简单，但是随着业务规模扩大，产品的功能也在不断完善。

在大多数电商业务中，用户支付成功后都会以短信或者其它方式通知用户，告知支付成功。假如后期产品经理提出这样新的需求，你怎么办？是不是要在上述业务中再加入通知用户的业务？

某些电商项目中，还会有积分或金币的概念。假如产品经理提出需求，用户支付成功后，给用户以积分奖励或者返还金币，你怎么办？是不是要在上述业务中再加入积分业务、返还金币业务？

最终你的支付业务会越来越臃肿：

image-20241128143524312

也就是说每次有新的需求，现有支付逻辑都要跟着变化，代码经常变动，不符合开闭原则，拓展性不好。

  1. 性能下降：

由于我们采用了同步调用，调用者需要等待服务提供者执行完返回结果后，才能继续向下执行，也就是说每次远程调用，调用者都是阻塞等待状态。最终整个业务的响应时长就是每次远程调用的执行时长之和：

image-20241128143701876

假如每个微服务的执行时长都是 50ms，则最终整个业务的耗时可能高达 300ms，性能太差了。

  1. 级联失败：

由于我们是基于 OpenFeign 调用交易服务、通知服务。当交易服务、通知服务出现故障时，整个事务都会回滚，交易失败。

这其实就是同步调用的级联失败问题。

不能因为短信通知、更新订单状态失败而回滚整个事务（这些都不是支付服务的主线任务）。

而要解决这些问题，我们就必须用异步调用的方式来代替同步调用。

1.2 异步调用：

异步调用方式其实就是基于消息通知的方式，一般包含三个角色：

  • 消息发送者：投递消息的人，就是原来的调用方。
  • 消息Broker：管理、暂存、转发消息。
  • 消息接收者：接收和处理消息的人，就是原来的服务提供方。
image-20241128144127753

还是以余额支付业务为例：

image-20241128144218877

除了扣减余额、更新支付流水单状态以外，其它调用逻辑全部取消。而是改为发送一条消息到 Broker。而相关的微服务都可以订阅消息通知，一旦消息到达 Broker，则会分发给每一个订阅了的微服务，处理各自的业务。

假如产品经理提出了新的需求，比如要在支付成功后更新用户积分。支付代码完全不用变更，而仅仅是让积分服务也订阅消息即可：

image-20241128144244787

不管后期增加了多少消息订阅者，作为支付服务来讲，执行问扣减余额、更新支付流水状态后，发送消息即可。业务耗时仅仅是这三部分业务耗时，仅仅 100ms，大大提高了业务性能。

另外，不管是交易服务、通知服务，还是积分服务，他们的业务与支付关联度低。现在采用了异步调用，解除了耦合，他们即便执行过程中出现了故障，也不会影响到支付服务。

综上，异步调用的优势包括：

  • 耦合度更低
  • 性能更好
  • 业务拓展性强
  • 故障隔离，避免级联失败

当然，异步通信也并非完美无缺，它存在下列缺点：

  • 完全依赖于 Broker 的可靠性、安全性和性能
  • 架构复杂，后期维护和调试麻烦

消息 Broker，目前常见的实现方案就是消息队列（MessageQueue），简称为 MQ。

下面我们就来进行 RabbitMQ 的学习。

二、RabbitMQ

RabbitMQ 是基于 Erlang 语言开发的开源消息通信中间件，官网地址：

https://www.rabbitmq.com/

接下来，我们就学习它的基本概念和基础用法。

安装：

基于 Docker 来安装 RabbitMQ，使用下面的命令即可：

docker run \-e RABBITMQ_DEFAULT_USER=itheima \-e RABBITMQ_DEFAULT_PASS=123321 \-v mq-plugins:/plugins \--name mq \--hostname mq \-p 15672:15672 \-p 5672:5672 \--network hm-net\-d \rabbitmq:3.8-management

可以看到在安装命令中有两个映射的端口：

  • 15672：RabbitMQ提供的管理控制台的端口
  • 5672：RabbitMQ的消息发送处理接口

安装完成后，我们访问 http://ip地址:15672即可看到管理控制台。首次访问需要登录，默认的用户名和密码在配置文件中已经指定了。

登录后即可看到管理控制台总览页面：

image-20241128144848440

RabbitMQ 对应的架构如图：

image-20241128144930936

其中包含几个概念：

  • publisher：生产者。
  • consumer：消费者。
  • queue：队列，存储消息。生产者投递的消息会暂存在消息队列中，等待消费者处理。
  • exchange：交换机，负责消息路由。生产者发送的消息由交换机决定投递到哪个队列。
  • virtual host：虚拟主机，起到数据隔离的作用。每个虚拟主机相互独立，有各自的 exchange、queue。这个就像一个 mysql 有多个数据库每个数据库有自己的表。

在 MQ 的客户端也可以实现收发消息，比较简单，所以这里跳过。

三、SpringAMQP

将来我们开发业务功能的时候，肯定不会在控制台收发消息，而是应该基于编程的方式。由于RabbitMQ采用了 AMQP 协议，因此它具备跨语言的特性。任何语言只要遵循 AMQP 协议收发消息，都可以与RabbitMQ交互。并且RabbitMQ官方也提供了各种不同语言的客户端。

但是，RabbitMQ 官方提供的 Java 客户端编码相对复杂，一般生产环境下我们更多会结合 Spring 来使用。而 Spring 的官方刚好基于RabbitMQ 提供了这样一套消息收发的模板工具：SpringAMQP。并且还基于 SpringBoot 对其实现了自动装配，使用起来非常方便。

SpringAmqp 的官方地址：

https://spring.io/projects/spring-amqp

SpringAMQP 提供了三个功能：

  • 自动声明队列、交换机及其绑定关系。
  • 基于注解的监听器模式，异步接收消息。
  • 封装了 RabbitTemplate 工具，用于发送消息。

3.1 依赖和配置文件

要进行下面的操作，首先我们需要引入相关依赖：

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

其次进行配置文件：

在application.yml中添加配置：

spring:rabbitmq:host: xxxxx # 你的虚拟机IPport: 5672 # 端口virtual-host: /hmall # 虚拟主机username: hmall # 用户名password: 123 # 密码

注意：不论是消息的发送者还是消息的接收者都需要进行上面的配置。

3.2 消息发送和接收：

3.2.1 消息发送：

利用RabbitTemplate实现消息发送，RabbitTemplate 在我们引入依赖和配置完文件启动项目就自动创建了，我们直接进行依赖注入即可。

下面的代码中，没有实现交换机，因为比较复杂，我们下面讲，这里其实就是感受 RabbitTemplate 的使用。队列需要我们在 MQ 控制台手动创建。

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

3.2.2 消息接收：

@Component
public class SpringRabbitListener {// 利用RabbitListener来声明要监听的队列信息// 将来一旦监听的队列中有了消息，就会推送给当前服务，调用当前方法，处理消息。@RabbitListener(queues = "simple.queue")public void listenSimpleQueueMessage(String msg) throws InterruptedException {System.out.println("spring 消费者接收到消息：【" + msg + "】");}
}

注意：消息接收的方法参数类型要和消息的发送的参数类型一致。例如上面都是 String 类型。

3.3 WorkQueues 模型：

Work queues，任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息。

image-20241128155740962

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

此时就可以使用work 模型，多个消费者共同处理消息处理，同一条消息只会被一个消费者处理，这样，消息处理的速度就能大大提高了。

不过在 RabbitMQ 中该模型还存在一个问题：消息是平均分配给每个消费者，并没有考虑到消费者的处理能力。

这显然是不合理的。

改进：

在spring中有一个简单的配置，可以解决这个问题，在 application.yml 文件中添加配置：

spring:rabbitmq:listener:simple:prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

这样就能实现能者多劳的效果，充分利用了每一个消费者的处理能力，可以有效避免消息积压问题。

总结：

Work模型的使用：

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

3.4 交换机类型：

在之前的案例中，都没有交换机，生产者直接发送消息到队列。而一旦引入交换机，消息发送的模式会有很大变化：

image-20241128161013810

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

  • Publisher：生产者，不再发送消息到队列中，而是发给交换机。
  • Exchange：交换机，一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。
  • Queue：消息队列也与以前一样，接收消息、缓存消息。不过队列一定要与交换机绑定。
  • Consumer：消费者，与以前一样，订阅队列，没有变化。

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

交换机的类型有四种：

  • Fanout：广播，将消息交给所有绑定到交换机的队列。
  • Direct：订阅，基于 RoutingKey（路由 key）发送给订阅了消息的队列。
  • Topic：通配符订阅，与 Direct 类似，只不过 RoutingKey 可以使用通配符。
  • Headers：头匹配，基于 MQ 的消息头匹配，用的较少。

我们这里讲解前面三种交换机。

3.4.1 Fanout 交换机：

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

image-20241128162202662

总结：

交换机的特点：

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

3.4.2 Direct 交换机：

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

image-20241128162611237

在 Direct 模型下：

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

总结：

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

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

3.4.3 Topic 交换机：

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。

只不过Topic类型Exchange可以让队列在绑定BindingKey 的时候使用通配符！

**BindingKey 一般都是由一个或多个单词组成，多个单词之间以.分割。**例如： item.insert

通配符规则：

  • #：匹配 0 个或多个词。
  • *：匹配不多不少恰好 1 个词。

image-20241128163534062

总结：

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

  • Topic 交换机与队列绑定时的 bindingKey 可以指定通配符。
  • #：代表 0 个或多个词。
  • *：代表 1 个词。

3.5 声明交换机和队列：

在之前我们都是基于RabbitMQ控制台来创建队列、交换机。但是在实际开发时，队列和交换机是程序员定义的，将来项目上线，又要交给运维去创建。那么程序员就需要把程序中运行的所有队列和交换机都写下来，交给运维。在这个过程中是很容易出现错误的。

因此推荐的做法是由程序启动时检查队列和交换机是否存在，如果不存在自动创建。

**声明交换机和队列一般是消息的接收者来做的。**这里的背景是微服务，消息的发送者和接收者一般是在不同的项目里面。

注意：如果项目中没有消费者（使用 @RabbitListener），可能创建交换机和队列会失败（MQ 上显示不出来，但是 spring 中对象成功创建），至于为什么会这样，我也不清楚，去网上找，问 AI 都没有这方面的资料。这个问题是我在项目中遇到的，解决了很久，算是比较小众的问题，如果有相同情况的友友，可以试试）。

3.5.1 使用 API：

SpringAMQP 提供了一个 Queue 类，用来创建队列：

image-20241128152047559

SpringAMQP 还提供了一个 Exchange 接口，来表示所有不同类型的交换机：

image-20241128152125575

我们可以自己创建队列和交换机，不过 SpringAMQP 还提供了 ExchangeBuilder 来简化这个过程：

image-20241128152158873

而在绑定队列和交换机时，则需要使用 BindingBuilder 来创建 Binding 对象：

image-20241128152250590

3.5.1.1 fanout 示例：
package com.itheima.consumer.config;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类型交换机*/@Beanpublic FanoutExchange fanoutExchange(){return new FanoutExchange("hmall.fanout");}/*** 第1个队列*/@Beanpublic Queue fanoutQueue1(){return new Queue("fanout.queue1");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);}/*** 第2个队列*/@Beanpublic Queue fanoutQueue2(){return new Queue("fanout.queue2");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);}
}
3.5.1.2 direct 示例：

direct 模式由于要绑定多个 KEY，会非常麻烦，每一个 Key 都要编写一个 binding：

package com.itheima.consumer.config;import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class DirectConfig {/*** 声明交换机* @return Direct类型交换机*/@Beanpublic DirectExchange directExchange(){return ExchangeBuilder.directExchange("hmall.direct").build();}/*** 第1个队列*/@Beanpublic Queue directQueue1(){return new Queue("direct.queue1");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue1WithRed(Queue directQueue1, DirectExchange directExchange){return BindingBuilder.bind(directQueue1).to(directExchange).with("red");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue1WithBlue(Queue directQueue1, DirectExchange directExchange){return BindingBuilder.bind(directQueue1).to(directExchange).with("blue");}/*** 第2个队列*/@Beanpublic Queue directQueue2(){return new Queue("direct.queue2");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue2WithRed(Queue directQueue2, DirectExchange directExchange){return BindingBuilder.bind(directQueue2).to(directExchange).with("red");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue2WithYellow(Queue directQueue2, DirectExchange directExchange){return BindingBuilder.bind(directQueue2).to(directExchange).with("yellow");}
}

由于 Topic 交换机的声明和 Direct 差不多，大家照着上面的 Direct ，修改一下类型就能成功创建，这里就不演示了。

3.5.2 使用注解：

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

3.5.2.1 fanout 示例:
@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "fanout.queue1"),exchange = @Exchange(name = "hmall.fanout", type = ExchangeTypes.FANOUT)
))
public void listenFanoutQueue1(String msg){System.out.println("消费者1接收到fanout.queue1的消息：【" + msg + "】");
}@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "fanout.queue2"),exchange = @Exchange(name = "hmall.fanout", type = ExchangeTypes.FANOUT)
))
public void listenFanoutQueue2(String msg){System.out.println("消费者2接收到fanout.queue2的消息：【" + msg + "】");
}
3.5.2.2 direct 示例：
@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "direct.queue1"),exchange = @Exchange(name = "hmall.direct", type = ExchangeTypes.DIRECT),key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){System.out.println("消费者1接收到direct.queue1的消息：【" + msg + "】");
}@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "direct.queue2"),exchange = @Exchange(name = "hmall.direct", type = ExchangeTypes.DIRECT),key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){System.out.println("消费者2接收到direct.queue2的消息：【" + msg + "】");
}

3.6 消息转化器：

convertAndSend 方法可以任意类型的消息。

image-20241128170230045

而在数据传输时，它会把你发送的消息序列化为字节发送给 MQ，接收消息的时候，还会把字节反序列化为 Java 对象。

只不过，默认情况下 Spring 采用的序列化方式是 JDK 序列化。JDK 序列化存在下列问题：

  • 数据体积过大
  • 有安全漏洞
  • 可读性差

所以我们需要换一个消息转化器。

这里采用 JSON 方式来做序列化和反序列化。

在发送者和接受者两个服务中都引入依赖。

<dependency><groupId>com.fasterxml.jackson.dataformat</groupId><artifactId>jackson-dataformat-xml</artifactId><version>2.9.10</version>
</dependency>

注意，如果项目中引入了spring-boot-starter-web依赖，则无需再次引入Jackson依赖。

配置消息转换器，在发送者和接受者两个服务的启动类中添加一个 Bean 即可：

@Bean
public MessageConverter messageConverter(){// 1.定义消息转换器Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();// 2.配置自动创建消息id，用于识别不同消息，也可以在业务中基于ID判断是否是重复消息jackson2JsonMessageConverter.setCreateMessageIds(true);return jackson2JsonMessageConverter;
}

消息转换器中添加的 messageId 可以便于我们将来做幂等性判断。

参考文献：

  • 黑马程序员

结语：
其实写博客不仅仅是为了教大家，同时这也有利于我巩固知识点，和做一个学习的总结，由于作者水平有限，对文章有任何问题还请指出，非常感谢。如果大家有所收获的话，还请不要吝啬你们的点赞收藏和关注，这可以激励我写出更加优秀的文章。

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

建筑行业数据分析如何做？

建筑行业数据分析如何做？

导读&#xff1a;在谈数字化转型之前&#xff0c;先来谈谈数据的价值。数字化转型的基础是数据&#xff0c;是数字化的基本的生产资料&#xff0c;数据的质量直接决定了数字化的能力、所能达到的深度和广度。目前做的数据可视化项目总感觉只是数据展现而已&#xff0c;而不达不…
阅读更多...
电脑投屏到电脑：Windows，macOS及Linux系统可以相互投屏！

电脑投屏到电脑：Windows，macOS及Linux系统可以相互投屏！

本篇其实是电脑远程投屏到另一台电脑的操作介绍。本篇文章的方法可用于Windows&#xff0c;macOS及Linux系统的相互投屏。 为了避免介绍过程中出现“这台电脑”投屏到“那台电脑”的混乱表述&#xff0c;假定当前屏幕投出端是Windows系统电脑&#xff0c;屏幕接收端是Linux系统…
阅读更多...
随时随地掌控数据：如何使用手机APP远程访问飞牛云NAS

随时随地掌控数据：如何使用手机APP远程访问飞牛云NAS

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…
阅读更多...
2024-12-04OpenCV视频处理基础

2024-12-04OpenCV视频处理基础

OpenCV视频处理基础 OpenCV的视频教学&#xff1a;https://www.bilibili.com/video/BV14P411D7MH 1-OpenCV视频捕获 在 OpenCV 中&#xff0c;cv2.VideoCapture() 是一个用于捕获视频流的类。它可以用来从摄像头捕获实时视频&#xff0c;或者从视频文件中读取帧。以下是如何使用…
阅读更多...
ubuntu安装navicat，并使用navicat连接mysql服务

ubuntu安装navicat，并使用navicat连接mysql服务

1.安装宝塔&#xff1a; 登录宝塔官网&#xff1a;https://www.bt.cn/new/download.html 使用对应命令安装宝塔&#xff0c;然后搭建mysql环境。 2.安装navicat 有需要教程的私我&#xff0c;我再更新整理出来 &#xff01;&#xff01;&#xff01; 有需要教程的私我&#xf…
阅读更多...
深度学习：MindSpore自动并行

深度学习：MindSpore自动并行

随着模型规模的逐渐增大&#xff0c;需要的算力逐渐增强&#xff0c;但是算力需求增长速度远高于芯片算力增长速度。现在唯一的解决方案只有通过超大规模集群训练大模型。 大集群训练大模型的挑战 内存墙 200B参数量的模型&#xff0c;参数内存占用745GB内存&#xff0c;训练…
阅读更多...
Qt Designer Ui设计 功能增加

Qt Designer Ui设计 功能增加

效果展示 输入密码&#xff0c;密码错误&#xff0c;弹出提示 密码正确&#xff0c;弹出提示并且关闭原窗口 代码&#xff08;只提供重要关键主代码&#xff09;lxh_log.py代码&#xff1a; import sysfrom PySide6.QtWidgets import QApplication, QWidget, QPushButtonfrom …
阅读更多...
版本控制器git

版本控制器git

版本控制git 什么是版本控制&#xff1f; 版本控制是一种跟踪管理文件变化的技术&#xff0c;特别是软件源码的修改、更新、和历史记录。当程序员想要进行用到之前版本的代码可以进行查看、协作、并编辑文件。 举个栗子 当一位初入职场的萌新程序员在进行执行产品经理的需求时…
阅读更多...
jetbrain 插件开发初体验

jetbrain 插件开发初体验

idea插件开发初体验 背景 标准化的git commit Message很重要&#xff0c;一直以来我用的都是commit-template-idea-plugin&#xff0c;他提供的模板遵循了conventionalcommits规范 <type>(<scope>): <subject> <BLANK LINE> <body> <BLANK…
阅读更多...
解决raw.githubusercontent.com无法访问的问题

解决raw.githubusercontent.com无法访问的问题

显示报错&#xff1a;ConnectionError: Couldn’t reach https://raw.githubusercontent.com/huggingfac 无法访问 在https://www.ipaddress.com 或者ip138.com网站中的查询框中输入&#xff1a;raw.githubusercontent.com 回车就能有下图中的网页&#xff0c;在里面找到相应的…
阅读更多...
高效职场人

高效职场人

文章目录 1.时间效能 ABCD2.高效员工的习惯之 自我掌控的秘诀3.学会做主4.学会互赢5.学会沟通、学会聆听6.学会可持续发展&#xff1a;四个方面更新自我(1)更新身体(2)更新精神(3)更新智力(4)更新人际情感 1.时间效能 ABCD 时间四象限&#xff1a; A类任务&#xff1a;重要且紧…
阅读更多...
数据结构 （33）选择类排序

数据结构 （33）选择类排序

前言 数据结构中的选择类排序主要包括简单选择排序&#xff08;也称为选择排序&#xff09;和堆排序。 一、简单选择排序 基本思想&#xff1a;简单选择排序是一种直观易懂的排序算法。它的工作原理是&#xff0c;在未排序序列中找到最小&#xff08;或最大&#xff09;元素&am…
阅读更多...
Kubernetes架构原则和对象设计（二）

Kubernetes架构原则和对象设计（二）

云原生学习路线导航页&#xff08;持续更新中&#xff09; kubernetes学习系列快捷链接 Kubernetes架构原则和对象设计&#xff08;一&#xff09;Kubernetes常见问题解答 本文从云计算架构发展入手&#xff0c;详细分析了kubernetes的生态系统、设计理念、分层架构、API设计…
阅读更多...
自建服务器，数据安全有保障

自建服务器，数据安全有保障

在远程桌面工具的选择上&#xff0c;向日葵和TeamViewer功能强大&#xff0c;但都存在收费昂贵、依赖第三方服务器、数据隐私难以完全掌控等问题。相比之下&#xff0c;RustDesk 凭借开源免费、自建服务的特性脱颖而出&#xff01;用户可以在自己的服务器上部署RustDesk服务端&…
阅读更多...
发布Apache2.4** 局域网无法访问

发布Apache2.4** 局域网无法访问

1。 防火墙关闭 或者 设置入站规则 2&#xff0c;查看httpd.conf 文件 设置配置 原 Listen 80 修改成 Listen 192.168.31.127:90 3.确保 本地IP 是否正确
阅读更多...
Flutter解压文件并解析数据

Flutter解压文件并解析数据

Flutter解压文件并解析数据 前言 在 Flutter 开发中&#xff0c;我们经常需要处理文件的读取和解压。 这在处理应用数据更新、安装包、存档文件等场景中尤为常见。 本文将介绍如何在Flutter中使用archive插件来解压文件并解析数据。 准备 在开始之前&#xff0c;我们需要…
阅读更多...
HiveSQL题——炸裂函数(explodeposexplode)

HiveSQL题——炸裂函数(explodeposexplode)

目录 一、炸裂函数的知识点 1.1?炸裂函数 ?explode? posexplode 1.2 lateral view 侧写视图 二、实际案例 2.1 每个学生及其成绩 0 问题描述 1 数据准备 2 数据分析 3 小结 2.2?日期交叉问题 0 问题描述 1 数据准备 2 数据分析 3 小结 2.3?用户消费金额 …
阅读更多...
从差分电容到多轴测量：解读 BendLabs 柔性弯曲传感器核心技术

从差分电容到多轴测量：解读 BendLabs 柔性弯曲传感器核心技术

BendLabs是一家技术公司&#xff0c;致力于通过灵活的软传感解决方案将运动测量和理解带给世界。BendLabs柔性弯曲传感器由医用级有机硅制成&#xff0c;能够满足精确、多轴、柔软、灵活的传感需求。BendLabs柔性弯曲传感器采用差分电容原理&#xff0c;具有高精度、低功耗、无…
阅读更多...
【数字电路与逻辑设计】实验二 数值比较器

【数字电路与逻辑设计】实验二 数值比较器

文章总览&#xff1a;YuanDaiMa2048博客文章总览 【数字电路与逻辑设计】实验二 数值比较器 一、实验内容二、设计过程&#xff08;一&#xff09;真值表&#xff08;二&#xff09;设计思路 三、源代码&#xff08;一&#xff09;代码说明&#xff1a;&#xff08;二&#xff…
阅读更多...
39 vector深入理解 · 迭代器失效深度浅拷贝

39 vector深入理解 · 迭代器失效深度浅拷贝

目录 一、迭代器失效 &#xff08;一&#xff09;外部迭代器失效 1、扩容引起的野指针问题 2、删除引起的逻辑问题 二、深度浅拷贝 一、迭代器失效 迭代器可以理解为像指针一样的类对象&#xff0c;但不要一味地认为迭代器就是指针&#xff0c;指针可以实现迭代器&#xff…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023