Spring Boot Json 返回格式 + 全局异常处理 + 参数验证注解

最新推荐文章于 2024-10-30 21:29:52 发布
最新推荐文章于 2024-10-30 21:29:52 发布
阅读量973 收藏 2
点赞数
分类专栏： JAVA SpringBoot 文章标签： spring boot json java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34916296/article/details/126415125
版权

介绍

1、小编是开发新手，如果有写的不好的地方或者缺乏优化的请您指教哈。
2、虽然说一些工具网上有很成熟的解决方案，但是我们动手写一写也可以巩固一下我们开发技术。
3、本篇文章知识点：Spring AOP、Spring 全局异常处理，注解开发、JAVA反射

DEMO 下载

码云：https://gitee.com/chen_haidong/paramsVerify
csdn：https://download.youkuaiyun.com/download/qq_34916296/86404318

效果预览

在这里插入图片描述

枚举消息

用枚举来存储一些常用的返回消息，后期维护在这添加或修改即可

public enum MSG {

    // TODO 20xxx 基础消息
    SUCCESS(20000,"操作成功",true),
    ERROR(20001,"操作失败",false),

    // TODO 30xxx 身份证认证
    LOGIN_ERROR(30000,"账号或密码错误",false),
    USER_STATUS_ERROR(30001,"账号被停用",false),
    SMS_CODE_ERROR(30002,"短信验证码错误",false),
    VERIFY_CODE_ERROR(30002,"验证码错误",false),

    // TODO 40xxx 基础业务错误
    UPDATE_USER_INFO_ERROR(40000,"更新用户详情失败",false),
    UPDATE_USER_PASSWORD_ERROR(40001,"更新密码失败",false),
    OLD_PASSWORD_ERROR(40002,"旧密码错误",false),
    REPEAT_PASSWORD_ERROR(40003,"确认密码不一致",false),
    UPDATE_USER_AVATAR_ERROR(40004,"更新用户头像失败",false),
    ACCOUNT_EXIST_ERROR(40006,"账号已被使用",false),
    MOBILE_EXIST_ERROR(40007,"手机号已被使用",false),
    UPLOAD_FILE_ERROR(40008,"上传文件失败",false),
    UPLOAD_FILE_SUFFIX_ERROR(40009,"不支持该文件类型",false),
    UPLOAD_FILE_SIZE_ERROR(40010,"上传文件大小不合法",false),
    READ_FILE_ERROR(40011,"解析文件错误",false),
    READ_TEMPLATE_ERROR(40012,"上传文件模板不合法",false),
    SMS_WAIT_ERROR(40013,"短信发送太快了~请稍后再试",false),
    SMS_UPPER_LIMIT_ERROR(40014,"今天发送短信已上限",false),
    PARAMS_ERROR(40015,"参数不合法",false),

    // TODO 50xxx 基础系统错误
    SYSTEM_INDEX_OUT_OF_BOUNDS(50000, "系统错误，数组越界！",false),
    SYSTEM_ARITHMETIC_BY_ZERO(50001, "系统错误，无法除零！",false),
    SYSTEM_NULL_POINTER(50002, "系统错误，空指针！",false),
    SYSTEM_NUMBER_FORMAT(50003, "系统错误，数字转换异常！",false),
    SYSTEM_PARSE(50004, "系统错误，解析异常！",false),
    SYSTEM_IO(50005, "系统错误，IO输入输出异常！",false),
    SYSTEM_FILE_NOT_FOUND(50006, "系统错误，文件未找到！",false),
    SYSTEM_CLASS_CAST(50007, "系统错误，类型强制转换错误！",false),
    SYSTEM_PARSER_ERROR(50008, "系统错误，解析出错！",false),
    SYSTEM_DATE_PARSER_ERROR(50009, "系统错误，日期解析出错！",false),

    // TODO 51xxx 未知系统错误
    SYSTEM_ERROR(51000, "系统繁忙，请稍后再试！",false),
    SYSTEM_OPERATION_ERROR(51001, "操作失败，请重试或联系管理员",false),
    SYSTEM_ERROR_ZUUL(51002, "请求系统过于繁忙，请稍后再试！",false);

