响应实体类

RespBodyVo

RespBodyVo 是一个自定义的响应体封装类，用于统一 API 接口的响应格式。通过使用 RespBodyVo，可以确保所有 API 响应的一致性，便于前后端的协作和错误处理。RespBodyVo 提供了多种静态工厂方法和链式调用方式，简化了响应的构建过程。

类定义

package com.litongjava.model.body;

import com.litongjava.model.resp.RespCode;

/**
 * 响应实体类
 */
public class RespBodyVo implements java.io.Serializable {
  private static final long serialVersionUID = 7492427869347211588L;

  /**
   * 是否成功，true 表示成功，false 表示失败
   */
  private boolean ok;

  /**
   * 业务编码：一般是在失败情况下会用到这个，以便告知用户失败的原因是什么
   */
  private Integer code;

  /**
   * 业务数据，譬如分页数据，用户信息数据等
   */
  private Object data;

  /**
   * 消息，一般用于显示
   */
  private String msg;

  // 静态工厂方法和构造方法省略
  // ...

  // Getter 和 Setter 方法省略
  // ...
}

属性说明

ok (boolean): 表示响应的结果状态，true 表示成功，false 表示失败。
code (Integer): 业务编码，通常在失败情况下使用，用于标识具体的错误类型或原因。
data (Object): 返回的业务数据，可以是任何类型的对象，如分页数据、用户信息等。
msg (String): 消息，用于向用户展示操作结果或错误信息。

构造方法

RespBodyVo(boolean ok): 私有构造方法，根据传入的 ok 状态设置 ok 属性。

静态工厂方法

成功响应 (`ok` 系列方法)

static RespBodyVo ok(): 创建一个默认的成功响应，ok 设置为 true，code 设置为 1。

public static RespBodyVo ok() {
  RespBodyVo resp = new RespBodyVo(true);
  resp.code = 1;
  return resp;
}

static RespBodyVo ok(Object data): 创建一个成功响应，并包含业务数据。
```
public static RespBodyVo ok(Object data) {
  return ok().data(data);
}
```

static RespBodyVo ok(String msg, Object data): 创建一个成功响应，包含自定义消息和业务数据。

public static RespBodyVo ok(String msg, Object data) {
  RespBodyVo resp = new RespBodyVo(true);
  resp.code = 1;
  resp.msg = msg;
  resp.data = data;
  return resp;
}

失败响应 (`fail` 系列方法)

static RespBodyVo fail(): 创建一个默认的失败响应，ok 设置为 false，code 设置为 0。

public static RespBodyVo fail() {
  RespBodyVo resp = new RespBodyVo(false);
  resp.code = 0;
  return resp;
}

static RespBodyVo fail(String msg): 创建一个失败响应，并包含错误消息。
```
public static RespBodyVo fail(String msg) {
  return fail().msg(msg);
}
```

static RespBodyVo failData(Object data): 创建一个失败响应，并包含业务数据。

public static RespBodyVo failData(Object data) {
  return fail().setData(data);
}

链式调用方法

RespBodyVo code(Integer code): 设置 code 属性并返回当前对象。
RespBodyVo data(Object data): 设置 data 属性并返回当前对象。
RespBodyVo msg(String msg): 设置 msg 属性并返回当前对象。
RespBodyVo setCode(Integer code): 同 code(Integer code)。
RespBodyVo setData(Object data): 同 data(Object data)。
RespBodyVo setMsg(String msg): 同 msg(String msg)。

方法说明

Integer getCode(): 获取业务编码。
Object getData(): 获取业务数据。
String getMsg(): 获取消息。
boolean isOk(): 判断响应是否为成功状态。

使用示例

以下是一个完整的控制器示例，展示如何使用 RespBodyVo 进行 API 响应封装：

package com.hami.book.kepping.controller;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.litongjava.annotation.Get;
import com.litongjava.annotation.RequestPath;
import com.litongjava.model.body.RespBodyVo;

@RequestPath("/example")
public class ExampleController {

  @Get("/success")
  public RespBodyVo getSuccess() {
    return RespBodyVo.ok();
  }

  @Get("/data")
  public RespBodyVo getData() {
    Map<String, String> data = new HashMap<>();
    data.put("key", "value");
    return RespBodyVo.ok(data);
  }

  @Get("/custom-success")
  public RespBodyVo getCustomSuccess() {
    List<String> list = Arrays.asList("item1", "item2");
    return RespBodyVo.ok("Operation successful", list);
  }

  @Get("/fail")
  public RespBodyVo getFail() {
    return RespBodyVo.fail();
  }

  @Get("/fail-message")
  public RespBodyVo getFailMessage() {
    return RespBodyVo.fail("Invalid request parameters");
  }

  @Get("/chain")
  public RespBodyVo getChain() {
    return RespBodyVo.ok().setMsg("Chained response").setData(Arrays.asList(1, 2, 3));
  }
}

