🐘 统一返回对象

public class RestResponse<T> implements Serializable {
    private String code;
    private T data;
    private boolean success;
    private String message;

    /**
     * 获取统一返回类型
     *
     * @param code    返回码
     * @param data    返回数据
     * @param success 返回结果
     * @param message 提示信息
     * @param <T>     数据类型
     * @return {@code RestResponse} 统一返回类型
     */
    public static <T> RestResponse<T> of(String code, T data, boolean success, String message) {
        return new RestResponse<>(code, data, success, message);
    }

    /**
     * 返回操作成功的统一类型
     * <p> {@link RestResponse#success} = true </p>
     *
     * @param code    返回码
     * @param data    返回数据
     * @param message 提示信息
     * @param <T>     数据类型
     * @return {@code RestResponse} 统一返回类型
     */
    public static <T> RestResponse<T> success(String code, T data, String message) {
        return of(code, data, true, message);
    }

    /**
     * 返回操作成功的统一类型
     * <p> {@link RestResponse#success} = true </p>
     * <p> {@link RestResponse#code} = 0 </p>
     *
     * @param data    返回数据
     * @param message 提示信息
     * @param <T>     数据类型
     * @return {@code RestResponse} 统一返回类型
     */
    public static <T> RestResponse<T> success(T data, String message) {
        return success("0", data, message);
    }

    /**
     * 返回操作成功的统一类型
     * <p> {@link RestResponse#success} = true </p>
     * <p> {@link RestResponse#code} = 0 </p>
     * <p> {@link RestResponse#message} = 响应成功 </p>
     *
     * @param data 返回数据
     * @param <T>  数据类型
     * @return {@code RestResponse} 统一返回类型
     */
    public static <T> RestResponse<T> success(T data) {
        return success(data, "响应成功");
    }

    /**
     * 返回操作失败的统一类型
     * <p> {@link RestResponse#success} = false </p>
     *
     * @param code    返回码
     * @param data    返回数据
     * @param message 提示信息
     * @param <T>     数据类型
     * @return {@code RestResponse} 统一返回类型
     */
    public static <T> RestResponse<T> error(String code, T data, String message) {
        return of(code, data, false, message);
    }

    /**
     * 返回操作成功的统一类型
     * <p> {@link RestResponse#success} = false </p>
     * <p> {@link RestResponse#data} = null </p>
     *
     * @param message 提示信息
     * @param <T>     数据类型
     * @return {@code RestResponse} 统一返回类型
     */
    public static <T> RestResponse<T> error(String code, String message) {
        return error(code, null, message);
    }

    /**
     * 返回操作成功的统一类型
     * <p> {@link RestResponse#success} = true </p>
     * <p> {@link RestResponse#code} = -1 </p>
     * <p> {@link RestResponse#data} = null </p>
     *
     * @param <T> 数据类型
     * @return {@code RestResponse} 统一返回类型
     */
    public static <T> RestResponse<T> error(String message) {
        return error("-1", message);
    }
}

public interface ResponseBodyAdvice<T> {

	/**
	 * Whether this component supports the given controller method return type
	 * and the selected {@code HttpMessageConverter} type.
	 * @param returnType the return type
	 * @param converterType the selected converter type
	 * @return {@code true} if {@link #beforeBodyWrite} should be invoked;
	 * {@code false} otherwise
	 */
	boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType);

	/**
	 * Invoked after an {@code HttpMessageConverter} is selected and just before
	 * its write method is invoked.
	 * @param body the body to be written
	 * @param returnType the return type of the controller method
	 * @param selectedContentType the content type selected through content negotiation
	 * @param selectedConverterType the converter type selected to write to the response
	 * @param request the current request
	 * @param response the current response
	 * @return the body that was passed in or a modified (possibly new) instance
	 */
	@Nullable
	T beforeBodyWrite(@Nullable T body, MethodParameter returnType, MediaType selectedContentType,
			Class<? extends HttpMessageConverter<?>> selectedConverterType,
			ServerHttpRequest request, ServerHttpResponse response);

}

@Override
public boolean supports(MethodParameter returnType, Class converterType) {
    // 当返回值类型已经时包装类时跳过
    return !returnType.getParameterType().equals(RestResponse.class);
}

@Override
public Object beforeBodyWrite(Object body,
                              MethodParameter returnType,
                              MediaType selectedContentType,
                              Class selectedConverterType,
                              ServerHttpRequest request,
                              ServerHttpResponse response) {
    // 1、处理无返回值（即 void）类型的方法
    if (returnType.getParameterType().equals(Void.class)) {
        return RestResponse.success(new Object());
    }
    // 2、Spring 默认使用 StringHttpMessageConverter 处理 String 类型的返回值
    // 一旦被包装成统一对象后，不能被转换成字符串，而产生类型转换异常 - 见下方注①
    if (body instanceof String) {
        // 2.1、用于重置字符串的响应类型为 application/json
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
        // 2.2 将统一对象转换成 json 字符串
        return JSON.toJSONString(RestResponse.success(body));
    }
    // 3、其他所有情况
    return RestResponse.success(body);
}