Dubbo 实战指南：从架构原理到高可用落地，解锁分布式服务治理新能力

回家路上绕了弯2025-08-28 11:04

Dubbo 实战指南：从架构原理到高可用落地，解锁分布式服务治理新能力

在微服务架构兴起的背景下，分布式系统中的服务调用、负载均衡、服务治理等问题日益凸显。Apache Dubbo（以下简称 Dubbo）作为一款成熟的分布式服务框架，自 2011 年开源以来，凭借其轻量级、高性能、易扩展的特性，已成为国内互联网企业构建微服务体系的核心工具之一。无论是电商平台的订单服务与支付服务调用，还是金融系统的账户服务与风控服务协作，Dubbo 都能提供稳定、高效的解决方案。

本文将从 Dubbo 的核心架构与工作原理出发，深入讲解服务注册发现、配置实战、负载均衡、高可用设计等关键环节，结合真实业务场景给出落地方案，帮助你快速上手 Dubbo，并解决分布式服务治理中的常见问题。

一、先搞懂：Dubbo 是什么？为何成为微服务架构的 "标配"？

在了解 Dubbo 的具体用法前，我们需要先明确其定位与核心价值 ------ 它并非简单的 "远程调用工具"，而是一套完整的分布式服务治理框架。

1. Dubbo 的核心定位与价值

Dubbo 的核心目标是解决分布式系统中 "服务如何高效调用" 与 "服务如何有效治理" 两大问题，其核心价值体现在三个方面：

  • 高效远程通信：支持多种协议（如 Dubbo、HTTP/2、gRPC），默认的 Dubbo 协议基于 Netty 实现，采用二进制传输，吞吐量高、延迟低，单节点支持每秒数万次调用；
  • 完善服务治理：内置服务注册发现、负载均衡、容错、限流、监控等能力，无需开发者重复造轮子；
  • 轻量易扩展：核心包体积小（仅数 MB），支持自定义协议、过滤器、路由规则，可灵活适配不同业务场景。

2. 与其他微服务框架的对比

目前主流的微服务框架包括 Dubbo、Spring Cloud、gRPC 等，它们的适用场景各有差异：

框架 核心特点 适用场景 优势 劣势
Dubbo 二进制协议、服务治理能力强、轻量级 中大型分布式系统，追求高性能服务调用 调用延迟低、吞吐量高、配置简单 生态相对 Spring Cloud 较窄，侧重服务调用而非全链路
Spring Cloud 基于 Spring 生态、组件丰富（注册中心、网关等） 中小型系统，追求快速搭建微服务体系 生态完善、组件联动性强、学习成本低 基于 HTTP 协议，调用性能略逊于 Dubbo
gRPC 基于 HTTP/2、Protobuf 序列化、跨语言支持好 跨语言服务调用（如 Java 与 Go、Python 交互） 跨语言能力强、序列化效率高 服务治理能力弱，需额外集成注册中心、监控等

结论：若你的系统以 Java 为主，追求高性能服务调用与成熟的服务治理，Dubbo 是最优选择；若需跨语言交互，可考虑 gRPC；若需快速搭建全链路微服务体系，可选择 Spring Cloud（或 Spring Cloud Alibaba，它集成了 Dubbo）。

二、Dubbo 核心架构：5 大组件看懂服务调用流程

Dubbo 的架构设计简洁清晰，核心包含 5 个组件，理解它们的交互逻辑是掌握 Dubbo 的关键。

1. 核心组件与角色

  • Provider：服务提供者，暴露服务接口供其他服务调用；
  • Consumer：服务消费者，调用 Provider 提供的服务；
  • Registry：注册中心，负责服务注册与发现（如 ZooKeeper、Nacos、Etcd），Provider 启动时将服务信息注册到 Registry，Consumer 从 Registry 获取服务列表；
  • Monitor：监控中心，统计服务调用次数、调用延迟、成功率等指标，用于性能分析与问题排查；
  • Container：服务容器，负责启动、加载、运行 Provider（如 Spring 容器）。

2. 完整服务调用流程（图文解析）

