Merge pull request 'dev' (#1) from dev into master

Reviewed-on: #1

plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/mybatis/MyBatisAutoConfiguration.java

@@ -1,17 +0,0 @@
-package xyz.zhouxy.plusone.mybatis;
-
-import org.apache.ibatis.session.SqlSessionFactory;
-import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@EnableAutoConfiguration
-public class MyBatisAutoConfiguration {
-
-    @Bean
-    MybatisUtil mybatisUtil(SqlSessionFactory sqlSessionFactory) {
-        return MybatisUtil.getInstance()
-                .setSqlSessionFactory(sqlSessionFactory);
-    }
-}

plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/mybatis/MyBatisContextUtil.java

@@ -0,0 +1,16 @@
+package xyz.zhouxy.plusone.mybatis;
+
+import org.apache.ibatis.session.SqlSessionFactory;
+
+import xyz.zhouxy.plusone.spring.SpringContextHolder;
+
+public final class MyBatisContextUtil {
+
+    private MyBatisContextUtil() {
+        throw new IllegalStateException("Utility class");
+    }
+
+    public static SqlSessionFactory getSqlSessionFactory() {
+        return SpringContextHolder.getContext().getBean(SqlSessionFactory.class);
+    }
+}

plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/mybatis/MyBatisPlusConfig.java

@@ -10,7 +10,7 @@ import org.springframework.context.annotation.Configuration;
 @Configuration
 public class MyBatisPlusConfig {
     @Bean
-    public MybatisPlusInterceptor mybatisPlusInterceptor() {
+    MybatisPlusInterceptor mybatisPlusInterceptor() {
         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
         interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
         interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/mybatis/MybatisUtil.java

@@ -1,28 +0,0 @@
-package xyz.zhouxy.plusone.mybatis;
-
-import org.apache.ibatis.session.SqlSessionFactory;
-
-public final class MybatisUtil {
-
-    private SqlSessionFactory sqlSessionFactory;
-
-    private MybatisUtil() {
-    }
-
-    MybatisUtil setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
-        this.sqlSessionFactory = sqlSessionFactory;
-        return this;
-    }
-
-    private static final class Holder {
-        private static final MybatisUtil INSTANCE = new MybatisUtil();
-    }
-
-    public static MybatisUtil getInstance() {
-        return Holder.INSTANCE;
-    }
-
-    public static SqlSessionFactory getSqlSessionFactory() {
-        return MybatisUtil.getInstance().sqlSessionFactory;
-    }
-}

plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/validator/BaseValidator.java

@@ -2,25 +2,31 @@ package xyz.zhouxy.plusone.validator;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.function.Supplier;
 
 import xyz.zhouxy.plusone.exception.InvalidInputException;
 
 /**
  * 校验器
  *
- * <p>可以使用以下方式初始化一个校验器：</p>
+ * <p>
+ * 可以使用以下方式初始化一个校验器：
+ * </p>
  *
  * <pre>
  * BaseValidator&lt;Integer&gt; validator = new BaseValidator&lt;&gt;() {
  *     {
- *         ruleFor(value -> Objects.nonNull(value), "value 不能为空");
+ *         withRule(value -> Objects.nonNull(value), "value 不能为空");
- *         ruleFor(value -> (value >= 0 && value <= 500), "value 应在 [0, 500] 内");
+ *         withRule(value -> (value >= 0 && value <= 500), "value 应在 [0, 500] 内");
  *     }
  * };
  * </pre>
  *
- * <p>也可以通过继承本类，定义一个校验器（可使用单例模式）。</p>
+ * <p>
+ * 也可以通过继承本类，定义一个校验器（可使用单例模式）。
+ * </p>
  *
  * <p>
  * 然后通过校验器的 {@link #validate} 方法，或
@@ -43,30 +49,40 @@ import xyz.zhouxy.plusone.exception.InvalidInputException;
  */
 public abstract class BaseValidator<T> {
 
-    private final List<RuleInfo<T>> rules = new ArrayList<>();
+    private final List<RuleInfo<T, ?>> rules = new ArrayList<>();
 
     protected BaseValidator() {
     }
 
-    protected final void ruleFor(Predicate<T> rule, String errorMessage) {
+    protected final void withRule(Predicate<T> rule, String errorMessage) {
-        this.rules.add(new RuleInfo<>(rule, errorMessage));
+        withRule(rule, () -> new InvalidInputException(errorMessage));
+    }
+
+    protected final <E extends RuntimeException> void withRule(Predicate<T> rule, Supplier<E> exceptionCreator) {
+        withRule(rule, value -> exceptionCreator.get());
+    }
+
+    protected final <E extends RuntimeException> void withRule(Predicate<T> rule, Function<T, E> exceptionCreator) {
+        this.rules.add(new RuleInfo<>(rule, exceptionCreator));
     }
 
     public void validate(T obj) {
-        this.rules.forEach((RuleInfo<T> ruleInfo) -> {
+        this.rules.forEach(ruleInfo -> ruleInfo.validate(obj));
-            if (!ruleInfo.rule.test(obj)) {
-                throw new InvalidInputException(ruleInfo.message);
-            }
-        });
     }
 
-    protected static class RuleInfo<T> {
+    protected static class RuleInfo<T, E extends RuntimeException> {
-        Predicate<T> rule;
+        private final Predicate<T> rule;
-        String message;
+        private final Function<T, E> exceptionCreator;
 
-        public RuleInfo(Predicate<T> rule, String message) {
+        private RuleInfo(Predicate<T> rule, Function<T, E> exceptionCreator) {
             this.rule = rule;
-            this.message = message;
+            this.exceptionCreator = exceptionCreator;
+        }
+
+        private void validate(T obj) {
+            if (!rule.test(obj)) {
+                throw exceptionCreator.apply(obj);
+            }
         }
     }
 }

plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/validator/BaseValidator2.java

@@ -1,129 +0,0 @@
-package xyz.zhouxy.plusone.validator;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Objects;
-import java.util.function.Function;
-import java.util.function.Predicate;
-
-import cn.hutool.core.exceptions.ValidateException;
-import lombok.AllArgsConstructor;
-import xyz.zhouxy.plusone.constant.RegexConsts;
-import xyz.zhouxy.plusone.util.RegexUtil;
-
-public abstract class BaseValidator2<T> {
-
-    private List<ValidValueHolder<T, ?>> hs = new ArrayList<>();
-
-    protected final <R> ValidValueHolder<T, R> ruleFor(Function<T, R> getter) {
-        ValidValueHolder<T, R> validValueHolder = new ValidValueHolder<>(getter);
-        hs.add(validValueHolder);
-        return validValueHolder;
-    }
-
-    public void validate(T obj) {
-        for (var holder : hs) {
-            var value = holder.getter.apply(obj);
-            for (var rule : holder.rules) {
-                if (!rule.condition.test(value)) {
-                    throw new ValidateException(rule.errMsg);
-                }
-            }
-        }
-    }
-}
-
-class ValidValueHolder<T, R> {
-    Function<T, R> getter;
-
-    List<RuleInfo<Object>> rules = new ArrayList<>();
-
-    public ValidValueHolder(Function<T, R> getter) {
-        this.getter = getter;
-    }
-
-    private void addRule(Predicate<Object> condition, String errMsg) {
-        this.rules.add(new RuleInfo<>(condition, errMsg));
-    }
-
-    public ValidValueHolder<T, R> nonNull(String errMsg) {
-        addRule(Objects::nonNull, errMsg);
-        return this;
-    }
-
-    public ValidValueHolder<T, R> nonEmpty(String errMsg) {
-        addRule(value -> {
-            if (value == null) {
-                return false;
-            }
-            if (value instanceof Collection) {
-                return ((Collection<?>) value).isEmpty();
-            }
-            if (value instanceof String) {
-                return ((String) value).isEmpty();
-            }
-            return false;
-        }, errMsg);
-        return this;
-    }
-
-    public ValidValueHolder<T, R> size(int min, int max, String errMsg) {
-        addRule(value -> {
-            if (value == null) {
-                return false;
-            }
-            if (value instanceof Collection) {
-                int size = ((Collection<?>) value).size();
-                return size >= min && size <= max;
-            }
-            return true;
-        }, errMsg);
-        return this;
-    }
-
-    public ValidValueHolder<T, R> length(int min, int max, String errMsg) {
-        addRule(value -> {
-            if (value == null) {
-                return false;
-            }
-            if (value instanceof String) {
-                int length = ((String) value).length();
-                return length >= min && length <= max;
-            }
-            return true;
-        }, errMsg);
-        return this;
-    }
-
-    public ValidValueHolder<T, R> matches(String regex, String errMsg) {
-        addRule(input -> RegexUtil.matches(regex, (String) input), errMsg);
-        return this;
-    }
-
-    public ValidValueHolder<T, R> matchesOr(String[] regexs, String errMsg) {
-        addRule(input -> RegexUtil.matchesOr((String) input, regexs), errMsg);
-        return this;
-    }
-
-    public ValidValueHolder<T, R> matchesAnd(String[] regexs, String errMsg) {
-        addRule(input -> RegexUtil.matchesAnd((String) input, regexs), errMsg);
-        return this;
-    }
-
-    public ValidValueHolder<T, R> email(String errMsg) {
-        return matches(RegexConsts.EMAIL, errMsg);
-    }
-
-    @SuppressWarnings("unchecked")
-    public ValidValueHolder<T, R> and(Predicate<R> condition, String errMsg) {
-        addRule((Predicate<Object>) condition, errMsg);
-        return this;
-    }
-
-    @AllArgsConstructor
-    static final class RuleInfo<R> {
-        Predicate<R> condition;
-        String errMsg;
-    }
-}

plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/validator/Validator.java

@@ -36,7 +36,7 @@ import java.util.function.Predicate;
  */
 public final class Validator<T> extends BaseValidator<T> {
     public final Validator<T> addRule(final Predicate<T> rule, final String errorMessage) {
-        ruleFor(rule, errorMessage);
+        withRule(rule, errorMessage);
         return this;
     }
 }

plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/validator/validator2/BaseValidator2.java

@@ -0,0 +1,22 @@
+package xyz.zhouxy.plusone.validator.validator2;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+public abstract class BaseValidator2<T> {
+
+    private List<ValueValidator<T, ?>> valueValidators = new ArrayList<>();
+
+    protected final <R> ValueValidator<T, R> ruleFor(Function<T, R> getter) {
+        ValueValidator<T, R> validValueHolder = new ValueValidator<>(getter);
+        valueValidators.add(validValueHolder);
+        return validValueHolder;
+    }
+
+    public void validate(T obj) {
+        for (ValueValidator<T, ?> valueValidator : this.valueValidators) {
+            valueValidator.validateProperty(obj);
+        }
+    }
+}

plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/validator/validator2/ValueValidator.java

@@ -0,0 +1,379 @@
+package xyz.zhouxy.plusone.validator.validator2;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+import cn.hutool.core.util.StrUtil;
+import xyz.zhouxy.plusone.constant.RegexConsts;
+import xyz.zhouxy.plusone.exception.InvalidInputException;
+import xyz.zhouxy.plusone.util.RegexUtil;
+
+public class ValueValidator<DTO, PROPERTY> {
+    Function<DTO, PROPERTY> getter;
+    List<Consumer<PROPERTY>> rules = new ArrayList<>();
+
+    public ValueValidator(Function<DTO, PROPERTY> getter) {
+        this.getter = getter;
+    }
+
+    private <E extends RuntimeException> void withRule(Predicate<PROPERTY> condition,
+            Function<PROPERTY, E> exceptionCreator) {
+        withRule(value -> {
+            if (!condition.test(value)) {
+                throw exceptionCreator.apply(value);
+            }
+        });
+    }
+
+    private <E extends RuntimeException> void withRule(Consumer<PROPERTY> rule) {
+        this.rules.add(rule);
+    }
+
+    // ====================
+    // ====== Object ======
+    // ====================
+
+    // ====== notNull =====
+
+    public ValueValidator<DTO, PROPERTY> notNull() {
+        return notNull("Value could not be null.");
+    }
+
+    public ValueValidator<DTO, PROPERTY> notNull(String errMsg) {
+        return notNull(convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notNull(Supplier<E> exceptionCreator) {
+        return notNull(convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notNull(Function<PROPERTY, E> exceptionCreator) {
+        withRule(Objects::nonNull, exceptionCreator);
+        return this;
+    }
+
+    // ====== isNull =====
+
+    public ValueValidator<DTO, PROPERTY> isNull(String errMsg) {
+        return isNull(convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isNull(Supplier<E> exceptionCreator) {
+        return isNull(convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isNull(Function<PROPERTY, E> exceptionCreator) {
+        withRule(Objects::isNull, exceptionCreator);
+        return this;
+    }
+
+    // ===== equals =====
+
+    public ValueValidator<DTO, PROPERTY> equalsThat(Object that) {
+        return equalsThat(that, value -> new InvalidInputException(String.format("(%s) 必须与 (%s) 相等", value, that)));
+    }
+
+    public ValueValidator<DTO, PROPERTY> equalsThat(Object that, String errMsg) {
+        return equalsThat(that, convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> equalsThat(
+            Object that, Supplier<E> exceptionCreator) {
+        return equalsThat(that, convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> equalsThat(
+            Object that, Function<PROPERTY, E> exceptionCreator) {
+        withRule(value -> Objects.equals(value, that), exceptionCreator);
+        return this;
+    }
+
+    // ===== state =====
+
+    public ValueValidator<DTO, PROPERTY> state(Predicate<PROPERTY> condition) {
+        return state(condition, "无效的用户输入");
+    }
+
+    public ValueValidator<DTO, PROPERTY> state(Predicate<PROPERTY> condition, String errMsg) {
+        return state(condition, convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> state(
+            Predicate<PROPERTY> condition,
+            Supplier<E> exceptionCreator) {
+        return state(condition, convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> state(
+            Predicate<PROPERTY> condition,
+            Function<PROPERTY, E> exceptionCreator) {
+        withRule(condition, exceptionCreator);
+        return this;
+    }
+
+    // =================
+    // ====== int ======
+    // =================
+
+    public ValueValidator<DTO, PROPERTY> between(int min, int max) {
+        return between(min, max, String.format("数值不在 %s 和 %s 之间", String.valueOf(min), String.valueOf(max)));
+    }
+
+    public ValueValidator<DTO, PROPERTY> between(int min, int max, String errMsg) {
+        return between(min, max, convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> between(int min, int max,
+            Supplier<E> exceptionCreator) {
+        return between(min, max, convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> between(int min, int max,
+            Function<PROPERTY, E> exceptionCreator) {
+        withRule(value -> ((int) value >= min && (int) value < max), exceptionCreator);
+        return this;
+    }
+
+    // ====================
+    // ====== double ======
+    // ====================
+
+    public ValueValidator<DTO, PROPERTY> between(double min, double max) {
+        return between(min, max, String.format("数值不在 %s 和 %s 之间", String.valueOf(min), String.valueOf(max)));
+    }
+
+    public ValueValidator<DTO, PROPERTY> between(double min, double max, String errMsg) {
+        return between(min, max, convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> between(double min, double max,
+            Supplier<E> exceptionCreator) {
+        return between(min, max, convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> between(double min, double max,
+            Function<PROPERTY, E> exceptionCreator) {
+        withRule(value -> ((double) value >= min && (double) value < max), exceptionCreator);
+        return this;
+    }
+
+    // ================================
+    // ====== Collection, String ======
+    // ================================
+
+    // ====== notEmpty =====
+
+    public ValueValidator<DTO, PROPERTY> notEmpty(String errMsg) {
+        return notEmpty(convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notEmpty(Supplier<E> exceptionCreator) {
+        return notEmpty(convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notEmpty(Function<PROPERTY, E> exceptionCreator) {
+        withRule(value -> {
+            if (value == null) {
+                return false;
+            }
+            if (value instanceof Collection) {
+                return !((Collection<?>) value).isEmpty();
+            }
+            if (value instanceof String) {
+                return !((String) value).isEmpty();
+            }
+            return false;
+        }, exceptionCreator);
+        return this;
+    }
+
+    // ====== isEmpty =====
+
+    public ValueValidator<DTO, PROPERTY> isEmpty(String errMsg) {
+        return isEmpty(convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isEmpty(Supplier<E> exceptionCreator) {
+        return isEmpty(convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isEmpty(Function<PROPERTY, E> exceptionCreator) {
+        withRule(value -> {
+            if (value == null) {
+                return false;
+            }
+            if (value instanceof Collection) {
+                return ((Collection<?>) value).isEmpty();
+            }
+            if (value instanceof String) {
+                return ((String) value).isEmpty();
+            }
+            return false;
+        }, exceptionCreator);
+        return this;
+    }
+
+    // =====================
+    // ====== boolean ======
+    // =====================
+
+    // ====== isTrue ======
+
+    public ValueValidator<DTO, PROPERTY> isTrue() {
+        return isTrue("The value must be true.");
+    }
+
+    public ValueValidator<DTO, PROPERTY> isTrue(String errMsg) {
+        return isTrue(convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isTrue(Supplier<E> exceptionCreator) {
+        return isTrue(convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isTrue(Function<PROPERTY, E> exceptionCreator) {
+        withRule(Boolean.TRUE::equals, exceptionCreator);
+        return this;
+    }
+
+    // ====== isFalse ======
+
+    public ValueValidator<DTO, PROPERTY> isFalse() {
+        return isFalse("The value must be false.");
+    }
+
+    public ValueValidator<DTO, PROPERTY> isFalse(String errMsg) {
+        return isFalse(convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isFalse(Supplier<E> exceptionCreator) {
+        return isFalse(convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isFalse(Function<PROPERTY, E> exceptionCreator) {
+        withRule(Boolean.FALSE::equals, exceptionCreator);
+        return this;
+    }
+
+    // ====================
+    // ====== String ======
+    // ====================
+
+    // ===== matches =====
+
+    public ValueValidator<DTO, PROPERTY> matches(String regex, String errMsg) {
+        return matches(regex, convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matches(
+            String regex,
+            Supplier<E> exceptionCreator) {
+        return matches(regex, convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matches(
+            String regex,
+            Function<PROPERTY, E> exceptionCreator) {
+        withRule(input -> RegexUtil.matches((String) input, regex), exceptionCreator);
+        return this;
+    }
+
+    // ===== matchesOr =====
+
+    public ValueValidator<DTO, PROPERTY> matchesOr(String[] regexs, String errMsg) {
+        return matchesOr(regexs, convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matchesOr(
+            String[] regexs,
+            Supplier<E> exceptionCreator) {
+        return matchesOr(regexs, convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matchesOr(
+            String[] regexs,
+            Function<PROPERTY, E> exceptionCreator) {
+        withRule(input -> RegexUtil.matchesOr((String) input, regexs), exceptionCreator);
+        return this;
+    }
+
+    // ===== matchesAnd =====
+
+    public ValueValidator<DTO, PROPERTY> matchesAnd(String[] regexs, String errMsg) {
+        return matchesAnd(regexs, convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matchesAnd(
+            String[] regexs,
+            Supplier<E> exceptionCreator) {
+        return matchesAnd(regexs, convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matchesAnd(
+            String[] regexs,
+            Function<PROPERTY, E> exceptionCreator) {
+        withRule(input -> RegexUtil.matchesAnd((String) input, regexs), exceptionCreator);
+        return this;
+    }
+
+    // ===== notBlank =====
+
+    public ValueValidator<DTO, PROPERTY> notBlank() {
+        return notBlank("This String argument must have text; it must not be null, empty, or blank");
+    }
+
+    public ValueValidator<DTO, PROPERTY> notBlank(String errMsg) {
+        return notBlank(convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notBlank(Supplier<E> exceptionCreator) {
+        return notBlank(convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notBlank(Function<PROPERTY, E> exceptionCreator) {
+        withRule(input -> StrUtil.isNotBlank((String) input), exceptionCreator);
+        return this;
+    }
+
+    // ===== email =====
+
+    public ValueValidator<DTO, PROPERTY> email() {
+        return email("The value is not an email address.");
+    }
+
+    public ValueValidator<DTO, PROPERTY> email(String errMsg) {
+        return email(convertExceptionCreator(errMsg));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> email(Supplier<E> exceptionCreator) {
+        return email(convertExceptionCreator(exceptionCreator));
+    }
+
+    public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> email(Function<PROPERTY, E> exceptionCreator) {
+        return matches(RegexConsts.EMAIL, exceptionCreator);
+    }
+
+    // ========================================================================
+
+    void validateProperty(DTO obj) {
+        PROPERTY value = this.getter.apply(obj);
+        for (var rule : this.rules) {
+            rule.accept(value);
+        }
+    }
+
+    private static <V> Function<V, InvalidInputException> convertExceptionCreator(String errMsg) {
+        return convertExceptionCreator(errMsg);
+    }
+
+    private static <V, E extends RuntimeException> Function<V, E> convertExceptionCreator(
+            Supplier<E> exceptionSupplier) {
+        return value -> exceptionSupplier.get();
+    }
+}

plusone-basic/plusone-basic-infrastructure/src/test/java/xyz/zhouxy/plusone/validatortest/BaseValidator2Test.java

@@ -1,4 +1,4 @@
-package xyz.zhouxy.plusone.validator;
+package xyz.zhouxy.plusone.validatortest;
 
 import org.junit.jupiter.api.Test;
 
@@ -6,12 +6,13 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import xyz.zhouxy.plusone.constant.RegexConsts;
+import xyz.zhouxy.plusone.validator.validator2.BaseValidator2;
 
 class BaseValidator2Test {
 
     @Test
     void testValid() {
-        LoginCommand loginCommand = new LoginCommand("13169053215@qq.com", "8GouTDE53a", false);
+        LoginCommand loginCommand = new LoginCommand("13169053215@qq.com", "A1qZ6c-cQ78=^(", false);
         LoginCommandValidator.INSTANCE.validate(loginCommand);
         System.err.println(loginCommand);
     }
@@ -32,10 +33,11 @@ class LoginCommandValidator extends BaseValidator2<LoginCommand> {
 
     private LoginCommandValidator() {
         ruleFor(loginCommand -> loginCommand.getAccount())
-                .nonNull("邮箱地址不能为空")
+                .notNull("邮箱地址不能为空")
-                .matchesOr(new String[] { RegexConsts.EMAIL, RegexConsts.MOBILE_PHONE }, "请输入邮箱地址或手机号");
+                .matchesOr(new String[] { RegexConsts.EMAIL, RegexConsts.MOBILE_PHONE }, value -> new RuntimeException('"' + value + "\" 不是邮箱地址或手机号"));
         ruleFor(loginCommand -> loginCommand.getPwd())
-                .nonNull("密码不能为空")
+                .notNull("密码不能为空")
+                .notEmpty("密码不能为空")
                 .matches(RegexConsts.PASSWORD, "密码格式错误");
     }
 }

plusone-system/plusone-system-application/src/main/java/xyz/zhouxy/plusone/system/application/service/command/validator/LoginByOtpCommandValidator.java

@@ -15,13 +15,13 @@ import xyz.zhouxy.plusone.validator.DtoValidator;
 @DtoValidator(LoginByOtpCommand.class)
 public class LoginByOtpCommandValidator extends BaseValidator<LoginByOtpCommand> {
     public LoginByOtpCommandValidator() {
-        ruleFor(loginCommand -> {
+        withRule(loginCommand -> {
             String principal = loginCommand.getPrincipal();
             return StringUtils.hasText(principal)
                     &&
                     RegexUtil.matchesOr(principal, RegexConsts.EMAIL, RegexConsts.MOBILE_PHONE);
         }, "输入邮箱地址或手机号");
-        ruleFor(loginCommand -> {
+        withRule(loginCommand -> {
             String otp = loginCommand.getOtp();
             return StringUtils.hasText(otp) && Pattern.matches(RegexConsts.CAPTCHA, otp);
         }, "验证码不符合要求");

plusone-system/plusone-system-application/src/main/java/xyz/zhouxy/plusone/system/application/service/command/validator/LoginByPasswordCommandValidator.java

@@ -15,13 +15,13 @@ import xyz.zhouxy.plusone.validator.DtoValidator;
 @DtoValidator(LoginByPasswordCommand.class)
 public class LoginByPasswordCommandValidator extends BaseValidator<LoginByPasswordCommand> {
     public LoginByPasswordCommandValidator() {
-        ruleFor(loginCommand -> {
+        withRule(loginCommand -> {
             String principal = loginCommand.getPrincipal();
             return StringUtils.hasText(principal)
                     &&
                     RegexUtil.matchesOr(principal, RegexConsts.USERNAME, RegexConsts.EMAIL, RegexConsts.MOBILE_PHONE, principal);
         }, "输入用户名、邮箱地址或手机号");
-        ruleFor(loginCommand -> {
+        withRule(loginCommand -> {
             String password = loginCommand.getPassword();
             return StringUtils.hasText(password)
                     &&

plusone-system/plusone-system-domain/src/main/java/xyz/zhouxy/plusone/system/domain/model/account/AccountInfo.java

@@ -38,6 +38,6 @@ public class AccountInfo implements IValueObject {
         } catch (MalformedURLException e) {
             throw new IllegalArgumentException(e);
         }
-        return new AccountInfo(Nickname.ofNullable(nickname), avatarURL, Objects.nonNull(sex) ? sex : Sex.UNSET);
+        return new AccountInfo(Nickname.ofNullable(nickname), avatarURL, sex);
     }
 }