当前位置： 首页 > article >正文

Spring Boot RESTful API 开发、测试与调试

article 2024/10/21 2:58:58
引言

在现代Web开发中，RESTful API 是一种非常流行的设计风格，它基于 HTTP 协议，提供了简单、灵活的方式来构建网络应用。Spring Boot 作为一款强大的微服务框架，提供了丰富的工具和支持，使得开发 RESTful API 变得更加便捷。本文将详细介绍如何在 Spring Boot 中开发、测试和调试 RESTful API，并结合大厂的最佳实践，深入探讨底层核心原理。

1. 开发 RESTful API
1.1 创建 Spring Boot 项目

首先，我们需要创建一个 Spring Boot 项目。可以通过 Spring Initializr （https://start.spring.io/） 快速生成项目骨架。选择以下依赖：

  • Spring Web
  • Lombok
  • Spring Boot DevTools

生成项目后，导入到 IDE 中。

1.2 定义 RESTful 控制器

在 Spring Boot 中，RESTful API 的控制器通常使用 @RestController 注解标记。以下是一个简单的示例：

import org.springframework.web.bind.annotation.*;

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

    @GetMapping
    public List<User> getAllUsers() {
        // 返回所有用户
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        // 根据 ID 获取用户
        return userService.getUserById(id);
    }

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

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        // 更新用户信息
        return userService.updateUser(id, user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        // 删除用户
        userService.deleteUser(id);
    }
}
1.3 处理异常

在 RESTful API 中，处理异常是非常重要的。Spring Boot 提供了 @ControllerAdvice 注解，可以用来全局处理异常。以下是一个示例：

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex) {
        ErrorResponse error = new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception ex) {
        ErrorResponse error = new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

class ErrorResponse {
    private int status;
    private String message;

    public ErrorResponse(int status, String message) {
        this.status = status;
        this.message = message;
    }

    // Getters and Setters
}
2. 测试 RESTful API
2.1 单元测试

单元测试是确保代码质量的重要手段。Spring Boot 提供了 @WebMvcTest 注解，可以用来测试控制器。以下是一个示例：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.web.servlet.MockMvc;

import java.util.Arrays;
import java.util.List;

import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(controllers = UserController.class)
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    public void shouldReturnDefaultMessage() throws Exception {
        List<User> users = Arrays.asList(new User(1L, "John Doe"), new User(2L, "Jane Doe"));
        when(userService.getAllUsers()).thenReturn(users);

        mockMvc.perform(get("/api/v1/users"))
                .andExpect(status().isOk())
                .andExpect(content().json("[{\"id\":1,\"name\":\"John Doe\"},{\"id\":2,\"name\":\"Jane Doe\"}]"));
    }
}
2.2 集成测试

集成测试用于验证整个系统的功能。Spring Boot 提供了 @SpringBootTest 注解，可以用来进行集成测试。以下是一个示例：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.ResponseEntity;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class UserControllerIntegrationTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void shouldReturnDefaultMessage() {
        ResponseEntity<List<User>> response = restTemplate.getForEntity("/api/v1/users", List.class);
        assertEquals(HttpStatus.OK, response.getStatusCode());
        assertEquals(2, response.getBody().size());
    }
}
3. 调试 RESTful API
3.1 使用 Postman 进行调试

Postman 是一个非常流行的 API 测试工具，可以帮助开发者方便地发送 HTTP 请求并查看响应。以下是一个简单的示例：

  1. 打开 Postman。
  2. 创建一个新的请求。
  3. 选择请求类型（GET、POST、PUT、DELETE）。
  4. 输入请求 URL（例如：http://localhost:8080/api/v1/users）。
  5. 发送请求并查看响应。
3.2 使用 IDE 进行调试

大多数现代 IDE 都支持断点调试。以下是在 IntelliJ IDEA 中进行调试的步骤：

  1. 在控制器方法中设置断点。
  2. 启动应用的调试模式。
  3. 使用 Postman 或其他工具发送请求。
  4. 当请求到达断点时，IDE 将暂停执行，允许你查看变量值、调用堆栈等信息。
4. Spring Boot RESTful API 最佳实践
4.1 使用 HATEOAS

HATEOAS（Hypermedia As The Engine Of Application State）是一种设计原则，通过在响应中包含链接，使客户端能够发现和导航 API。Spring Boot 提供了 spring-hateoas 模块来支持这一原则。以下是一个示例：

import org.springframework.hateoas.EntityModel;
import org.springframework.hateoas.server.RepresentationModelAssembler;
import org.springframework.hateoas.server.mvc.WebMvcLinkBuilder;
import org.springframework.stereotype.Component;

@Component
public class UserAssembler implements RepresentationModelAssembler<User, EntityModel<User>> {

    @Override
    public EntityModel<User> toModel(User user) {
        return EntityModel.of(user,
                WebMvcLinkBuilder.linkTo(WebMvcLinkBuilder.methodOn(UserController.class).getUserById(user.getId())).withSelfRel(),
                WebMvcLinkBuilder.linkTo(WebMvcLinkBuilder.methodOn(UserController.class).getAllUsers()).withRel("users"));
    }
}
4.2 使用 Swagger 文档