Dubbo 的服务调用流程可分为 7 个步骤，结合下图理解更清晰：

  1. 服务注册：Provider 启动时，通过 Container 加载服务接口，将服务名称、IP、端口等信息注册到 Registry；
  1. 服务发现：Consumer 启动时，向 Registry 订阅所需服务，Registry 将 Provider 列表推送给 Consumer（或 Consumer 定期拉取）；
  1. 负载均衡：Consumer 从 Provider 列表中，根据负载均衡策略（如随机、轮询）选择一个 Provider；
  1. 远程调用：Consumer 通过 Dubbo 协议（或其他协议）向选中的 Provider 发起远程调用；
  1. 结果返回：Provider 处理请求后，将结果通过相同协议返回给 Consumer；
  1. 监控上报：Provider 与 Consumer 定期将调用次数、延迟等指标上报给 Monitor；
  1. 服务下线：Provider 关闭前，向 Registry 发送下线请求，Registry 删除该服务信息，并通知 Consumer 更新服务列表。

3. 核心协议与序列化方式

Dubbo 支持多种通信协议与序列化方式，不同组合会影响调用性能，需根据业务场景选择：

（1）通信协议
  • Dubbo 协议（默认） ：基于 Netty 的二进制协议，采用单一长连接、NIO 异步通信，适合 "小数据量、高并发" 场景（如查询接口），不适合传输大数据（如文件上传）；
  • HTTP/2 协议：基于 HTTP/2 的多路复用特性，支持双向流、头部压缩，适合需要跨语言调用或浏览器访问的场景；
  • gRPC 协议：基于 HTTP/2 与 Protobuf，跨语言支持好，序列化效率高，适合跨语言服务交互；
  • Thrift 协议：Apache Thrift 的跨语言协议，适合多语言开发的系统。
（2）序列化方式
  • Hessian2（默认） ：Java 专用序列化方式，序列化效率高、体积小，适合纯 Java 系统；
  • Protobuf：跨语言序列化协议，结构化数据存储效率高，适合跨语言场景；
  • JSON：可读性强，适合调试或简单数据传输，但序列化效率低，不适合高性能场景；
  • Kryo：高性能 Java 序列化框架，效率优于 Hessian2，适合对性能要求极高的场景。

三、Dubbo 实战：从 0 到 1 搭建服务调用（Spring Boot 整合）

Dubbo 官方提供了与 Spring Boot 的整合 starter，配置简单、上手快。下面以 "用户服务（Provider）" 与 "订单服务（Consumer）" 为例，演示完整的服务调用流程。

1. 环境准备

  • JDK：1.8 及以上；
  • 注册中心：以 Nacos 为例（Dubbo 推荐的注册中心，支持服务发现与配置管理）；
  • 依赖管理：使用 Maven，引入 Dubbo Spring Boot Starter 与 Nacos 客户端依赖。

2. 步骤 1：搭建 Nacos 注册中心

（1）下载并启动 Nacos
  • 解压后进入bin目录，执行启动命令：
    • Windows：startup.cmd -m standalone（单机模式）；

3. 步骤 2：开发服务提供者（Provider）

（1）创建 Maven 项目，引入依赖
xml 复制代码 
<dependencies>
    <!-- Spring Boot核心依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <!-- Dubbo Spring Boot Starter -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>3.2.0</version>
    </dependency>
    <!-- Nacos注册中心客户端 -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-registry-nacos</artifactId>
        <version>3.2.0</version>
    </dependency>
    <!-- Nacos配置中心客户端（可选） -->
    <dependency>
        <groupId>com.alibaba.nacos</groupId>
        <artifactId>nacos-client</artifactId>
        <version>2.3.0</version>
    </dependency>
</dependencies>
（2）定义服务接口（API）

创建公共接口，供 Provider 实现与 Consumer 调用（建议将接口单独抽成模块，便于多服务复用）：

kotlin 复制代码 
// com.example.dubbo.api.UserService
public interface UserService {
    // 根据用户ID查询用户信息
    UserDTO getUserById(Long userId);
}
// 数据传输对象（DTO）
@Data
public class UserDTO {
    private Long userId;
    private String username;
    private String phone;
    private Integer age;
}
（3）实现服务接口
java 复制代码 
// com.example.dubbo.provider.service.UserServiceImpl
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.stereotype.Service;
// @DubboService：标记该类为Dubbo服务实现，会自动暴露服务
@DubboService(version = "1.0.0")
@Service // Spring注解，将Bean注入容器
public class UserServiceImpl implements UserService {
    @Override
    public UserDTO getUserById(Long userId) {
        // 模拟数据库查询（实际业务中需调用DAO层）
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId(userId);
        userDTO.setUsername("user_" + userId);
        userDTO.setPhone("1380013800" + userId % 10);
        userDTO.setAge(20 + (int) (userId % 10));
        return userDTO;
    }
}
（4）配置 application.yml
yaml 复制代码 
# 服务端口
server:
  port: 8081
