自定义注解3-反射

今天有在工程代码中看到了另一种自定义注解的使用方式，通过反射来使用注解。

注解的定义：

package sv2.common.excel.validators;


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

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Required {

    String message() default "";

}

注解的使用：

package sv2.facade.isp.vo;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import sv2.common.excel.EntityWrap;
import sv2.common.excel.FieldWrap;
import sv2.common.excel.validators.Required;

import java.io.Serializable;


@Getter
@Setter
@ToString
public class CarOutputActualItemVo extends EntityWrap implements Serializable {

    @Required(message = "型号名称不能为空")
    private FieldWrap carModelName;

    @Required(message = "客户不能为空")
    private FieldWrap customerName;

    private FieldWrap jan;

    private FieldWrap feb;

    private FieldWrap mar;

    private FieldWrap apr;

    private FieldWrap may;

    private FieldWrap jun;

    private FieldWrap jul;

    private FieldWrap aug;

    private FieldWrap sep;

    private FieldWrap octo;

    private FieldWrap nov;

    private FieldWrap dece;

    @Required(message = "年度不能为空")
    private FieldWrap  annual;

}

通过反射作于于直接的方法：

 public static boolean validate(EntityWrap obj) {

        boolean validFlag = true;

        if (obj != null) {

            Field[] fields = obj.getClass().getDeclaredFields();

            for (Field field : fields) {

                if (!field.getType().isAssignableFrom(FieldWrap.class))
                    continue;

                //反射得到值
                field.setAccessible(true);
                FieldWrap fieldWrap = null;

                try {
                    fieldWrap = (FieldWrap) field.get(obj);
                } catch (IllegalAccessException ix) {
                    //
                }

                if (fieldWrap == null)
                    continue;

                //验证集合
                String value = fieldWrap.getValue();
            //--------------------获取注解---------------------------------
                for (Annotation v : field.getDeclaredAnnotations()) {

                    if (v.annotationType().isAssignableFrom(Required.class)) {
                        Required required = (Required) v;
                        if (ObjectUtil.isEmpty(value)) {
                            validFlag = setInvalid(obj, fieldWrap, required.message());
                            break;
                        }
                    } else if (v.annotationType().isAssignableFrom(Regex.class)) {
                        Regex regex = (Regex) v;
                        if (StringUtils.isNotBlank(value)) {
                            Pattern pattern = Pattern.compile(regex.value(), Pattern.CASE_INSENSITIVE);
                            Matcher matcher = pattern.matcher(value);
                            if (!matcher.matches()) {
                                validFlag = setInvalid(obj, fieldWrap, regex.message());
                                break;
                            }
                        }
                    } else if (v.annotationType().isAssignableFrom(MinLength.class)) {
                        MinLength length = (MinLength) v;
                        if (value == null || value.length() < length.value()) {
                            validFlag = setInvalid(obj, fieldWrap, length.message());
                            break;
                        }
                    } else if (v.annotationType().isAssignableFrom(MinNumber.class)) {
                        MinNumber minNumber = (MinNumber) v;
                        if (StringUtils.isNotBlank(value)) {
                            if (minNumber.equal() && Float.parseFloat(value) <= minNumber.value()) {
                                validFlag = setInvalid(obj, fieldWrap, minNumber.message());
                                break;
                            }else if (!minNumber.equal() && Float.parseFloat(value) < minNumber.value()) {
                                validFlag = setInvalid(obj, fieldWrap, minNumber.message());
                                break;
                            }
                        }
                    } else if (v.annotationType().isAssignableFrom(MaxLength.class)) {
                        MaxLength maxLength = (MaxLength) v;
                        if (value != null && value.length() > maxLength.value()) {
                            validFlag = setInvalid(obj, fieldWrap, maxLength.message());
                            break;
                        }
                    } else if (v.annotationType().isAssignableFrom(MaxNumber.class)) {
                        MaxNumber maxNumber = (MaxNumber) v;
                        if (StringUtils.isNotBlank(value)) {
                            if (Float.parseFloat(value) > maxNumber.value()) {
                                validFlag = setInvalid(obj, fieldWrap, maxNumber.message());
                                break;
                            }
                        }
                    } else if (v.annotationType().isAssignableFrom(IsDate.class)) {
                        IsDate isDate = (IsDate) v;
                        if (StringUtils.isNotBlank(value)) {
                            boolean valid = false;
                            for (String f : dateFormats) {
                                try {
                                    SimpleDateFormat format = new SimpleDateFormat(f);
                                    format.parse(value);
                                    valid = true;
                                    break;
                                } catch (ParseException e) {
                                    //e.printStackTrace();
                                }
                            }
                            if (!valid) {
                                validFlag = setInvalid(obj, fieldWrap, isDate.message());
                                break;
                            }
                        }
                    } else if (v.annotationType().isAssignableFrom(InRange.class)) {
                        if (StringUtils.isNotBlank(value)) {
                            InRange range = (InRange) v;
                            String[] arr = range.value().split(",");

                            boolean contains = false;
                            for (String a : arr) {
                                if (a.length() > 0 && a.equals(value)) {
                                    contains = true;
                                    break;
                                }
                            }

                            if (!contains) {
                                validFlag = setInvalid(obj, fieldWrap, range.message());
                                break;
                            }
                        }
                    }
                }
            }
        }
        else{
            validFlag = false;
        }

        return validFlag;
    }

工具的使用方法：

for (CarOutputActualItemVo itemVo: itemVos) {
            //----------------------工具的使用方法-----------------
            Engine.validate(itemVo);
            boolean isValid = itemVo.getIsValid();

            //客户型号匹配校验
            if (isValid && itemVo.getCustomerName().getIsValid() && itemVo.getCarModelName().getIsValid()) {
                Map<String, Object> titleMap = new HashMap<String, Object>();
                titleMap.put("carModelName", itemVo.getCarModelName().getValue());
                titleMap.put("customerName", itemVo.getCustomerName().getValue());
                List<CarModelEntity> carModelList = carModelDao.matchCustomerName(titleMap);
                if (carModelList != null && carModelList.size() > 0) {
                }else{
                    isValid = false;
                    itemVo.getCarModelName().setMessage("客户型号不相匹配");
                }

            }

            //型号校验
            if (isValid && itemVo.getCarModelName().getIsValid()){
                Map<String, Object> titleMap = new HashMap<String, Object>();
                titleMap.put("carModelName", itemVo.getCarModelName().getValue());
                List<CarModelEntity> carModelList = carModelDao.selectCarModelIdByName(titleMap);
                if (carModelList != null && carModelList.size() > 0) {
                    //同一年同一车型只能添加一条记录
                    titleMap.put("annual", Integer.parseInt(itemVo.getAnnual().getValue()));
                    titleMap.put("outputMark", 1);
                    List<CarOutputEntity> carOutputList = carOutputDao.selectOutputByParam(titleMap);
                    if (carOutputList != null && carOutputList.size() > 0) {
                        isValid = false;
                        itemVo.getCarModelName().setMessage("同一年同一型号只能添加一条实际产量");
                    }
                } else {
                    isValid = false;
                    itemVo.getCarModelName().setMessage("型号名称不存在");
                }
            }
            if (isValid) {
                successCount += 1;
            }else{
                errorCount += 1;
                errorList.add(UtilBiz.errMap(itemVo));
            }
        }