@Null 被注释的元素必须为null
@NotNull 被注释的元素不能为null
@AssertTrue 被注释的元素必须为true
@AssertFalse 被注释的元素必须为false
@Min(value) 被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@Max(value) 被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@DecimalMin(value) 被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@DecimalMax(value) 被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@Size(max,min) 被注释的元素的大小必须在指定的范围内。
@Digits(integer,fraction) 被注释的元素必须是一个数字，其值必须在可接受的范围内
@Past 被注释的元素必须是一个过去的日期
@Future 被注释的元素必须是一个将来的日期
@Pattern(value) 被注释的元素必须符合指定的正则表达式。
@Email 被注释的元素必须是电子邮件地址
@Length 被注释的字符串的大小必须在指定的范围内
@NotEmpty 被注释的字符串必须非空
@Range 被注释的元素必须在合适的范围内

在实体类里面添加注解：

/**
     * 电池编号
     */
    @NotNull(message = AlarmMes.bmsNoMsg)
    private String bmsNo;

    /**
     * 电池类型
     * 电池类型只有：三元锂电池和磷酸铁锂电池
     */
    @NotNull(message = AlarmMes.bmsTypeMsg)
    private String bmsType;

    /**
     *  报警类型
     */
    @NotNull(message = AlarmMes.bmsTypeMsg)
    private String type;

    /**
     * 车辆id
     */
    private Long vehicleId;
    /**
     * 组织id
     */
    private Integer groupId;

    /**
     * 组名称
     */
    private String organizationName;

    /**
     * 报警时间
     */
    private String timeBegin;

如果不符合注解的条件会被异常捕获：

 /**
     * 参数校验返回
     *
     * @param ex
     * @return
     * @throws Exception
     */
    @ExceptionHandler(value = BindException.class)
    public JsonResult bindExceptionErrorHandler(BindException ex) {
        log.error("bindExceptionErrorHandler info:{}", ex.getMessage());
        StringBuilder sb = new StringBuilder();
        FieldError fieldError = ex.getFieldError();
        sb.append(fieldError.getDefaultMessage());
        return new JsonResult(JsonResultEnum.FAIL.getCode(), sb.toString());
    }

全局异常处理：

import com.bsj.config.global.JsonResult;
import com.bsj.config.global.JsonResultEnum;
import com.bsj.util.ExceptionUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.ConversionNotSupportedException;
import org.springframework.beans.TypeMismatchException;
import org.springframework.core.annotation.Order;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.validation.BindException;
import org.springframework.validation.FieldError;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.sql.SQLException;

/**
 * 全局的的异常拦截器（拦截所有的控制器）（带有@RequestMapping注解的方法上都会拦截）
 */
@RestControllerAdvice
@Order(-1)
public class GlobalExceptionHandler{
    private static Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    private static final String logExceptionFormat = "Capture Exception By GlobalExceptionHandler: requestUrl: %s Code: %s Detail: %s";

    /**
     * 参数校验返回
     *
     * @param ex
     * @return
     * @throws Exception
     */
    @ExceptionHandler(value = BindException.class)
    public JsonResult bindExceptionErrorHandler(BindException ex) {
        log.error("bindExceptionErrorHandler info:{}", ex.getMessage());
        StringBuilder sb = new StringBuilder();
        FieldError fieldError = ex.getFieldError();
        sb.append(fieldError.getDefaultMessage());
        return new JsonResult(JsonResultEnum.FAIL.getCode(), sb.toString());
    }

    /**
     * 自定义异常返回
     * @param apiException
     * @return
     */
    @ExceptionHandler(ApiException.class)
    public JsonResult handFaceException(ApiException apiException) {
        JsonResultEnum status = apiException.getStatus();
        return new JsonResult(status, apiException.getMessage());
    }

    /**
     * 其他错误
     *
     * @param ex
     * @return
     */
    @ExceptionHandler({Exception.class})
    public JsonResult exception(HttpServletRequest request, Exception ex) {
        return resultFormat(request, JsonResultEnum.EXCEPTION, ex);
    }

    /**
     * 运行时异常
     *
     * @param ex
     * @return
     */
    @ExceptionHandler(RuntimeException.class)
    public JsonResult runtimeExceptionHandler(HttpServletRequest request, RuntimeException ex) {
        return resultFormat(request, JsonResultEnum.RUNTIME_EXCEPTION, ex);
    }