# Spring配置
spring:
  application:
    name: dubbo-user-provider # 服务名称（唯一）
# Dubbo配置
dubbo:
  application:
    name: dubbo-user-provider # 与spring.application.name保持一致
  protocol:
    name: dubbo # 通信协议
    port: -1 # 端口号，-1表示随机分配
  registry:
    address: nacos://localhost:8848 # 注册中心地址（Nacos）
  scan:
    base-packages: com.example.dubbo.provider.service # 扫描@DubboService注解的包
  config-center:
    address: nacos://localhost:8848 # 配置中心地址（可选，用于动态配置）
  metadata-report:
    address: nacos://localhost:8848 # 元数据中心地址（可选，用于服务元数据存储）
（5）启动类
typescript 复制代码 
// com.example.dubbo.provider.DubboUserProviderApplication
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DubboUserProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(DubboUserProviderApplication.class, args);
    }
}

启动 Provider 后，访问 Nacos 控制台的 "服务管理→服务列表"，可看到dubbo-user-provider已注册成功。

4. 步骤 3：开发服务消费者（Consumer）

（1）创建 Maven 项目，引入依赖

依赖与 Provider 类似，只需将服务接口模块引入（若接口单独抽成模块，直接依赖即可）：

xml 复制代码 
<dependencies>
    <!-- Spring Boot Web依赖（用于提供HTTP接口测试） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Dubbo Spring Boot Starter -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>3.2.0</version>
    </dependency>
    <!-- Nacos注册中心客户端 -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-registry-nacos</artifactId>
        <version>3.2.0</version>
    </dependency>
    <!-- 引入服务接口模块 -->
    <dependency>
        <groupId>com.example.dubbo</groupId>
        <artifactId>dubbo-api</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>
（2）调用服务接口

创建 Controller，通过@DubboReference注解注入 Provider 的服务：

kotlin 复制代码 
// com.example.dubbo.consumer.controller.OrderController
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/order")
public class OrderController {
    // @DubboReference：引用Dubbo服务，version需与Provider一致
    @DubboReference(version = "1.0.0", check = false) // check=false：启动时不检查服务是否存在
    private UserService userService;
    // 模拟订单查询，需要调用用户服务获取用户信息
    @GetMapping("/user/{userId}")
    public String getOrderUserInfo(@PathVariable Long userId) {
        UserDTO userDTO = userService.getUserById(userId);
        return "订单关联的用户信息：" + userDTO.toString();
    }
}
（3）配置 application.yml
yaml 复制代码 
# 服务端口（与Provider不同，避免冲突）
server:
  port: 8082
# Spring配置
spring:
  application:
    name: dubbo-order-consumer # 服务名称
# Dubbo配置
dubbo:
  application:
    name: dubbo-order-consumer
  registry:
    address: nacos://localhost:8848 # 注册中心地址，与Provider一致
  config-center:
    address: nacos://localhost:8848
  metadata-report:
    address: nacos://localhost:8848
（4）启动类
typescript 复制代码 
// com.example.dubbo.consumer.DubboOrderConsumerApplication
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DubboOrderConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(DubboOrderConsumerApplication.class, args);
    }
}

5. 测试服务调用

启动 Consumer 后，访问http://localhost:8082/order/user/1，若返回以下结果，说明服务调用成功：

ini 复制代码 
订单关联的用户信息：UserDTO(userId=1, username=user_1, phone=13800138001, age=21)

四、Dubbo 核心特性实战：负载均衡、容错与限流

Dubbo 的服务治理能力是其核心优势，掌握负载均衡、容错、限流等特性，能让你的分布式系统更稳定、更可靠。

1. 负载均衡：合理分配请求压力