    // 响应码
    private Integer code;
    // 响应消息
    private String message;
    // 是否成功
    private Boolean success;

    MSG(Integer code,String message, Boolean success) {
        this.code = code;
        this.message = message;
        this.success = success;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Boolean getSuccess() {
        return success;
    }

    public void setSuccess(Boolean success) {
        this.success = success;
    }

}

返回对象

返回 json 的基础结构对象

public class Result {

    // 响应编码
    private Integer code;
    // 响应消息
    private String message;
    // 是否成功
    private Boolean success;
    // 数据
    private Object data;

    public Result() {}

    public Result(Integer code, String message, Boolean success, Object data) {
        this.code = code;
        this.message = message;
        this.success = success;
        this.data = data;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Boolean getSuccess() {
        return success;
    }

    public void setSuccess(Boolean success) {
        this.success = success;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("Result{");
        sb.append("code=").append(code);
        sb.append(", message='").append(message).append('\'');
        sb.append(", success=").append(success);
        sb.append(", data=").append(data);
        sb.append('}');
        return sb.toString();
    }
}

返回数据方法

在不同的业务场景我们可用不同的方法进行消息返回

public class ResultData extends Result {

    // 默认成功方法
    public static Result success() {
        return new Result(MSG.SUCCESS.getCode(), MSG.SUCCESS.getMessage(), MSG.SUCCESS.getSuccess(),"");
    }
    // 自定义成功数据方法
    public static Result success(Object data) {
        return new Result(MSG.SUCCESS.getCode(), MSG.SUCCESS.getMessage(), MSG.SUCCESS.getSuccess(),data);
    }

    // 自定义成功数据、消息方法
    public static Result success(String message, Object data) {
        return new Result(MSG.SUCCESS.getCode(), message, MSG.SUCCESS.getSuccess(),data);
    }

    // 默认失败方法
    public static Result error() {
        return new Result(MSG.ERROR.getCode(), MSG.ERROR.getMessage(), MSG.ERROR.getSuccess(),"");
    }

    // 自定义枚举消息方法
    public static Result error(MSG msg) {
        return new Result(msg.getCode(), msg.getMessage(), msg.getSuccess(),"");
    }

    // 自定义失败消息方法
    public static Result error(String message) {
        return new Result(MSG.ERROR.getCode(), message, MSG.ERROR.getSuccess(),"");
    }

    // 自定义失败消息、数据方法
    public static Result error(String message, Object data) {
        return new Result(MSG.ERROR.getCode(), message, MSG.ERROR.getSuccess(),data);
    }
    // 自定义失败消息(枚举)、数据方法
    public static Result error(MSG msg, Object data) {
        return new Result(msg.getCode(), msg.getMessage(), msg.getSuccess(),data);
    }

}

测试一下

写一个controller 返回类型用我们刚写的Result对象

@RestController
@RequestMapping("/hello")
public class HelloController {
	
	@GetMapping("/index")
    public Result index() {
        Map<String,String> data = new HashMap<>();
        data.put("name","张三");
        data.put("sex","男");
        return ResultData.success(data);
    }
	
}

在这里插入图片描述

到这里基本就差不多好了，接下来我们做全局异常捕捉

全局异常处理

这里我定义了一些常见的异常和自定的异常，如需要其他可以自行扩展

@ControllerAdvice
public class MyExceptionHandler {

    @ExceptionHandler(CustomException.class)
    @ResponseBody
    public Result returnCustomException(CustomException e) {
        e.printStackTrace();
        return ResultData.error(e.getResponseEnum());
    }

    @ExceptionHandler(ParamsException.class)
    @ResponseBody
    public Result returnCustomException(ParamsException e) {
        return ResultData.error(e.getResponseEnum(),e.getData());
    }

    // 除零异常
    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public Result arithmeticException(ArithmeticException e) {
        e.printStackTrace();
        return ResultData.error(MSG.SYSTEM_ARITHMETIC_BY_ZERO);
    }

    // 空指针
    @ExceptionHandler(NullPointerException.class)
    @ResponseBody
    public Result nullException(NullPointerException e) {
        e.printStackTrace();
        return ResultData.error(MSG.SYSTEM_NULL_POINTER);
    }

