常见的http状态码 + ResponseEntity

常见的http状态码

@ResponseStatus(HttpStatus.CREATED) 是 Spring Framework 中的注解，用于指定 HTTP 响应状态码。
1. 基本阐明

• HttpStatus.CREATED 对应 HTTP 状态码 201
  
• 表现哀求成功且创建了新的资源
  
• 通常用于 POST 哀求的处置惩罚方法上
  

2. 利用场景和示例

基本利用

1. @RestController
2. @RequestMapping("/api/users")
3. public class UserController {
5.     @PostMapping
6.     @ResponseStatus(HttpStatus.CREATED)  // 将返回 201 状态码
7.     public User createUser(@RequestBody User user) {
8.         return userService.createUser(user);
9.     }
10. }

复制代码

带有详细响应的利用

1. @RestController
2. @RequestMapping("/api/products")
3. public class ProductController {
5.     @PostMapping
6.     @ResponseStatus(HttpStatus.CREATED)
7.     public ResponseEntity<Product> createProduct(@RequestBody Product product) {
8.         Product savedProduct = productService.save(product);
9.         
10.         // 创建资源的 URI
11.         URI location = ServletUriComponentsBuilder
12.             .fromCurrentRequest()
13.             .path("/{id}")
14.             .buildAndExpand(savedProduct.getId())
15.             .toUri();
17.         // 返回 201 状态码和资源位置
18.         return ResponseEntity
19.             .created(location)
20.             .body(savedProduct);
21.     }
22. }

复制代码

3. 常用的 HTTP 状态码注解

1. // 成功相关
2. @ResponseStatus(HttpStatus.OK)           // 200 - 请求成功，返回资源或结果
3. @ResponseStatus(HttpStatus.CREATED)      // 201 - 资源创建成功
4. @ResponseStatus(HttpStatus.NO_CONTENT)   // 204 - 成功但无返回内容
6. // 客户端错误
7. @ResponseStatus(HttpStatus.BAD_REQUEST)         // 400 - 请求格式错误,客户端请求无效
8. @ResponseStatus(HttpStatus.UNAUTHORIZED)        // 401 - 未授权，需身份验证
9. @ResponseStatus(HttpStatus.FORBIDDEN)           // 403 - 禁止访问
10. @ResponseStatus(HttpStatus.NOT_FOUND)          // 404 - 资源未找到
11. @ResponseStatus(HttpStatus.CONFLICT)           // 409 - 资源冲突
13. // 服务器错误
14. @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) // 500 - 服务器内部错误

复制代码

假如需要更灵活地设置响应内容（如返回自定义的响应体或头部信息），可以利用 ResponseEntity，而不是 @ResponseStatus
@ResponseStatus 是一种简洁的方式，用于指定固定的 HTTP 状态码，但它的功能相对有限。假如需要更灵活地设置响应内容（如自定义响应体、响应头、动态状态码等），可以利用 ResponseEntity。

---

1. 为什么选择 ResponseEntity？

ResponseEntity 是 Spring 提供的一个强大的工具，用于构建 HTTP 响应。它允许你：

• 动态设置 HTTP 状态码
  
• 自定义响应头
  
• 返回复杂的响应体
  
• 更灵活地处置惩罚不同的场景
  

---

2. ResponseEntity 的基本用法

示例 1: 返回自定义状态码和响应体

1. @PostMapping("/users")
2. public ResponseEntity<String> createUser(@RequestBody UserRequest userRequest) {
3.     userService.createUser(userRequest);
4.     return ResponseEntity.status(HttpStatus.CREATED).body("User created successfully");
5. }

复制代码

• ResponseEntity.status(HttpStatus.CREATED)：设置 HTTP 状态码为 201 Created。
  
• .body("User created successfully")：设置响应体为自定义的字符串。
  

---

示例 2: 返回带有响应头的信息

1. @PostMapping("/users")
2. public ResponseEntity<String> createUser(@RequestBody UserRequest userRequest) {
3.     userService.createUser(userRequest);
5.     // 设置自定义响应头
6.     HttpHeaders headers = new HttpHeaders();
7.     headers.add("Custom-Header", "CustomHeaderValue");
9.     return ResponseEntity.status(HttpStatus.CREATED)
10.                          .headers(headers)
11.                          .body("User created successfully");
12. }

