springboot-表单验证Valid|AOP|统一异常处理

左手的ㄟ右手 2022-05-08 09:28 298阅读 0赞

### 文章目录 ###

*  1️⃣ Validator
 *   *  1.1 使用场景
     *   *  1.1.1 验证模式
         *  1.1.2 Validator 配置
         *  1.1.3 分组配置
         *  1.1.4 国际化
         *  1.1.5 声明和验证Bean
     *  依赖
     *  使用方法 1 (缺点:每个方法需要+BindingResult参数)
     *  使用方法 2
     *  使用方法 3
     *  实体注解
 *  2️⃣使用AOP处理请求或记录日志
 *  3️⃣统一异常处理
 *   *  统一处理校验异常

# 1️⃣ Validator #

*  [bean-validator 官方文档][bean-validator]
 *  [hibernate-validator 官方文档][hibernate-validator]

## 1.1 使用场景 ##

提供接口与用户交互(获取数据、上传数据等)，由于这个过程需要用户进行相关的操作，为了避免出现一些错误的数据等，**一般需要对数据进行校验**，随着接口的增多，校验逻辑的冗余度也越来越大，虽然可以通过**抽象出校验的方法来处理**，但还是需要每次手动调用校验逻辑

### 1.1.1 验证模式 ###

*  普通模式（默认）  
    　会校验完所有的属性，然后返回所有的验证失败信息
 *  快速失败返回模式  
    　只要有一个验证失败，则返回此条验证失败信息

### 1.1.2 Validator 配置 ###

默认工厂  
Validation.buildDefaultValidatorFactory().getValidator()  
![在这里插入图片描述][20191211114835783.png]

@Configuration
    public class ValidatorConfiguration { 
        @Bean
        public Validator validator(){ 
            ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
                    .configure()
                    // true-快速失败返回模式 false-普通模式
                    .addProperty( "hibernate.validator.fail_fast", "true" )
                    .buildValidatorFactory();
    
            return validatorFactory.getValidator();
        }
    }

### 1.1.3 分组配置 ###

[分组配置介绍][Link 1]

1.  在实体字段上分组 groups=InterfaceA.class

### 1.1.4 国际化 ###

[learn more][]

### 1.1.5 声明和验证Bean ###

*  字段级别约束 : bean-validator直接访问变量不需要getter
 *  属性级别约束 : 标准的java bean(拥有setget), 注解可以放在get方法上,不是set
 *  类别级约束 : 自定义约束
 *  约束是可以继承的
 *  可以使用@Valid校验对象图 (成员变量是对象)
 *  创建自定义约束注解

## 依赖 ##

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

spring-boot-starter-web包中已经包含了Hibernate-Validator 依赖

<dependency>
    	<groupId>org.hibernate.validator</groupId>
    	<artifactId>hibernate-validator</artifactId>
    	<version>6.0.17.Final</version>
    	<scope>compile</scope>
    </dependency>

## 使用方法 1 (缺点:每个方法需要+BindingResult参数) ##

`@Valid`注解用于校验，所属包为：javax.validation.Valid。  
使用过程:  
验证传进controller的对象属性是否有错  
①.Girl实体类成员变量需要添加充当校验条件的注解，如：@Min

@Min(value = 18 , message = "未满18岁不可访问")
    private Integer age;

②.其次在controller层的方法的要校验的参数上添加@Valid注解

@PostMapping(value = "/girls")
    //!!!!需要加@Valid注解
    // SpringBoot会自动将异常错误信息绑定到该参数上BindingResult 
       public Object addGirl(@Valid Girl girl,BindingResult br) { 
       	Result result = new Result("addGirl_Error", 0, false);
       	
       	if (br.hasErrors()){  //需要处理没验证通过的结果,错误信息返回
       		result.setMessage(br.getFieldError().getDefaultMessage());
       		return result;
       	}
           try { 
               result.setResult(commandService.addGirl(girl));
               result.setType("addGirl_ACK");
               return result;
           } catch (Exception e) { 
               logger.error("添加女生失败", e);
               result.setCode(-3);
               return result;
           }
       }