    // 数组越界
    @ExceptionHandler(ArrayIndexOutOfBoundsException.class)
    @ResponseBody
    public Result arrayIndexException(ArrayIndexOutOfBoundsException e) {
        e.printStackTrace();
        return ResultData.error(MSG.SYSTEM_INDEX_OUT_OF_BOUNDS);
    }

    // 未知异常
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public Result unknown(Exception e) {
        e.printStackTrace();
        return ResultData.error(MSG.SYSTEM_OPERATION_ERROR);
    }
    
}

测试异常处理

这里用了一个除零异常测试一下

// 除零异常
    @GetMapping("/server")
    public Result serverError() {
        int i = 1 / 0;
        return ResultData.success();
    }

在这里插入图片描述

可以看到我们捕获到异常后会自动返回我们定义好的消息处理

在这里插入图片描述
在这里插入图片描述

自定义异常

public class CustomException extends RuntimeException{

    private MSG responseEnum;

    public CustomException(MSG responseEnum) {
        super("具体异常信息为：" + responseEnum.getMessage());
        this.responseEnum = responseEnum;
    }

    public MSG getResponseEnum() {
        return responseEnum;
    }

    public void setResponseEnum(MSG responseEnum) {
        this.responseEnum = responseEnum;
    }

}

这里再来个非法参数异常，用来等下做参数验证时使用

public class ParamsException extends RuntimeException{

    private MSG responseEnum;

    private Object data;

    public ParamsException(MSG responseEnum,Object data) {
        this.responseEnum = responseEnum;
        this.data = data;
    }

    public MSG getResponseEnum() {
        return responseEnum;
    }

    public Object getData() {
        return data;
    }
}

我们先写一个异常类，在写一个优雅的触发类

public class MyException {

    public static void display(MSG responseEnum) {
        throw new CustomException(responseEnum);
    }

    public static void display(MSG responseEnum, Object data) {
        throw new ParamsException(responseEnum, data);
    }
    
}

如果不想每次抛异常都需要写 throw new 那我们可用定义一个统一调用类，这样使用异常时只需要使用 MyException 的 display 方法即可。

测试一下

// 测试统一异常
    @GetMapping("/error")
    public Result error() {
        MyException.display(MSG.SYSTEM_ERROR);
        return ResultData.success();
    }

在这里插入图片描述

接下来我们来实现对象参数验证 和自定义的注解开发

对象参数验证

这里我就简单的写几个个注解分别是 @Length（效验长度）、@NotNull（判断是否为空）、@Phone（手机号验证），我们还需要要一个触发注解 @Valid

创建注解

  • @Target 注解范围声明

CONSTRUCTOR:用于描述构造器
FIELD:用于描述域（对象属性）
LOCAL_VARIABLE:用于描述局部变量
METHOD:用于描述方法
PACKAGE:用于描述包
PARAMETER:用于描述参数
TYPE:用于描述类、接口(包括注解类型) 或enum声明