Swagger 是一个规范和完整的框架，用于生成、描述、调用和可视化 RESTful 风格的 Web 服务。Spring Boot 提供了 springfox-swagger2 和 springfox-swagger-ui 模块来支持 Swagger。以下是一个示例：

  1. 添加依赖：
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>
  1. 配置 Swagger：
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@EnableSwagger2
@Configuration
public class SwaggerConfig {

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.demo.controller"))
                .paths(PathSelectors.any())
                .build();
    }
}
  1. 访问 Swagger UI：启动应用后，访问 http://localhost:8080/swagger-ui.html。
4.3 使用 JWT 进行认证

JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在网络应用环境间安全地传输信息。Spring Boot 提供了多种方式来集成 JWT。以下是一个简单的示例：

  1. 添加依赖：
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
  1. 配置 JWT：
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

@Service
public class JwtUtil {

    private String secret = "secret";

    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }

    public Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }

    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }

    private Claims extractAllClaims(String token) {
        return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }

    private Boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }

    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        return createToken(claims, userDetails.getUsername());
    }

    private String createToken(Map<String, Object> claims, String subject) {
        return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10))
                .signWith(SignatureAlgorithm.HS256, secret).compact();
    }

    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = extractUsername(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
}
  1. 配置安全：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class JwtRequestFilter extends OncePerRequestFilter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private JwtUtil jwtUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {

        final String authorizationHeader = request.getHeader("Authorization");

        String username = null;
        String jwt = null;

        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);

            if (jwtUtil.validateToken(jwt, userDetails)) {
                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken
                        .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }
        chain.doFilter(request, response);
    }
}
5. Spring Boot RESTful API 面试题解析
5.1 什么是 RESTful API？

答案：RESTful API 是一种基于 HTTP 协议的设计风格，用于构建网络应用。它强调使用标准的 HTTP 方法（如 GET、POST、PUT、DELETE）来操作资源，并通过 URI 来标识资源。

5.2 如何在 Spring Boot 中创建 RESTful API？

答案：在 Spring Boot 中，可以使用 @RestController 注解标记控制器类，并使用 @RequestMapping、@GetMapping、@PostMapping 等注解来定义 API 接口。例如：

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

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }
}
5.3 如何处理 RESTful API 中的异常？

答案：可以使用 @ControllerAdvice 注解来全局处理异常。例如：

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex) {
        ErrorResponse error = new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }
}
5.4 如何测试 RESTful API？

答案：可以使用 @WebMvcTest 注解进行单元测试，使用 @SpringBootTest 注解进行集成测试。例如：

@WebMvcTest(controllers = UserController.class)
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    public void shouldReturnDefaultMessage() throws Exception {
        List<User> users = Arrays.asList(new User(1L, "John Doe"), new User(2L, "Jane Doe"));
        when(userService.getAllUsers()).thenReturn(users);

        mockMvc.perform(get("/api/v1/users"))
                .andExpect(status().isOk())
                .andExpect(content().json("[{\"id\":1,\"name\":\"John Doe\"},{\"id\":2,\"name\":\"Jane Doe\"}]"));
    }
}
5.5 如何使用 Swagger 文档？

答案：可以添加 springfox-swagger2 和 springfox-swagger-ui 依赖，并配置 Swagger。启动应用后，访问 http://localhost:8080/swagger-ui.html 即可查看 API 文档。

6. 总结

通过本文，我们详细介绍了如何在 Spring Boot 中开发、测试和调试 RESTful API，并结合大厂的最佳实践，深入探讨了底层核心原理。希望本文对你有所帮助，欢迎继续关注后续文章！

7. 扩展阅读
  • 官方文档：Spring Boot Reference Guide
  • Spring Boot 官网：Spring Boot Official Website
  • 书籍推荐：《Spring Boot in Action》、《Spring Boot Recipes》

如果你有任何疑问或建议，欢迎在评论区留言交流！


http://www.kler.cn/news/358144.html

相关文章：

  • 127-4通道 12bit 125Msps 直流耦合 AD FMC 子卡
  • Kafka-设计思想-1
  • 基于百度智能体开发爱情三十六计
  • Linux——软件安装操作命令
  • 【JavaEE初阶】深入理解网络编程—使用UDP协议API实现回显服务器
  • 数据库原理图
  • STM32F1+HAL库+FreeTOTS学习18——任务通知
  • ubuntu 安装keepalived+haproxy
  • Linux小知识2 系统的启动
  • docker搭建etcd集群环境方式
  • J.D商品详情，一“网”打尽 —— PHP爬虫API数据获取全攻略
  • springcloud之服务集群注册与发现 Eureka
  • 递归、搜索与回溯（二）——递归练习与快速幂
  • sqli-labs less-26 空格绕过
  • 各种排序方法总结
  • Git 多环境(平台)密钥配置（与 gitee和 github上的俩个项目）
  • 即懂——XML Schema的名称空间
  • 【二维数组】对称图形
  • 2024_E_100_连续字母长度
  • ESP32-C3 入门笔记04：gpio_key 按键 (ESP-IDF + VSCode)