复制代码

• HttpHeaders：用于设置响应头。
  
• .headers(headers)：将自定义的响应头添加到响应中。
  

---

示例 3: 返回带有资源位置的响应

在 RESTful API 中，创建资源后通常会返回 Location 头，指向新创建资源的 URI。

1. @PostMapping("/users")
2. public ResponseEntity<Void> createUser(@RequestBody UserRequest userRequest) {
3.     Long userId = userService.createUser(userRequest);
5.     // 构造资源的 URI
6.     URI location = ServletUriComponentsBuilder
7.         .fromCurrentRequest()
8.         .path("/{id}")
9.         .buildAndExpand(userId)
10.         .toUri();
12.     // 返回 201 Created 和 Location 头
13.     return ResponseEntity.created(location).build();
14. }

复制代码

• ServletUriComponentsBuilder：用于动态构建资源的 URI。
  
• .created(location)：设置状态码为 201 Created，并添加 Location 头。
  

---

示例 4: 动态返回不同的状态码

1. @PostMapping("/users")
2. public ResponseEntity<String> createUser(@RequestBody UserRequest userRequest) {
3.     if (userService.isDuplicate(userRequest)) {
4.         return ResponseEntity.status(HttpStatus.CONFLICT).body("User already exists");
5.     }
7.     userService.createUser(userRequest);
8.     return ResponseEntity.status(HttpStatus.CREATED).body("User created successfully");
9. }

复制代码

• 假如用户已存在，返回 409 Conflict。
  
• 假如创建成功，返回 201 Created。
  

---

3. 与 @ResponseStatus 的对比

特性@ResponseStatusResponseEntity设置状态码固定状态码，不能动态设置可以动态设置状态码自定义响应体不支持支持返回任意范例的响应体自定义响应头不支持支持通过 HttpHeaders 设置响应头实用场景简单场景，状态码固定复杂场景，需要动态响应代码简洁性更简洁代码稍显冗长

---

4. 综合示例：联合异常处置惩罚

自定义异常类

1. @ResponseStatus(HttpStatus.NOT_FOUND) // 默认返回 404
2. public class UserNotFoundException extends RuntimeException {
3.     public UserNotFoundException(String message) {
4.         super(message);
5.     }
6. }

复制代码

利用 ResponseEntity 处置惩罚异常

1. @RestController
2. @RequestMapping("/users")
3. public class UserController {
5.     @GetMapping("/{id}")
6.     public ResponseEntity<User> getUser(@PathVariable Long id) {
7.         User user = userService.findById(id)
8.             .orElseThrow(() -> new UserNotFoundException("User not found with id: " + id));
10.         return ResponseEntity.ok(user); // 返回 200 和用户信息
11.     }
13.     @ExceptionHandler(UserNotFoundException.class)
14.     public ResponseEntity<ErrorResponse> handleUserNotFound(UserNotFoundException ex) {
15.         ErrorResponse errorResponse = new ErrorResponse("USER_NOT_FOUND", ex.getMessage());
16.         return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
17.     }
18. }

复制代码

• @ExceptionHandler：捕捉异常并返回自定义的响应。
  
• ErrorResponse：自定义的错误响应体。
  

---

5. 总结

• @ResponseStatus：得当简单场景，状态码固定，代码简洁。
  
• ResponseEntity：得当复杂场景，允许动态设置状态码、响应头和响应体。
  

假如你的需求需要动态响应内容（如返回资源位置、错误信息、或自定义头部信息），ResponseEntity 是更灵活的选择。通过利用 ResponseEntity，我们可以更精确地控制 HTTP 响应的各个方面，使 API 更加灵活和专业。这对于构建复杂的 RESTful API 特别有用，由于它允许我们根据不同的业务场景返回不同的响应。
@RestController/@ResponseBody + ResponseEntity