1. 返回默认的成功响应

@Get("/success")
public RespBodyVo getSuccess() {
    return RespBodyVo.ok();
}

返回值

{
  "ok": true,
  "code": 1,
  "data": null,
  "msg": null
}

2. 返回成功响应并包含数据

@Get("/data")
public RespBodyVo getData() {
    Map<String, String> data = new HashMap<>();
    data.put("key", "value");
    return RespBodyVo.ok(data);
}

返回值

{
  "ok": true,
  "code": 1,
  "data": {
    "key": "value"
  },
  "msg": null
}

3. 返回成功响应并包含自定义消息和数据

@Get("/custom-success")
public RespBodyVo getCustomSuccess() {
    List<String> list = Arrays.asList("item1", "item2");
    return RespBodyVo.ok("Operation successful", list);
}

返回值

{
  "ok": true,
  "code": 1,
  "data": ["item1", "item2"],
  "msg": "Operation successful"
}

4. 返回默认的失败响应

@Get("/fail")
public RespBodyVo getFail() {
    return RespBodyVo.fail();
}

返回值

{
  "ok": false,
  "code": 0,
  "data": null,
  "msg": null
}

5. 返回失败响应并包含错误消息

@Get("/fail-message")
public RespBodyVo getFailMessage() {
    return RespBodyVo.fail("Invalid request parameters");
}

返回值

{
  "ok": false,
  "code": 0,
  "data": null,
  "msg": "Invalid request parameters"
}

6. 使用链式调用设置响应内容

@Get("/chain")
public RespBodyVo getChain() {
    return RespBodyVo.ok()
                   .setMsg("Chained response")
                   .setData(Arrays.asList(1, 2, 3));
}

返回值

{
  "ok": true,
  "code": 1,
  "data": [1, 2, 3],
  "msg": "Chained response"
}

注意事项

序列化: RespBodyVo 实现了 Serializable 接口，确保其可以被序列化为 JSON 或其他格式。
结果状态: ok 属性用于表示响应状态，true 表示成功，false 表示失败。
业务编码: code 属性在失败情况下用于标识具体的错误类型或原因，便于前端进行相应的错误处理。
链式调用: 通过链式调用方式设置属性，提升代码的可读性和简洁性。例如：RespBodyVo.ok().setMsg("...").setData(...)
扩展性: 可以根据业务需求扩展 RespBodyVo 的属性和方法，以满足更复杂的响应需求。

总结

RespBodyVo 提供了一种简洁且一致的方式来封装 API 响应。通过其丰富的静态工厂方法和灵活的链式调用方式，可以满足各种场景下的响应需求。结合清晰的属性定义和方法设计，使得代码更加可维护和易于理解。

RsultVo

ResultVo 是 tio-boot 框架内置的响应体封装类，用于统一 API 接口的响应格式。通过使用 ResultVo，可以确保所有 API 响应的一致性，便于前后端的协作和错误处理。

类定义

package com.litongjava.model.result;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class ResultVo implements java.io.Serializable {
  private static final long serialVersionUID = 7295952087858355659L;
  public static final int FAIL_CODE = 400;

  private int code = 200;
  private String message;
  private Object data;

  // 构造方法
  public ResultVo(Object data) { /* ... */ }
  public ResultVo(int code, String message) { /* ... */ }
  public ResultVo(int code, Object data) { /* ... */ }
  public ResultVo(String message, Object data) { /* ... */ }

  // 静态工厂方法 - 成功响应
  public static ResultVo ok() { /* ... */ }
  public static ResultVo ok(Object data) { /* ... */ }
  public static ResultVo ok(String message, Object data) { /* ... */ }
  public static ResultVo ok(int code, String message, Object data) { /* ... */ }
  public static ResultVo ok(int code, Object data) { /* ... */ }

  // 静态工厂方法 - 失败响应
  public static ResultVo fail() { /* ... */ }
  public static ResultVo fail(String message) { /* ... */ }
  public static ResultVo fail(int code, String message) { /* ... */ }
  public static ResultVo fail(String message, Object data) { /* ... */ }
  public static ResultVo fail(int code, String message, Object data) { /* ... */ }
}

属性说明

code (int): 状态码。默认值为 200，表示成功。失败时常用 400。
message (String): 提示信息，用于描述操作结果或错误信息。
data (Object): 返回的数据，可以是任何类型的对象。

构造方法

ResultVo(): 无参构造，默认 code 为 200。
ResultVo(Object data): 仅设置 data。
ResultVo(int code, String message): 设置 code 和 message。
ResultVo(int code, Object data): 设置 code 和 data。
ResultVo(String message, Object data): 设置 message 和 data。

静态工厂方法

成功响应 (`ok` 系列方法)