  • @Retention 生命周期

RetentionPolicy.SOURCE 在源码阶段生效
RetentionPolicy.CLASS 在编译后生效
RetentionPolicy.RUNTIME 在运行时生效

长度验证注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Length {
    String value() default "长度不合法";
    int length();
}

非空验证注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface  NotNull {
    String value() default "参数不能为空";
}

手机号验证注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Phone {
    String value() default "手机号不合法";
}

触发注解

这个就是为了触发我们的验证需要用的注解所以不需要任何属性和方法，直接写个空注解即可

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Valid {
}

注解处理器

import com.example.annotations.Length;
import com.example.annotations.NotNull;
import com.example.annotations.Phone;

import java.lang.annotation.Annotation;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class VerifyHandler {

    private static final Pattern CHINA_PATTERN = Pattern.compile("^((13[0-9])|(14[0,1,4-9])|(15[0-3,5-9])|(16[2,5,6,7])|(17[0-8])|(18[0-9])|(19[0-3,5-9]))\\d{8}$");

    public static String verify(Annotation annotation,Object data) {
        if (annotation.annotationType() == NotNull.class) {
            return notNullBack(annotation, data);
        }else if (annotation.annotationType() == Length.class) {
            return lengthBack(annotation,data);
        }else if (annotation.annotationType() == Phone.class){
            return phoneBack(annotation,data);
        }
        return "未找到匹配器";
    }

    // 这里返回的是不合法消息,空则合法
    public static String notNullBack(Annotation annotation, Object data) {
        NotNull notNull = (NotNull) annotation;
        if (data == null || "".equals(data.toString().trim()))  {
            return notNull.value();
        }
        return null;
    }

    public static String lengthBack(Annotation annotation, Object data) {
        Length length = (Length) annotation;
        if (data == null || length.length() > data.toString().trim().length())  {
            return length.value();
        }
        return null;
    }

    public static String phoneBack(Annotation annotation, Object data) {
        Matcher m = CHINA_PATTERN.matcher(Objects.toString(data));
        Phone phone = (Phone) annotation;
        if (!m.matches())  {
            return phone.value();
        }
        return null;
    }

}

测试对象

import com.example.annotations.Length;
import com.example.annotations.NotNull;
import com.example.annotations.Phone;

public class Student {
    // 姓名
    @NotNull
    private String name;
    // 手机号
    @Phone
    private String phone;
    // 密码
    @Length(value = "密码至少6位",length = 6)
    private String password;
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("Student{");
        sb.append("name='").append(name).append('\'');
        sb.append(", phone='").append(phone).append('\'');
        sb.append(", password='").append(password).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

AOP 横切拦截验证

controller 方法拦截

@Aspect
@Component
public class MyAnnotationsHandler {

    @Pointcut("execution(* com.example.controller.*.*(..))")
    public void pointCut() {
    }

    // 增强方法
    @Around("pointCut()")
    public Object verifyParams(ProceedingJoinPoint joinPoint) throws Throwable{
        Object[] args = joinPoint.getArgs();
        Object result = joinPoint.proceed(args);
        // 方法签名
        Signature signature = joinPoint.getSignature();
        // 获取的是代理类的method对象
        Method method = ( (MethodSignature)signature ).getMethod();
        // 这个方法才是目标对象上有注解的方法
        Method realMethod = joinPoint.getTarget().getClass().getDeclaredMethod(signature.getName(), method.getParameterTypes());
        // 参数下标
        int paramIndex = -1;
        boolean isVerify = false;
        Annotation[][] parameterAnnotations = realMethod.getParameterAnnotations();
        A: for (Annotation[] annotations : parameterAnnotations) {
            for (Annotation annotation : annotations) {
                paramIndex += 1;
                // 获取注解名
                if (annotation.annotationType().getName().equalsIgnoreCase(Valid.class.getName())) {
                    isVerify = true;
                    break A;
                }
            }
        }
        if (isVerify) {
            ParamsVerifyHandler.verify(args[paramIndex]);
        }
        return result;
    }
}

参数处理器

public class ParamsVerifyHandler {

    public static List<Class> verifyClass = new ArrayList<>();

    static {
        verifyClass.add(Length.class);
        verifyClass.add(NotNull.class);
        verifyClass.add(Phone.class);
    }

