微服务-nacos服务中心

单体与微服务

单体架构：项目所有功能都在一个 war 包 /jar 包里，像商城的订单、库存、会员、支付等服务，都打包在一起，部署在 Tomcat 服务器，数据存在 MySQL。

  • 优点：开发简单，易于理解和维护；部署方便，只需部署一个应用包；测试容易，在一个环境就能完成。
  • 缺点：可维护性差，代码量增大后，模块间耦合度高，修改一处可能影响多处；扩展性受限，无法针对特定功能单独扩展；可靠性低，一处故障就可能导致整个应用不可用 。
单体架构阶段例子

整个电商平台的所有功能，像用户浏览商品的前端界面、下单的订单服务、查询库存的库存服务、会员管理服务、支付服务，都被打包在一个 WAR 包里，部署在一台 Tomcat 服务器上，数据都存在一个 MySQL 数据库里。就好比开了一家小杂货店，所有商品、收银、库存记录都在一个小店铺里，老板一个人能管过来，但要是店里某一处（比如收银台）出问题，整个店可能就没法正常营业了，而且要是节日期间人特别多（订单量暴增），想只增加收银的 “能力” 也做不到，得把整个店铺都扩大，成本高还麻烦。

集群级垂直化（业务系统级的拆分）：为解决单体的问题，

  • 横向加服务器，变成集群；
  • 纵向按业务拆，订单、库存、会员、支付各成一个 WAR 包，分别部署到不同的服务器，数据库也对应拆成订单库、库存库等。这样业务耦合度降低，单个业务出问题，不影响其他，也方便针对热门业务（比如订单量暴增）单独扩展服务器。
  • 优点：业务耦合度降低，单个业务系统故障对其他系统影响小；可以针对不同业务需求，独立扩展资源，提高资源利用率；便于不同业务模块的并行开发 。
  • 缺点：系统间调用复杂度增加，需要考虑分布式通信和数据一致性问题；整体维护成本上升，要管理多个独立部署的系统 。
集群级垂直化阶段例子

为了应对业务增长，横向增加了 Tomcat 服务器，变成多台服务器的集群；纵向按业务把订单、库存、会员、支付这些业务拆分开，每个业务都有自己的 WAR 包，分别部署在不同的 Tomcat 服务器上，数据库也对应拆成订单库、库存库、会员库、支付库。这就像把杂货店变成了有多个分区的大超市，订单区、库存区、会员服务区、支付区各自独立，一个区（比如订单区）人多了，就可以单独给这个区增加人手和场地（扩展服务器），一个区出问题，也不会影响其他区正常运作，但每个区内部还是有很多流程和功能混在一起。