当 Provider 集群部署时，Consumer 需要通过负载均衡策略选择一个 Provider，避免单个节点压力过大。Dubbo 内置 4 种负载均衡策略，可通过注解或配置指定。

（1）内置负载均衡策略
策略名称 特点 适用场景
Random（默认） 随机选择，权重越高的节点被选中概率越大 大多数场景，均衡分配压力
RoundRobin 轮询选择，按权重依次分配请求 需均匀分配请求的场景（如秒杀预热）
LeastActive 选择活跃调用数最少的节点（活跃数 = 当前调用数 - 已完成调用数） 避免慢节点接收过多请求，适合请求耗时差异大的场景
ConsistentHash 一致性哈希，相同参数的请求路由到同一节点 需会话粘滞的场景（如用户会话相关查询）
（2）配置方式
  • 在 Consumer 端通过注解指定：
kotlin 复制代码 
@DubboReference(version = "1.0.0", loadbalance = "roundrobin") // 轮询策略
private UserService userService;
  • 在 Provider 端设置权重（影响 Random、RoundRobin 策略） ：
kotlin 复制代码 
@DubboService(version = "1.0.0", weight = 2) // 权重设为2（默认1），被选中概率是其他节点的2倍
public class UserServiceImpl implements UserService { ... }

2. 容错机制：服务故障时的 "应急预案"

当 Provider 出现故障（如网络中断、服务宕机）时，Dubbo 的容错机制能避免 Consumer 直接抛出异常，保证业务连续性。内置 5 种容错策略，可通过cluster参数配置。

（1）内置容错策略
策略名称 特点 适用场景
Failover（默认） 失败重试，当调用失败时，重试其他 Provider（默认重试 2 次） 读操作（如查询），允许少量重试开销
Failfast 快速失败，调用失败后立即抛出异常，不重试 写操作（如订单创建），避免重复执行
Failsafe 失败安全，调用失败时返回空结果或默认值，不抛出异常 非核心操作（如日志上报），不影响主流程
Failback 失败自动恢复，调用失败后异步重试（默认 5 秒重试一次） 需保证最终成功的操作（如消息发送）
Forking 并行调用多个 Provider，只要有一个成功就返回结果（默认并行 2 个） 需快速获取结果的场景，容忍额外资源开销
（2）配置方式
kotlin 复制代码 
// 读操作使用Failover策略，重试3次
@DubboReference(version = "1.0.0", cluster = "failover", retries = 3)
private UserService userService;
// 写操作使用Failfast策略，不重试
@DubboReference(version = "1.0.0", cluster = "failfast")
private OrderService orderService;

3. 限流机制：防止服务被 "压垮"

当并发请求超过 Provider 的处理能力时，限流机制能限制请求数量，避免服务过载。Dubbo 支持多种限流方式，常用的有 "令牌桶限流" 和 "并发数限流"。

（1）并发数限流（限制同时处理的请求数）

在 Provider 端配置，限制单个服务的最大并发处理数：

kotlin 复制代码 
@DubboService(version = "1.0.0", executes = 100) // 最大并发数100，超过则排队或拒绝
public class UserServiceImpl implements UserService { ... }
（2）令牌桶限流（限制每秒处理的请求数）

需结合 Dubbo 的 "令牌桶过滤器"，在配置文件中添加：

yaml 复制代码 
dubbo:
  provider:
    filter: tokenlimit # 启用令牌桶限流过滤器
  parameters:
    tokenlimit.rate: 500 # 每秒生成500个令牌，即每秒最多处理500个请求
    tokenlimit.burst: 100 # 令牌桶最大容量，允许短时间突发请求

五、Dubbo 问题排查：3 大工具快速定位故障

在分布式系统中，服务调用故障排查难度大，Dubbo 提供了多种工具帮助开发者快速定位问题。

1. 日志排查：开启详细日志

Dubbo 的日志默认级别为 INFO，若需查看详细调用信息（如请求参数、响应结果、调用耗时），可将日志级别调整为 DEBUG。

在logback.xml（或 log4j2.xml）中配置：

ini 复制代码 
<logger name="org.apache.dubbo" level="DEBUG" additivity="false">
    <appender-ref ref="CONSOLE"/>
    <appender-ref ref="FILE"/>
</logger>

开启后，日志会输出类似以下内容：

