在 Spring 项目中，如何实现对 Restful API 的支持？

在 Spring 项目里实现对 Restful API 的支持，可借助 Spring 的 Spring Web MVC 或 Spring WebFlux 模块。下面分别对这两种方式进行介绍。

使用 Spring Web MVC 实现 Restful API

1. 添加依赖

若使用 Maven 项目，需在 pom.xml 中添加 spring-boot-starter-web 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2. 创建实体类

创建用于表示资源的实体类，例如创建一个 User 类：

public class User {
    private Long id;
    private String name;
    private String email;

    // 构造函数、Getter 和 Setter 方法
    public User() {}

    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

3. 创建控制器

创建一个控制器类，使用 @RestController 注解标记该类，同时使用不同的注解（如 @GetMapping、@PostMapping 等）来处理不同的 HTTP 请求：

import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    private List<User> users = new ArrayList<>();

    // 获取所有用户
    @GetMapping
    public List<User> getAllUsers() {
        return users;
    }

    // 根据 ID 获取用户
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return users.stream()
               .filter(user -> user.getId().equals(id))
               .findFirst()
               .orElse(null);
    }

    // 创建新用户
    @PostMapping
    public User createUser(@RequestBody User user) {
        users.add(user);
        return user;
    }

    // 更新用户信息
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User updatedUser) {
        for (int i = 0; i < users.size(); i++) {
            User user = users.get(i);
            if (user.getId().equals(id)) {
                users.set(i, updatedUser);
                return updatedUser;
            }
        }
        return null;
    }

    // 删除用户
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        users.removeIf(user -> user.getId().equals(id));
    }
}

4. 启动 Spring Boot 应用

创建一个主应用类，使用 @SpringBootApplication 注解标记该类，并启动 Spring Boot 应用：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RestfulApiApplication {
    public static void main(String[] args) {
        SpringApplication.run(RestfulApiApplication.class, args);
    }
}

使用 Spring WebFlux 实现 Restful API

1. 添加依赖

若使用 Maven 项目，需在 pom.xml 中添加 spring-boot-starter-webflux 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

2. 创建实体类

与 Spring Web MVC 中的实体类相同，这里依旧使用 User 类。

3. 创建处理器

创建一个处理器类，处理不同的 HTTP 请求：

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.Flux;
import reactor.core.publisher.Mono;

import java.util.ArrayList;
import java.util.List;

@Component
public class UserHandler {
    private List<User> users = new ArrayList<>();

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

    // 根据 ID 获取用户
    public Mono<ServerResponse> getUserById(ServerRequest request) {
        Long id = Long.parseLong(request.pathVariable("id"));
        Mono<User> userMono = Mono.justOrEmpty(users.stream()
               .filter(user -> user.getId().equals(id))
               .findFirst());
        return userMono.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 -> {
            users.add(user);
            return ServerResponse.ok()
                   .contentType(MediaType.APPLICATION_JSON)
                   .bodyValue(user);
        });
    }

    // 更新用户信息
    public Mono<ServerResponse> updateUser(ServerRequest request) {
        Long id = Long.parseLong(request.pathVariable("id"));
        Mono<User> updatedUserMono = request.bodyToMono(User.class);
        return updatedUserMono.flatMap(updatedUser -> {
            for (int i = 0; i < users.size(); i++) {
                User user = users.get(i);
                if (user.getId().equals(id)) {
                    users.set(i, updatedUser);
                    return ServerResponse.ok()
                           .contentType(MediaType.APPLICATION_JSON)
                           .bodyValue(updatedUser);
                }
            }
            return ServerResponse.notFound().build();
        });
    }

    // 删除用户
    public Mono<ServerResponse> deleteUser(ServerRequest request) {
        Long id = Long.parseLong(request.pathVariable("id"));
        users.removeIf(user -> user.getId().equals(id));
        return ServerResponse.noContent().build();
    }
}

4. 配置路由

创建一个路由配置类，配置不同的路由规则：

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> route(UserHandler userHandler) {
        return RouterFunctions
               .route(GET("/users"), userHandler::getAllUsers)
               .andRoute(GET("/users/{id}"), userHandler::getUserById)
               .andRoute(POST("/users"), userHandler::createUser)
               .andRoute(PUT("/users/{id}"), userHandler::updateUser)
               .andRoute(DELETE("/users/{id}"), userHandler::deleteUser);
    }
}

5. 启动 Spring Boot 应用

创建一个主应用类，使用 @SpringBootApplication 注解标记该类，并启动 Spring Boot 应用：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RestfulApiWebFluxApplication {
    public static void main(String[] args) {
        SpringApplication.run(RestfulApiWebFluxApplication.class, args);
    }
}

总结

• Spring Web MVC：适合传统的同步阻塞式应用，使用注解的方式配置控制器和处理请求，简单直观。
• Spring WebFlux：适合构建响应式、非阻塞的应用，使用函数式编程的方式配置路由和处理请求，能提升应用的性能和吞吐量。