![](https://i-blog.csdnimg.cn/img_convert/5b5496a9a242c1bbe965ac5b0c47b6b4.png)

SOA:核心是把通用、会被多个上层服务调用的业务，抽成独立基础服务，用 ESB（企业服务总线）连接。比如电商、运营系统都可能用订单、库存等服务。这样解决了 “信息孤岛”，让共享业务能复用，像会员服务，电商和运营系统都能调用。[即电商、运营都能调用订单、库存服务】

  • 优点：解决信息孤岛问题，实现业务共享和复用，提高开发效率；业务灵活性高，能快速响应业务变化，便于新业务集成；提高系统的可扩展性，可独立扩展单个服务 。
  • 缺点：架构复杂，建设和维护成本高，需要专业的 ESB 等技术支撑；服务治理难度大，需要管理服务间的依赖、版本、安全等 。
SOA 阶段

电商平台和运营系统（比如用于平台运营管理的系统）都需要用到订单、库存、会员等服务，于是把这些通用的、会被多个上层系统调用的业务，抽取成独立的基础服务，通过 ESB（企业服务总线）来连接各个服务。比如电商系统要下单，运营系统要统计会员数据，都可以调用对应的订单服务、会员服务。这样就解决了不同系统之间的 “信息孤岛” 问题，让订单、会员这些共享业务能被多个系统复用，不过服务之间的调用还是通过比较重的 ESB 来管理。

![](https://i-blog.csdnimg.cn/img_convert/ca28f35eef7a11c2bd6123b4fc7a8a7d.png)

微服务：SOA 拆分的服务，还能按更细的业务功能拆，独立部署，降低耦合、提升容错。

比如订单服务还能拆得更细。微服务用 API 网关统一管理服务，服务间用 REST API 通信。但服务拆得太细，数量变多，构建、发布、运维就更复杂了。可以说 SOA 是微服务的 “超集”，多个微服务能组成一个 SOA 服务。

  • 优点：高内聚低耦合，每个微服务专注单一功能，开发、测试、维护更方便；扩展性强，可针对不同微服务进行单独的资源扩展；技术选型灵活，不同微服务可根据需求选择不同技术栈。
  • 缺点：
    * 服务数量多，管理和监控复杂，运维难度大；
    * 分布式系统带来的数据一致性、网络延迟等问题，增加开发复杂性；部署成本高，要管理多个微服务的部署和运行 。
微服务阶段

SOA 拆分出来的服务，又按照更细的业务功能进行拆分和独立部署。比如订单服务，还能拆分成订单创建、订单查询等更细的微服务，每个微服务都有自己的数据库（或数据存储），通过 API 网关来统一管理服务，服务之间用 REST API 进行通信。就像把大超市的每个区又拆成了更小的独立小店，订单创建店、订单查询店等，各自独立运营，一家店出问题，不影响其他店，而且能根据具体需求（比如订单创建需求猛增），只给订单创建的微服务增加资源。但这样一来，服务数量变多，管理、发布、运维这些工作的复杂度也大大增加了。

![](https://i-blog.csdnimg.cn/img_convert/791c84c9d7efa70947beeff30e6f4b63.png)

微服务技术栈

  1. 配置管理：借助 Nacos、Config 等工具，统一管理微服务的配置信息，让所有微服务能便捷获取和使用配置，方便配置的集中维护与动态更新。
  2. 服务注册列表：通过注册中心，把所有微服务都注册进去，形成一个服务清单，这样其他微服务要调用服务时，能轻松找到目标服务。
  3. 网关处理请求：网关作为所有请求的入口，对进来的请求进行处理，可进行权限控制，判断请求是否有权限；也能设置白名单，白名单内的请求可通行；还能对请求进行路由，决定哪些请求转发到新系统。
  4. 熔断限流：当某个微服务请求量过大，负载过高时，熔断器会从关闭状态转为打开状态，此时请求会被拦截，返回 “系统繁忙，请稍等” 的提示。之后熔断器会每隔一段时间发送测试请求，查看服务是否恢复，此时处于半开状态，若服务负载正常了，熔断器就转回关闭状态，允许请求正常访问。
  5. 负载均衡策略：运用 Ribbon 等工具，制定规则，决定请求分发到哪台运行服务的机器上，让多台机器合理分担请求压力，避免单台机器负载过高。
  6. 流处理与消息总线：在消息队列之上添加了一层数据处理逻辑，原本是想实现用户能无缝切换不同的消息队列，但实际效果并不理想。
  7. 日志跟踪：利用生成的 Trace ID，对微服务之间的调用链路进行跟踪，像从订单服务到物流服务等不同微服务的调用关系，都能通过这个 Trace ID 清晰呈现，便于排查问题。

CAP&BASE

名称详细说明
Consistency（一致性）在分布式系统中的所有数据备份，在同一时刻是否同样的值。（等同于所有节点访问同一份最新的数据副本）
Availability（可用性）在集群中一部分节点故障后，集群整体是否还能响应客户端的读写请求。（对数据更新具备高可用性）
Partition tolerance（分区容忍性）一个分布式系统里面，节点组成的网络本来应该是连通的。然而可能因为一些故障，使得有些节点之间不连通了，整个网络就分成了几块区域，数据就散布在了这些不连通的区域中，这就叫分区。
当一个数据项只在一个节点中保存，那么分区出现后，和这个节点不连通的部分就访问不到这个数据了，这时分区就是无法容忍的。
提高分区容忍性的办法就是把数据项复制到多个节点上，容忍性就提高了。然而，要把数据复制到多个节点，就会带来一致性的问题，而要保证一致，每次写操作就都要等待全部节点写成功，而这等待又会带来可用性的问题
【复制多个副本，使得分区时保证该分区内部有足够多的数据，但是多副本会导致数据一致性问题（副本越多数据一致性问题越大，比如一个副本必然没有数据一致性问题）
解决：等待所有节点写入数据成功，但是这个又会导致可用性问题（即等待时候集群不可用） 】

高可用性：如果说某个节点故障了但是集群整体还可以运行 ，则说明保持了高可用性

nacos-服务注册与发现

服务发现

1.通过 nameServer 去调用某服务，而不是通过传统的固定 ip，每个服务都自动将 ip 和端口发送到服务列表，要调取的服务去拉取该服务列表即可，然后通过 name 去调用，这样子就可以做到自动刷新ip

客户端服务发现

服务端服务发现

这里的话要考虑load balancer的高可用性（因为所有的请求都经过这个，所以可能会导致大量的请求同时打过来）

核心思想

无论是 OpenFeign 还是 Dubbo，在 Nacos 的帮助下，实现服务调用的核心思想都是一样的：

  1. 服务注册 (Provider)：服务提供者启动时，将自己的服务地址、接口信息等“注册”到 Nacos 服务中心。就像在黄页上登记自己的电话号码和业务范围。
  2. 服务发现 (Consumer)：服务消费者启动时，向 Nacos “订阅”某个服务。Nacos 会将那个服务所有提供者的地址列表拉取到消费者本地。
  3. 服务调用 (Consumer -> Provider)：消费者从本地的地址列表中，通过负载均衡算法（如轮询）选择一个提供者的地址，然后发起远程调用。

OpenFeign + Nacos 的流程与原理

OpenFeign 是 声明式 HTTP 客户端，基于 RESTful 风格通信，需依赖 Spring Cloud 生态；Nacos 作为注册中心，负责服务地址的动态管理。

1. Provider 端：服务注册到 Nacos

  • 步骤1：引入依赖
    在 Spring Boot 项目的 pom.xml 中添加 Nacos 服务发现依赖：
<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
  • 步骤2：配置 Nacos 地址
    在 application.yml 中指定服务名称和 Nacos 地址：
spring:application:name: provider-service # 服务名（Consumer 端通过该名称发现服务）cloud:nacos:discovery:server-addr: localhost:8848 # Nacos 服务端地址
  • 步骤3：暴露服务接口
    通过 Spring MVC 注解（如 @RestController）定义 HTTP 接口：
@RestController
@RequestMapping("/provider")
public class ProviderController {@GetMapping("/hello")public String hello() {return "Hello from Provider!";}
}
  • 原理：服务启动时，Nacos 客户端会自动将服务名、IP、端口等元数据注册到 Nacos Server，并定期发送心跳包维持“在线”状态。

2. Consumer 端：通过 OpenFeign 调用 Provider

  • 步骤1：引入依赖
    除 Nacos 依赖外，需添加 OpenFeign 依赖：
<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
  • 步骤2：启用 Feign 客户端
    在启动类上添加 @EnableFeignClients 注解：
@SpringBootApplication
@EnableDiscoveryClient // 启用服务发现
@EnableFeignClients    // 启用 OpenFeign
public class ConsumerApplication {public static void main(String[] args) {SpringApplication.run(ConsumerApplication.class, args);}
}
  • 步骤3：定义 Feign 客户端接口
    通过 @FeignClient 声明要调用的服务名，并映射 HTTP 路径：
@FeignClient(name = "provider-service") // name 对应 Provider 的服务名
public interface ProviderFeignClient {@GetMapping("/provider/hello") // 映射 Provider 的 HTTP 接口【这里即是去调用provider服务的接口】String callHello();
}
  • 步骤4：注入并调用 Feign 接口
    在 Controller 中注入 Feign 接口，直接调用方法：
@RestController
@RequestMapping("/consumer")
public class ConsumerController {@Autowiredprivate ProviderFeignClient feignClient;@GetMapping("/call")public String callProvider() {return feignClient.callHello(); // 远程调用 Provider 的 /provider/hello}
}
  • 原理：
    • 服务发现：Consumer 启动时，Nacos 客户端会拉取 <font style="color:#DF2A3F;">provider-service</font> 对应的所有实例地址（IP:端口）。
    • 负载均衡：OpenFeign 底层集成了 Spring Cloud LoadBalancer（或 Ribbon），自动从实例列表中选择一个（默认轮询策略）。
    • 动态代理：Feign 通过 JDK 动态代理为接口生成 HTTP 客户端实现类，将方法调用转化为 HTTP 请求（如 <font style="color:#DF2A3F;">GET http://{ip}:{port}/provider/hello</font>），并解析响应。

Dubbo + Nacos 的流程与原理

Dubbo 是 高性能 RPC 框架，基于二进制协议（如 Dubbo 协议）通信，天生支持服务治理；Nacos 作为注册中心，负责服务地址的注册与推送。

1. Provider 端：服务注册到 Nacos

  • 步骤1：引入依赖
    在 pom.xml 中添加 Dubbo 和 Nacos 整合依赖：
<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-dubbo</artifactId>
</dependency>
<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
  • 步骤2：配置 Dubbo + Nacos
    在 application.yml 中指定 Dubbo 协议、Nacos 地址，并暴露服务：
spring:application:name: dubbo-providercloud:nacos:discovery:server-addr: localhost:8848
dubbo:protocol:name: dubbo # 通信协议（默认 Dubbo 协议，高性能二进制协议）port: -1    # 自动分配端口registry:address: nacos://localhost:8848 # 注册中心地址scan:base-packages: com.example.provider.service # 扫描服务实现类的包
  • 步骤3：定义并实现服务接口
    服务接口需单独定义（通常抽成公共模块供给 Consumer 依赖）：
// 公共接口模块
public interface HelloService {String sayHello(String name);
}
// Provider 实现类
@Service(interfaceClass = HelloService.class) // Dubbo 注解，暴露服务
public class HelloServiceImpl implements HelloService {@Overridepublic String sayHello(String name) {return "Hello, " + name + "!";}
}
  • 原理：服务启动时，Dubbo 会**将接口的全限定名（如 com.example.HelloService）与服务地址**注册到 Nacos，并通过心跳维持存活状态。

2. Consumer 端：通过 Dubbo 调用 Provider

  • 步骤1：引入依赖
    需添加 Dubbo、Nacos 依赖，以及 Provider 的接口依赖：
<dependency><groupId>com.example</groupId><artifactId>provider-interface</artifactId> <!-- 引入 Provider 的接口模块 --><version>1.0.0</version>
</dependency>
<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-dubbo</artifactId>
</dependency>
<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
  • 步骤2：配置 Dubbo + Nacos
    在 application.yml 中指定注册中心和引用服务：
spring:application:name: dubbo-consumercloud:nacos:discovery:server-addr: localhost:8848
dubbo:registry:address: nacos://localhost:8848 # 注册中心地址
  • 步骤3：引用远程服务
    通过 @Reference 注解注入 Provider 的接口
@RestController
@RequestMapping("/consumer")
public class ConsumerController {@Reference // Dubbo 注解，自动发现并引用服务private HelloService helloService;@GetMapping("/call")public String callProvider() {return helloService.sayHello("Dubbo"); // 远程调用 Provider 的 sayHello 方法}
}
  • 原理：
    • 服务发现：Consumer 启动时，Dubbo 客户端从 Nacos 订阅 <font style="color:#DF2A3F;">HelloService</font> 对应的所有 Provider 地址，并缓存到本地。
    • 负载均衡：Dubbo 内置多种负载均衡策略（如随机、轮询、一致性哈希），从地址列表中选择一个 Provider。
    • RPC 调用：Dubbo 通过动态代理为 HelloService 生成客户端 Stub，将方法调用转化为二进制 RPC 请求（通过 Netty 发送），Provider 端的 Stub 接收请求后反射调用实际方法，再将结果返回。

dubbo的工作流程

1. 项目整体结构
  • provider-interface 模块：存放服务接口定义。
  • provider 模块：实现服务接口，并注册服务到 Nacos。
  • consumer 模块：引入接口模块，调用 Provider 提供的服务。
2. provider-interface/provider-api 模块
定义服务接口

在 src/main/java/com/example/service 目录下创建 HelloService 接口：

package com.example.service;public interface HelloService {String sayHello(String name);
}

使用 Maven 构建该模块，生成 Jar 包供其他模块依赖。pom.xml 文件内容如下：

<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.example</groupId><artifactId>provider-interface</artifactId><version>1.0.0</version><dependencies><!-- 可以根据需要添加其他公共依赖 --></dependencies>
</project>
3. provider/provider-application 模块
引入依赖

在 pom.xml 中引入 provider-interface 模块以及 Dubbo 和 Nacos 相关依赖：

<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.example</groupId><artifactId>provider</artifactId><version>1.0.0</version><dependencies><dependency><groupId>com.example</groupId><artifactId>provider-interface</artifactId><version>1.0.0</version></dependency><dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-dubbo</artifactId></dependency><dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>
</project>
配置文件

在 src/main/resources/application.yml 中进行配置：

spring:application:name: dubbo-providercloud:nacos:discovery:server-addr: localhost:8848  # Nacos 服务地址
dubbo:protocol:name: dubboport: -1  # 自动分配端口registry:address: nacos://localhost:8848  # 注册到 Nacosscan:base-packages: com.example.provider.service  # 扫描服务实现类的包
实现服务接口

在 src/main/java/com/example/provider/service 目录下创建 HelloServiceImpl 类，实现 HelloService 接口：

package com.example.provider.service;import com.alibaba.dubbo.config.annotation.Service;
import com.example.service.HelloService;@Service(interfaceClass = HelloService.class)
public class HelloServiceImpl implements HelloService {@Overridepublic String sayHello(String name) {return "Hello, " + name + "! From Dubbo Provider";}
}
启动类

在 src/main/java/com/example/provider 目录下创建 ProviderApplication 启动类：

package com.example.provider;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;@SpringBootApplication
@EnableDiscoveryClient
public class ProviderApplication {public static void main(String[] args) {SpringApplication.run(ProviderApplication.class, args);}
}
4. consumer 模块
引入依赖

在 pom.xml 中引入 provider-interface 模块以及 Dubbo 和 Nacos 相关依赖：

<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.example</groupId><artifactId>consumer</artifactId><version>1.0.0</version><dependencies><dependency><groupId>com.example</groupId><artifactId>provider-interface</artifactId><version>1.0.0</version></dependency><dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-dubbo</artifactId></dependency><dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>
</project>
配置文件

在 src/main/resources/application.yml 中进行配置：

spring:application:name: dubbo-consumercloud:nacos:discovery:server-addr: localhost:8848  # Nacos 服务地址
dubbo:registry:address: nacos://localhost:8848  # 从 Nacos 发现服务
调用服务

在 src/main/java/com/example/consumer/controller 目录下创建 ConsumerController 类，通过 @Reference 注解注入 HelloService 接口：

package com.example.consumer.controller;import com.alibaba.dubbo.config.annotation.Reference;
import com.example.service.HelloService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;@RestController
public class ConsumerController {@Referenceprivate HelloService helloService;@GetMapping("/hello/{name}")public String sayHello(@PathVariable String name) {return helloService.sayHello(name);}
}
启动类

在 src/main/java/com/example/consumer 目录下创建 ConsumerApplication 启动类：

package com.example.consumer;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;@SpringBootApplication
@EnableDiscoveryClient
public class ConsumerApplication {public static void main(String[] args) {SpringApplication.run(ConsumerApplication.class, args);}
}
5. 运行与测试
  1. 启动 Nacos 服务。
  2. 启动 provider 模块的 ProviderApplication 类，服务会注册到 Nacos。
  3. 启动 consumer 模块的 ConsumerApplication 类，访问 http://localhost:8080/hello/John （假设 Consumer 应用端口是 8080 ，根据实际配置而定），会返回 Hello, John! From Dubbo Provider，说明 Consumer 成功通过接口模块调用到了 Provider 提供的服务。

通过上述代码结构和实现，可以清晰看到 Dubbo 中 Provider 和 Consumer 基于接口模块的设计与调用流程。

总结

  • OpenFeign：通过“Nacos 注册发现 + HTTP 协议 + 动态代理”实现声明式远程调用，适合简单场景，整合成本低。
  • Dubbo：通过“Nacos 注册发现 + RPC 协议 + 服务治理”实现高性能调用，适合复杂微服务场景，需关注接口定义和二进制协议。

两者的核心思路一致：服务注册到 Nacos → 消费者发现服务 → 动态代理封装网络通信，只是在“通信协议”和“框架封装程度”上有差异。

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

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

相关文章

嵌入式硬件——IMX6ULL 裸机LED点亮实验

嵌入式硬件——IMX6ULL 裸机LED点亮实验

一. 实验准备 基于正点原子 IMX6ULL-Mini 开发板&#xff0c;实现 LED 周期性闪烁功能&#xff0c;需完成环境搭建与硬件原理确认两大核心准备工作。 1.1 开发环境搭建 需在Windows和Ubuntu中安装工具&#xff0c;确保文件传输、交叉编译、代码编辑功能正常。1.1.1 跨系统文件传…
阅读更多...
深度学习之PyTorch基本使用（一）

深度学习之PyTorch基本使用（一）

一、PyTorch简介与安装1.核心概念PyTorch 是一款 Python 深度学习框架&#xff0c;其核心是张量&#xff08;Tensor&#xff09; —— 元素为同一种数据类型的多维矩阵&#xff0c;以 “类” 的形式封装&#xff0c;内置了张量运算、处理等方法&#xff0c;是深度学习中数据存储…
阅读更多...
SQLAlchemy -＞ Base.metadata.create_all(engine ）详解

SQLAlchemy -＞ Base.metadata.create_all(engine ）详解

目录 一、核心作用 二、是否每次运行项目都会执行&#xff1f; 1. ​​典型场景​​&#xff08;推荐&#xff09; 2. ​​需要避免的情况​​ 三、最佳实践建议 1. ​​生产环境​​ 2. ​​开发/测试环境​​ 四、常见问题解答 Q1: 如果表结构改了&#xff0c;creat…
阅读更多...
C++异步任务处理与消息可靠性保障指南：从基础到实战

C++异步任务处理与消息可靠性保障指南：从基础到实战

在当今多核处理器普及的时代&#xff0c;程序性能和响应能力的提升成为开发者面临的核心课题。无论是高频交易系统的毫秒级响应需求、实时游戏引擎的流畅交互体验&#xff0c;还是网络服务器的高并发处理能力&#xff0c;异步编程都已成为突破性能瓶颈的关键技术[1]。作为高性能…
阅读更多...
LazyForEach性能优化：解决长列表卡顿问题

LazyForEach性能优化：解决长列表卡顿问题

本文将深入解析HarmonyOS中LazyForEach的工作原理、性能优势、实战优化技巧及常见问题解决方案&#xff0c;帮助你构建流畅的长列表体验。 1. LazyForEach 核心优势与原理 LazyForEach 是鸿蒙ArkUI框架中为高性能列表渲染设计的核心组件&#xff0c;其核心设计思想基于动态加载…
阅读更多...
Spring Boot 全栈优化：服务器、数据、缓存、日志的场景应用！

Spring Boot 全栈优化：服务器、数据、缓存、日志的场景应用！

Spring Boot以其“开箱即用”闻名&#xff0c;但默认配置往往在高并发场景下成为瓶颈&#xff1a;Tomcat线程堵塞、数据库连接耗尽、缓存命中率低下、日志洪水般淹没磁盘。想象一个电商微服务&#xff0c;峰值流量下响应迟钝&#xff0c;用户流失——这不是宿命&#xff0c;而是…
阅读更多...
Leetcode sql 50 ~5

Leetcode sql 50 ~5

select product_idfrom Productswhere low_fats Y and recyclable Y;SQL 规定&#xff1a;null 的比较必须用 is null 或 is not null&#xff0c;不能用普通的等号&#xff08;&#xff09;。# Write your MySQL query statement below select name from Customer where ref…
阅读更多...
C#高并发与并行理解处理

C#高并发与并行理解处理

目录 1.什么是IO密集型任务/CPU密集型任务 2.高并发概念和技术实现 2.并行&#xff08;Parallelist&#xff09;概念和技术实现 4.核心区别对比 1.什么是IO密集型任务/CPU密集型任务 1.IO密集型任务&#xff1a; 定义&#xff1a;任务核心逻辑不依赖CPU计算&#xff0c;而是…
阅读更多...
正点原子STM32F407 U盘升级程序（IAP）OTA Bootloader APP USB升级+FATFS+USB Host

正点原子STM32F407 U盘升级程序（IAP）OTA Bootloader APP USB升级+FATFS+USB Host

正点原子STM32F407 U盘升级程序&#xff08;IAP&#xff09;OTA Bootloader APP USB升级FATFSUSB HostChapter0 解决STM32 Bootloader跳转APP失败问题问题背景问题描述问题解决原APP跳转的函数为&#xff1a;修改APP程序main入口处Chapter1 MDK如何生成*.bin格式的文件Chapter2…
阅读更多...
MySQL 8.0 在 Ubuntu 22.04 中如何将启用方式改为mysql_native_password（密码认证）

MySQL 8.0 在 Ubuntu 22.04 中如何将启用方式改为mysql_native_password（密码认证）

MySQL 8.0 在 Ubuntu 22.04 中默认启用了 auth_socket 认证方式（而非密码认证），导致 mysql_secure_installation 跳过了 root 密码设置。这会直接影响后续用 Navicat 连接 MySQL（因为 Navicat 需要密码登录），必须手动调整 root 用户的认证方式并设置密码。 核心问题：au…
阅读更多...
七层网络协议-面试

七层网络协议-面试

七层网络协议概述七层网络协议&#xff0c;即OSI&#xff08;Open Systems Interconnection&#xff09;模型&#xff0c;是由国际标准化组织&#xff08;ISO&#xff09;提出的网络通信框架。它将网络通信过程划分为七个层次&#xff0c;每一层负责特定的功能&#xff0c;并通…
阅读更多...
【Blender】二次元人物制作【二】：五官的制作

【Blender】二次元人物制作【二】：五官的制作

一、制作眼睛 选中眼眶内部的一圈线。shiftD复制出来调整成圆形&#xff0c;然后F快捷键填充将眼睛放在眼框内合适的位置&#xff0c;并用i键进行几次内插&#xff0c;做出瞳孔&#xff0c;并且将内部的眼瞳做得稍微向内凹陷一点。二、制作睫毛 选中眼眶上半部分的面&#xff0…
阅读更多...
Deepin 25 系统安装 Docker：完整教程 + 常见问题解决

Deepin 25 系统安装 Docker：完整教程 + 常见问题解决

Deepin 25 系统安装 Docker&#xff1a;完整教程 常见问题解决 作为基于 Debian 的 Linux 发行版&#xff0c;Deepin 25 因系统目录&#xff08;如/usr&#xff09;默认只读的特性&#xff0c;安装 Docker 时需特殊处理 GPG 公钥存储路径。本文结合社区实践&#xff0c;整理出…
阅读更多...
Redis MySQL小结

Redis MySQL小结

问题1&#xff1a;Redis为什么高效&#xff1f;答&#xff1a;基于内存&#xff0c;reactor&#xff0c;value的数据组织&#xff08;五种数据结构&#xff09;&#xff0c;KV的数据组织方式&#xff08;渐进hash&#xff09;问题2&#xff1a;跳表是什么&#xff1f;和红黑树的…
阅读更多...
Flink on YARN 实战问题排查指南（精华版）

Flink on YARN 实战问题排查指南（精华版）

一、客户端常见问题速查 ‌1. JAR加载失败终极解法‌报错提示&#xff1a;"Could not build the program from JAR file" 核心原因&#xff1a;80%的情况是Hadoop依赖缺失 黄金配置&#xff1a;export HADOOP_CONF_DIR${HADOOP_HOME}/etc/hadoop export HADOOP_CLASS…
阅读更多...
迅为RK3576开发板Android12制作使用系统签名

迅为RK3576开发板Android12制作使用系统签名

配套资料在网盘资料“iT0P-RK3576 开发板\02_【iTOP-RK3576 开发板】开发资料\ 08Android 系统开发配套资料\ 07 Android 制作使用系统签名”目录下制作签名文件 在 Android 源码 build/make/target/product/security/下存放着签名文件&#xff0c;如下所示&#xff1a;将北京迅…
阅读更多...
django连接minio实现文件上传下载（提供接口示例）

django连接minio实现文件上传下载（提供接口示例）

django连接minio实现文件上传下载&#xff08;提供接口示例&#xff09;项目环境前提1.模型创建2. 在 settings.py 中添加 MINIO 配置3.创建 MINIO 工具类4.创建序列化器5. 创建视图6. 配置 URL 路由7.接口测试项目环境前提 已安装python3.8以上环境已安装djangorestframework…
阅读更多...
Kafka消息队列进阶：发送策略与分区算法优化指南

Kafka消息队列进阶：发送策略与分区算法优化指南

Kafka消息队列进阶&#xff1a;发送策略与分区算法优化指南 目录Kafka消息队列进阶&#xff1a;发送策略与分区算法优化指南摘要1. Kafka消息发送模式概述1.1 消息发送的核心流程1.2 三种发送模式对比2. 同步发送模式详解2.1 同步发送实现原理2.2 同步发送性能优化3. 异步发送模…
阅读更多...
【VScode】ssh报错

【VScode】ssh报错

【VScode】ssh报错1. ssh报错2. 解决1. ssh报错 Failed to parse remote port from server output 2. 解决 windows电脑删除 C:\Users\username\.ssh\known_hosts linux cd /home/username/.vscode-server/ rm -rf ~/.vscode-server重新回到Vscode连接ok
阅读更多...
Grafana+Loki+Alloy构建企业级日志平台

Grafana+Loki+Alloy构建企业级日志平台

1.日志系统介绍日志系统&#xff1a;GLA、ELK、数仓 ⽇志处理流程&#xff1a;采集 > 存储 > 检索 > 可视化日志系统工作流程&#xff1a;日志平台的目的&#xff1a;统一聚合分散的日志日志平台搭建方案&#xff1a;ELK&#xff1a;ElasticSearch:存储日志&#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023