java结果返回集的进阶配置

最新推荐文章于 2024-07-16 23:18:45 发布
最新推荐文章于 2024-07-16 23:18:45 发布
阅读量316 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： springboot基础建筑 文章标签： java postman json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jinchen_xia/article/details/124734108
本文档展示了如何创建一个名为`Rest`的Java类，用于封装REST API的响应状态，包括成功、错误等各种HTTP状态码，并提供了便捷的方法来快速构造相应状态的响应。同时定义了一个枚举`RestStatus`，包含了常见的HTTP状态码及其描述。此外，还定义了`RestException`异常类，用于在API调用中抛出异常。测试代码演示了如何使用这些类在Controller中返回不同状态的响应。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.声明一个Rest.java文件

@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
@ApiIgnore
@NoArgsConstructor
public class Rest<T> implements Serializable {
    @ApiModelProperty(value = "状态码")
    private int status;
    @ApiModelProperty(value = "状态信息")
    private String msg;
    @ApiModelProperty(value = "返回的Json数据")
    private T data;


    private Rest(RestStatus status){
        changeHttpStatus(status);
    }
    private Rest(RestStatus status,String msg){
        changeHttpStatus(status);
        this.msg = msg;
    }
    private Rest(RestStatus status,T data){
        changeHttpStatus(status);
        this.data = data;
    }
    private Rest(RestStatus status,String msg,T data){
        changeHttpStatus(status);
        this.data =  data;
        this.msg = msg;
    }