ini 复制代码 
DEBUG [DubboClientHandler-127.0.0.1:20880-thread-1] org.apache.dubbo.rpc.protocol.dubbo.DubboCodec: [DUBBO] Decode reply message id=1, result=UserDTO(...), cost=12ms, channel=127.0.0.1:54321 -> 127.0.0.1:20880

2. Dubbo Admin：可视化管理平台

Dubbo Admin 是官方提供的可视化管理工具，支持服务列表查看、配置管理、负载均衡调整、调用追踪等功能，是排查问题的 "利器"。

（1）部署 Dubbo Admin
  • 修改application.yml中的注册中心地址（与项目一致，如 Nacos）；
  • 编译打包：mvn clean package -Dmaven.test.skip=true；
  • 启动：java -jar dubbo-admin-server/target/dubbo-admin-server-0.5.0.jar；
（2）核心功能
  • 服务查询：查看 Provider/Consumer 列表，查看服务接口、版本、IP 等信息；
  • 调用测试：直接在页面调用 Provider 接口，验证服务是否正常；
  • 配置管理：动态修改负载均衡、容错策略、限流参数，无需重启服务；
  • 监控统计：查看服务调用次数、延迟分布、成功率，定位性能瓶颈。

3. 链路追踪：集成 SkyWalking

当服务调用链路较长（如 Consumer→A 服务→B 服务→C 服务）时，需通过链路追踪工具查看完整调用链，定位哪个环节出现问题。Dubbo 可与 SkyWalking 集成，实现全链路追踪。

（1）集成步骤
  • 在 Provider 与 Consumer 的 JVM 参数中添加：
ini 复制代码 
-javaagent:/path/to/skywalking-agent.jar
-Dskywalking.agent.service_name=dubbo-user-provider # Provider服务名
-Dskywalking.collector.backend_service=localhost:11800 # SkyWalking OAP地址
  • 启动服务后，访问 SkyWalking UI（默认http://localhost:8080），在 "链路追踪" 中可查看完整调用链，包括每个服务的调用耗时、异常信息。

六、Dubbo 高可用设计：5 个实战技巧

要构建高可用的 Dubbo 系统，除了使用内置特性，还需结合架构设计与部署策略，以下是 5 个关键技巧：

1. 注册中心高可用：避免单点故障

注册中心是 Dubbo 的 "大脑"，若注册中心宕机，Consumer 无法获取服务列表，会导致服务调用失败。因此需部署注册中心集群：

  • Nacos 集群：至少部署 3 个节点，通过 Raft 协议保证数据一致性；
  • Dubbo 配置：Consumer 与 Provider 的注册中心地址配置为多个节点，用逗号分隔：
yaml 复制代码 
dubbo:
  registry:
    address: nacos://node1:8848?backup=node2:8848,node3:8848

2. 服务降级：非核心服务 "让资源"

当系统整体负载过高（如秒杀高峰期），可降级非核心服务（如用户画像查询），释放资源给核心服务（如订单创建）。Dubbo 支持两种降级方式：

  • 静态降级：在 Consumer 端配置降级策略，当服务调用失败时返回默认值：
kotlin 复制代码 
@DubboReference(version = "1.0.0", mock = "com.example.dubbo.consumer.mock.UserServiceMock")
private UserService userService;
// 降级实现类
public class UserServiceMock implements UserService {
    @Override
    public UserDTO getUserById(Long userId) {
        // 降级返回默认用户信息
        UserDTO mockUser = new UserDTO();
        mockUser.setUserId(userId);
        mockUser.setUsername("default_user");
        return mockUser;
    }
}
  • 动态降级：通过 Dubbo Admin 或配置中心，实时开启 / 关闭降级，无需重启服务。

3. 超时设置：避免 "长耗时请求" 阻塞线程

若 Provider 处理请求耗时过长（如数据库慢查询），会导致 Consumer 的线程被阻塞，最终引发线程池耗尽。因此需为每个服务设置合理的超时时间：

kotlin 复制代码 
// Consumer端设置超时时间（单位：毫秒），优先于Provider端配置
@DubboReference(version = "1.0.0", timeout = 3000) // 超时时间3秒
private UserService userService;
// Provider端设置超时时间（作为默认值）
@DubboService(version = "1.0.0", timeout = 2000) // 超时时间2秒
public class UserServiceImpl implements UserService { ... }

