springboot 自定义注解实现数据唯一性和数据是否存在的校验

本文链接：https://blog.csdn.net/z09z27b_/article/details/130851492

一、编写需要validate验证的自定义注解 CommonFieldValidate

import com.anglin.common.validate.CommonFieldValidator;
import com.anglin.common.validate.enums.CommonFieldValidateOperatesEnum;
import com.anglin.common.validate.enums.CommonFieldValidateOptionEnum;

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解--字段验证
 *
 * @author zhuzhibin
 * @date 2023/5/16 14:25
 **/
@Target({ElementType.TYPE})
//使用validator时必须添加，指定与CommonFieldValidator自定义校验器配合使用
@Constraint(validatedBy = CommonFieldValidator.class)
@Retention(RetentionPolicy.RUNTIME)
public @interface CommonFieldValidate {

    String message() default "输入的内容验证不通过";

    /**
     * 选项类型 用 AND 或者 OR 进行连接
     */
    CommonFieldValidateOptionEnum option() default CommonFieldValidateOptionEnum.AND;

    CommonFieldValidateOperatesEnum [] operates() default {CommonFieldValidateOperatesEnum.UNIQUE};

    Class<?>[] groups() default {};

    Class<? extends Payload>[]  payload() default {};
}

二、编写自定义唯一性注解和数据是否存在的注解

import com.baomidou.mybatisplus.extension.activerecord.Model;

import java.lang.annotation.*;

/**
 * 自定义注解验证字段唯一性
 *
 * @author zhuzhibin
 * @date 2023/5/16 14:25
 **/
//仅仅用于请求字段的非空校验
@Target({ElementType.FIELD})
//需要jvm运行时使用
@Retention(RetentionPolicy.RUNTIME)
public @interface CommonFieldUniqueValidate {
    /**exist
     * 验证的字段
     */
    String fieldName() default "";
    /**
     * 错误提示
     */
    String message() default "输入的内容验证失败";

    /**
     *  别名 同一个别名下的字段进行联合查询
     */
    String alias() default "";

    Class<? extends Model> clazz();

}

package com.anglin.common.annotation;

import com.baomidou.mybatisplus.extension.activerecord.Model;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解验证 --字段--数据是否存在
 *
 * @author zhuzhibin
 * @date 2023/5/16 14:25
 **/
//仅仅用于请求字段的非空校验
@Target({ElementType.FIELD})
//需要jvm运行时使用
@Retention(RetentionPolicy.RUNTIME)
public @interface CommonFieldYNExistValidate {
    /**exist
     * 验证的字段
     */
    String fieldName() default "";
    /**
     * 错误提示
     */
    String message() default "输入的内容验证失败";

    /**
     *  别名 同一个别名下的字段进行联合查询
     */
    String alias() default "";

    Class<? extends Model> clazz();

}

三、编写注解解析器

package com.anglin.common.validate;

import com.anglin.common.annotation.CommonFieldValidate;
import com.anglin.common.util.FieldValidatorUtil;
import com.anglin.common.validate.enums.CommonFieldValidateOperatesEnum;
import com.anglin.common.validate.enums.CommonFieldValidateOptionEnum;
import org.springframework.beans.factory.annotation.Autowired;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

/**
 * @Title: FieldUniqueValidator
 * @ProjectName online-plus
 * @Description: 字段校验
 * @Author ZhuZhiBin
 * @Version
 * @Date 2023/5/16 11:44
 */
public class CommonFieldValidator implements ConstraintValidator<CommonFieldValidate,Object> {

    @Autowired
    FieldValidatorUtil validatorUtil;

    private String message;
    private CommonFieldValidateOperatesEnum[] operates;
    private CommonFieldValidateOptionEnum option;

    @Override
    public void initialize(CommonFieldValidate validator) {
        this.message = validator.message();
        this.operates = validator.operates();
        this.option = validator.option();
    }

    @Override
    public boolean isValid(Object o, ConstraintValidatorContext constraintValidatorContext) {
        if(operates != null && operates.length == 0){
            return true;
        }
        return validatorUtil.validator(message, operates, option, o);
    }
}

四、编写注解中使用的枚举类

package com.anglin.common.validate.enums;

import com.anglin.common.exception.CommonException;
import lombok.Getter;

/**
 * 字段验证
 *
 * @date 2023/5/17 14:02
 **/
@Getter
public enum CommonFieldValidateOperatesEnum {

