精华内容
下载资源
问答
  • SpringBoot封装统一返回数据格式

    千次阅读 2020-04-23 16:22:53
    一、定义统一响应结果类 名称 描述 code ... 返回数据 public class ResultReturn implements Serializable { private static final long serialVersionUID = 580579298763...

    一、定义统一响应结果类

    名称描述
    code状态码:0成功,-1失败
    msg响应信息
    data返回数据
    public class ResultReturn implements Serializable {
    
        private static final long serialVersionUID = 5805792987639183304L;
        /**
         * 0成功  -1失败
         */
        private String code;
    
        private String msg;
    
        private Object data;
    
        省略getter,setter...
    
        public ResultReturn(){
            super();
        }
    
        public ResultReturn(String code, String msg){
            this.code = code;
            this.msg = msg;
        }
    
        public ResultReturn(String code, String msg, Object data){
            this.code = code;
            this.msg = msg;
            this.data = data;
        }
    }

    二、工具类

    构建一个返回结果工具类,使得不用在每个业务方法中去new一个ResultReturn对象,代码看起来也更加简洁。

    public class ResultReturnUtil {
    
        /**
         * 成功 返回默认码值
         * @param msg
         * @return
         */
        public static ResultReturn success(String msg){
            return new ResultReturn("0",msg);
        }
    
        /**
         * 成功  返回自定义码值
         * @param code
         * @param msg
         * @return
         */
        public static ResultReturn success(String code, String msg){
            return new ResultReturn(code,msg);
        }
    
        public static ResultReturn success(String msg, Object data){
            return  new ResultReturn("0",msg,data);
        }
    
        public static ResultReturn fail(String msg){
            return new ResultReturn("-1",msg);
        }
    
        public static ResultReturn fail(String code, String msg){
            return new ResultReturn(code,msg);
        }
    }

    对于工具类中的静态方法根据不同的场景来定义,比如我这里定义了一个可以自定义状态码的方法。

    三、通用常量信息类

    对于一些增删改查的操作,它的返回信息我们可以使用字符串常量类来事先定义好,就不用每次去写了。这里举个栗子

    public class Constant {
    
        /**
         * 数据插入成功返回信息
         */
        public static final String ADDINFO_SUCCESS = "数据添加成功!";
    
        /**
         * 数据插入失败返回信息
         */
        public static final String ADDINFO_FAIL = "数据添加失败";
    
    }

    四、使用与测试

    比如说我这里需要添加一个用户     举个栗子,不要复制代码

     Controller:

    @Controller
    @RequestMapping("/userManage")
    public class UserController{
    
        @Autowired
        UserService userService;
        /**
         * 添加用户数据
         * @param user
         * @return
         */
        @CustomLogNotes(module = "添加用户")
        @RequestMapping("/doAddUser")
        @ResponseBody
        public ResultReturn doAddUser(User user) {
            return userService.addUser(user);
        }
    
    
    }

    Service:

    直接看实现类   这里就用到我们的工具类了

    @Service("userService")
    public class UserServiceImpl implements UserService {
        @Autowired
        UserMapper userMapper;
    
     @Override
     public ResultReturn addUser(User user) {
             int flag = userMapper.insert(user);
            if (flag > 0){
               return ResultReturnUtil.success(Constant.ADDINFO_SUCCESS);
            }else{
                return ResultReturnUtil.fail(Constant.ADDINFO_FAIL);
            }
       }
    }

    返回结果

    展开全文
  • 一般成功时,需要返回的是数据(data,比如List),此时的状态码和返回信息比较固定,而请求异常(比如输入的密码错误)时不返回数据,而返回的是特定的状态码和错误提示。 package com.ergouy.miaosha.result; .

    最近做了一个springboot项目,对返回的数据做了进一步的封装,做一些必要的笔记,一来是对自己学习的知识的巩固,二来对有同样问题的人有参考作用。



    一 封装结果类

    一般成功时,需要返回的是数据(data,比如List),此时的状态码和返回信息比较固定,而请求异常(比如输入的密码错误)时不返回数据,而返回的是特定的状态码和错误提示。

    package com.ergouy.miaosha.result;
    
    public class Result <T> {
    
        private int code; // 状态码
        private String msg; // 返回的信息
        private T data; // 返回的数据
        
        private Result(T data) {
            this.code = 0;
            this.msg = "success";
            this.data = data;
        }
    
        private Result(CodeMsg cm) {
            if (cm == null){
                return ;
            }
            this.code = cm.getCode();
            this.msg = cm.getMsg();
        }
        
        /**
         * 成功时候的调用
         * @param data
         * @param <T>
         * @return
         */
        public static <T> Result<T> success(T data){
            return new Result<T>(data);
        }
    
        /**
         * 异常时候的调用
         * @param cm
         * @param <T>
         * @return
         */
        public static <T> Result<T> error(CodeMsg cm){
            return new Result<T>(cm);
        }
        
        public int getCode() {
            return code;
        }
    
        public String getMsg() {
            return msg;
        }
    
        public T getData() {
            return data;
        }
    
    }
    

    二 错误信息进一步封装

    对错误信息进行封装,有利于对系统的维护。

    package com.ergouy.miaosha.result;
    
    public class CodeMsg {
    
        private int code;
        private String msg;
        
        private CodeMsg(int i, String success) {
            this.code = i;
            this.msg = success;
        }
    
        //通用异常
        public static CodeMsg SUCCESS = new CodeMsg(0,"success");
        public static CodeMsg SERVER_ERROR = new CodeMsg(500100,"服务端异常");
        public static CodeMsg BIND_ERROR = new CodeMsg(500101,"参数校验异常: %s");
        public static CodeMsg REQUEST_ILLEGAL = new CodeMsg(500102,"请求非法");
        
        //带动态参数的异常
        public CodeMsg fillArgs(Object... args){
            int code = this.code;
            String message = String.format(this.msg, args);
            return new CodeMsg(code,message);
        }
    
        public int getCode() {
            return code;
        }
    
        public String getMsg() {
            return msg;
        }
        
    }
    

    三 静态返回结果测试

    1. 后台代码
    /**
      * 轮询秒杀结果
      * orderId:成功
      * -1:失败
      * 0:排队中
      * @param model
      * @param user
      * @param goodsId
      * @return
      */
     @RequestMapping(value = "/result",method = RequestMethod.GET)
     @ResponseBody
     public Result<Long> miaoshaResult(Model model, MiaoshaUser user, @RequestParam("goodsId") long goodsId) {
         model.addAttribute("user", user);
         if (user == null){
             return Result.error(CodeMsg.SESSION_ERROR);
         }
         long result = miaoshaService.getMiaoshaResult(user.getId(),goodsId);
         return Result.success(result);
     }
    
    1. 前端代码
    function getMiaoshaResult(goodsId) {
         g_showLoading();
         $.ajax({
             url:'/miaosha/result',
             type:'GET',
             data:{
                 goodsId:$('#goodsId').val()
             },
             success:function (data) {
                 if (data.code == 0){
                     var result = data.data;
                     if (result < 0){//秒杀失败
                         layer.msg('对不起,秒杀失败');
                     }else if(result == 0){//继续轮询
                         setTimeout(function () {
                             getMiaoshaResult(goodsId);
                         },400);
                     }else{//秒杀成功
                         layer.confirm('恭喜您,秒杀成功!查看订单?',{btn:['确定','取消']}
                             ,function () {
                                 window.location.href = '/order_detail.htm?orderId='+ result;
                             }
                             ,function () {
                                 layer.closeAll();
                             });
                     }
                 } else{
                     layer.msg(data.msg)
                 }
             },
             error:function () {
                 layer.msg('客户端请求错误');
             }
         });
     }
    

    四 动态返回结果测试

    if (e instanceof BindException){
        BindException ex = (BindException) e;
        List<ObjectError> errors = ex.getAllErrors();
        ObjectError error = errors.get(0);
        String msg = error.getDefaultMessage(); // msg = "手机格式错误 ";
        return Result.error(CodeMsg.BIND_ERROR.fillArgs(msg)); //拼接后的返回给前端的错误提示是 "参数校验异常:手机格式错误"
      }
    

    五 总结

    如有错误恳请指正,如有侵权请联系我删除

    展开全文
  • 之前我所在公司程序员后台返回给前台的的数据结构未做统一处理,风格各不同,前台人员也对此深感头疼。这样的代码必然冗余,杂乱,不利于项目的维护与扩展,也浪费大量宝贵的时间。后面来个一个同事,对这一乱像做了...

    参考博文:https://blog.csdn.net/ZHWang102107/article/details/82931584

    之前我所在公司程序员后台返回给前台的的数据结构未做统一处理,风格各不同,前台人员也对此深感头疼。这样的代码必然冗余,杂乱,不利于项目的维护与扩展,也浪费大量宝贵的时间。后面来个一个同事,对这一乱像做了改变,是的代码风格焕然一新!今天我也模仿该同事思路做了一个同样的数据封装。以下代码在参考过多人的博客后,对自己写的做了改善出来的最终版的。
    封装数据类
    思路就是采用泛型类来进行数据模型封装,比较简单,代码如下

    /**
     * 
     */
    package learn.until;
    import io.swagger.annotations.ApiModel;
    import io.swagger.annotations.ApiModelProperty;
    import lombok.Data;
    
    /**
     * 返回给客户端信息实体
     * 
     * @Author: ljg 2020年3月11日 下午9:51:26
     * 
     * @Desc: <p>
     * 用于统一返回给客户端信息实体,统一格式,提高友好度
     * </p>
     */
    @Data
    @ApiModel
    public class RestResponse<T> {
        /**
         * 返回码
         * 
         */
        @ApiModelProperty(value = "返回码")
        private int code;
        /**
         * 返回信息
         * 
         */
        @ApiModelProperty(value = "返回信息")
        private String message;
        /**
         * 返回数据
         */
        @ApiModelProperty(value = "返回数据")
        private T data;
        public RestResponse(int code, String message, T data) {
            this.code = code;
            this.message = message;
            this.data = data;
        }
        public RestResponse(int code, String message) {
            this.code = code;
            this.message = message;
        }
        public RestResponse() {
        }
    }
    
    

    写一个公共类来生成数据对象,我开始是在上面类中写了一个静态生成方法,我觉这样耦合度太高,所以参考了别人的博客,代码如下。

    /**
     * 
     */
    package learn.until;
    
    import learn.until.staticdata.RestCode;
    
    /**
     * 
     * @Author: ljg 2020年3月12日 上午10:18:48
     * 
     * @Desc: <p>
     * </p>
     */
    public class RestResposeUtil {
    
        /**
         * 成功返回成功实体
         * 
         * @Author ljg 2020年3月11日 下午10:04:39
         * @param data 返回数据
         * @return
         */
        public static <T> RestResponse<T> success(T data) {
    
            RestResponse<T> restResponse = new RestResponse<T>();
            restResponse.setCode(RestCode.SUCCESS.getCode());
            restResponse.setMessage(RestCode.SUCCESS.getMsg());
            restResponse.setData(data);
            return restResponse;
        }
    
        /**
         * 创建一个响应实体类
         * 
         * @Author ljg 2020年3月11日 下午10:04:39
         * @param data 返回数据
         * @return
         */
        public static <T> RestResponse<T> createResponse(RestCode restCode, T data) {
            RestResponse<T> restResponse = new RestResponse<T>();
            restResponse.setCode(restCode.getCode());
            restResponse.setMessage(restCode.getMsg());
            restResponse.setData(data);
            return restResponse;
        }
    
        /**
         * 创建一个响应实体类
         * 
         * @Author ljg 2020年3月11日 下午10:04:39
         * @param data 返回数据
         * @return
         */
        public static <T> RestResponse<T> createResponse(RestCode restCode) {
            RestResponse<T> restResponse = new RestResponse<T>();
            restResponse.setCode(restCode.getCode());
            restResponse.setMessage(restCode.getMsg());
            return restResponse;
        }
    
        /**
         * 成功返回成功实体
         * 
         * @Author ljg 2020年3月11日 下午10:04:39
         * @param data 返回数据
         * @return
         */
        public static RestResponse<Object> success() {
            return success(null);
        }
    
        /**
         * 错误返回实体
         * 
         * @Author ljg 2020年3月12日 上午10:26:59
         * @param code 错误码
         * @param msg 错误信息
         * @return
         */
        public static <T> RestResponse<T> error(int code, String msg) {
            RestResponse<T> restResponse = new RestResponse<T>();
            restResponse.setCode(code);
            restResponse.setMessage(msg);
            return restResponse;
    
        }
    }
    
    

    建一个枚举类型,统一管理code和message,为了更好的降低耦合度,规范代码,利于后期维护,代码如下

    /**
     * 
     */
    package learn.until.staticdata;
    
    /**
     * 
     * @Author: ljg 2020年3月11日 下午10:07:29
     * 
     * @Desc: <p>
     * </p>
     */
    public enum RestCode {
        SUCCESS(200, "success"), ERROR(500, "error"), UNDEFINED_ERROR(-1, "未知错误"), EMPTY(1001, "参数为空");
        int code;
        String msg;
    
        RestCode(int code, String msg) {
            this.code = code;
            this.msg = msg;
        }
    
        public int getCode() {
            return code;
        }
    
        public void setCode(int code) {
            this.code = code;
        }
    
        public String getMsg() {
            return msg;
        }
    
        public void setMsg(String msg) {
            this.msg = msg;
        }
    }
    
    

    实战代码

     @ApiOperation(value = "登陆入口", notes = "登陆逻辑")
        @RequestMapping(value = "/", method = RequestMethod.POST)
        @ResponseBody
        public RestResponse<String> login(@RequestBody UserInfoCond userInfoCond) {
            RestResponse<String> response = null;
            try {
                response = RestResposeUtil.createResponse(RestCode.SUCCESS, loginService.login(userInfoCond));
            } catch (Exception e) {
                response = ExceptionHandleUtil.handle(e);
            }
            return response;
        }
    
    展开全文
  • { "code": 1, "msg": "年龄需要大于6岁", "data": null } { "code": 0, "msg": "成功", "data": { "id": 10, "name": "李", "age": 7 } } 2、定义http请求返回的最外层对象,封装返回数据的统一格式 /** * http请求...

    github源码 https://github.com/zehuawong/SpringBoot-JPA-Thymeleaf-Demo
    慕课网课程廖师兄Web进阶:https://www.imooc.com/video/14342

    1、统一响应数据格式的json

    统一json格式的response,如添加一条数据失败的时候的响应码是1而不是500,

    {
        "code": 1,
        "msg": "年龄需要大于6岁",
        "data": null
    }
    
    {
        "code": 0,
        "msg": "成功",
        "data": {
            "id": 10,
            "name": "李",
            "age": 7
        }
    }
    

    2、定义http请求返回的最外层对象,封装返回数据的统一格式

    /**
     * http请求返回的最外层对象
     * Created by wzh-zhua on 2018/10/1.
     */
    public class Result<T> {
        /** 错误码. */
        private Integer code;
    
        /** 提示信息. */
        private String msg;
    
        /** 具体的内容. */
        private T data;
    
        public Integer getCode() {
            return code;
        }
    
        public void setCode(Integer code) {
            this.code = code;
        }
    
        public String getMsg() {
            return msg;
        }
    
        public void setMsg(String msg) {
            this.msg = msg;
        }
    
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
    }
    

    3、代码复用,为了防止多次出现new Result()的代码造成冗余,增加一个工具类ResultUtil

    在这里插入图片描述
    为了避免上面出现的代码冗余情况,应该增加工具类,封装请求失败和成功时候的方法,这里可使用静态方法

    public class ResultUtil {
    
        public static Result success(Object object) {
            Result result = new Result();
            result.setCode(0);
            result.setMsg("成功");
            result.setData(object);
            return result;
        }
    
        public static Result success() {
            return success(null);
        }
    
        public static Result error(Integer code, String msg) {
            Result result = new Result();
            result.setCode(code);
            result.setMsg(msg);
            return result;
        }
    }
    

    4、Controller中冗余代码修改后变为

    ### 5、统一异常处理和全局异常捕获:@ControllerAdvice + @ExceptionHandler
    可以参考
    @ControllerAdvice + @ExceptionHandler 全局处理 Controller 层异常 
    https://blog.csdn.net/kinginblue/article/details/70186586
    Spring Boot @ControllerAdvice 处理全局异常,返回固定格式Json
    https://blog.csdn.net/u014044812/article/details/78219692
    
    **场景一**
    ![在这里插入图片描述](https://img-blog.csdn.net/20181003151031664?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIV2FuZzEwMjEwNw==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
    上面的这个异常的status的响应码的格式是500,而且json的字段不是我们自定义的字段
    **为了得到异常情况统一的返回数据,我们可以对异常捕获,取到我们想要的内容,再给它封装,最后返回给浏览器。**
    
    **场景二**
    **还有一种情况是**,对于与数据库相关的 Spring MVC 项目,我们通常会把 事务 配置在 Service层,当数据库操作失败时让 Service 层抛出运行时异常,Spring 事物管理器就会进行回滚。
    
    如此一来,我们的 Controller 层就不得不进行 try-catch Service 层的异常,否则会返回一些不友好的错误信息到客户端。但是,Controller 层每个方法体都写一些**模板化的 try-catch 的代码**,很难看也难维护,特别是还需要对 Service 层的不同异常进行不同处理的时候。
    
    **新建一个handle包,新建ExceptionHandle.java类**
    
    ```java
    /**
     * 捕获异常的类,返回信息给浏览器,可以自定义返回的code,msg等信息
     */
    @ControllerAdvice
    public class ExceptionHandle {
    
        private final static Logger logger = LoggerFactory.getLogger(ExceptionHandle.class);
    
        @ExceptionHandler(value = Exception.class)
        @ResponseBody
        public Result handle(Exception e) {
            if (e instanceof GirlException) {   //判断异常是否是我们定义的异常
                GirlException girlException = (GirlException) e;
                return ResultUtil.error(girlException.getCode(), girlException.getMessage());
            }else {
                logger.error("【系统异常】{}", e);
                return ResultUtil.error(-1, "未知错误");
            }
        }
    }
    
    

    需要注意

    • @ControllerAdvice:在spring 3.2中,新增了@ControllerAdvice 注解,用于拦截全局的Controller的异常,注意:ControllerAdvice注解只拦截Controller不会拦截Interceptor的异常。
    • 如果有需要,可以用Logger记录异常信息

    优点和缺点

    • 优点:将 Controller 层的异常和数据校验的异常进行统一处理,减少模板代码,减少编码量,提升扩展性和可维护性。
    • 缺点:只能处理 Controller 层未捕获(往外抛)的异常,对于 Interceptor(拦截器)层的异常,Spring 框架层的异常,就无能为力了。

    注意完善ExceptionHandle类
    可以参考文章 https://blog.csdn.net/kinginblue/article/details/70186586

    1. @ExceptionHandler(BusinessException.class) 声明了对 BusinessException 业务异常的处理,并获取该业务异常中的错误提示,构造后返回给客户端。

    2. @ExceptionHandler(Exception.class) 声明了对 Exception 异常的处理,起到兜底作用,不管 Controller 层执行的代码出现了什么未能考虑到的异常,都返回统一的错误提示给客户端。

    3. @ExceptionHandler(MethodArgumentNotValidException.class) 处理所有接口数据验证异常

    6、自定义异常类

    注意:spring中,只有继承RuntimeException才会进行事务回滚,Exception不会进行事务回滚

    public class GirlException extends RuntimeException{    //注意:spring中,只有RuntimeException才会进行事务回滚,Exception不会进行事务回滚
    
        private Integer code;
    
        public GirlException(ResultEnum resultEnum) {
            super(resultEnum.getMsg());
            this.code = resultEnum.getCode();
        }
    
        public Integer getCode() {
            return code;
        }
    
        public void setCode(Integer code) {
            this.code = code;
        }
    }
    

    7、Service层中异常部分的代码就可以修改为

    8、为了统一管理返回数据结果code和message,新建一个枚举类ResultEnum

    public enum ResultEnum {
        UNKONW_ERROR(-1, "未知错误"),
        SUCCESS(0, "成功"),
        PRIMARY_SCHOOL(100, "我猜你可能还在上小学"),
        MIDDLE_SCHOOL(101, "你可能在上初中"),
    
        ;
    
        private Integer code;
    
        private String msg;
    
        ResultEnum(Integer code, String msg) {
            this.code = code;
            this.msg = msg;
        }
    
        public Integer getCode() {
            return code;
        }
    
        public String getMsg() {
            return msg;
        }
    }
    
    展开全文
  • springboot返回数据封装

    2020-03-02 16:16:56
    //---系统错误返回码----- FAIL ( false , 10001 , " 操 作 失 败 " ) , UNAUTHENTICATED ( false , 10002 , "您还未登录" ) , UNAUTHORISE ( false , 10003 , "权限不足" ) , SERVER_...
  • rest接口会返回各种各样的数据,如果对接口的格式不加约束,很容易造成混乱。 在实际项目中,一般会把结果放在一个封装类中,封装类中包含http状态值,状态消息,以及实际的数据。这里主要记录两种方式:(效果如下...
  • 本文目录如下:1. Spring Boot 默认对Json的处理1.1 创建 User 实体类1.2 创建Controller类1.3 测试不同数据类型返回的json1.4 jackso...
  • 1、统一响应数据格式的json 统一json格式的response,如添加一条数据失败的时候的响应码是1而不是500, {  "code": 1,  "msg": "年龄需要大于6岁",  "data": null } ...
  • @ApiModelProperty(value = "返回数据") private Map, Object> data = new HashMap, Object>(); //构造方法私有化 private R(){} //成功的静态方法 public static R ok(){ R r=new R(); r.setSuccess(true); r.set...
  • 在 Controller 中使用@RestController注解即可返回 Json 格式的数据 Spring Boot 中默认使用的 Json 解析技术框架是 jackson jackson 中对null的处理(配置文件重要) FastJson与jackson 对比 FastJson对null的...
  • 包装SpringBoot Controller返回值示例代码。 建议用idea导入。
  • springboot 封装接口返回

    千次阅读 2019-07-30 11:13:03
    接口调用或者前后端交互都必不可少一个返回封装类 ResponseMessage.java package com.hiqiblog.ViewModel; public class ResponseMessage<T> { private static final String CODE_SUCCESS = "200"; ...
  • SpringBoot封装Json数据

    2020-07-16 13:29:11
    SpringBoot封装Json数据 1.创建模块 2.创建封装数据类ResultCode,类R public class ResultCode { public static Integer SUCCESS = 20000; //成功 public static Integer ERROR = 20001; //失败 } import ...
  • springboot返回类型封装

    千次阅读 2018-01-23 10:35:08
    controller类: /** * 获取店铺信息 * 根据城市编码查询当前城市下 根据定位的经纬度...返回符合门店配送条件的门店配送信息 没有匹配到会返回null */ @RequestMapping(value = ["/sellershop/list"]) @ApiMe
  • springboot返回数据封装

    千次阅读 2018-12-25 22:21:32
    封装类的代码实现 package com.example.demo.model; public class AjaxResult &lt;T&gt; { private static final int CODE_SUCCESS = 200; private static final int CODE_FAIL = 400; private ...
  • 在项目框架整合阶段,为了更优雅的封装后端返回结果,便于前后端联调,通常需要对后端的返回值进行一定的封装处理,下面介绍2种比较实用的方式 方式1:常规处理 定义一个枚举类,主要包括返回的code和message,更多...
  • 需求场景: ...2,封装成一个ResultUtil,优化代码 3,使用: 太长了图片显示不全,挡住的部分是: “`java bindingResult.getFieldError.getDefaultMessage(); 参考源于:imooc——Sprin...
  • 首先提供一个枚举,用于封装返回的提示码和提示信息。 package com.example.demo.result; import lombok.AllArgsConstructor; import lombok.Getter; /** * @auther wangbo * @date 2021-01-10 15:59 */ @...
  • SpringBoot返回统一封装格式的JSON数据

    千次阅读 2020-06-19 13:05:31
    最近做了一个springboot项目,了解了下controller层统一格式返回数据,做一些必要的笔记,一来是对自己学习的知识的巩固,二来对有同样问题的人有参考作用 文章目录一 概要二 @RestController注解三 常用数据类型...
  • SpringBoot返回类型封装

    千次阅读 2019-02-01 21:50:12
    SpringBoot返回类型封装返回类型封装的工具类工具类的调用总结 返回类型封装的工具类 //把返回值封装成工具类,方便调用 public class ResultMapUtils { //常量,代表后台调用的结果:成功、失败和异常 ...
  • 拖延了两天,中间有些别的需求在写,而且也遇到了点坎坷。 本章主要完善上一章一些业务的剩余瑕疵,查询时避免不了数据分页的功能,还有业务...1.封装返回数据类: 首先封装一个数据返回枚举项,准备后续异常信息...
  • Spring Boot 返回 JSON 数据数据封装

    万次阅读 多人点赞 2019-03-06 17:26:59
    文章目录2.1 @RestController 注解2.2 常用数据类型转为 JSON 格式2.2.1 创建 User 实体类2.2.2 创建 Controller 类2.2.3 测试不同数据类型返回的 JSON2.2.4 Jackson 中对 null 的处理2.3 使用 fastjson2.3.1 ...
  • 根据level_code列封装树形数据结构 每四位为一个节点 0001、0002…为根节点,诸如此类四位为第一层根节点 00010001、00010002为0001子节点 数据库表(无parent_id列) 实体类(只列部分代码) /** * 由于数据库...
  • 1.添加最外层的封装类 package com.iflytek.edu.hnezzhxy.vo; import io.swagger.annotations.ApiModel; import io.swagger.annotations.ApiModelProperty; import lombok.AllArgsConstructor; import lombok.Data;...
  • * @description:封装json对象,所有返回结果都使用它 **/ public class Result<T> { private int code;// 业务自定义状态码 private String msg;// 请求状态描述,调试用 private T data;// ...
  • SpringBoot AOP封装全局接口返回需求说明接口返回结构返回值说明AOP正题测试接口结果返回目前存在问题 需求说明 使用AOP定义一个统一的返回结构,使得项目规范化,能够自定义异常说明 接口返回结构 import io....
  • springboot统一接口返回数据

    千次阅读 2020-04-07 15:50:05
    一,没有异常的情况,正常返回数据 希望接口统一返回的数据格式如下: { "status": 0, "msg": "成功", "data": null } 和接口数据对应的bean /** * 统一返回结果的实体 * @param <T> */ public ...
  • 使用JSON作为统一响应数据格式 统一json格式的response,给出一组结果返回值的参考: { "hasPrePage": false, "hasNextPage": false, "everyPage": 10, "totalPage": 1, "currentPage": 1, "beginIndex": 0, ...
  • 最近公司项目出现这样一个...在spring框架下,可以利用ResponseBodyAdvice接口,实现该接口则能够在声明了ResponseBody注解的controller返回json数据前,统一对json数据做处理,将资源地址的url统一替换为cdn资源url。
  • 根据名称模糊查询: 封装请求参数和返回参数

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,471
精华内容 11,788
关键字:

springboot封装返回数据

spring 订阅