利用 @RestController 或 @ResponseBody 返回对象时，Spring 会自动将返回的对象序列化为 JSON 并写入响应体，@RestController 或 @ResponseBody 返回的对象会自动设置状态码为 200 OK。 缺点：无法直接设置响应头或动态状态码。利用 @RestController 或 @ResponseBody 返回对象 假如需要返回特定的 HTTP 状态码，可以联合 ResponseEntity 利用。
利用 @RestController 或 @ResponseBody 直接返回对象时的重要缺点是无法直接设置响应头或动态状态码。以下是这些限制的详细阐明和办理方案：
1. 基本限制示例

1. @RestController
2. @RequestMapping("/api/users")
3. public class UserController {
4.    
5.     // 直接返回对象的方式
6.     @GetMapping("/{id}")
7.     @ResponseBody
8.     public User getUser(@PathVariable Long id) {
9.         return userService.findById(id);  // 只能返回 200 OK
10.     }
11.    
12.     // 无法直接设置响应头
13.     @PostMapping
14.     @ResponseBody
15.     public User createUser(@RequestBody User user) {
16.         return userService.save(user);  // 应该返回 201 Created，但只能是 200 OK
17.     }
18. }

复制代码

2. 重要限制

• 状态码限制：
  
  
  
  • 默认总是返回 200 OK
    
  • 无法动态设置状态码
    
  • 无法返回创建成功（201）等特定状态码
    
  
  
• 响应头限制：
  
  
  
  • 无法添加自定义响应头
    
  • 无法设置 Content-Disposition 等特别头部
    
  • 无法控制缓存相关头部
    
  
  
• 错误处置惩罚限制：
  
  
  
  • 无法直接返回错误状态码
    
  • 需要依赖全局异常处置惩罚
    
  
  

3. 办理方案

方案一：利用 ResponseEntity

1. @RestController
2. @RequestMapping("/api/users")
3. public class UserController {
5.     // 使用 ResponseEntity 返回特定状态码
6.     @PostMapping
7.     public ResponseEntity<User> createUser(@RequestBody User user) {
8.         User savedUser = userService.save(user);
9.         return ResponseEntity
10.             .status(HttpStatus.CREATED)
11.             .body(savedUser);
12.     }
14.     // 设置自定义响应头
15.     @GetMapping("/{id}")
16.     public ResponseEntity<User> getUser(@PathVariable Long id) {
17.         return userService.findById(id)
18.             .map(user -> ResponseEntity.ok()
19.                 .header("X-Custom-Header", "value")
20.                 .body(user))
21.             .orElse(ResponseEntity.notFound().build());
22.     }
23. }

复制代码

方案二：利用 HttpServletResponse

1. @RestController
2. @RequestMapping("/api/users")
3. public class UserController {
5.     // 注入 HttpServletResponse
6.     @PostMapping("/manual")
7.     @ResponseBody
8.     public User createUserManual(
9.             @RequestBody User user,
10.             HttpServletResponse response) {
11.         User savedUser = userService.save(user);
12.         response.setStatus(HttpServletResponse.SC_CREATED);
13.         response.setHeader("X-Custom-Header", "value");
14.         return savedUser;
15.     }
16. }

复制代码

方案三：利用统一响应包装类

1. // 统一响应包装类
2. public class ApiResponse<T> {
3.     private int code;
4.     private String message;
5.     private T data;
6.     private Map<String, String> headers = new HashMap<>();
8.     // 构造方法和静态工厂方法
9.     public static <T> ApiResponse<T> success(T data) {
10.         return new ApiResponse<>(200, "Success", data);
11.     }
13.     public static <T> ApiResponse<T> created(T data) {
14.         return new ApiResponse<>(201, "Created", data);
15.     }
16. }
18. // 使用响应包装类的控制器
19. @RestController
20. @RequestMapping("/api/users")
21. public class UserController {
23.     @PostMapping
24.     public ApiResponse<User> createUser(@RequestBody User user) {
25.         User savedUser = userService.save(user);
26.         return ApiResponse.created(savedUser);
27.     }
28. }
30. // 响应拦截器
31. @Component
32. public class ApiResponseInterceptor implements ResponseBodyAdvice<ApiResponse<?>> {
34.     @Override
35.     public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
36.         return ApiResponse.class.isAssignableFrom(returnType.getParameterType());
37.     }
39.     @Override
40.     public ApiResponse<?> beforeBodyWrite(ApiResponse<?> body,
41.             MethodParameter returnType,
42.             MediaType selectedContentType,
43.             Class<? extends HttpMessageConverter<?>> selectedConverterType,
44.             ServerHttpRequest request,
45.             ServerHttpResponse response) {
46.         
47.         if (body != null) {
48.             response.setStatusCode(HttpStatus.valueOf(body.getCode()));
49.             body.getHeaders().forEach((key, value) ->
50.                 response.getHeaders().add(key, value));
51.         }
52.         return body;
53.     }
54. }