建议：超时时间设置为 "99% 的请求耗时"+ 缓冲时间（如 99% 的请求耗时 1 秒，超时时间设为 2 秒）。

4. 线程池配置：优化服务处理能力

Dubbo 的 Provider 与 Consumer 均使用线程池处理请求，合理配置线程池参数能提升服务吞吐量。常用的线程池类型为fixed（固定大小线程池）。

（1）Provider 端线程池配置
yaml 复制代码 
dubbo:
  provider:
    threadpool: fixed # 线程池类型：fixed（固定）、cached（缓存）、limited（有限）
    threads: 200 # 核心线程数（固定线程池的线程数）
    queues: 100 # 队列大小，请求超过线程数时排队，队列满则拒绝请求
（2）Consumer 端线程池配置
yaml 复制代码 
dubbo:
  consumer:
    threadpool: fixed
    threads: 100
    queues: 50

5. 数据一致性：避免分布式事务问题

Dubbo 调用是跨服务的，若涉及多服务数据修改（如订单创建时扣减库存），需保证数据一致性。常用方案有：

  • TCC（Try-Confirm-Cancel） ：适合复杂业务场景，如金融转账；
  • SAGA：适合长事务场景，如订单履约（下单→支付→发货）；
  • 本地消息表：适合非实时一致性场景，如日志同步、消息通知；
  • 集成 Seata：Alibaba 开源的分布式事务框架，支持 AT、TCC、SAGA 等模式，可与 Dubbo 无缝集成。

七、总结：Dubbo 的进阶之路

Dubbo 作为一款成熟的分布式服务框架，从基础的服务调用到复杂的服务治理，再到高可用架构设计，为开发者提供了完整的解决方案。掌握 Dubbo 的核心步骤可分为 3 个阶段：

  1. 入门阶段：理解核心架构与服务调用流程，能通过 Spring Boot 整合 Dubbo 实现简单服务调用；
  1. 进阶阶段：熟练使用负载均衡、容错、限流等核心特性，能通过 Dubbo Admin 与链路追踪工具排查问题；
  1. 高级阶段：结合业务场景设计高可用架构，解决注册中心集群、服务降级、分布式事务等复杂问题。

随着 Dubbo 3.x 版本的发布，官方新增了服务网格（Service Mesh）支持、Triple 协议（基于 HTTP/2，兼容 gRPC）等特性，进一步拓展了 Dubbo 的适用场景。未来，Dubbo 将在云原生领域持续发力，成为连接传统微服务与云原生架构的重要桥梁。

如果你在 Dubbo 实战中遇到了问题（如服务注册失败、调用超时），欢迎在评论区分享场景，一起探讨解决方案！

相关推荐
花妖大人几秒前
Python写成接口
后端
得物技术1 分钟前
可扩展系统设计的黄金法则与Go语言实践｜得物技术
后端·go
莹莹啦1 分钟前
聊一聊Java线程池的核心参数
java·后端
訾博ZiBo9 分钟前
Python虚拟环境完全指南：从入门到精通
后端
SimonKing26 分钟前
优雅地实现ChatGPT式的打字机效果：Spring流式响应
java·后端·程序员
xiaok28 分钟前
Nginx代理URL路径拼接问题（页面报404）
后端
咖啡Beans30 分钟前
干货：敏感数据实现加解密脱敏？Hutool的AES+hide一气呵成
后端
IT_陈寒2 小时前
Python开发者必知的5个高效技巧，让你的代码速度提升50%！
前端·人工智能·后端
谦行3 小时前
Andrej Karpathy 谈持续探索最佳大语言模型辅助编程体验之路
后端
热门推荐
01UV安装并设置国内源02不再让Windows更新！&Edge游戏助手卸载及关闭自动更新03KGG转MP3工具|非KGM文件|解密音频04Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code05【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）06突破百度网盘的下载限速，两种方法教会你【超详细】07Linux下V2Ray安装配置指南08Claude Code VSCode集成开发指南：AI编程助手完整配置0937、需求预测与库存优化 (快消品) - /供应链管理组件/fmcg-inventory-optimization10jdk21下载、安装（Windows、Linux、macOS）