    //
    public static void verify(Object obj) {
        // 获取到对象
        Class clz = obj.getClass();
        // 属性列表
        List<Field> allFields = new ArrayList<>();
        // 获取当前类属性
        allFields.addAll(Arrays.asList(clz.getDeclaredFields()));
        // 如果有父类获取父类属性
        if (clz.getSuperclass() != null) {
            allFields.addAll(Arrays.asList(clz.getSuperclass().getDeclaredFields()));
        }
        Map<String,String> verifyMessage = new HashMap<>();
        for (Field field : allFields) {
            List<Annotation> fieldAnnotations = Arrays.asList(field.getAnnotations());
            for (Annotation fieldAnnotation : fieldAnnotations) {
                if (verifyClass.contains(fieldAnnotation.annotationType())) {
                    // 对应的注解事件
                    try {
                        field.setAccessible(true);
                        String message = VerifyHandler.verify(fieldAnnotation,field.get(obj));
                        if (message != null) {
                            verifyMessage.put(field.getName(),message);
                        }
                    }catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        if (verifyMessage.size() > 0) {
            MyException.display(MSG.PARAMS_ERROR,verifyMessage);
        }
    }
}

测试一下参数

只要在方法里面加入我们自定义的 @Valid 注解就可以通过 aop 拦截验证

@PostMapping("/params")
    public Result verifyParams(@Valid @RequestBody Student student) {
        return ResultData.success(student);
    }

在这里插入图片描述

Spring Boot 进阶-Spring Boot的全局异常处理机制详解
初学者
09-29 1943
其实在Spring 3.x的版本中就已经有全局异常处理的注解被提出使用了。例如@ControllerAdvice、@ExceptionHandler、@InitBinder、@ModelAttribute 等等注解。而这些注解从字面上来看与异常有关的就只有一个@ExceptionHandler 注解，也就是异常处理器的关键注解。其实在Spring中的异常处理机制有两种，一种是全局异常处理、一种是局部异常处理。那么什么是全局异常处理？什么是局部异常处理？
Spring Boot全局异常处理
洛卡JAVA架构师每日分享Java架构师知识
06-02 4819
我们知道 Spring Boot 已经提供了一套默认的异常处理机制，但是 Spring Boot 提供的默认异常处理机制却并不一定适合我们实际的业务场景，因此，我们通常会根据自身的需要对 Spring Boot 全局异常进行统一定制，例如定制错误页面，定制错误数据等。 定制错误页面 我们可以通过以下 3 种方式定制 Spring Boot 错误页面： 自定义 error.html 自定义动态错误页面 自定义静态错误页面 自定义 error.html 我们可以直接在模板引擎文件夹（/resources/tem
SpringBoot学习之全局异常处理设置（返回JSON）
10-18
本篇文章主要介绍了SpringBoot学习之全局异常处理设置（返回JSON），小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot-Json常用注解
m0_67401920的博客
04-25 976
SpringBoot 内置了 Jackson 来处理转化 Json 数据 常用注解： @ResponseBody Controller 层 方法上标注 表示将返回值类型转为 Json 数据类型 @JsonIgnore Entity 实体类 属性上标注 表示忽略 （此属性不做Json转化） @JsonProperty("xxx") Entity 实体类 属性上标注 表示起别名 @JsonFormat(pattern = "yyyy-MM-dd") Entity 实体类 属性上标注 表示日
spring boot 返回json注解
qq_42026855的博客
05-04 2067
pojo的bean里面通常会有Date类型的数据，直接通过@ResponseBody返回出去的是一个长整型时间戳（从1970到该变量时间的毫秒数），关于原因，网上很多，此处不细讲。如果想要返回自定义的日期格式，如：yyyymmddhhmmss，需做相关处理，网上有很多处理方式，大体都是继承、重写，比较复杂。实际上JSON已有注解@JsonFormat支持，使用实例： @JsonFormat(
SpringBoot @JsonMixin + Jackson @JsonProperty注解 实现返回json数据key的转换
菜鸟记录
05-17 2387
⏹SpringBoot @JsonMixin + Jackson @JsonProperty注解 实现返回json数据key的转换
SpringBoot返回json数据
jingshenbusi的博客
06-10 3387
1.pom文件 <!-- pring-boot-start-parent,可以提供dependency management,依赖管理， 引入以后在其它dependency的时候就不需要version了 --> org.springframework.boot spring-boot-starter-parent 1.3.3.RELEASE
Spring Boot 系列教程6-全局异常处理
11-30
在Spring Boot应用中，全局异常处理是至关重要的一个部分，它确保了系统在遇到错误时能够优雅地响应，提供统一的错误信息，并且保持良好的用户体验。这篇教程将深入讲解如何在Spring Boot中实现全局异常处理。 首先...
Java程序设计：spring boot（13）——全局异常与事务控制
最新发布
茜茜西西的博客
10-30 913
在使⽤ Jdbc 作为数据库访问技术时，Spring Boot框架定义了基于jdbc的PlatformTransaction Manager 接⼝的实现 DataSourceTransactionManager，并在 Spring Boot 应⽤ 启动时⾃动进⾏配置。如果使⽤ jpa 的话 Spring Boot 同样提供了对应实现。
spring 统一再处理接口返回的json数据
01-14
最近公司项目出现这样一个问题，公司的项目部署在政务云服务器，而政务云服务器所在网络是电信提供的，如果用户通过手机的非电信4G网络访问项目资源，比如MP4等，则会被电信拦截，导致访问极慢无法正常提供服务。为了解决这个问题需要用cdn服务来提供资源，以前的资源都是存在服务器上，因此需要做最小的调整切换cdn服务。 解决方案： 在spring框架下，可以利用ResponseBodyAdvice接口，实现该接口则能够在声明了ResponseBody注解的controller返回json数据前，统一对json数据做处理，将资源地址的url统一替换为cdn资源url。
【Spring boot 返回 json 数据】
m0_72254454的博客
11-07 2190
Spring boot 返回 json 数据
SpringBoot (二) --- 返回Json数据
qq_54103767的博客
03-24 9121
SpringBoot的学习之旅~
SpringBoot 返回 Json 数据格式
360°顺滑
12-09 9755
一、@RestController 注解二、Jackson1、对象、List、Map 转换为Json格式2、Jackson 的配置类三、Fastjson1、Fastjson 配置类四、封装返回的数据格式 一、@RestController 注解 在 Spring Boot 中的 Controller 中使用 @RestController 注解即可返回 JSON 格式的数据。 @RestController 注解包含了 @Controller 和 @ResponseBody 注解。@ResponseB.
校验json格式_SpringBoot数据校验（普通校验、分组校验）
weixin_36323390的博客
01-14 996
作者：吴声子夜歌原文链接：https://blog.youkuaiyun.com/cold___play/article/details/104209719普通校验普通检验是基础用法，非常容易，首先需要用户在SpringBootWeb项目中添加数据校验相关的依赖： org.springframework.boot spring-boot-start...
json格式校验并显示错误_SpringBoot统一参数校验
weixin_39868592的博客
11-22 549
前言 在日常的开发中，「参数校验」是非常重要的一个环节，严格参数校验会减少很多出bug的概率，增加接口的安全性。也会减少对接时不必要的沟通。比如说：在对接的时候前端动不动就甩个截图过来说接口有问题，你检查了半天发现前端传递的参数有问题。针对以上：今天给大家分享一下「SpringBoot」如何实现统一参数校验。实现方式 使用 @Validated注解配合参数校验注解， 比如：@NotEmpty对...
SpringBoot处理全局异常返回json字符串
IT人利哥的博客
04-20 1572
之所以要在项目中定义全局异常捕获，是因为直接异常信息给前端是真的很不友好。 首先，创建一个CommonExceptionHandler 类（自定义） ，在类头加上@ControllerAdvice注解。 /** * @Description: 公共异常处理类 * @Author: Gary * @Date: 2019-03-22 23:57 * <p>Code is ...
springboot基础教程之二--Spring boot返回json数据
2401_84181286的博客
04-11 1689
虽然面试套路众多，但对于技术面试来说，主要还是考察一个人的技术能力和沟通能力。不同类型的面试官根据自身的理解问的问题也不尽相同，没有规律可循。上面提到的关于这些JAVA基础、三大框架、项目经验、并发编程、JVM及调优、网络、设计模式、spring+mybatis源码解读、Mysql调优、分布式监控、消息队列、分布式存储等等面试题笔记及资料。
SpringBoot自定义全局异常处理并返回统一JSON格式
m0_67737207的博客
04-03 892
这个注解用于定义全局的控制器相关的行为，比如全局的异常处理、数据绑定等。：这个注解用于指示一个方法返回的值应该被写入到HTTP响应体中，通常用于将Java对象转换为JSON或XML响应。注解用于标记一个方法，该方法将处理由控制器方法抛出的特定异常。：系统返回信息给客户端需要JSON格式，定义一个类可以统一返回，不用在每个要返回的控制器写上重复的代码。标记的类中定义的方法返回的任何对象都会自动转换为JSON或XML响应，而不需要在每个方法上都添加。3.定义一个统一返回的JSON格式的类。
Spring Boot 全局异常处理详解与实践
在Spring Boot中，主要使用`@ControllerAdvice`和`@ExceptionHandler`注解来实现全局异常处理。 - `@ControllerAdvice`：这是一个类级别的注解，用于定义全局异常处理类。当在Spring应用中定义了一个带有`@...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

您好，世界

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值