    /** 唯一性 */
    UNIQUE("UNIQUE"),

    /** 是否存在 */
    YN_EXIST("YN_EXIST");

    private final String value;


    CommonFieldValidateOperatesEnum(String value) {
        this.value = value;
    }

    public static void validate(String value) {
        boolean flag = UNIQUE.getValue().equals(value) || YN_EXIST.getValue().equals(value);
        if(!flag) {
            throw new CommonException("不支持该验证方式：{}", value);
        }
    }
}

package com.anglin.common.validate.enums;

import com.anglin.common.exception.CommonException;
import lombok.Getter;

/**
 * 验证字段选项是and 还是 or
 *
 * @date 2023/5/17 14:02
 **/
@Getter
public enum CommonFieldValidateOptionEnum {

    /** 关联 **/
    AND("AND"),

    /** 非关联 **/
    OR("OR");

    private final String value;


    CommonFieldValidateOptionEnum(String value) {
        this.value = value;
    }

    public static void validate(String value) {
        boolean flag = AND.getValue().equals(value) || OR.getValue().equals(value);
        if(!flag) {
            throw new CommonException("不支持该验证方式：{}", value);
        }
    }
}

五、编写验证的Util

package com.anglin.common.util;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import com.anglin.common.annotation.CommonFieldUniqueValidate;
import com.anglin.common.annotation.CommonFieldYNExistValidate;
import com.anglin.common.validate.enums.CommonFieldValidateOperatesEnum;
import com.anglin.common.validate.enums.CommonFieldValidateOptionEnum;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;

import javax.validation.ValidationException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Title: FieldUniqueUtils
 * @ProjectName online-plus
 * @Description: 字段唯一性校验工具类
 * @Author ZhuZhiBin
 * @Version
 * @Date 2023/5/16 11:48
 */
@Slf4j
@Component
public class FieldValidatorUtil {

    /**
     * 实体类中id字段
     */
    private String idColumnName;

    /**
     * 实体类中id的值
     */
    private Object idColumnValue;

    private final String declaredField = "memberValues";
    private final String annotateAttribute = "fieldName";
    private final String objKey = "obj";
    private final String msgKey = "msg";

    /**
     * 首先通过遍历获取vo或者dto上 自定义注解 不同选项下的列表
     * 空值字段上的注解 不进行下一步的判断
     * @param message
     * @param operates
     * @param option
     * @param o
     * @return
     */
    public boolean validator(String message, CommonFieldValidateOperatesEnum[] operates, CommonFieldValidateOptionEnum option, Object o) {
        Field[] fields = ReflectUtil.getFields(o.getClass());
        List<CommonFieldUniqueValidate> commonFieldUniqueValidateList = new LinkedList<>();
        List<CommonFieldYNExistValidate> commonFieldYNExistValidateList = new LinkedList<>();

        Map<String,Object> queryUniqueValidateMap = new HashMap<>();
        Map<String,Object> queryYNExistValidateMap = new HashMap<>();

        boolean unique = ArrayUtil.contains(operates, CommonFieldValidateOperatesEnum.UNIQUE);
        boolean ynExist = ArrayUtil.contains(operates, CommonFieldValidateOperatesEnum.YN_EXIST);

        for (Field f : fields) {
            Object fieldValue = ReflectUtil.getFieldValue(o, f);
            //排除空值字段
            if (ObjectUtil.isNull(fieldValue)) {
                continue;
            }
            //唯一性验证
            if(unique){
                uniqueBuilder(f, fieldValue, commonFieldUniqueValidateList, queryUniqueValidateMap);
            }
            //是否存在验证
            if(ynExist){
                ynExistBuilder(f, fieldValue, commonFieldYNExistValidateList, queryYNExistValidateMap);
            }
        }
        boolean res = true;
        if(ArrayUtil.contains(operates, CommonFieldValidateOperatesEnum.UNIQUE) && CollectionUtil.isNotEmpty(commonFieldUniqueValidateList)){
            res = uniqueValidator(CommonFieldValidateOperatesEnum.UNIQUE, message, option, commonFieldUniqueValidateList, queryUniqueValidateMap, o);
        }
        if(ArrayUtil.contains(operates, CommonFieldValidateOperatesEnum.YN_EXIST) && CollectionUtil.isNotEmpty(commonFieldYNExistValidateList)){
            res = yNExistValidator(CommonFieldValidateOperatesEnum.YN_EXIST, message, option,commonFieldYNExistValidateList, queryYNExistValidateMap, o);
        }
        return res;
    }