复制代码

方案四：利用 AOP 拦截

1. @Aspect
2. @Component
3. public class ResponseHeaderAspect {
5.     @Around("@annotation(responseHeaders)")
6.     public Object addResponseHeaders(ProceedingJoinPoint joinPoint,
7.             ResponseHeaders responseHeaders) throws Throwable {
8.         Object result = joinPoint.proceed();
9.         HttpServletResponse response =
10.             ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes())
11.                 .getResponse();
13.         if (response != null) {
14.             for (Header header : responseHeaders.value()) {
15.                 response.setHeader(header.name(), header.value());
16.             }
17.         }
18.         return result;
19.     }
20. }
22. // 自定义注解
23. @Target(ElementType.METHOD)
24. @Retention(RetentionPolicy.RUNTIME)
25. public @interface ResponseHeaders {
26.     Header[] value();
27. }
29. @Target(ElementType.METHOD)
30. @Retention(RetentionPolicy.RUNTIME)
31. public @interface Header {
32.     String name();
33.     String value();
34. }
36. // 使用示例
37. @RestController
38. @RequestMapping("/api/users")
39. public class UserController {
41.     @PostMapping
42.     @ResponseHeaders({
43.         @Header(name = "X-Custom-Header", value = "value"),
44.         @Header(name = "X-Created-By", value = "system")
45.     })
46.     public User createUser(@RequestBody User user) {
47.         return userService.save(user);
48.     }
49. }

复制代码

方案五：利用过滤器

1. @Component
2. public class ResponseModifierFilter implements Filter {
4.     @Override
5.     public void doFilter(ServletRequest request,
6.             ServletResponse response,
7.             FilterChain chain) throws IOException, ServletException {
8.         
9.         HttpServletResponse httpResponse = (HttpServletResponse) response;
10.         ContentCachingResponseWrapper responseWrapper =
11.             new ContentCachingResponseWrapper(httpResponse);
13.         chain.doFilter(request, responseWrapper);
15.         // 修改响应
16.         if (isUserCreationEndpoint(request)) {
17.             responseWrapper.setStatus(HttpServletResponse.SC_CREATED);
18.             responseWrapper.setHeader("X-Custom-Header", "value");
19.         }
21.         responseWrapper.copyBodyToResponse();
22.     }
23. }

复制代码

特性@RestController / @ResponseBodyResponseEntityHttpServletResponse默认状态码固定为 200 OK可动态设置可动态设置自定义响应头不支持支持支持动态状态码不支持支持支持代码复杂性简单中等较高推荐场景简单的 RESTful API需要动态状态码或自定义头部的场景特别场景（如文件流、低级操作） 详细解释如何利用 @RestController 或 @ResponseBody 联合 ResponseEntity 来返回对象和特定的 HTTP 状态码。
1. 基本用法

1. @RestController
2. @RequestMapping("/api/users")
3. public class UserController {
5.     @PostMapping
6.     public ResponseEntity<User> createUser(@RequestBody User user) {
7.         User savedUser = userService.save(user);
8.         return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
9.     }
11.     @GetMapping("/{id}")
12.     public ResponseEntity<User> getUser(@PathVariable Long id) {
13.         return userService.findById(id)
14.             .map(ResponseEntity::ok)  // 返回 200 OK
15.             .orElse(ResponseEntity.notFound().build());  // 返回 404 Not Found
16.     }
17. }