    /**
     * 空指针异常
     *
     * @param ex
     * @return
     */
    @ExceptionHandler(NullPointerException.class)
    public JsonResult nullPointerExceptionHandler(HttpServletRequest request, NullPointerException ex) {
        return resultFormat(request, JsonResultEnum.NPE, ex);
    }

    /**
     * 类型转换异常
     *
     * @param ex
     * @return
     */
    @ExceptionHandler(ClassCastException.class)
    public JsonResult classCastExceptionHandler(HttpServletRequest request, ClassCastException ex) {
        return resultFormat(request, JsonResultEnum.CLASS_CAST_EXCEPTION, ex);
    }

    /**
     * IO异常
     *
     * @param ex
     * @return
     */
    @ExceptionHandler(IOException.class)
    public JsonResult iOExceptionHandler(HttpServletRequest request, IOException ex) {
        return resultFormat(request, JsonResultEnum.IO_EXCEPTION, ex);
    }

    /**
     * 未知方法异常
     *
     * @param ex
     * @return
     */
    @ExceptionHandler(NoSuchMethodException.class)
    public JsonResult noSuchMethodExceptionHandler(HttpServletRequest request, NoSuchMethodException ex) {
        return resultFormat(request, JsonResultEnum.NO_SUCH_METHOD_EXCEPTION, ex);
    }

    /**
     * 数组越界异常
     *
     * @param ex
     * @return
     */
    @ExceptionHandler(IndexOutOfBoundsException.class)
    public JsonResult indexOutOfBoundsExceptionHandler(HttpServletRequest request, IndexOutOfBoundsException ex) {
        return resultFormat(request, JsonResultEnum.INDEX_OUT_OF_BOUNDS_EXCEPTION, ex);
    }

    /**
     * 400错误
     *
     * @param ex
     * @return
     */
    @ExceptionHandler({HttpMessageNotReadableException.class})
    public JsonResult requestNotReadable(HttpServletRequest request, HttpMessageNotReadableException ex) {
        System.out.println("400..requestNotReadable");
        return resultFormat(request, JsonResultEnum.HTTP_MESSAGE_NOT_READABLE_EXCEPTION, ex);
    }

    /**
     * 400错误
     *
     * @param ex
     * @return
     */
    @ExceptionHandler({TypeMismatchException.class})
    public JsonResult requestTypeMismatch(HttpServletRequest request, TypeMismatchException ex) {
        System.out.println("400..TypeMismatchException");
        return resultFormat(request, JsonResultEnum.Type_MISMATCH_EXCEPTION, ex);
    }

    /**
     * 400错误
     *
     * @param ex
     * @return
     */
    @ExceptionHandler({MissingServletRequestParameterException.class})
    public JsonResult requestMissingServletRequest(HttpServletRequest request, MissingServletRequestParameterException ex) {
        System.out.println("400..MissingServletRequest");
        return resultFormat(request, JsonResultEnum.MISSING_SERVLET_REQUEST_PARAMETER_EXCEPTION, ex);
    }

    /**
     * 405错误
     *
     * @param ex
     * @return
     */
    @ExceptionHandler({HttpRequestMethodNotSupportedException.class})
    public JsonResult request405(HttpServletRequest request, HttpRequestMethodNotSupportedException ex) {
        return resultFormat(request, JsonResultEnum.HTTP_REQUEST_METHOD_NOT_SUPPORTED_EXCEPTION, ex);
    }


    /**
     * 500错误
     *
     * @param ex
     * @return
     */
    @ExceptionHandler({ConversionNotSupportedException.class, HttpMessageNotWritableException.class})
    public JsonResult server500(HttpServletRequest request, RuntimeException ex) {
        System.out.println("500...");
        return resultFormat(request, JsonResultEnum.FAIL_SERVER, ex);
    }

    /**
     * 栈溢出
     *
     * @param ex
     * @return
     */
    @ExceptionHandler({StackOverflowError.class})
    public JsonResult requestStackOverflow(HttpServletRequest request, StackOverflowError ex) {
        return resultFormat(request, JsonResultEnum.SOE, ex);
    }



    private <T extends Throwable> JsonResult resultFormat(HttpServletRequest request, JsonResultEnum jsonResultEnum, T ex) {
        ex.printStackTrace();
        log.error("@@@服务异常" + String.format(logExceptionFormat, request.getRequestURL(), jsonResultEnum, ExceptionUtil.getStackStr(ex)));
        return new JsonResult(jsonResultEnum);
    }


}