com.qingcha.verifier.core.VerifierBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of verifier-core Show documentation
There is a newer version: 1.2.0
package com.qingcha.verifier.core;

import com.qingcha.verifier.core.annotation.SelectionOptions;
import com.qingcha.verifier.core.annotation.VerifierConfig;
import com.qingcha.verifier.core.annotation.VerifyObject;
import com.qingcha.verifier.core.annotation.VerifySubject;
import com.qingcha.verifier.core.utils.StringUtils;
import com.qingcha.verifier.core.verifier.*;

import java.lang.reflect.Field;
import java.util.*;

/**
 * @author qiqiang
 */
public class VerifierBuilder {
    /**
     * 是否已经构建过
     */
    private boolean built;

    private final Map verifiers;
    private final List verifierList;

    public VerifierBuilder() {
        this.verifiers = new HashMap<>(8);
        this.verifierList = new ArrayList<>(8);
    }

    public VerifierBuilder add(String verifierName, String key, String subject, Object value, Object... append) {
        VerifyItem verifyItem = new VerifyItem(key, value, append);
        verifyItem.setSubject(subject);
        Verifier verifier = verifiers.get(verifierName);
        if (verifier == null) {
            throw new VerifierException(verifierName + "未找到");
        }
        verifier.addDatum(verifyItem);
        return this;
    }

    public VerifierBuilder addAndPassIfNull(String verifierName, String key, String subject, Object value, boolean passIfNull, Object... append) {
        if (passIfNull && value == null) {
            return this;
        }
        return add(verifierName, key, subject, value, append);
    }

    public VerifierBuilder addVerifier(Verifier verifier) {
        return this.addVerifier(verifier.getClass().getSimpleName(), verifier);
    }

    public VerifierBuilder addVerifier(String verifierName, Verifier verifier) {
        verifiers.put(verifierName, verifier);
        verifierList.add(verifierName);
        return this;
    }

    public VerifierBuilder verifyObject(Object object) {
        if (object == null) {
            throw new VerifierException("verify object is null");
        }
        Class clazz = object.getClass();
        VerifyObject verifyObject = clazz.getAnnotation(VerifyObject.class);
        if (verifyObject == null) {
            throw new VerifierException("需要校验的对象没有标记@VerifyObject注解");
        }
        VerifierConfig[] config = verifyObject.value();
        try {
            for (VerifierConfig verifierConfig : config) {
                Class verifierClass = verifierConfig.verifier();
                String name = verifierConfig.name();
                if (StringUtils.isBlank(name)) {
                    name = verifierClass.getSimpleName();
                }
                Verifier verifier = this.verifiers.get(name);
                if (verifier == null) {
                    verifier = verifierClass.getDeclaredConstructor().newInstance();
                    // 通过索引设置 warningFormat
                    String warningFormat = verifierConfig.warningFormat();
                    if (!StringUtils.isBlank(warningFormat)) {
                        verifier.setWaringFormat(warningFormat);
                    }
                }
                this.addVerifier(name, verifier);
            }
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                VerifySubject[] verifySubjects = field.getAnnotationsByType(VerifySubject.class);
                field.setAccessible(true);
                Object value = field.get(object);
                for (VerifySubject verifySubject : verifySubjects) {
                    String verifierName = verifySubject.verifierName();
                    // 没有指定verifier名称
                    if (StringUtils.isBlank(verifierName)) {
                        int verifyIndex = verifySubject.verifyIndex();
                        if (verifyIndex == -1) {
                            Class verifierClass = verifySubject.verifier();
                            if (verifierClass == Verifier.class) {
                                throw new VerifierException("verifier、verifyIndex 和 verifierName必须三选一");
                            }
                            verifierName = verifierClass.getSimpleName();
                        } else if (verifyIndex >= 0 && verifyIndex < verifiers.size()) {
                            verifierName = verifierList.get(verifyIndex);
                        }
                    }
                    Verifier verifier = verifiers.get(verifierName);
                    // 如果是选择校验器，那么处理选项 SelectionOptions
                    Object[] append = new Object[0];
                    if (verifier.getClass() == SelectVerifier.class || verifier.getClass() == MultipleSelectVerifier.class) {
                        SelectionOptions selectionOptions = field.getAnnotation(SelectionOptions.class);
                        if (selectionOptions != null) {
                            SelectVerifierOptionsFunction append1 = () -> new ArrayList<>(Arrays.asList(selectionOptions.value()));
                            append = new Object[]{append1};
                        }
                    }
                    this.add(verifierName, field.getName(), verifySubject.subject(), value, append);
                }
            }
        } catch (Exception e) {
            throw new VerifierException(e);
        }
        return this;
    }

    public VerifierBuilder warningFormat(String verifierName, String warningFormat) {
        Verifier verifier = verifiers.get(verifierName);
        if (verifier == null) {
            throw new VerifierException(verifierName + "未找到");
        }
        verifier.setWaringFormat(warningFormat);
        return this;
    }

    public Verifier build() {
        if (!built) {
            built = true;
            return new ComplexVerifier(new ArrayList<>(verifiers.values()));
        } else {
            throw new VerifierException("VerifierBuilder已经构建过了");
        }
    }
}