复制代码

2. 统一响应格式

1. // 统一响应格式
2. public class ApiResponse<T> {
3.     private int code;           // 状态码
4.     private String message;     // 消息
5.     private T data;            // 数据
6.     private LocalDateTime timestamp = LocalDateTime.now();  // 时间戳
8.     // 成功静态方法
9.     public static <T> ApiResponse<T> success(T data) {
10.         return new ApiResponse<>(200, "Success", data);
11.     }
13.     // 错误静态方法
14.     public static <T> ApiResponse<T> error(int code, String message) {
15.         return new ApiResponse<>(code, message, null);
16.     }
18.     // 构造方法、getter和setter
19. }

复制代码

3. CRUD 操作示例

1. @RestController
2. @RequestMapping("/api/users")
3. public class UserController {
5.     private final UserService userService;
7.     // 构造注入
8.     public UserController(UserService userService) {
9.         this.userService = userService;
10.     }
12.     // 创建用户
13.     @PostMapping
14.     public ResponseEntity<ApiResponse<User>> createUser(@RequestBody @Valid User user) {
15.         User savedUser = userService.save(user);
16.         return ResponseEntity
17.             .status(HttpStatus.CREATED)
18.             .body(ApiResponse.success(savedUser));
19.     }
21.     // 获取用户
22.     @GetMapping("/{id}")
23.     public ResponseEntity<ApiResponse<User>> getUser(@PathVariable Long id) {
24.         return userService.findById(id)
25.             .map(user -> ResponseEntity.ok(ApiResponse.success(user)))
26.             .orElse(ResponseEntity
27.                 .status(HttpStatus.NOT_FOUND)
28.                 .body(ApiResponse.error(404, "User not found")));
29.     }
31.     // 更新用户
32.     @PutMapping("/{id}")
33.     public ResponseEntity<ApiResponse<User>> updateUser(
34.             @PathVariable Long id,
35.             @RequestBody @Valid User user) {
36.         return userService.findById(id)
37.             .map(existingUser -> {
38.                 User updatedUser = userService.update(id, user);
39.                 return ResponseEntity.ok(ApiResponse.success(updatedUser));
40.             })
41.             .orElse(ResponseEntity
42.                 .status(HttpStatus.NOT_FOUND)
43.                 .body(ApiResponse.error(404, "User not found")));
44.     }
46.     // 删除用户
47.     @DeleteMapping("/{id}")
48.     public ResponseEntity<ApiResponse<Void>> deleteUser(@PathVariable Long id) {
49.         if (userService.existsById(id)) {
50.             userService.deleteById(id);
51.             return ResponseEntity.ok(ApiResponse.success(null));
52.         }
53.         return ResponseEntity
54.             .status(HttpStatus.NOT_FOUND)
55.             .body(ApiResponse.error(404, "User not found"));
56.     }
58.     // 获取用户列表（分页）
59.     @GetMapping
60.     public ResponseEntity<ApiResponse<Page<User>>> getUsers(
61.             @RequestParam(defaultValue = "0") int page,
62.             @RequestParam(defaultValue = "10") int size) {
63.         Page<User> users = userService.findAll(PageRequest.of(page, size));
64.         return ResponseEntity.ok(ApiResponse.success(users));
65.     }
66. }

复制代码

4. 异常处置惩罚

1. @RestControllerAdvice
2. public class GlobalExceptionHandler {
4.     // 处理验证错误
5.     @ExceptionHandler(MethodArgumentNotValidException.class)
6.     public ResponseEntity<ApiResponse<Map<String, String>>> handleValidationErrors(
7.             MethodArgumentNotValidException ex) {
8.         Map<String, String> errors = new HashMap<>();
9.         ex.getBindingResult().getFieldErrors().forEach(error ->
10.             errors.put(error.getField(), error.getDefaultMessage())
11.         );
12.         
13.         return ResponseEntity
14.             .status(HttpStatus.BAD_REQUEST)
15.             .body(ApiResponse.error(400, "Validation failed", errors));
16.     }
18.     // 处理业务逻辑异常
19.     @ExceptionHandler(BusinessException.class)
20.     public ResponseEntity<ApiResponse<Void>> handleBusinessException(BusinessException ex) {
21.         return ResponseEntity
22.             .status(ex.getStatus())
23.             .body(ApiResponse.error(ex.getStatus().value(), ex.getMessage()));
24.     }
26.     // 处理其他未知异常
27.     @ExceptionHandler(Exception.class)
28.     public ResponseEntity<ApiResponse<Void>> handleUnknownException(Exception ex) {
29.         return ResponseEntity
30.             .status(HttpStatus.INTERNAL_SERVER_ERROR)
31.             .body(ApiResponse.error(500, "Internal server error"));
32.     }
33. }

