SpringBoot-22-RESTful统一规范响应数据格式

简介: REST是Representational State Transfer的缩写,是在2000年被Roy Thomas Fielding提出的,Fielding是一个很厉害的人物,他是HTTP协议的主要设计者。REST是他对互联网软件构架的原则。REST是一种针对网络应用设计和软件开发方式,降低了开发的复杂性,提高了系统的可伸缩性。如果想要具体了解一下其含义可以查看一下阮一峰老师对REST理解RESTful架构。

SpringBoot-22-RESTful统一规范响应数据格式

什么是REST?



REST是Representational State Transfer的缩写,是在2000年被Roy Thomas Fielding提出的,Fielding是一个很厉害的人物,他是HTTP协议的主要设计者。REST是他对互联网软件构架的原则。REST是一种针对网络应用设计和软件开发方式,降低了开发的复杂性,提高了系统的可伸缩性。如果想要具体了解一下其含义可以查看一下阮一峰老师对REST理解RESTful架构。


我们在开发过程中需要有一个统一的数据返回格式,这样可以使得所有开发人员返回结果风格统一,减少前后端开发人员的沟通时间。REST只是一种标准化的开发约定,下面我们提供一个通过返回结果的实现


返回码接口

/**
 * 统一返回结果接口
 */
public interface IResultCode {
    /**
     * 返回码
     *
     * @return int
     */
    int getCode();
    /**
     * 返回消息
     *
     * @return String
     */
    String getMsg();
}



返回码接口实现

@Getter
@AllArgsConstructor
public enum  ResultCode implements  IResultCode{
    /**
     * 操作成功
     */
    SUCCESS(200, "操作成功"),
    /**
     * 业务异常
     */
    FAILURE(400, "业务异常"),
    /**
     * 服务异常
     */
    ERROR(500, "服务异常"),
    /**
     * 参数错误
     */
    GLOBAL_PARAM_ERROR(4000, "参数错误");
    /**
     * 状态码
     */
    final int code;
    /**
     * 消息内容
     */
    final String msg;
}



统一响应结果的实现

@Data
@Getter
public class Result<T> implements Serializable {
    private static final long serialVersionUID = 1L;
    private int code;
    private String msg;
    private long time;
    private T data;
    private Result() {
        this.time = System.currentTimeMillis();
    }
    private Result(IResultCode resultCode) {
        this(resultCode, null, resultCode.getMsg());
    }
    private Result(IResultCode resultCode, String msg) {
        this(resultCode, null, msg);
    }
    private Result(IResultCode resultCode, T data) {
        this(resultCode, data, resultCode.getMsg());
    }
    private Result(IResultCode resultCode, T data, String msg) {
        this(resultCode.getCode(), data, msg);
    }
    private Result(int code, T data, String msg) {
        this.code = code;
        this.data = data;
        this.msg = msg;
        this.time = System.currentTimeMillis();
    }
    /**
     * 返回状态码
     *
     * @param resultCode 状态码
     * @param <T>        泛型标识
     * @return ApiResult
     */
    public static <T> Result<T> success(IResultCode resultCode) {
        return new Result<>(resultCode);
    }
    public static <T> Result<T> success(String msg) {
        return new Result<>(ResultCode.SUCCESS, msg);
    }
    public static <T> Result<T> success(IResultCode resultCode, String msg) {
        return new Result<>(resultCode, msg);
    }
    public static <T> Result<T> data(T data) {
        return data(data, "处理成功");
    }
    public static <T> Result<T> data(T data, String msg) {
        return data(ResultCode.SUCCESS.code, data, msg);
    }
    public static <T> Result<T> data(int code, T data, String msg) {
        return new Result<>(code, data, data == null ? "承载数据为空" : msg);
    }
    public static <T> Result<T> fail() {
        return new Result<>(ResultCode.FAILURE, ResultCode.FAILURE.getMsg());
    }
    public static <T> Result<T> fail(String msg) {
        return new Result<>(ResultCode.FAILURE, msg);
    }
    public static <T> Result<T> fail(int code, String msg) {
        return new Result<>(code, null, msg);
    }
    public static <T> Result<T> fail(IResultCode resultCode) {
        return new Result<>(resultCode);
    }
    public static <T> Result<T> fail(IResultCode resultCode, String msg) {
        return new Result<>(resultCode, msg);
    }
    public static <T> Result<T> condition(boolean flag) {
        return flag ? success("处理成功") : fail("处理失败");
    }
}



定义实体对象

@Data
public class Student  implements Serializable {
    /**
     * ID
     */
    private Long id;
    /**
     * 学生姓名
     */
    private String name;
    /**
     * 性别默认男
     */
    private String sex;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 注册手机号
     */
    private String mobile;
    /**
     * 注册邮箱
     */
    private String email;
    private Date createDate;
    private Date updateDate;
    /**
     *是否可用(1 可用,0 删除用户)
     */
    private Integer isEnabled;
    private static final long serialVersionUID = 1L;
}


实现mapper

  • 实现studentmapper