`@Validated`是@Valid 的一次封装，是Spring提供的校验机制使用。@Valid不提供分组功能

## 使用方法 2 ##

不添加`BindingResult br` ,抛出异常交给全局异常类处理

## 使用方法 3 ##

实体

@NotNull(message = "id不能为空")
    private Integer id;
    
    @Range(min=0,max=3,message="type需要在0-3之间")
    private Integer type;

import lombok.Data;
    
    import javax.validation.ConstraintViolation;
    import javax.validation.Validation;
    import javax.validation.Validator;
    import javax.validation.groups.Default;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /** * 校验工具类 * <p> * ValidationResult result = ValidationUtils.validateEntity(obj); // 校验实体 * ValidationResult result = ValidationUtils.validateProperty(obj,"name")//校验属性; * result.isHasErrors();//是否有错误 * result.getErrorMessage();//取得错误信息 * * @author zhaojy */
    public class ValidationUtils { 
        /** * 默认校验工厂 生产的 validator * 也可以通过博客中 配置类注入 */
        private static Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
    
        /** * 对 整个 对象进行校验 * * @param <T>object 对象 * @return ValidationResult 校验结果 */
        public static <T> ValidationResult validateEntity(T object) { 
            ValidationResult result = new ValidationResult();
            // 使用默认分组 Default.class
            Set<ConstraintViolation<T>> set = validator.validate(object, Default.class);
            if (set != null && !set.isEmpty()) { 
                result.setHasErrors(true);
                Map<String, String> errorMsg = new HashMap<>(5);
                for (ConstraintViolation<T> constraintViolation : set) { 
                    // propertyPath: 从北验证跟对象到被验证的属性的路径 message: 错误信息
                    errorMsg.put(constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage());
                }
                result.setErrorMsg(errorMsg);
            }
            return result;
        }
    
        /** * 对 对象中的 某个属性进行校验 * * @param <T>object 对象 * @param propertyName 属性名称 * @return ValidationResult 校验结果 */
        public static <T> ValidationResult validateProperty(T object, String propertyName) { 
            ValidationResult result = new ValidationResult();
            Set<ConstraintViolation<T>> set = validator.validateProperty(object, propertyName, Default.class);
            if (set != null && !set.isEmpty()) { 
                result.setHasErrors(true);
                Map<String, String> errorMsg = new HashMap<>(5);
                for (ConstraintViolation<T> constraintViolation : set) { 
                    errorMsg.put(propertyName, constraintViolation.getMessage());
                }
                result.setErrorMsg(errorMsg);
            }
            return result;
        }
    
        @Data
        public static class ValidationResult { 
    
            /** * 校验结果是否有错 */
            private boolean hasErrors;
    
            /** * 校验错误信息 */
            private Map<String, String> errorMsg;
    
        }
    }

## 实体注解 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">实体注解bean validator</th> 
   <th align="left">用法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">@Null</td> 
   <td align="left">检查该字段为必须为 null</td> 
  </tr> 
  <tr> 
   <td align="left">@NotNull</td> 
   <td align="left">用在基本类型上 不能为null</td> 
  </tr> 
  <tr> 
   <td align="left">@NotBlank</td> 
   <td align="left">用在String上面 不能为空，检查时会将空格忽略</td> 
  </tr> 
  <tr> 
   <td align="left">@AssertTrue/@AssertFalse</td> 
   <td align="left">用于boolean字段，该字段只能为true 或false</td> 
  </tr> 
  <tr> 
   <td align="left">@DecimalMax/ @DecimalMin</td> 
   <td align="left">只能小于或等于该值/只能大于或等于该值</td> 
  </tr> 
  <tr> 
   <td align="left">@Max</td> 
   <td align="left">必须是数字 值只能小于或等于该值</td> 
  </tr> 
  <tr> 
   <td align="left">@Min</td> 
   <td align="left">必须是数字 只能大于或等于该值</td> 
  </tr> 
  <tr> 
   <td align="left">@Size(min=, max=)</td> 
   <td align="left">检查该字段的size是否在min和max之间，可以是字符串、数组、集合、Map</td> 
  </tr> 
  <tr> 
   <td align="left">@Digits(integer=2,fraction=20)</td> 
   <td align="left">检查是否是一种数字的整数、分数,小数位数的数字。</td> 
  </tr> 
  <tr> 
   <td align="left">@Future</td> 
   <td align="left">检查该字段的日期是否是属于将来的日期</td> 
  </tr> 
  <tr> 
   <td align="left">@Past</td> 
   <td align="left">检查该字段的日期是在过去</td> 
  </tr> 
  <tr> 
   <td align="left">@Pattern(regexp = )</td> 
   <td align="left">正则表达式校验</td> 
  </tr> 
  <tr> 
   <td align="left">@Valid</td> 
   <td align="left">该注解只要用于字段为一个包含其他对象的集合或map或数组的字段，或该字段直接为一个其他对象的引用，</td> 
  </tr> 
 </tbody> 
