项目中遇到一个需求，保存医生信息时，执业范围在医师编号为23开头时为必填项，其他医师编号时，执业范围为非必填项。当然这样的需求可以使用简单的if判断来解决，但是最近学习了注解的使用，刚才此需求可以用到，基本思路如下：
1、创建有条件判断字段为空的注解 ConditionalNotEmpty
2、在医生实体类--》执业范围字段上添加 ConditionalNotEmpty，并给出相应条件
3、切面类中使用java反射机制拿到注解信息，并根据传入的条件动态判断配置了该注解的字段是否需要校验空值
以下是大致代码：
1、注解
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ConditionalNotEmpty {
//分组标识
String groupIdentify() default "";
//错误提示信息
String message();
//业务操作标识
String[] operation() default {};
//判断依据的字段名称，如医师编号
String conditionFiledName() default "";
//判断条件，如本例中为医师编号起始值为23或者25，那么配置23,25
String contionString() default "";
}
2、医生信息实体中，在执业范围字段配置该注解
@Data
@Table(name = "t_ins_staff")
public class Doctor implements Serializable{
private static final long serialVersionUID = -7355208328761399457L;
@Id
private String id;
@NotEmpty(message = "专业技术职务代码不能为空",groups = {InsertGroup.class})
@Length(max = 3,message = "专业技术职务代码不能超过3位",groups = {InsertGroup.class})
private String zyjszwdm;
@Length(max = 30,message = "执业证书编码不能超过30位",groups = {InsertGroup.class})
@ConditionalNotEmpty(groupIdentify = "1",message = "当专业技术职务代码前缀为 23（医师）及前缀为 25（护理）的编码时，执业证书编码必填",operation = {ValidateConstants.INSERT},conditionFiledName = "zyjszwdm",contionString = "23,25")
private String zyzsbm;
}
3、切面类中获取注解并进行判断
package com.xikang.common.validator.aop;
import com.xikang.common.exception.business.BusinessException;
import com.xikang.common.util.UUIDUtils;
import com.xikang.common.validator.annotation.ConditionalNotEmpty;
import com.xikang.common.validator.annotation.CustomValidated;
import com.xikang.common.validator.annotation.GroupNotEmpty;
import com.xikang.common.validator.annotation.ValidateObj;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import javax.validation.Validator;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;
/**
* @author jiaorui
* @version 2018-09-29
* @desc 校验结果处理
*/
@Aspect
@Component
public class CustomValidatedAop {
@Autowired
protected Validator validator;
/**
* @desc 判断是否存在@CustomValidated注解
*/
@Before("@annotation(org.springframework.web.bind.annotation.PostMapping) || @annotation(org.springframework.web.bind.annotation.DeleteMapping) || @annotation(org.springframework.web.bind.annotation.PutMapping) || @annotation(org.springframework.web.bind.annotation.GetMapping )|| @annotation(org.springframework.web.bind.annotation.RequestMapping )")
public void doBefore(JoinPoint joinPoint) throws IOException {
//切入点方法参数
Object[] params = joinPoint.getArgs();
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
Method method = methodSignature.getMethod();
//获取方法参数类型
Class<?>[] paramsType = method.getParameterTypes();
Set<String> errorMessages = new HashSet<>();
//获取方法参数上的注解（因为方法可以有多参数；参数上可以有注解，返回二维数组）
Annotation[][] an = method.getParameterAnnotations();
int index = 0;
//循环参数
for (Annotation[] an1 : an) {
Object param = params[index];
//循环参数上的注解
for (Annotation an2 : an1) {
//有自定义校验注解
if (an2 instanceof CustomValidated) {
//参数是List
if (param instanceof List) {
List list = (List) param;
for (Object l : list) {
errorMessages.addAll(this.beanValidator(l, ((CustomValidated) an2).value()));
}
} else {//参数非list
//获取该参数类型
Class clazz = paramsType[index];
//反射所有字段
Field[] fields = clazz.getDeclaredFields();
for(Field field : fields){
ValidateObj validateObj = field.getAnnotation(ValidateObj.class);
//如果字段上有自定义注解@ValidateObj
if(validateObj != null){
field.setAccessible(true);
try {
Object obj = field.get(param);
errorMessages.addAll(this.beanValidator(obj, ((CustomValidated) an2).value()));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
errorMessages.addAll(this.beanValidator(param, ((CustomValidated) an2).value()));
}
//执行分组校验 begin
Set<String> errorMessage = this.groupNotEmpty(param,((CustomValidated) an2).operation());
if(errorMessage != null && errorMessage.size() > 0){
errorMessages.addAll(errorMessage);
}
//执行分组校验 end
//执行有条件动态校验 begin
Set<String> errorMessageCon = this.conditionalNotEmpty(param,((CustomValidated) an2).operation());
if(errorMessageCon != null && errorMessageCon.size() > 0){
errorMessages.addAll(errorMessageCon);
}
//执行有条件动态校验 end
if (errorMessages.size() > 0) {
List rtnStr = new ArrayList<>();
rtnStr.addAll(errorMessages);
throw new BusinessException(this.listToString(rtnStr));
}
}
}
index++;
}
}
/**
* @desc 通过validator进行分组校验返回错误信息
*/
protected List<String> beanValidator(Object object, Class<?>... groups) {
List<String> errorMessages = new ArrayList();
try {
Set constraintViolations = validator.validate(object, groups);
if (!constraintViolations.isEmpty()) {
return this.extractMessage(constraintViolations);
}
} catch (ConstraintViolationException ex) {
return errorMessages;
}
return errorMessages;
}
/**
* 转换Set<ConstraintViolation>为List<message>
*/
protected List<String> extractMessage(Set<? extends ConstraintViolation> constraintViolations) {
List<String> errorMessages = new ArrayList();
for (ConstraintViolation violation : constraintViolations) {
errorMessages.add(violation.getMessage());
}
return errorMessages;
}
/**
* 工具方法 list转string
*/
protected String listToString(List<String> mList) {
String convertedListStr = "";
if (null != mList && mList.size() > 0) {
String[] mListArray = mList.toArray(new String[mList.size()]);
for (int i = 0; i < mListArray.length; i++) {
if (i < mListArray.length - 1) {
convertedListStr += mListArray[i] + ",";
} else {
convertedListStr += mListArray[i];
}
}
return convertedListStr;
} else {
return "";
}
}
/***
* Description: 分组校验属性不能同时为空
* Date: 2019/3/15 8:56
* @param
* @return
* @author: jiaorui
*/
protected Set<String> groupNotEmpty(Object param,String[] operation){
//本类及其父类的属性集合
List<Field> fieldList = new ArrayList<>() ;
Class tempClass = param.getClass();
//递归获取本身及父类的属性
//当父类不是object并且为null的时候说明到达了最上层的父类(form继承的Entity类).
while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {
//反射本类所有属性，包括私有属性
fieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
//得到父类,然后赋给自己
tempClass = tempClass.getSuperclass();
}
// key--groupId value true 都为空 false 不全为空
Map<String, Boolean> isNotEmptyMap = new HashMap<>();
// key--groupId value 所有message
Map<String, Set> emptyMessageMap = new HashMap<>();
for(Field field : fieldList){
GroupNotEmpty groupNotEmpty = field.getAnnotation(GroupNotEmpty.class);
if(groupNotEmpty != null){
//分组标识
String groupId = groupNotEmpty.groupIdentify();
if(StringUtils.isBlank(groupId)) {
groupId = UUIDUtils.generateUuid();
}
//操作标识
String[] operations = groupNotEmpty.operation();
//判断是否匹配controller中的校验操作
boolean isValidat = this.checkArray(operations,operation);
//不匹配跳出本次循环
if(isValidat){
continue;
}
//错误提示
String message = groupNotEmpty.message();
field.setAccessible(true);
try {
//带GroupNotEmpty注解的字段的值
Object obj = field.get(param);
boolean isNull = this.isNull(obj);
if (isNull) {
// 1. 为空则
if (isNotEmptyMap.containsKey(groupId)) {
emptyMessageMap.get(groupId).add(message);
} else {
isNotEmptyMap.put(groupId, true);
Set set = new HashSet();
set.add(message);
emptyMessageMap.put(groupId, set);
}
} else {
// 2. 不为空
isNotEmptyMap.put(groupId, false);
emptyMessageMap.put(groupId, new HashSet());
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
Set returnSet = new HashSet();
for(String groupId: isNotEmptyMap.keySet()) {
if (isNotEmptyMap.get(groupId)) {
returnSet.addAll(emptyMessageMap.get(groupId));
}
}
return returnSet;
}
/***
* Description: 校验当某属性属于特定值时，该注解字段校验非空
* Date: 2020/06/01 8:56
* @param
* @return
* @author: zhangzihui
*/
protected Set<String> conditionalNotEmpty(Object param,String[] operation){
//本类及其父类的属性集合
List<Field> fieldList = new ArrayList<>() ;
Class tempClass = param.getClass();
//递归获取本身及父类的属性
//当父类不是object并且为null的时候说明到达了最上层的父类(form继承的Entity类).
while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {
//反射本类所有属性，包括私有属性
fieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
//得到父类,然后赋给自己
tempClass = tempClass.getSuperclass();
}
Set returnSet = new HashSet();
try{
for(Field field : fieldList){
ConditionalNotEmpty conditionalNotEmpty = field.getAnnotation(ConditionalNotEmpty.class);
if(conditionalNotEmpty != null){
String conditionFiledName=conditionalNotEmpty.conditionFiledName();
String contionString=conditionalNotEmpty.contionString();
String[] prefixStrs=null;
if(StringUtils.isNotEmpty(contionString)){
prefixStrs=contionString.split(",");
}
//根据conditionFiledName 的值动态判断当前field是否需要不为空
boolean needCheckEmptyFlag=false;
//获取条件字段的值
Field conditionField = param.getClass().getDeclaredField(conditionFiledName);
conditionField.setAccessible(true);
//该参数为想要获取值得对象
Object conditionFieldValue = conditionField.get(param);
for(String prefixStr:prefixStrs){
if(conditionFieldValue.toString().startsWith(prefixStr)){
//需要校验当前字段不为空
needCheckEmptyFlag=true;
}
}
if(needCheckEmptyFlag){
//操作标识
String[] operations = conditionalNotEmpty.operation();
//判断是否匹配controller中的校验操作
boolean isValidat = this.checkArray(operations,operation);
//不匹配跳出本次循环
if(isValidat){
continue;
}
//错误提示
String message = conditionalNotEmpty.message();
field.setAccessible(true);
//带ConditionalNotEmpty注解的字段的值
Object obj = field.get(param);
boolean isNull = this.isNull(obj);
if (isNull) {
returnSet.add(message);
}
}
}
}
}
catch (IllegalAccessException e) {
e.printStackTrace();
}
catch(Exception e){
e.printStackTrace();
}
return returnSet;
}
//判空
protected boolean isNull(Object obj){
boolean isNull = false;
//字段是数组类型
if(obj instanceof java.lang.String[]){
String[] array = (String[]) obj;
if(array == null || array.length == 0){
isNull = true;
}
}
//字段是集合类型
else if(obj instanceof java.util.Collection){
Collection c = (Collection) obj;
if(c == null || c.size() == 0){
isNull = true;
}
}
//字段是其他对象类型
else {
if(obj == null){
isNull = true;
}else {
isNull = org.springframework.util.StringUtils.isEmpty(obj);
}
}
return isNull;
}
//判断一个数组中的元素是否在另一个数组中出现
private boolean checkArray(String [] array1,String [] array2){
boolean flag = true;
if((array1 != null && array1.length > 0) && (array2 != null && array2.length > 0)){
for(String s1 : array1){
if(ArrayUtils.contains(array2,s1)){
flag = false;
break;
}
}
}
return flag;
}
}