public interface StudentMapper {
    Student findById(@Param("id") Long id);
    List<Student> selectAll();
    void updateStudent(Student student);
    int insertByObject(Student student);
}


  • 实现map的xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.learn.springboot.mapper.StudentMapper">
    <resultMap id="student" type="com.learn.springboot.entity.Student">
        <id column="id" property="id" />
        <result column="name" property="name" />
        <result column="sex" property="sex" />
        <result column="age" property="age" />
        <result column="mobile" property="mobile" />
        <result column="email" property="email" />
        <result column="create_date" property="createDate" />
        <result column="update_date" property="updateDate" />
        <result column="is_enabled" property="isEnabled" />
    </resultMap>
    <select id="findById" resultType="com.learn.springboot.entity.Student">
        SELECT * FROM STUDENT WHERE ID = #{id}
    </select>
    <select id="selectAll" resultMap="student">
        SELECT * FROM STUDENT
    </select>
    <insert id="insertByObject">
        INSERT INTO STUDENT(NAME, SEX,AGE,EMAIL,MOBILE) VALUES(#{name}, #{sex}, #{age}, #{email}, #{mobile})
    </insert>
    <update id="updateStudent" parameterType="com.learn.springboot.entity.Student">
       UPDATE STUDENT SET NAME=#{name},SEX=#{sex},AGE=#{age},EMAIL=#{email},MOBILE=#{mobile} WHERE id=#{id}
    </update>
</mapper>


控制层的实现

实现student的控制层

@Slf4j
@RequestMapping("/student")
@RestController
@AllArgsConstructor
public class StudentController {
    /**
     * studentService注入StudentController
     */
    private StudentService studentService;
    @PostMapping("insert")
    public Result insertByObject(@RequestBody Student student){
        Integer byObject = studentService.insertByObject(student);
        return  Result.success(byObject.toString());
    }
    @PostMapping("update")
    public Result<Student> updateStudent(@RequestBody Student student) {
        return   Result.data(studentService.updateStudent(student));
    }
    @GetMapping("/select/{id}")
    public Result<Student> findByName(@PathVariable("id") Long id) {
        Student byId = studentService.findById(id);
        return Result.data(studentService.findById(id));
    }
    @GetMapping("/selectAll")
    public Result<List<Student>> selectAll() {
        List<Student> students = studentService.selectAll();
        return  Result.data(students);
    }
}



测试


使用postman分别测试

  • http://localhost:8899/student/select/11 Get方法
  • http://localhost:8899/student/selectAll Get方法

测试结果如下


2f29bd8ad1eef660026b741c6127c904.png


目录
相关文章
|
6月前
|
JSON 前端开发 Java
SpringBoot之响应的详细解析
SpringBoot之响应的详细解析
49 0
|
6月前
|
Java API 微服务
【Spring Boot系列】通过OpenAPI规范构建微服务服务接口
【4月更文挑战第5天】通过OpenAPI接口构建Spring Boot服务RestAPI接口
238 0
|
1月前
|
JSON 前端开发 Java
Spring Boot框架中的响应与分层解耦架构
在Spring Boot框架中,响应与分层解耦架构是两个核心概念,它们共同促进了应用程序的高效性、可维护性和可扩展性。
50 3
|
1月前
|
XML Java 应用服务中间件
【Spring】运行Spring Boot项目,请求响应流程分析以及404和500报错
【Spring】运行Spring Boot项目,请求响应流程分析以及404和500报错
167 2
|
2月前
|
设计模式 Java API
Quarkus RESTful API性能揭秘:如何打造极速响应的应用程序?
在互联网高速发展的背景下,企业对应用性能的要求日益提升。Quarkus作为一款基于Java的开源框架,以出色的性能和简洁的设计模式成为开发者的首选。本文通过实例展示如何利用Quarkus构建响应迅速的RESTful API应用。首先创建Maven项目并配置Quarkus依赖,接着逐步实现用户管理系统的各个模块,包括实体类、数据访问层、服务层及资源层,最终完成一个高性能的RESTful API。通过Quarkus,开发者可以更高效地开发出轻量级且响应快速的应用程序。
52 1
|
3月前
|
前端开发 小程序 Java
【规范】SpringBoot接口返回结果及异常统一处理,这样封装才优雅
本文详细介绍了如何在SpringBoot项目中统一处理接口返回结果及全局异常。首先,通过封装`ResponseResult`类,实现了接口返回结果的规范化,包括状态码、状态信息、返回信息和数据等字段,提供了多种成功和失败的返回方法。其次,利用`@RestControllerAdvice`和`@ExceptionHandler`注解配置全局异常处理,捕获并友好地处理各种异常信息。
1101 0
【规范】SpringBoot接口返回结果及异常统一处理,这样封装才优雅
|
3月前
|
Java 数据库 开发者
"揭秘!SpringBoot+事务钩子,如何携手打造零差错、秒级响应的高效支付系统,让你的业务飞起来!"
【8月更文挑战第11天】构建高效稳定的支付系统时,Spring Boot凭借其快速开发与丰富生态成为优选框架。通过集成Spring事务管理抽象,@Transactional注解简化了数据库事务处理。针对复杂业务,可利用`TransactionSynchronizationManager`和`TransactionSynchronization`接口自定义事务钩子函数,在事务不同阶段执行特定逻辑,如支付成功或失败时的通知,确保数据一致性与业务完整性。
92 4
|
5月前
|
前端开发 Java 程序员
SpringBoot统一功能处理,拦截器,统一数据格式,捕捉异常
SpringBoot统一功能处理,拦截器,统一数据格式,捕捉异常
|
5月前
|
JSON Java Spring
实战SpringCloud响应式微服务系列教程(第八章)构建响应式RESTful服务
实战SpringCloud响应式微服务系列教程(第八章)构建响应式RESTful服务
|
5月前
|
Java
springboot提高编辑Controller和Service层速度和规范小技巧
springboot提高编辑Controller和Service层速度和规范小技巧