ResultVo.ok(): 返回一个默认的成功响应。
ResultVo.ok(Object data): 返回成功响应，并包含数据。
ResultVo.ok(String message, Object data): 返回成功响应，包含自定义消息和数据。
ResultVo.ok(int code, String message, Object data): 返回自定义 code、消息和数据的成功响应。
ResultVo.ok(int code, Object data): 返回自定义 code 和数据的成功响应。

失败响应 (`fail` 系列方法)

ResultVo.fail(): 返回一个默认的失败响应，code 为 400。
ResultVo.fail(String message): 返回失败响应，包含自定义消息。
ResultVo.fail(int code, String message): 返回自定义 code 和消息的失败响应。
ResultVo.fail(String message, Object data): 返回失败响应，包含自定义消息和数据。
ResultVo.fail(int code, String message, Object data): 返回自定义 code、消息和数据的失败响应。

使用示例

1. 返回默认的成功响应

@GetMapping("/success")
public ResultVo getSuccess() {
    return ResultVo.ok();
}

返回值

{
  "code": 200,
  "message": null,
  "data": null
}

2. 返回成功响应并包含数据

@GetMapping("/data")
public ResultVo getData() {
    Map<String, String> data = new HashMap<>();
    data.put("key", "value");
    return ResultVo.ok(data);
}

返回值

{
  "code": 200,
  "message": null,
  "data": {
    "key": "value"
  }
}

3. 返回成功响应并包含自定义消息和数据

@GetMapping("/custom-success")
public ResultVo getCustomSuccess() {
    List<String> list = Arrays.asList("item1", "item2");
    return ResultVo.ok("Operation successful", list);
}

返回值

{
  "code": 200,
  "message": "Operation successful",
  "data": ["item1", "item2"]
}

4. 返回默认的失败响应

@GetMapping("/fail")
public ResultVo getFail() {
    return ResultVo.fail();
}

返回值

{
  "code": 400,
  "message": null,
  "data": null
}

5. 返回失败响应并包含错误消息

@GetMapping("/fail-message")
public ResultVo getFailMessage() {
    return ResultVo.fail("Invalid request parameters");
}

返回值

{
  "code": 400,
  "message": "Invalid request parameters",
  "data": null
}

6. 使用链式调用设置响应内容

@GetMapping("/chain")
public ResultVo getChain() {
    return ResultVo.ok()
                   .setMessage("Chained response")
                   .setData(Arrays.asList(1, 2, 3));
}

返回值

{
  "code": 200,
  "message": "Chained response",
  "data": [1, 2, 3]
}

注意事项

序列化: ResultVo 实现了 Serializable 接口，确保其可以被序列化为 JSON 或其他格式。
默认值: 当未设置 code 时，默认值为 200，表示成功。
错误码: 通过 FAIL_CODE 常量统一表示失败的默认状态码为 400，可根据需要自定义其他错误码。
链式调用: 由于使用了 Lombok 的 @Accessors(chain = true) 注解，可以通过链式调用方式设置属性，提升代码的可读性和简洁性。

总结

ResultVo 提供了一种简洁且一致的方式来封装 API 响应。通过其丰富的静态工厂方法和灵活的构造函数，可以满足各种场景下的响应需求。结合 Lombok 的简化注解，使得代码更加简洁和易于维护。

示例代码

以下是一个完整的 Spring Boot 控制器示例，展示如何使用 ResultVo 进行 API 响应封装：

package com.hami.book.kepping.controller;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.litongjava.annotation.Get;
import com.litongjava.annotation.RequestPath;
import com.litongjava.model.result.ResultVo;

@RequestPath("/example")
public class ExampleController {

  @Get("/success")
  public ResultVo getSuccess() {
    return ResultVo.ok();
  }

  @Get("/data")
  public ResultVo getData() {
    Map<String, String> data = new HashMap<>();
    data.put("key", "value");
    return ResultVo.ok(data);
  }

  @Get("/custom-success")
  public ResultVo getCustomSuccess() {
    List<String> list = Arrays.asList("item1", "item2");
    return ResultVo.ok("Operation successful", list);
  }

  @Get("/fail")
  public ResultVo getFail() {
    return ResultVo.fail();
  }

  @Get("/fail-message")
  public ResultVo getFailMessage() {
    return ResultVo.fail("Invalid request parameters");
  }

  @Get("/chain")
  public ResultVo getChain() {
    return ResultVo.ok().setMessage("Chained response").setData(Arrays.asList(1, 2, 3));
  }
}

通过上述控制器，可以访问不同的端点来获取各种形式的 ResultVo 响应，确保 API 的一致性和易用性。

结论

ResultVo 作为 tio-boot 提供的内置响应体封装类，极大地简化了 API 响应的构建和管理。通过合理使用其提供的方法，可以有效提升代码的可维护性和可读性，同时确保前后端交互的一致性。