    /**
     * 是否存在
     * 将我们的属性和值组装在map中，方便后续拼接条件
     * @param f
     * @param fieldValue
     * @param commonFieldYNExistValidateList
     * @param queryYNExistValidateMap
     */
    private void ynExistBuilder(Field f, Object fieldValue, List<CommonFieldYNExistValidate> commonFieldYNExistValidateList, Map<String, Object> queryYNExistValidateMap) {
        CommonFieldYNExistValidate commonFieldYNExistValidate = f.getAnnotation(CommonFieldYNExistValidate.class);
        if(commonFieldYNExistValidate != null){
            String fieldName = StrUtil.isEmpty(commonFieldYNExistValidate.fieldName()) ? StrUtil.toUnderlineCase(f.getName())
                    : commonFieldYNExistValidate.fieldName();
            dynamicAnnotateAttribute(commonFieldYNExistValidate, fieldName);
            commonFieldYNExistValidateList.add(commonFieldYNExistValidate);
            queryYNExistValidateMap.put(fieldName, fieldValue);
        }
    }


    /**
     * 唯一性
     * 将我们的属性和值组装在map中，方便后续拼接条件
     * 动态给注解属性赋值 代码处理 主要是怕 注解在后期的使用过程中不规范的问题
     * @param f
     * @param fieldValue
     * @param commonFieldUniqueValidateList
     * @param queryUniqueValidateMap
     */
    private void uniqueBuilder(Field f, Object fieldValue, List<CommonFieldUniqueValidate> commonFieldUniqueValidateList, Map<String, Object> queryUniqueValidateMap) {
        CommonFieldUniqueValidate commonFieldUniqueValidate = f.getAnnotation(CommonFieldUniqueValidate.class);
        if(commonFieldUniqueValidate != null){
            String fieldName = StrUtil.isEmpty(commonFieldUniqueValidate.fieldName()) ? StrUtil.toUnderlineCase(f.getName())
                    : commonFieldUniqueValidate.fieldName();
            dynamicAnnotateAttribute(commonFieldUniqueValidate, fieldName);
            commonFieldUniqueValidateList.add(commonFieldUniqueValidate);
            queryUniqueValidateMap.put(fieldName, fieldValue);
        }
    }