</table>

//这样在检查当前对象的同时也会检查该字段所引用的对象

<table> 
 <thead> 
  <tr> 
   <th align="left">hibernate validator</th> 
   <th align="left">用法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">@NotEmpty</td> 
   <td align="left">这里的空是指空 字符串 或 集合类</td> 
  </tr> 
  <tr> 
   <td align="left">@Email</td> 
   <td align="left">检查是否是一个有效的email地址</td> 
  </tr> 
  <tr> 
   <td align="left">@CreditCardNumber</td> 
   <td align="left">对信用卡号进行一个大致的验证</td> 
  </tr> 
  <tr> 
   <td align="left">@URL(protocol=,host,port)</td> 
   <td align="left">检查是否是一个有效的URL，如果提供了protocol，host等，则该URL还需满足提供的条件</td> 
  </tr> 
  <tr> 
   <td align="left">@Length(min=,max=)</td> 
   <td align="left">检查所属的字段的长度是否在min和max之间,只能用于字符串</td> 
  </tr> 
  <tr> 
   <td align="left">@Range</td> 
   <td align="left">检查所属的字段的长度是否在min和max之间 Apply on numeric values or string</td> 
  </tr> 
 </tbody> 
</table>

# 2️⃣使用AOP处理请求或记录日志 #

面向切面的编程，或AOP，是一种编程技术，允许程序模块化横向切割关注点，或横切典型的责任划分，如日志和事务管理。

1.引入依赖

<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-aop</artifactId>
    	</dependency>

2.具体切面代码

/** * 日志写入管理 * zjy */
    @Aspect
    @Component
    public class ControllerAspect { 
    	
    	private final static Logger logger = LoggerFactory.getLogger(ControllerAspect.class);
    
        @Autowired
        @Qualifier("logServiceImpl")
        private LogService logService;
    
        @Autowired
        private UserService userService;
    
        @Pointcut("execution(* com.honghe.managerTool.controller.CommandController.*(..)) "
                + "|| execution(* com.honghe.managerTool.controller.UserController.*(..)) ")
        public void aspect() { //拦截所有类下所有方法
        }
    
    	//配置前置通知,使用在方法aspect()上注册的切入点
        @Before("aspect()")
        public void before(JoinPoint joinPoint) { 
            String[] paramNames = ((CodeSignature) joinPoint
                    .getSignature()).getParameterNames();
            Object[] paramValues = joinPoint.getArgs();
            String userIp = "127.0.0.1";
            String oprationName = joinPoint.getSignature().getName();
    
            switch (oprationName){ 
                case "start":
                    oprationName=Operation.START.value;
                    break;
                case "stop":
                    oprationName=Operation.STOP.value;
                    break;
                case "restart":
                    oprationName=Operation.RESTART.value;
                    break;
                    default:
                        return;
            }
            if(paramValues.length>0){ 
                if(paramValues[0] instanceof HttpServletRequest){ 
                    HttpServletRequest request = (HttpServletRequest)paramValues[0];
                    userIp = ParamUtil.getIpAddress(request);
                }
            }
    
            Log log = new Log(oprationName,new Date(),userIp,1);
            logService.saveLog(log);
        }
    
        //配置后置通知,使用在方法aspect()上注册的切入点
        @After("aspect()")
        public void after(JoinPoint joinPoint){ 
            logger.info("after out successfully");
        }
    }

