Spring Boot 整合 Reactive Web

Spring Boot 是一个简化 Spring 应用开发的框架，通过约定优于配置的理念，减少开发人员的工作量。Spring WebFlux 是 Spring 5 引入的一个反应式编程框架，提供了异步的非阻塞式编程模型。结合 Spring Data R2DBC，可以实现对关系数据库（如 MySQL）的非阻塞访问。

这种技术组合适用于高并发、实时性要求高的应用场景，比如实时数据流处理、聊天系统、在线游戏等。

配置及使用

pom 文件

在 pom.xml 中添加 Spring Boot 和相关依赖项：

<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>  
<!-- r2dbc mysql库 -->  
<dependency>  
    <groupId>dev.miku</groupId>  
    <artifactId>r2dbc-mysql</artifactId>  
    <version>0.8.2.RELEASE</version>  
</dependency>  
<!--  r2dbc 连接池 -->  
<dependency>  
    <groupId>io.r2dbc</groupId>  
    <artifactId>r2dbc-pool</artifactId>  
</dependency>  
<dependency>  
    <groupId>com.mysql</groupId>  
    <artifactId>mysql-connector-j</artifactId>  
    <scope>runtime</scope>  
</dependency>  
<dependency>  
    <groupId>org.projectlombok</groupId>  
    <artifactId>lombok</artifactId>  
    <optional>true</optional>  
</dependency>

application.yml

在 src/main/resources 目录下创建 application.yml 配置文件：

spring:  
  r2dbc:  
    url: r2dbc:mysql://localhost:3306/mydb  
    username: root  
    password: mysql@123  
  
  jpa:  
    hibernate:  
      ddl-auto: update  
    show-sql: true  
  
server:  
  port: 8080

实体类

使用 Lombok 定义学生实体类：

package com.jkxiao.reactiveweb.model;  
  
import lombok.Data;  
import org.springframework.data.annotation.Id;  
import org.springframework.data.relational.core.mapping.Table;  
  
@Data  
@Table("student")  
public class Student {  
    @Id  
    private Long id;  
    private String name;  
    private int age;  
    private String email;  
}

仓库接口

定义用于数据库操作的 Repository 接口：

package com.jkxiao.reactiveweb.repository;  
  
import com.jkxiao.reactiveweb.model.Student;  
import org.springframework.data.repository.reactive.ReactiveCrudRepository;  
import org.springframework.stereotype.Repository;  
  
@Repository  
public interface StudentRepository extends ReactiveCrudRepository<Student, Long> {  
}

服务类

实现学生服务类：

package com.jkxiao.reactiveweb.service;  
  
import com.jkxiao.reactiveweb.model.Student;  
import com.jkxiao.reactiveweb.repository.StudentRepository;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import reactor.core.publisher.Flux;  
import reactor.core.publisher.Mono;  
  
@Service  
public class StudentService {  
  
    @Autowired  
    private StudentRepository studentRepository;  
  
    public Flux<Student> getAllStudents() {  
        return studentRepository.findAll();  
    }  
  
    public Mono<Student> getStudentById(Long id) {  
        return studentRepository.findById(id);  
    }  
  
    public Mono<Student> createStudent(Student student) {  
        return studentRepository.save(student);  
    }  
  
    public Mono<Student> updateStudent(Long id, Student student) {  
        return studentRepository.findById(id)  
                .flatMap(existingStudent -> {  
                    existingStudent.setName(student.getName());  
                    existingStudent.setAge(student.getAge());  
                    existingStudent.setEmail(student.getEmail());  
                    return studentRepository.save(existingStudent);  
                });  
    }  
  
    public Mono<Void> deleteStudent(Long id) {  
        return studentRepository.deleteById(id);  
    }  
}

控制器类

创建控制器类处理 HTTP 请求：

package com.jkxiao.reactiveweb.controller;  
  
import com.jkxiao.reactiveweb.model.Student;  
import com.jkxiao.reactiveweb.service.StudentService;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.http.ResponseEntity;  
import org.springframework.web.bind.annotation.*;  
import reactor.core.publisher.Flux;  
import reactor.core.publisher.Mono;  
  
@RestController  
@RequestMapping("/students")  
public class StudentController {  
  
    @Autowired  
    private StudentService studentService;  
  
    @GetMapping  
    public Flux<Student> getAllStudents() {  
        return studentService.getAllStudents();  
    }  
  
    @GetMapping("/{id}")  
    public Mono<ResponseEntity<Student>> getStudentById(@PathVariable Long id) {  
        return studentService.getStudentById(id)  
                .map(ResponseEntity::ok)  
                .defaultIfEmpty(ResponseEntity.notFound().build());  
    }  
  
    @PostMapping  
    public Mono<Student> createStudent(@RequestBody Student student) {  
        return studentService.createStudent(student);  
    }  
  
    @PutMapping("/{id}")  
    public Mono<ResponseEntity<Student>> updateStudent(@PathVariable Long id, @RequestBody Student student) {  
        return studentService.updateStudent(id, student)  
                .map(ResponseEntity::ok)  
                .defaultIfEmpty(ResponseEntity.notFound().build());  
    }  
  