    /**
     * 动态调整自定义注解的fieldName属性值
     *
     * @param annotate 注解
     * @param fieldName
     */
    private void dynamicAnnotateAttribute(Object annotate, String fieldName) {
        //获取 foo 这个代理实例所持有的 InvocationHandler
        InvocationHandler h = Proxy.getInvocationHandler(annotate);
        // 获取 AnnotationInvocationHandler 的 memberValues 字段
        Field hField = null;
        try {
            hField = h.getClass().getDeclaredField(declaredField);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        // 因为这个字段事 private final 修饰，所以要打开权限
        hField.setAccessible(true);
        // 获取 memberValues
        Map memberValues = null;
        try {
            memberValues = (Map) hField.get(h);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        // 修改 value 属性值
        memberValues.put(annotateAttribute, fieldName);
    }


    /**
     * 字段信息唯一性验证
     * 根据自定义注解上的属性信息 进行逻辑处理
     * 根据class 获取对象 根据mybatis-plus active-record操作进行后续持久化等操作
     *
     *
     * @param unique
     * @param option
     * @param commonFieldUniqueValidates
     * @param queryUniqueValidateMap
     * @param o
     * @return
     */
    public boolean uniqueValidator(CommonFieldValidateOperatesEnum unique, String message, CommonFieldValidateOptionEnum option, List<CommonFieldUniqueValidate> commonFieldUniqueValidates, Map<String, Object> queryUniqueValidateMap, Object o){
        //别名进行分组
        Map<String, List<CommonFieldUniqueValidate>> collect =
                commonFieldUniqueValidates.stream().collect(Collectors.groupingBy(CommonFieldUniqueValidate::alias));
        boolean res = true;
        for (String key : collect.keySet()) {

            if(CommonFieldValidateOptionEnum.AND.equals(option)) {
                Map<String, Object> stringObjectMap = uniqueValidatorBuilder(collect.get(key).get(0), message, o);
                checkUpdateOrSave(stringObjectMap.get(objKey));
                Object msg = stringObjectMap.get(msgKey);
                res = checkBuilder(unique, queryUniqueValidateMap, stringObjectMap.get(objKey), msg.toString());
            } else {
                List<CommonFieldUniqueValidate> commonFieldUniqueValidateList = collect.get(key);
                for (CommonFieldUniqueValidate commonFieldUniqueValidate : commonFieldUniqueValidateList) {
                    Map<String,Object> queryMap = new HashMap<>();
                    Map<String, Object> stringObjectMap = uniqueValidatorBuilder(commonFieldUniqueValidate, message, o);
                    checkUpdateOrSave(stringObjectMap.get(objKey));
                    Object msg = stringObjectMap.get(msgKey);
                    queryMap.put(commonFieldUniqueValidate.fieldName(), queryUniqueValidateMap.get(commonFieldUniqueValidate.fieldName()));
                    res = checkBuilder(unique, queryMap, stringObjectMap.get(objKey), msg.toString());
                    if(!res){
                        return res;
                    }
                }
            }
        }
        return res;
    }

    private Map<String,Object> uniqueValidatorBuilder(CommonFieldUniqueValidate commonFieldUniqueValidate, String message, Object o) {
        Map<String,Object> map = new HashMap();
        Object obj = null;
        if(ObjectUtil.isNotNull(commonFieldUniqueValidate.clazz())){
            try {
                obj = commonFieldUniqueValidate.clazz().newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        String msg = commonFieldUniqueValidate.message();
        if (null == obj) {
            obj = o;
        } else {
            BeanUtils.copyProperties(o, obj);
        }
        msg = StrUtil.isEmpty(msg) ? message : msg;
        map.put(objKey, obj);
        map.put(msgKey, msg);
        return map;
    }

    /**
     * 字段信息唯一性验证
     * 根据自定义注解上的属性信息 进行逻辑处理
     * 根据class 获取对象 根据mybatis-plus active-record操作进行后续持久化等操作
     *
     *
     * @param ynExist
     * @param option
     * @param commonFieldYNExistValidates
     * @param queryYNExistValidateMap
     * @param o
     * @return
     */
    public boolean yNExistValidator(CommonFieldValidateOperatesEnum ynExist, String message, CommonFieldValidateOptionEnum option, List<CommonFieldYNExistValidate> commonFieldYNExistValidates, Map<String, Object> queryYNExistValidateMap, Object o){
        //别名进行分组
        Map<String, List<CommonFieldYNExistValidate>> collect =
                commonFieldYNExistValidates.stream().collect(Collectors.groupingBy(CommonFieldYNExistValidate::alias));
        boolean res = true;
        for (String key : collect.keySet()) {
            if(CommonFieldValidateOptionEnum.AND.equals(option)) {
                Map<String, Object> stringObjectMap = yNExistValidatorBuilder(collect.get(key).get(0), message, o);
                checkUpdateOrSave(stringObjectMap.get(objKey));
                Object msg = stringObjectMap.get(msgKey);
                res = checkBuilder(ynExist, queryYNExistValidateMap, stringObjectMap.get(objKey), msg.toString());
            } else {
                for (CommonFieldYNExistValidate commonFieldYNExistValidate : collect.get(key)) {
                    Map<String,Object> queryMap = new HashMap<>();
                    Map<String, Object> stringObjectMap = yNExistValidatorBuilder(commonFieldYNExistValidate, message, o);
                    checkUpdateOrSave(stringObjectMap.get(objKey));
                    Object msg = stringObjectMap.get(msgKey);
                    queryMap.put(commonFieldYNExistValidate.fieldName(), queryYNExistValidateMap.get(commonFieldYNExistValidate.fieldName()));
                    res =  checkBuilder(ynExist, queryMap, stringObjectMap.get(objKey), msg.toString());
                    if(!res){
                        return res;
                    }
                }
            }
        }
        return res;
    }

    private Map<String, Object> yNExistValidatorBuilder(CommonFieldYNExistValidate commonFieldYNExistValidate, String message, Object o) {

        Map<String,Object> map = new HashMap();
        Object obj = null;
        if(ObjectUtil.isNotNull(commonFieldYNExistValidate.clazz())){
            try {
                obj = commonFieldYNExistValidate.clazz().newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        String msg = commonFieldYNExistValidate.message();
        if (null == obj) {
            obj = o;
        } else {
            BeanUtils.copyProperties(o, obj);
        }
        msg = StrUtil.isEmpty(msg) ? message : msg;
        map.put(objKey, obj);
        map.put(msgKey, msg);
        return map;
    }


    /**
     * 通过传入的实体类中 @TableId 注解的值是否为空，来判断是更新还是保存
     * 将值id值和id列名赋值
     * id的值不为空 是更新 否则是插入
     * @param o 被注解修饰过的实体类
     * @return
     */
    public void checkUpdateOrSave(Object o){
        Field[] fields = getAllFields(o.getClass());
        for (Field f:fields) {
            // 设置私有属性可读
            f.setAccessible(true);
            if(f.isAnnotationPresent(TableId.class)){
                TableId tableId = f.getAnnotation(TableId.class);
                idColumnName = tableId.value();
                try {
                    idColumnValue = f.get(o);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * 获取本类及其父类的属性的方法
     * @param clazz 当前类对象
     * @return 字段数组
     */
    private static Field[] getAllFields(Class<?> clazz) {
        List<Field> fieldList = new ArrayList<>();
        while (clazz != null){
            fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
            clazz = clazz.getSuperclass();
        }
        Field[] fields = new Field[fieldList.size()];
        return fieldList.toArray(fields);
    }


    /**
     * 通过传入的字段值获取数据是否重复
     * @param operate
     * @param queryMap
     * @param o
     * @param message
     * @return
     */
    public boolean checkBuilder(CommonFieldValidateOperatesEnum operate, Map<String, Object> queryMap, Object o, String message){
        Model model = (Model) o;
        QueryWrapper queryWrapper = new QueryWrapper();
        for(String key : queryMap.keySet()){
            queryWrapper.eq(key,queryMap.get(key));
        }
        if(operate.equals(CommonFieldValidateOperatesEnum.UNIQUE)){
            if(idColumnValue != null){
                //更新的话，那条件就要排除自身
                queryWrapper.ne(idColumnName,idColumnValue);
            }
            if (model.selectCount(queryWrapper) > 0){
                log.error(message);
                throw new ValidationException(message);
            }
        } else  if(operate.equals(CommonFieldValidateOperatesEnum.YN_EXIST) && model.selectCount(queryWrapper) < 0){
            log.error(message);
            throw new ValidationException(message);
        }
        return true;
    }


}

六、编写验证的dto

package com.anglin.biz.modular.user.param;

import com.anglin.biz.modular.user.entity.BizUser;
import com.anglin.common.annotation.CommonFieldUniqueValidate;
import com.anglin.common.annotation.CommonFieldValidate;
import com.anglin.common.annotation.CommonPhoneOrEmail;
import com.anglin.common.validate.enums.CommonFieldValidateOperatesEnum;
import com.anglin.common.validate.enums.CommonFieldValidateOptionEnum;
import com.anglin.common.validate.enums.CommonPhoneOrEmailTypeEnum;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;

/**
 * 人员添加参数
 *
 * @date 2022/7/26 15:36
 **/
@Getter
@Setter
@CommonFieldValidate(operates = {CommonFieldValidateOperatesEnum.UNIQUE}, option = CommonFieldValidateOptionEnum.OR, message = "用户数据验证失败，请重新输入")
public class BizUserAddParam {

    /** 账号 */
    @ApiModelProperty(value = "账号", required = true, position = 1)
    @NotBlank(message = "account不能为空")
    @CommonFieldUniqueValidate(fieldName = "account", message = "存在重复的账号，请重新输入", clazz = BizUser.class, alias = "bizUser")
    private String account;

    /** 姓名 */
    @ApiModelProperty(value = "姓名", required = true, position = 2)
    @NotBlank(message = "name不能为空")
    private String name;

    /** 机构id */
    @ApiModelProperty(value = "机构id", required = true, position = 3)
    @NotBlank(message = "orgId不能为空")
    private String orgId;

    /** 岗位id */
    @ApiModelProperty(value = "岗位id", required = true, position = 4)
    @NotBlank(message = "positionId不能为空")
    private String positionId;

    /** 岗级 */
    @ApiModelProperty(value = "岗级", position = 5)
    private String positionLevel;

    /** 主管id */
    @ApiModelProperty(value = "主管id", position = 6)
    private String directorId;

    /** 头像 */
    @ApiModelProperty(value = "头像，图片base64", position = 7)
    private String avatar;

    /** 签名 */
    @ApiModelProperty(value = "签名，图片base64", position = 8)
    private String signature;

    /** 昵称 */
    @ApiModelProperty(value = "昵称", position = 9)
    private String nickname;

    /** 性别 */
    @ApiModelProperty(value = "性别", position = 10)
    private String gender;

    /** 年龄 */
    @ApiModelProperty(value = "年龄", position = 11)
    private String age;

    /** 出生日期 */
    @ApiModelProperty(value = "出生日期", position = 12)
    private String birthday;

    /** 民族 */
    @ApiModelProperty(value = "民族", position = 13)
    private String nation;

    /** 籍贯 */
    @ApiModelProperty(value = "籍贯", position = 14)
    private String nativePlace;

    /** 家庭住址 */
    @ApiModelProperty(value = "家庭住址", position = 15)
    private String homeAddress;

    /** 通信地址 */
    @ApiModelProperty(value = "通信地址", position = 16)
    private String mailingAddress;

    /** 证件类型 */
    @ApiModelProperty(value = "证件类型", position = 17)
    private String idCardType;

    /** 证件号码 */
    @ApiModelProperty(value = "证件号码", position = 18)
    private String idCardNumber;

    /** 文化程度 */
    @ApiModelProperty(value = "文化程度", position = 19)
    private String cultureLevel;

    /** 政治面貌 */
    @ApiModelProperty(value = "政治面貌", position = 20)
    private String politicalOutlook;

    /** 毕业院校 */
    @ApiModelProperty(value = "毕业院校", position = 21)
    private String college;

    /** 学历 */
    @ApiModelProperty(value = "学历", position = 22)
    private String education;

    /** 学制 */
    @ApiModelProperty(value = "学制", position = 23)
    private String eduLength;

    /** 学位 */
    @ApiModelProperty(value = "学位", position = 24)
    private String degree;

    /** 手机 */
    @ApiModelProperty(value = "手机", position = 25)
    @CommonPhoneOrEmail(message = "手机号格式不正确", type = CommonPhoneOrEmailTypeEnum.PHONE)
    @CommonFieldUniqueValidate(fieldName = "phone", message = "存在重复的手机号，请重新输入", clazz = BizUser.class, alias = "bizUser")
    private String phone;

    /** 邮箱 */
    @ApiModelProperty(value = "邮箱", position = 26)
    @CommonPhoneOrEmail(message = "邮箱格式不正确", type = CommonPhoneOrEmailTypeEnum.EMAIL)
    @CommonFieldUniqueValidate(fieldName = "email", message = "存在重复的邮箱，请重新输入", clazz = BizUser.class, alias = "bizUser")
    private String email;

    /** 家庭电话 */
    @ApiModelProperty(value = "家庭电话", position = 27)
    private String homeTel;

    /** 办公电话 */
    @ApiModelProperty(value = "办公电话", position = 28)
    private String officeTel;

    /** 紧急联系人 */
    @ApiModelProperty(value = "紧急联系人", position = 29)
    private String emergencyContact;

    /** 紧急联系人电话 */
    @ApiModelProperty(value = "紧急联系人电话", position = 30)
    private String emergencyPhone;

    /** 紧急联系人地址 */
    @ApiModelProperty(value = "紧急联系人地址", position = 31)
    private String emergencyAddress;

    /** 员工编号 */
    @ApiModelProperty(value = "员工编号", position = 32)
    private String empNo;

    /** 入职日期 */
    @ApiModelProperty(value = "员工编号", position = 33)
    private String entryDate;

    /** 兼任信息 */
    @ApiModelProperty(value = "兼任信息", position = 34)
    private String positionJson;

    /** 排序码 */
    @ApiModelProperty(value = "排序码", position = 35)
    private Integer sortCode;

    /** 扩展信息 */
    @ApiModelProperty(value = "扩展信息", position = 36)
    private String extJson;
}

七、编写controller

/**
     * 添加人员
     *
     * @date 2022/4/24 20:47
     */
    @ApiOperationSupport(order = 2)
    @ApiOperation("添加人员")
    @CommonLog("添加人员")
    @SaCheckPermission("/biz/user/add")
    @PostMapping("/biz/user/add")
    public CommonResult<String> add(@RequestBody @Valid BizUserAddParam bizUserAddParam) {
        bizUserService.add(bizUserAddParam);
        return CommonResult.ok();
    }