对http请求解析

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Date;
    
    /** * @author: zhaojianyu * @create: 2018-10-11 09:11 **/
    @Aspect
    @Component
    public class HttpAspect { 
    
        private final static Logger logger = LoggerFactory.getLogger(HttpAspect.class);
    
        /** * 拦截所有类下所有方法 */
        @Pointcut("execution(* com.zjy.blog.blog_start.controller.HelloContraller.*(..)) ")
        public void aspect() { 
        }
    
        /** * 配置前置通知,使用在方法aspect()上注册的切入点 */
        @Before("aspect()")
        public void before(JoinPoint joinPoint) { 
            logger.info("方法开始执行"+new Date());
    
            ServletRequestAttributes attributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
    
            //url
            logger.info("url={}",request.getRequestURL());
    
            logger.info("uri={}",request.getRequestURI());
            //请求方法
            logger.info("method={}",request.getMethod());
            //请求ip地址
            logger.info("ip={}",request.getRemoteAddr());
            //类名 类方法
            logger.info("class_method={}",joinPoint.getSignature().getDeclaringTypeName()+"="+joinPoint.getSignature().getName());
            //参数
            logger.info("args={}",joinPoint.getArgs());
        }
    
        @After("aspect()")
        public void after() { 
            logger.info("方法执行完毕1"+new Date());
        }
    
        @AfterReturning(returning = "object",pointcut = "aspect()")
        public void afterReturning(Object object) { 
            logger.info("方法执行完毕2"+new Date() + object);
        }
    }

https://blog.csdn.net/xiebilan/article/details/80965859

# 3️⃣统一异常处理 #

统一异常处理类

import com.honghe.managerTool.config.exception.MySecurityException;
    import com.honghe.managerTool.entity.Result;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    
    /** * @ControllerAdvice //处理所有 * @ControllerAdvice(annotations=RestController.class) //处理这个类下的异常 * @ControllerAdvice(basePackages={"com.honghe.managerTool.controller"}) //处理包下的异常 */
    
    @ControllerAdvice
    public class GlobalExceptionHandler { 
    
    
        private Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
        /** * //处理需要处理的异常类 * @ExceptionHandler(value={RuntimeException.class,MyRuntimeException.class}) * @ExceptionHandler //处理所有异常 * @ExceptionHandler(MySecurityException.class) //处理专门的异常 */
    
        @ResponseBody//返回字符串
        @ExceptionHandler
        public Result exceptionHandler(Exception e) { 
            if (e instanceof MySecurityException){ 
                MySecurityException me = (MySecurityException)e;
                //logger.error("权限异常",e);
                return new Result(me.getCode(),false,e.getMessage());
            }else if (e instanceof NullPointerException){ 
                logger.error("空指针异常",e);
                return new Result(-3,false,"空指针异常");
            }else{ 
                return new Result(-3,false,"异常");
            }
        }
    }

2.![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzYyNjc3_size_16_color_FFFFFF_t_70]  
自定义异常类

/** * 权限验证异常 * @author zhaojianyu */
    public class MySecurityException extends RuntimeException { 
    
        private Integer code;
    
        /** * 无参构造方法 */
        public MySecurityException(){ 
            super();
        }
    
        /** * 有参的构造方法 */
        public MySecurityException(String message,Integer code){ 
            super(message);
            this.code = code;
        }
    
        /** * 用指定的详细信息和原因构造一个新的异常 */
        public MySecurityException(String message, Throwable cause){ 
    
            super(message,cause);
        }
    
        /** * 用指定原因构造一个新的异常 */
         public MySecurityException(Throwable cause) { 
             super(cause);
         }
    
    
        public Integer getCode() { 
            return code;
        }
        public void setCode(Integer code) { 
            this.code = code;
        }
    }

抛出自定义异常

throw new MySecurityException("请求超时,请同步服务器时间",-2);

返回值代码枚举类