    @DeleteMapping("/{id}")  
    public Mono<ResponseEntity<Void>> deleteStudent(@PathVariable Long id) {  
        return studentService.deleteStudent(id)  
                .map(r -> ResponseEntity.ok().<Void>build())  
                .defaultIfEmpty(ResponseEntity.notFound().build());  
    }  
}

单元测试

编写单元测试类：

package com.jkxiao.reactiveweb.controller;  
  
import com.jkxiao.reactiveweb.model.Student;  
import com.jkxiao.reactiveweb.service.StudentService;  
import org.junit.jupiter.api.Test;  
import org.mockito.Mockito;  
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;  
  
@WebFluxTest(controllers = StudentController.class)  
class StudentControllerTest {  
  
    @Autowired  
    private WebTestClient webTestClient;  
  
    @MockBean  
    private StudentService studentService;  
  
    @Test  
    void getAllStudents() {  
        Student student = new Student();  
        student.setId(1L);  
        student.setName("jeikerxiao");  
        student.setAge(20);  
        student.setEmail("jeikerxiao@example.com");  
  
        Mockito.when(studentService.getAllStudents()).thenReturn(Flux.just(student));  
  
        webTestClient.get().uri("/students")  
                .exchange()  
                .expectStatus().isOk()  
                .expectBody()  
                .jsonPath("$[0].id").isEqualTo(1L)  
                .jsonPath("$[0].name").isEqualTo("jeikerxiao")  
                .jsonPath("$[0].age").isEqualTo(20)  
                .jsonPath("$[0].email").isEqualTo("jeikerxiao@example.com");  
    }  
  
    @Test  
    void getStudentById() {  
        Student student = new Student();  
        student.setId(1L);  
        student.setName("jeikerxiao");  
        student.setAge(20);  
        student.setEmail("jeikerxiao@example.com");  
  
        Mockito.when(studentService.getStudentById(1L)).thenReturn(Mono.just(student));  
  
        webTestClient.get().uri("/students/1")  
                .exchange()  
                .expectStatus().isOk()  
                .expectBody()  
                .jsonPath("$.id").isEqualTo(1L)  
                .jsonPath("$.name").isEqualTo("jeikerxiao")  
                .jsonPath("$.age").isEqualTo(20)  
                .jsonPath("$.email").isEqualTo("jeikerxiao@example.com");  
    }  
  
    @Test  
    void createStudent() {  
        Student student = new Student();  
        student.setId(1L);  
        student.setName("jeikerxiao");  
        student.setAge(20);  
        student.setEmail("jeikerxiao@example.com");  
  
        Mockito.when(studentService.createStudent(student)).thenReturn(Mono.just(student));  
  
        webTestClient.post().uri("/students")  
                .contentType(MediaType.APPLICATION_JSON)  
                .bodyValue(student)  
                .exchange()  
                .expectStatus().isOk()  
                .expectBody()  
                .jsonPath("$.id").isEqualTo(1L)  
                .jsonPath("$.name").isEqualTo("jeikerxiao")  
                .jsonPath("$.age").isEqualTo(20)  
                .jsonPath("$.email").isEqualTo("jeikerxiao@example.com");  
    }  
  
    @Test  
    void updateStudent() {  
        Student student = new Student();  
        student.setId(1L);  
        student.setName("jeikerxiao");  
        student.setAge(21);  
        student.setEmail("jeikerxiao@example.com");  
  
        Mockito.when(studentService.updateStudent(1L, student)).thenReturn(Mono.just(student));  
  
        webTestClient.put().uri("/students/1")  
                .contentType(MediaType.APPLICATION_JSON)  
                .bodyValue(student)  
                .exchange()  
                .expectStatus().isOk()  
                .expectBody()  
                .jsonPath("$.id").isEqualTo(1L)  
                .jsonPath("$.name").isEqualTo("jeikerxiao")  
                .jsonPath("$.age").isEqualTo(21)  
                .jsonPath("$.email").isEqualTo("jeikerxiao@example.com");  
    }  
  
    @Test  
    void deleteStudent() {  
        Mockito.when(studentService.deleteStudent(1L)).thenReturn(Mono.empty());  
  
        webTestClient.delete().uri("/students/1")  
                .exchange()  
                .expectStatus().isOk();  
    }  
}

CURL 测试请求

使用以下 cURL 命令测试各个 API 接口：

1. 创建学生

curl -X POST http://localhost:8080/students \ 
-H "Content-Type: application/json" \ 
-d '{"name": "jeikerxiao", "age": 20, "email": "jeikerxiao@example.com"}'

1. 获取所有学生

curl -X GET http://localhost:8080/students

1. 根据 ID 获取学生

curl -X GET http://localhost:8080/students/1

1. 更新学生信息

curl -X PUT http://localhost:8080/students/1 \ 
-H "Content-Type: application/json" \ 
-d '{"name": "jeikerxiao", "age": 21, "email": "jeikerxiao@example.com"}'

1. 删除学生

curl -X DELETE http://localhost:8080/students/1

注意事项

1. 依赖管理：确保所有依赖项版本匹配，避免版本冲突。依赖管理：确保所有依赖项版本匹配，避免版本冲突。
2. 数据库配置：确保 MySQL 数据库已启动并配置正确的连接信息。

通过以上步骤，我们成功使用 Spring Boot 3.2.5 和 Spring Reactive Web 实现了一个完整的学生 CRUD 功能。