复制代码

5. 自定义业务异常

1. public class BusinessException extends RuntimeException {
2.     private final HttpStatus status;
4.     public BusinessException(String message, HttpStatus status) {
5.         super(message);
6.         this.status = status;
7.     }
9.     public HttpStatus getStatus() {
10.         return status;
11.     }
12. }

复制代码

6. 带条件的响应示例

1. @RestController
2. @RequestMapping("/api/orders")
3. public class OrderController {
5.     // 创建订单
6.     @PostMapping
7.     public ResponseEntity<ApiResponse<Order>> createOrder(@RequestBody @Valid OrderRequest request) {
8.         // 检查库存
9.         if (!inventoryService.checkStock(request)) {
10.             return ResponseEntity
11.                 .status(HttpStatus.CONFLICT)
12.                 .body(ApiResponse.error(409, "Insufficient stock"));
13.         }
15.         // 检查用户信用
16.         if (!userService.checkCredit(request.getUserId())) {
17.             return ResponseEntity
18.                 .status(HttpStatus.PAYMENT_REQUIRED)
19.                 .body(ApiResponse.error(402, "Insufficient credit"));
20.         }
22.         // 创建订单
23.         Order order = orderService.createOrder(request);
25.         // 如果是加急订单，添加特殊响应头
26.         if (request.isUrgent()) {
27.             return ResponseEntity
28.                 .status(HttpStatus.CREATED)
29.                 .header("X-Priority", "High")
30.                 .body(ApiResponse.success(order));
31.         }
33.         return ResponseEntity
34.             .status(HttpStatus.CREATED)
35.             .body(ApiResponse.success(order));
36.     }
37. }

复制代码

7. 文件上传响应示例

1. @RestController
2. @RequestMapping("/api/files")
3. public class FileController {
5.     @PostMapping("/upload")
6.     public ResponseEntity<ApiResponse<FileInfo>> uploadFile(
7.             @RequestParam("file") MultipartFile file) {
8.         try {
9.             FileInfo savedFile = fileService.store(file);
10.             
11.             return ResponseEntity
12.                 .status(HttpStatus.CREATED)
13.                 .header("Location", "/api/files/" + savedFile.getId())
14.                 .body(ApiResponse.success(savedFile));
15.         } catch (IOException e) {
16.             return ResponseEntity
17.                 .status(HttpStatus.INTERNAL_SERVER_ERROR)
18.                 .body(ApiResponse.error(500, "Failed to upload file"));
19.         }
20.     }
22.     @GetMapping("/download/{id}")
23.     public ResponseEntity<Resource> downloadFile(@PathVariable String id) {
24.         Resource file = fileService.loadAsResource(id);
25.         
26.         return ResponseEntity.ok()
27.             .header(HttpHeaders.CONTENT_DISPOSITION,
28.                 "attachment; filename="" + file.getFilename() + """)
29.             .body(file);
30.     }
31. }

复制代码

8. 返回流式数据

假如需要返回流式数据（如文件下载），可以联合 ResponseEntity 和 InputStreamResource。
示例：返回文件下载

1. @RestController  
2. @RequestMapping("/files")  
3. public class FileController {  
5.     @GetMapping("/download/{filename}")  
6.     public ResponseEntity<InputStreamResource> downloadFile(@PathVariable String filename) throws IOException {  
7.         File file = fileService.getFile(filename);  
9.         InputStreamResource resource = new InputStreamResource(new FileInputStream(file));  
11.         return ResponseEntity.ok()  
12.             .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + file.getName())  
13.             .contentLength(file.length())  
14.             .contentType(MediaType.APPLICATION_OCTET_STREAM)  
15.             .body(resource);  
16.     }  
17. }  