/** * * 返回值枚举类 * @author: zhaojianyu * @create: 2018-10-11 17:50 **/
    public enum ResultEnum { 
        /** * 异常信息 */
        UNKONW_ERROR(-1,"未知错误"),
        SUCCESS(0,"请求成功"),
        SECURITY_EXCEPTION(-2,"权限异常"),
        PARAMS_EXCEPTION(-3,"权限异常")
        ;
        private Integer code;
        private String message;
    
        ResultEnum() { 
        }
    
        ResultEnum(Integer code, String message) { 
            this.code = code;
            this.message = message;
        }
    
        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;
        }
    }

## 统一处理校验异常 ##

针对参数校验 会发生以下三种异常

*  `@RequestBody` 可以标注在实体上 校验失败抛出异常: `MethodArgumentNotValidException`
 *  `@PathVariable` 以及 `@RequestParam` 时 直接标注在方法参数上,同时需要在controller类上加上 `@Validated` 进行标注 校验失败抛出异常: `ConstraintViolationException`
 *  当get请求中 参数为实体时, 校验失败会抛出 `BindException`

import com.tinet.smartlink.commons.mvc.response.ApiResponseEntity;
    import com.tinet.smartlink.commons.mvc.response.ErrorCode;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.http.ResponseEntity;
    import org.springframework.validation.BindException;
    import org.springframework.validation.BindingResult;
    import org.springframework.validation.FieldError;
    import org.springframework.web.bind.MethodArgumentNotValidException;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    import org.springframework.web.context.request.WebRequest;
    
    import javax.validation.ConstraintViolationException;
    import java.util.*;
    
    /** * 统一异常处理 * @author zhaojy */
    @Slf4j
    @RestControllerAdvice
    public class GlobalExceptionHandler { 
    
        /** * 参数校验统一异常处理 */
        @ResponseBody
        @ExceptionHandler(value = { ConstraintViolationException.class, MethodArgumentNotValidException.class, BindException.class})
        public ResponseEntity<Object> handleMethodArgumentException(Exception e, WebRequest request) { 
    
            StringBuilder message = new StringBuilder("[参数校验失败]: ");
    
            Map<String, Object> map = null;
            if (e instanceof MethodArgumentNotValidException) { 
                BindingResult bindingResult = ((MethodArgumentNotValidException) e).getBindingResult();
    
                message.append(getExceptionMessageMap(bindingResult));
    
            } else if (e instanceof ConstraintViolationException) { 
                message.append(e.getMessage());
    
            } else if (e instanceof BindException) { 
                message.append(getExceptionMessageMap((BindingResult) e));
    
            }
            log.warn(message.toString());
            return ApiResponseEntity.error(ErrorCode.InvalidParameter, message.toString()).toResponseEntity();
        }
    
        /** * 获取校验失败字段 及message * * @param bindingResult 结果 * @return 空map 或 错误信息map */
        private Map<String, Object> getExceptionMessageMap(BindingResult bindingResult) { 
            Map<String, Object> map;
            if (Objects.isNull(bindingResult)){ 
                return new HashMap<>(1);
            }
            if (bindingResult.hasErrors()) { 
                List<FieldError> fieldErrors = bindingResult.getFieldErrors();
                map = new HashMap<>(fieldErrors.size());
                fieldErrors.forEach(error -> map.put(error.getField(), error.getDefaultMessage()));
            } else { 
                map = new HashMap<>(1);
            }
            return map;
        }
    }

--------------------

参考视频连接  
https://www.bilibili.com/video/av62728471

[bean-validator]: https://docs.jboss.org/hibernate/beanvalidation/spec/2.0/api/
[hibernate-validator]: https://docs.jboss.org/hibernate/validator/
[20191211114835783.png]: /images/20220508/3b3ba19a1ab348fbaa828546524e4e89.png
[Link 1]: https://blog.csdn.net/qq_37859539/article/details/82708993
[learn more]: https://www.ibm.com/developerworks/cn/java/j-cn-hibernate-validator/index.html?ca=drs-&utm_source=tuicool&utm_medium=referral
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzYyNjc3_size_16_color_FFFFFF_t_70]: /images/20220508/8429ba67475641018944730fb1204a93.png