111

k94314517

2025-07-11 372822d209a560b017294b594906aa89bd46f4ce

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package com.doumee.core.model;
 
import com.alibaba.fastjson.JSON;
import com.doumee.core.constants.ResponseStatus;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
 
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.Serializable;
import java.nio.charset.StandardCharsets;
 
/**
 * 接口返回对象
 * @author  dm
 * @since 2025/03/31 16:44
 */
@Slf4j
@ApiModel("响应对象")
@Data
@AllArgsConstructor
public class ApiResponse<T> implements Serializable {
 
    @ApiModelProperty(value = "响应码")
    private int code;
 
    @ApiModelProperty(value = "请求是否成功")
    private boolean success;
 
    @ApiModelProperty(value = "错误消息")
    private String message;
 
    @ApiModelProperty(value = "数据")
    private T data;
 
    @ApiModelProperty(value = "异常消息")
    private String exception;
 
    public ApiResponse () {}
 
    /**
     * 请求成功
     *
     * @param data 数据
     * @return ApiResponse
     */
    public static <T> ApiResponse<T> success(T data) {
        return ApiResponse.success("请求成功", data);
    }
 
    /**
     * 请求成功
     *
     * @param message 消息
     * @param data 数据
     * @return ApiResponse
     */
    public static <T> ApiResponse<T> success(String message, T data) {
        return new ApiResponse<>(HttpStatus.OK.value(), Boolean.TRUE, message, data, null);
    }
 
    /**
     * 请求失败
     *
     * @param message 消息
     * @return ApiResponse
     */
    public static <T> ApiResponse<T> failed(String message) {
        return ApiResponse.failed(HttpStatus.INTERNAL_SERVER_ERROR.value(), message);
    }
 
    /**
     * 请求失败
     *
     * @param status 响应状态
     * @return ApiResponse
     */
    public static <T> ApiResponse<T> failed(ResponseStatus status) {
        return ApiResponse.failed(status.getCode(), status.getMessage());
    }
 
    /**
     * 请求失败
     *
     * @param status 响应状态
     * @param ex 异常对象
     * @return ApiResponse
     */
    public static <T> ApiResponse<T> failed(ResponseStatus status, Throwable ex) {
        return ApiResponse.failed(status.getCode(), status.getMessage(), ex);
    }
 
    /**
     * 请求失败
     *
     * @param code 响应码
     * @param message 消息
     * @return ApiResponse
     */
    public static <T> ApiResponse<T> failed(Integer code, String message) {
        return ApiResponse.failed(code, message, null);
    }
 
    /**
     * 请求失败
     *
     * @param code 响应码
     * @param message 消息
     * @param ex 异常
     * @return ApiResponse
     */
    public static <T> ApiResponse<T> failed(Integer code, String message, Throwable ex) {
        if (ex == null) {
            return new ApiResponse<>(code, Boolean.FALSE, message, null, null);
        }
        // 处理异常栈，防止过多内容导致响应内容过大
        StackTraceElement[] trace = ex.getStackTrace();
        StringBuilder exceptionStack = new StringBuilder(ex + "\n");
        for (StackTraceElement traceElement : trace) {
            exceptionStack.append("\tat ").append(traceElement).append("\n");
            if (exceptionStack.length() > 5000) {
                break;
            }
        }
        return new ApiResponse<>(code, Boolean.FALSE, message, null, exceptionStack.toString());
    }
 
    /**
     * 直接通过HttpServletResponse写出响应结果
     *
     * @param response 响应
     * @param apiResponse ApiResponse
     */
    public static void response (HttpServletResponse response, ApiResponse apiResponse) {
        try {
            response.setHeader("content-type", "application/json;charset=UTF-8");
            response.getOutputStream().write(JSON.toJSONString(apiResponse).getBytes(StandardCharsets.UTF_8));
        } catch (IOException e) {
            log.error("EVA: response throw an exception", e);
        }
    }
}