复制代码

• 响应：
  
  
  
  • 状态码：200 OK
    
  • 响应头：
    
    1. Content-Disposition: attachment; filename=myfile.txt  

    复制代码
  • 响应体：文件内容
    
  
  

9. 利用建议

• 统一响应格式：
  
  
  
  • 利用统一的响应封装类（如 ApiResponse）
    
  • 包含必要的状态码、消息和数据字段
    
  • 添加时间戳便于调试和日志追踪
    
  
  
• 适当的状态码：
  
  
  
  • 200: 成功获取资源
    
  • 201: 成功创建资源
    
  • 204: 成功处置惩罚但无返回内容
    
  • 400: 哀求参数错误
    
  • 401: 未认证
    
  • 403: 无权限
    
  • 404: 资源不存在
    
  • 409: 资源冲突
    
  • 500: 服务器错误
    
  
  
• 异常处置惩罚：
  
  
  
  • 利用全局异常处置惩罚器统一处置惩罚异常
    
  • 区分业务异常和体系异常
    
  • 提供清晰的错误信息
    
  
  
• 响应头设置：
  
  
  
  • 根据需要设置自定义响应头
    
  • 文件操作时设置适当的 Content-Type 和 Content-Disposition
    
  
  
• 验证处置惩罚：
  
  
  
  • 利用 @Valid 注解举行哀求验证
    
  • 提供详细的验证错误信息
    
  
  

通过这种方式，可以构建出统一、规范的 API 响应，便于客户端处置惩罚和调试。
10. 最佳实践建议

• 优先利用 @RestController 或 @ResponseBody：
  
  
  
  • 假如不需要动态设置状态码或响应头，直接返回对象即可，简单高效。
    
  
  
• 利用 ResponseEntity 办理局限性：
  
  
  
  • 当需要动态设置状态码或自定义响应头时，推荐利用 ResponseEntity，它是 Spring 提供的标准办理方案，代码优雅且易于维护。
    
  
  
• 仅在特别场景下利用 HttpServletResponse：
  
  
  
  • 假如需要直接操作底层响应流（如文件下载、流式数据），可以利用 HttpServletResponse。
    
  
  

• 优先利用 ResponseEntity：
  
  
  
  • 最清晰和直接的办理方案
    
  • 提供完备的响应控制
    
  • 范例安全且易于维护
    
  
  
• 统一响应格式：
  
  
  
  • 定义统一的响应包装类
    
  • 利用响应拦截器统一处置惩罚
    
  • 便于维护和扩展
    
  
  
• 分层处置惩罚：
  
  
  
  • 控制器层：业务逻辑和基本响应
    
  • 拦截器层：通用响应头和状态码
    
  • 过滤器层：全局响应修改
    
  
  
• 异常处置惩罚：
  

1. @RestControllerAdvice
2. public class GlobalExceptionHandler {
4.     @ExceptionHandler(Exception.class)
5.     public ResponseEntity<ApiResponse<String>> handleException(Exception ex) {
6.         ApiResponse<String> response = ApiResponse.error(
7.             500,
8.             "Internal Server Error",
9.             ex.getMessage()
10.         );
11.         
12.         return ResponseEntity
13.             .status(HttpStatus.INTERNAL_SERVER_ERROR)
14.             .body(response);
15.     }
16. }

复制代码

• 文档和注释：
  

1. /**
2. * 用户控制器
3. * 注意：直接返回对象时无法设置状态码和响应头
4. * 建议使用 ResponseEntity 或其他替代方案
5. */
6. @RestController
7. @RequestMapping("/api/users")
8. public class UserController {
9.     // 控制器方法...
10. }

复制代码

通过以上方案，可以克服 @RestController 和 @ResponseBody 的限制，实现更灵活的响应控制。选择符合的方案取决于具体需求和项目架构。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。