    private void changeHttpStatus(RestStatus status) {
        try {
            //Response请求头获取配置
            HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
            //设置返回的请求头
            response.setStatus(status.getCode());
            this.status  = status.getCode();
            this.msg = status.getDesc();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 200 GET/PUT请求返回
     */

    public static <T> Rest<T> SUCCESS() {
        return new Rest<>(RestStatus.SUCCESS);
    }

    public static <T> Rest<T> SUCCESS(String msg) {
        return new Rest<>(RestStatus.SUCCESS, msg);
    }

    public static <T> Rest<T> SUCCESS(T data) {
        return new Rest<>(RestStatus.SUCCESS, data);
    }

    public static <T> Rest<T> SUCCESS(String msg, T data) {
        return new Rest<>(RestStatus.SUCCESS, msg, data);
    }

    /**
     * 201 POST请求返回
     */

    public static <T> Rest<T> CREATED() {
        return new Rest<>(RestStatus.CREATED);
    }

    public static <T> Rest<T> CREATED(String msg) {
        return new Rest<>(RestStatus.CREATED, msg);
    }

    public static <T> Rest<T> CREATED(T data) {
        return new Rest<>(RestStatus.CREATED, data);
    }

    public static <T> Rest<T> CREATED(String msg, T data) {
        return new Rest<>(RestStatus.CREATED, msg, data);
    }

    /**
     * 202 暂时挂起的请求
     */

    public static <T> Rest<T> ACCEPTED() {
        return new Rest<>(RestStatus.ACCEPTED);
    }

    public static <T> Rest<T> ACCEPTED(String msg) {
        return new Rest<>(RestStatus.ACCEPTED, msg);
    }

    public static <T> Rest<T> ACCEPTED(T data) {
        return new Rest<>(RestStatus.ACCEPTED, data);
    }

    public static <T> Rest<T> ACCEPTED(String msg, T data) {
        return new Rest<>(RestStatus.ACCEPTED, msg, data);
    }

    /**
     * 204 DELETE请求返回
     */

    public static <T> Rest<T> NO_CONTENT() {
        return new Rest<>(RestStatus.NO_CONTENT);
    }

    public static <T> Rest<T> NO_CONTENT(String msg) {
        return new Rest<>(RestStatus.NO_CONTENT, msg);
    }

    public static <T> Rest<T> NO_CONTENT(T data) {
        return new Rest<>(RestStatus.NO_CONTENT, data);
    }

    public static <T> Rest<T> NO_CONTENT(String msg, T data) {
        return new Rest<>(RestStatus.NO_CONTENT, msg, data);
    }

    /**
     * 304 用于判断缓存是否过期
     */

    public static <T> Rest<T> NO_CHANGE() {
        return new Rest<>(RestStatus.NO_CHANGE);
    }

    public static <T> Rest<T> NO_CHANGE(String msg) {
        return new Rest<>(RestStatus.NO_CHANGE, msg);
    }

    public static <T> Rest<T> NO_CHANGE(T data) {
        return new Rest<>(RestStatus.NO_CHANGE, data);
    }

    public static <T> Rest<T> NO_CHANGE(String msg, T data) {
        return new Rest<>(RestStatus.NO_CHANGE, msg, data);
    }

    /**
     * 400 接口调用失败
     */

    public static <T> Rest<T> BAD_REQUEST() {
        return new Rest<>(RestStatus.BAD_REQUEST);
    }

    public static <T> Rest<T> BAD_REQUEST(String msg) {
        return new Rest<>(RestStatus.BAD_REQUEST, msg);
    }

    public static <T> Rest<T> BAD_REQUEST(T data) {
        return new Rest<>(RestStatus.BAD_REQUEST, data);
    }

    public static <T> Rest<T> BAD_REQUEST(String msg, T data) {
        return new Rest<>(RestStatus.BAD_REQUEST, msg, data);
    }

    /**
     * 401 无身份信息
     */

    public static <T> Rest<T> UNAUTHORIZED() {
        return new Rest<>(RestStatus.UNAUTHORIZED);
    }

    public static <T> Rest<T> UNAUTHORIZED(String msg) {
        return new Rest<>(RestStatus.UNAUTHORIZED, msg);
    }

    public static <T> Rest<T> UNAUTHORIZED(T data) {
        return new Rest<>(RestStatus.UNAUTHORIZED, data);
    }

    public static <T> Rest<T> UNAUTHORIZED(String msg, T data) {
        return new Rest<>(RestStatus.UNAUTHORIZED, msg, data);
    }

    /**
     * 403 有身份信息，但是无权限调用
     */

    public static <T> Rest<T> FORBIDDEN() {
        return new Rest<>(RestStatus.FORBIDDEN);
    }

    public static <T> Rest<T> FORBIDDEN(String msg) {
        return new Rest<>(RestStatus.FORBIDDEN, msg);
    }

    public static <T> Rest<T> FORBIDDEN(T data) {
        return new Rest<>(RestStatus.FORBIDDEN, data);
    }

    public static <T> Rest<T> FORBIDDEN(String msg, T data) {
        return new Rest<>(RestStatus.FORBIDDEN, msg, data);
    }

    /**
     * 404 资源不存在
     */

    public static <T> Rest<T> NOT_FOUND() {
        return new Rest<>(RestStatus.NOT_FOUND);
    }

    public static <T> Rest<T> NOT_FOUND(String msg) {
        return new Rest<>(RestStatus.NOT_FOUND, msg);
    }

    public static <T> Rest<T> NOT_FOUND(T data) {
        return new Rest<>(RestStatus.NOT_FOUND, data);
    }

    public static <T> Rest<T> NOT_FOUND(String msg, T data) {
        return new Rest<>(RestStatus.NOT_FOUND, msg, data);
    }

    /**
     * 410 请求已过时
     */

    public static <T> Rest<T> GONE() {
        return new Rest<>(RestStatus.GONE);
    }

    public static <T> Rest<T> GONE(String msg) {
        return new Rest<>(RestStatus.GONE, msg);
    }

    public static <T> Rest<T> GONE(T data) {
        return new Rest<>(RestStatus.GONE, data);
    }

    public static <T> Rest<T> GONE(String msg, T data) {
        return new Rest<>(RestStatus.GONE, msg, data);
    }

    /**
     * 429 请求次数过多
     */

    public static <T> Rest<T> TOO_MANY() {
        return new Rest<>(RestStatus.TOO_MANY);
    }

    public static <T> Rest<T> TOO_MANY(String msg) {
        return new Rest<>(RestStatus.TOO_MANY, msg);
    }

    public static <T> Rest<T> TOO_MANY(T data) {
        return new Rest<>(RestStatus.TOO_MANY, data);
    }

    public static <T> Rest<T> TOO_MANY(String msg, T data) {
        return new Rest<>(RestStatus.TOO_MANY, msg, data);
    }

    /**
     * 500 服务器错误
     */

    public static <T> Rest<T> ERROR() {
        return new Rest<>(RestStatus.ERROR);
    }

    public static <T> Rest<T> ERROR(String msg) {
        return new Rest<>(RestStatus.ERROR, msg);
    }

    public static <T> Rest<T> ERROR(T data) {
        return new Rest<>(RestStatus.ERROR, data);
    }

    public static <T> Rest<T> ERROR(String msg, T data) {
        return new Rest<>(RestStatus.ERROR, msg, data);
    }

    /**
     * 通用，请传入status
     */

    public static <T> Rest<T> COMMON(RestStatus status) {
        return new Rest<>(status);
    }

    public static <T> Rest<T> COMMON(RestStatus status, String msg) {
        return new Rest<>(status, msg);
    }

    public static <T> Rest<T> COMMON(RestStatus status, T data) {
        return new Rest<>(status, data);
    }

    public static <T> Rest<T> COMMON(RestStatus status, String msg, T data) {
        return new Rest<>(status, msg, data);
    }

    /**
     * 抛出异常
     */

    public static void Exception(String msg) throws RestException {
        throw new RestException(msg);
    }

    public static void Exception(RestStatus status) throws RestException {
        throw new RestException(status, status.getDesc());
    }

    public static void Exception(RestStatus status, String msg) throws RestException {
        throw new RestException(status, msg);
    }
}

2.新建一个枚举类RestStatus

public enum RestStatus {
    // 常用，用于GET【查询】/PUT【修改】请求
    SUCCESS(200, "成功"),

    // 常用，用于POST【新增】请求
    CREATED(201, "创建成功"),

    // 不常用，暂时挂起时启用，如异步处理某信息
    ACCEPTED(202, "已接受请求"),

    // 不常用，无返回值
    NO_CONTENT(204, "操作成功"),

    // 不常用，用于查询客户端缓存数据是否适用，一般附带时间戳请求
    NO_CHANGE(304, "数据无变化"),

    // 常用，请求的参数不合法，如参数格式不对、参数为空等
    BAD_REQUEST(400, "请求参数不合法"),

    // 常用，用户未登录时某些操作不许可时使用
    UNAUTHORIZED(401, "无身份信息"),

    // 常用，用户登录但权限不足时使用
    FORBIDDEN(403, "无操作权限"),

    // 常用，数据查询为空时使用
    NOT_FOUND(404, "资源不存在"),

    // 常用，数据查询为空时使用
    GONE(410, "该请求已过时"),

    // 常用，用户短时间发送短信等验证
    TOO_MANY(429, "请求次数过多"),

    // 常用，异常捕获
    ERROR(500, "服务器错误");

    private final int code;
    private final String desc;

    RestStatus(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public int getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }
}

3.新建一个抛出异常的返回类RestException,在Rest中被应用



import lombok.Data;
import springfox.documentation.annotations.ApiIgnore;

@Data
@ApiIgnore
public class RestException extends RuntimeException {
    private static final long serialVersionUID = 1L;

    private RestStatus status;
    private String msg;

    public RestException(String error) {
        super(error);
        this.msg = error;
    }

    public RestException(RestStatus status, String msg) {
        this.status = status;
        this.msg = msg;
    }


}

4.编写测试类代码

    @RequestMapping("/success")
    public Rest testSuccess(){
        return Rest.SUCCESS("成功返回");
    }

    @RequestMapping("/error")
    public Rest testError(){
        return  Rest.ERROR("失败返回");
    }

5.运行代码，访问localhost:8088/../success

 

 

Java 的 OkHttp 高级进阶：HTTP 请求的艺术
java专栏
09-04 2021
构建复杂的请求：使用FormBody和来构建包含文件或表单数据的请求。处理重定向：使用和循环检查来控制重定向行为。配置连接池：使用来管理连接池。使用 SSL 连接：使用和来配置 SSL 连接。处理身份验证：使用来处理基本身份验证。处理错误状态码：检查响应的状态码来决定如何处理。使用 HTTP 代理：使用proxy来配置代理服务器。使用 Cookie：使用CookieJar来管理和处理 Cookie。使用 HTTP 压缩：使用拦截器来处理压缩的数据。使用 HTTP 头部。
Java Retrofit：高级进阶与刨根问底
最新发布
java专栏
12-03 1702
通过这篇文章，我们不仅学习了Retrofit的基础知识，还深入了解了其高级特性。Retrofit是一款用于Android和Java应用的类型安全的HTTP客户端，它使得构建干净、流畅的API接口变得轻松愉快。Retrofit通过注解驱动的方式，将复杂的网络请求抽象成简单的接口调用，使得我们可以专注于业务逻辑的实现。为了使用上述定义的API接口，我们需要创建一个Retrofit实例，并将其与API接口绑定起来。为了调试网络请求，我们可以使用OkHttp的拦截器来打印HTTP请求和响应的详细信息。
统一结果集返回java代码
06-10
统一结果集返回java代码
Java封装统一返回结果集
小小得愿望-博客
09-19 2714
此封装返回结果集主要包括：状态码、结果描述、数据。可根据结果调用对应的结果集方法返回，返回数据中可以为任意类型的数据。 一、统计返回结果集 import com.fasterxml.jackson.annotation.JsonIgnore; import java.io.Serializable; //静态导入枚举类 import static com.yf.common.Response.ResultEnum.*; public class MyResult<T> implemen
java反射返回结果集集合
wqrerwr的专栏
01-19 483
/** * 实例化X实体 * @param _tableName String 实体对应的数据库表 * @param _columnNameList ArrayList 实体对应表中的字段列表 * @param _con Connection 数据库连接 * @param _entityName String 实体类名（全名 ...
java结果_java返回结果集封装
weixin_29771573的博客
02-12 604
1、返回消息统一定义文件CodeMsg.javapublicclassCodeMsg{privateintretCode;privateStringmessage;//按照模块定义CodeMsg//通用异常publicstaticCodeMsgSUCCESS=newCodeMsg(0,"success");publicstaticCodeMsgSERVER_EXCEP...
java通用返回结果集（适用于前后端分离数据交互）
qq_51965854的博客
04-26 1351
java通用返回结果集（适用于前后端分离数据交互）
Java的ssm商城项目-适合Java开发人员学习进阶
10-20
【标题】"Java的SSM商城项目"是一个适合Java开发人员进行学习和进阶的实践项目，它基于Spring、SpringMVC以及Redis等技术构建。这个项目旨在帮助开发者熟悉和掌握在实际电商场景中如何应用Java后端技术，提升开发...
Java 面试资料 进阶版
03-08
### Java面试资料进阶版知识点解析 #### 一、Redis高级特性详解 ##### 1. 缓存穿透 - **定义**: 当用户查询某个数据时，Redis中不存在该数据，MySQL中同样不存在，这种情况下的查询被称为缓存穿透。 - **危害**: ...
Java进阶面试合集笔记——19个技术栈（2024最新总结）
2401_85377603的博客
07-16 759
介**
java方法通用返回结果集封装操作
08-24
主要介绍了java方法通用返回结果集封装操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
JavaWeb Servler respone 返回值的设置
YL_WH的专栏
07-27 1148
// xml resp.setContentType("text/xml"); resp.setCharacterEncoding("UTF-8"); // json中文设置 resp.setHeader("Cache-Control", "no-cache"); resp.setContentType("text/json;charset=utf-8"); // json
java统一结果返回配置
ALin_Think的博客
04-04 771
统一结果返回配置 第一步，创建模块 第二步，定义状态码 public interface ResultCode { public static Integer SUCCESS = 20000; //成功 public static Integer ERROR = 20001; //失败 } 第三步，定义数据格式 import io.swagger.annotation...
java后端通用返回json结果封装
飞奔的小强
11-04 1378
Response 类 public class Response { /**** * 成功响应Msg中的信息 **/ private final static String SUCCESS = "success"; /**** * 失败响应Msg中的信息 **/ private final static String FAILED = "failed"; public static <T> Res.
java直接在response中添加写入返回信息
你来当垫子的博客
04-28 8079
工具代码 一般用于网关返回提示信息，会将信息直接写入response，。 /** * 网络请求直接在response中返回信息 * @param map 返回response中的信息 * @param request * @param response * @param code * @param msg * @throws JsonProcessingException * @throws IOException */ public static void outP
【巨人的肩膀】Spring Rest 调用的异常处理
lbh_paopao的博客
10-23 823
概述 本文将说明如何对使用 REST API 的 Spring 实现异常处理 Spring在不同版本中对异常处理的支持 Spring 3.2 之前，在 Spring MVC 应用程序中处理异常的两种主要方法是 HandlerExceptionResolver 或 @ExceptionHandler 注解。两者都有明显的缺点 Spring 3.2 开始，增加了 @ControllerAdvice 注解，以解决前两个解决方案的局限性，并在整个应用程序中促进统一的异常处理 Spring 5 引入了 Resp
如果优美地设计 springboot 接口返回
清泉影月
07-12 832
前言： 开发过程中接口数据的交互总是不可避免，数据返回的格式虽说没有统一规定，但是一些优美的接口返回总是会给予一些好的体验。 1. 数据返回通用格式 public class ResultBean<T> { private Integer code; private String message; private T data; } code ：状态码，常见的 200，404 这些，常规的状态码可能会不够用，几乎稍微大点的项目都会...
java 根据情况返回不同类型_Java里如何实现一个方法在不同情况下“返回”不同的类型变量？...
weixin_39947351的博客
02-13 2605
实践中，我们经常遇到这样的问题：要求一个方法对输入的参数进行判断后，返回不同的类型变量。我们知道，一个给定的方法的返回值只能是一种数据类型，看起来，和上面的要求是矛盾的。但是，当我们换个角度看这个问题的时候，就可以得到解决之道。比如，要求实现一个方法对输入的年龄(年龄用int类型变量表示)进行判断：如果>= 1 && <= 100方法就返回该年龄；如果不在上面那个范围之...
java 返回数据类型,从Java中的方法返回不同类型的数据？
weixin_39911066的博客
02-15 662
public static void main(String args[]) {myMethod(); // i am calling static method from main()}.public static ? myMethod(){ // ? = what should be the return typereturn value;// is Stringreturn index;//...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值