统一响应结果vo 全局异常处理器 统一返回_responsevo

springboot2 项目 统一响应结果vo 返回类3个基础参数，一个code，一个msg，一个data，data就用来做具体返回的内容，用泛型，想返回啥就返回啥；

在 Spring Boot 项目中，你可以创建一个统一的响应结果类（VO），其中包含了三个基础参数：code、msg、data。你可以使用泛型来表示data字段的类型，以便实现灵活的数据返回。

以下是一个简单的示例代码：

public class ApiResponse<T> {
    private int code;
    private String msg;
    private T data;

    public ApiResponse() {
        // 默认构造函数
    }

    public ApiResponse(int code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    // 省略 getter 和 setter 方法

    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(200, "Success", data);
    }

    public static <T> ApiResponse<T> error(int code, String msg) {
        return new ApiResponse<>(code, msg, null);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在这个示例中，ApiResponse 类包含了一个带有泛型的data字段，用于表示具体的返回内容。类中提供了两个静态方法 success 和 error，用于创建成功和错误的响应对象。

在控制器（Controller）中，你可以使用这个响应对象来统一返回结果：

@RestController
@RequestMapping("/api")
public class MyController {

    @GetMapping("/example")
    public ApiResponse<String> getExample() {
        String exampleData = "Hello, World!";
        return ApiResponse.success(exampleData);
    }

    @GetMapping("/error")
    public ApiResponse<?> handleError() {
        return ApiResponse.error(500, "Internal Server Error");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这个例子中，getExample 方法返回一个成功的响应，包含了字符串类型的数据。handleError 方法返回一个错误的响应，不包含具体的数据。根据需要，你可以在不同的控制器方法中使用不同的泛型类型。
前端根据code写返回逻辑，正常code是0，不是0的全是异常

springboot2 用 ResponseBodyAdvice 实现统一响应数据格式ApiResponse

Spring MVC 切面 ResponseBodyAdvice 对响应/返回值增强、API接口数据统一格式返回-CSDN博客
https://blog.csdn.net/wangmx1993328/article/details/81054474/

在 Spring Boot 中，你可以使用 ResponseBodyAdvice 接口来实现统一响应数据格式，将响应的数据包装成 ApiResponse 对象。ResponseBodyAdvice 接口提供了在响应体写入之前和之后执行的方法，使你能够对响应进行处理。

以下是一个简单的示例，演示如何使用 ResponseBodyAdvice 实现统一响应数据格式：

import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

@ControllerAdvice
public class ApiResponseAdvice implements ResponseBodyAdvice<Object> {

    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        // 确保只有返回类型为 ApiResponse 时才执行 beforeBodyWrite 方法
        return !ResponseEntity.class.isAssignableFrom(returnType.getParameterType());
    }

    @Override
    public Object beforeBodyWrite(
            Object body,
            MethodParameter returnType,
            MediaType selectedContentType,
            Class selectedConverterType,
            ServerHttpRequest request,
            ServerHttpResponse response) {

        // 如果返回类型是 ApiResponse，则直接返回
        if (body instanceof ApiResponse) {
            return body;
        }

        // 对其他返回类型进行包装
        if (body instanceof String) {
            // 如果是字符串类型，则包装成 ApiResponse
            return ApiResponse.success(body);
        } else {
            // 对其他类型进行包装
            return ApiResponse.success(body);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

在上述代码中，ApiResponseAdvice 类实现了 ResponseBodyAdvice 接口。supports 方法用于确定是否应该执行 beforeBodyWrite 方法。在 beforeBodyWrite 方法中，我们检查响应的数据类型，如果是 ApiResponse 类型则直接返回，否则将其包装成 ApiResponse 对象。

请注意，上述示例中的包装逻辑可能需要根据你的实际需求进行调整。你可以根据实际情况对不同类型的响应进行不同的包装处理。

---

ResponseBodyAdvice 2个方法的详细用法

ResponseBodyAdvice 接口是 Spring 框架提供的用于处理响应体的拦截器接口，主要用于在返回响应之前和之后对响应体进行修改或处理。该接口包含两个方法：supports 和 beforeBodyWrite。

1. supports 方法

boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType);
1

supports 方法用于判断是否应该执行 beforeBodyWrite 方法。通常，你可以在这个方法中根据条件判断是否需要对响应进行处理。如果返回 true，则执行 beforeBodyWrite 方法；如果返回 false，则不执行。

例如，你可以通过判断返回类型、请求头等条件来决定是否进行处理：

@Override
public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
    // 判断返回类型是否是需要处理的类型
    return returnType.getParameterType() == YourResponseType.class;
}
1
2
3
4
5

2. beforeBodyWrite 方法

T beforeBodyWrite(T body, MethodParameter returnType, MediaType selectedContentType,
    Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request,
    ServerHttpResponse response);
1
2
3

beforeBodyWrite 方法用于在将响应体写入到响应之前进行处理。你可以在这个方法中对响应体进行修改、包装或其他处理。该方法的返回值即为最终写入响应的响应体。

例如，你可以在这个方法中对响应体进行包装：

@Override
public ApiResponse<Object> beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
        Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request,
        ServerHttpResponse response) {

    // 对响应体进行包装
    ApiResponse<Object> apiResponse = new ApiResponse<>(200, "Success", body);
    return apiResponse;
}
1
2
3
4
5
6
7
8
9

在这个例子中，ApiResponse 类型用于包装响应体。

使用示例

下面是一个完整的使用示例，假设有一个统一的响应格式 ApiResponse：

@ControllerAdvice
public class ApiResponseAdvice implements ResponseBodyAdvice<Object> {

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        // 判断返回类型是否是需要处理的类型
        return returnType.getParameterType() == YourResponseType.class;
    }

    @Override
    public ApiResponse<Object> beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
            Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request,
            ServerHttpResponse response) {

        // 对响应体进行包装
        ApiResponse<Object> apiResponse = new ApiResponse<>(200, "Success", body);
        return apiResponse;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在这个例子中，YourResponseType 是你希望进行处理的响应类型。如果返回的响应体类型是 YourResponseType，则在返回之前使用 ApiResponse 进行包装。这样可以实现全局的统一响应格式。

---

统一返回ResponseEntity 用法 示例

在 Spring Boot 中，你可以使用 ResponseEntity 类来实现统一的 HTTP 响应，该类提供了更灵活的方式来控制 HTTP 响应的状态码、头部信息和响应体。下面是一个简单的示例，演示如何使用 ResponseEntity 来实现统一的响应：

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class MyController {

    @GetMapping("/example")
    public ResponseEntity<ApiResponse<String>> getExample() {
        try {
            // 执行业务逻辑
            String result = "Hello, World!";
            return ResponseEntity.ok(new ApiResponse<>(200, "Success", result));
        } catch (Exception e) {
            // 处理异常情况
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(new ApiResponse<>(500, "Internal Server Error", null));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在这个例子中，ApiResponse 是一个自定义的响应体类，用于表示统一的响应格式。MyController 类中的 getExample 方法返回一个 ResponseEntity<ApiResponse<String>> 类型的响应。

• ResponseEntity.ok() 方法表示响应状态码为 200。
• ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) 方法表示响应状态码为 500。

你可以根据业务逻辑的成功与否选择不同的状态码，并根据需要设置响应头和响应体。

此外，如果你希望在全局处理异常并返回统一格式的响应，你可以使用全局异常处理器（@ControllerAdvice 和 @ExceptionHandler）。以下是一个简单的全局异常处理器的示例：

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

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiResponse<Object>> handleException(Exception e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new ApiResponse<>(500, "Internal Server Error", null));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这个全局异常处理器捕获所有的异常，并返回一个状态码为 500 的统一格式的响应。你可以根据实际需求进一步优化异常处理。

---