添加 EditorConfig 配置。

.editorconfig

@@ -0,0 +1,12 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = false
+insert_final_newline = true

pom.xml

@@ -5,7 +5,7 @@
   <modelVersion>4.0.0</modelVersion>
 
   <groupId>xyz.zhouxy.plusone</groupId>
-  <artifactId>plusone-validator</artifactId>
+  <artifactId>plusone-validator-for-mfp</artifactId>
   <version>0.1.3-SNAPSHOT</version>
 
   <name>plusone-validator</name>

src/main/java/xyz/zhouxy/plusone/validator/BaseValidator.java

@@ -39,25 +39,25 @@ public class BaseValidator<T> {
         return validValueHolder;
     }
 
-    protected final IntValidator<T> ruleForInt(Function<T, Integer> getter) {
+    protected final IntValidator<T> ruleForInt(Function<T, ?> getter) {
         IntValidator<T> validValueHolder = new IntValidator<>(getter);
         propertyValidators.add(validValueHolder);
         return validValueHolder;
     }
 
-    protected final DoubleValidator<T> ruleForDouble(Function<T, Double> getter) {
+    protected final DoubleValidator<T> ruleForDouble(Function<T, ?> getter) {
         DoubleValidator<T> validValueHolder = new DoubleValidator<>(getter);
         propertyValidators.add(validValueHolder);
         return validValueHolder;
     }
 
-    protected final BoolValidator<T> ruleForBool(Function<T, Boolean> getter) {
+    protected final BoolValidator<T> ruleForBool(Function<T, ?> getter) {
         BoolValidator<T> validValueHolder = new BoolValidator<>(getter);
         propertyValidators.add(validValueHolder);
         return validValueHolder;
     }
 
-    protected final StringValidator<T> ruleForString(Function<T, String> getter) {
+    protected final StringValidator<T> ruleForString(Function<T, ?> getter) {
         StringValidator<T> validValueHolder = new StringValidator<>(getter);
         propertyValidators.add(validValueHolder);
         return validValueHolder;

src/main/java/xyz/zhouxy/plusone/validator/BoolValidator.java

@@ -7,7 +7,7 @@ import org.apache.commons.lang3.BooleanUtils;
 
 public class BoolValidator<DTO> extends PropertyValidator<DTO, Boolean, BoolValidator<DTO>> {
 
-    BoolValidator(Function<DTO, Boolean> getter) {
+    BoolValidator(Function<DTO, ?> getter) {
         super(getter);
     }
 

src/main/java/xyz/zhouxy/plusone/validator/DoubleValidator.java

@@ -5,7 +5,7 @@ import java.util.function.Supplier;
 
 public class DoubleValidator<DTO> extends PropertyValidator<DTO, Double, DoubleValidator<DTO>> {
 
-    DoubleValidator(Function<DTO, Double> getter) {
+    DoubleValidator(Function<DTO, ?> getter) {
         super(getter);
     }
 

src/main/java/xyz/zhouxy/plusone/validator/IntValidator.java

@@ -5,7 +5,7 @@ import java.util.function.Supplier;
 
 public class IntValidator<DTO> extends PropertyValidator<DTO, Integer, IntValidator<DTO>> {
 
-    IntValidator(Function<DTO, Integer> getter) {
+    IntValidator(Function<DTO, ?> getter) {
         super(getter);
     }
 

src/main/java/xyz/zhouxy/plusone/validator/MapValidator.java

@@ -0,0 +1,89 @@
+package xyz.zhouxy.plusone.validator;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+public class MapValidator {
+    private final List<Consumer<Map<String, Object>>> rules = new ArrayList<>();
+    private final List<PropertyValidator<Map<String, Object>, ?, ?>> propertyValidators = new ArrayList<>();
+
+    protected void withRule(final Predicate<Map<String, Object>> rule, final String errorMessage) {
+        withRule(rule, () -> InvalidInputException.of(errorMessage));
+    }
+
+    protected <E extends RuntimeException> void withRule(Predicate<Map<String, Object>> rule, Supplier<E> exceptionBuilder) {
+        withRule(rule, value -> exceptionBuilder.get());
+    }
+
+    protected <E extends RuntimeException> void withRule(Predicate<Map<String, Object>> condition,
+            Function<Map<String, Object>, E> exceptionBuilder) {
+        withRule(value -> {
+            if (!condition.test(value)) {
+                throw exceptionBuilder.apply(value);
+            }
+        });
+    }
+
+    protected void withRule(Consumer<Map<String, Object>> rule) {
+        this.rules.add(rule);
+    }
+
+    @SuppressWarnings("unchecked")
+    protected final <R> ObjectValidator<Map<String, Object>, R> ruleFor(String key) {
+        ObjectValidator<Map<String, Object>, R> validValueHolder = new ObjectValidator<>(map -> (R) map.get(key));
+        propertyValidators.add(validValueHolder);
+        return validValueHolder;
+    }
+
+    protected final IntValidator<Map<String, Object>> ruleForInt(String key) {
+        IntValidator<Map<String, Object>> validValueHolder = new IntValidator<>(map -> map.get(key));
+        propertyValidators.add(validValueHolder);
+        return validValueHolder;
+    }
+
+    protected final DoubleValidator<Map<String, Object>> ruleForDouble(String key) {
+        DoubleValidator<Map<String, Object>> validValueHolder = new DoubleValidator<>(map -> map.get(key));
+        propertyValidators.add(validValueHolder);
+        return validValueHolder;
+    }
+
+    protected final BoolValidator<Map<String, Object>> ruleForBool(String key) {
+        BoolValidator<Map<String, Object>> validValueHolder = new BoolValidator<>(map -> map.get(key));
+        propertyValidators.add(validValueHolder);
+        return validValueHolder;
+    }
+
+    protected final StringValidator<Map<String, Object>> ruleForString(String key) {
+        StringValidator<Map<String, Object>> validValueHolder = new StringValidator<>(map -> map.get(key));
+        propertyValidators.add(validValueHolder);
+        return validValueHolder;
+    }
+
+    @SuppressWarnings("unchecked")
+    protected final <E> CollectionValidator<Map<String, Object>, E> ruleForCollection(String key) {
+        CollectionValidator<Map<String, Object>, E> validValueHolder = new CollectionValidator<>(m -> (Collection<E>) m.get(key));
+        propertyValidators.add(validValueHolder);
+        return validValueHolder;
+    }
+
+    public Map<String, Object> validate(Map<String, Object> obj, String... keys) {
+        for (Consumer<Map<String, Object>> rule : this.rules) {
+            rule.accept(obj);
+        }
+        for (PropertyValidator<Map<String, Object>, ?, ?> valueValidator : this.propertyValidators) {
+            valueValidator.validate(obj);
+        }
+        final Map<String, Object> result = new HashMap<>(keys.length);
+        for (String key : keys) {
+            result.put(key, obj.get(key));
+        }
+        return result;
+    }
+}

src/main/java/xyz/zhouxy/plusone/validator/PropertyValidator.java

@@ -8,10 +8,10 @@ import java.util.function.Predicate;
 import java.util.function.Supplier;
 
 abstract class PropertyValidator<DTO, PROPERTY, THIS> {
-    Function<DTO, PROPERTY> getter;
+    Function<DTO, ?> getter;
     Validator<PROPERTY> validator = new Validator<>();
 
-    PropertyValidator(Function<DTO, PROPERTY> getter) {
+    PropertyValidator(Function<DTO, ?> getter) {
         this.getter = getter;
     }
 
@@ -137,8 +137,9 @@ abstract class PropertyValidator<DTO, PROPERTY, THIS> {
 
     // ========================================================================
 
+    @SuppressWarnings("unchecked")
     void validate(DTO obj) {
-        PROPERTY value = this.getter.apply(obj);
+        PROPERTY value = (PROPERTY) this.getter.apply(obj);
         this.validator.validate(value);
     }
 
@@ -150,6 +151,6 @@ abstract class PropertyValidator<DTO, PROPERTY, THIS> {
             Supplier<E> exceptionSupplier) {
         return value -> exceptionSupplier.get();
     }
-    
+
     protected abstract THIS thisObject();
 }

src/main/java/xyz/zhouxy/plusone/validator/StringValidator.java

@@ -13,7 +13,7 @@ import xyz.zhouxy.plusone.commons.util.RegexUtil;
 
 public class StringValidator<DTO> extends PropertyValidator<DTO, String, StringValidator<DTO>> {
 
-    StringValidator(Function<DTO, String> getter) {
+    StringValidator(Function<DTO, ?> getter) {
         super(getter);
     }
 

src/test/java/xyz/zhouxy/plusone/map/MapValidatorTests.java

@@ -0,0 +1,50 @@
+package xyz.zhouxy.plusone.map;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import org.junit.jupiter.api.Test;
+
+import xyz.zhouxy.plusone.commons.constant.PatternConsts;
+import xyz.zhouxy.plusone.validator.MapValidator;
+
+class MapValidatorTests {
+
+    @Test
+    void testMapValidator() {
+        Map<String, Object> params = new HashMap<>();
+        params.put("username", "ZhouXY");
+        params.put("admin", true);
+        params.put("password", "99Code108");
+        params.put("password2", "99Code108");
+        params.put("test", "88gggg");
+        params.put("roles", Arrays.asList("admin", "ZhongShanAdmin"));
+
+        params = RegisterParamsValidator.INSTANCE
+                .validate(params, "roles", "username", "admin", "password");
+        System.out.println(params);
+    }
+}
+
+class RegisterParamsValidator extends MapValidator {
+    RegisterParamsValidator() {
+        this.<List<String>>ruleFor("roles")
+                .notNull(() -> new NullPointerException("roles"));
+        this.ruleForString("username")
+                .matches(PatternConsts.USERNAME, "用户名不符合条件！");
+        this.ruleForBool("admin")
+                .notNull("admin could not be null.")
+                .isTrue("admin must be true.");
+        this.ruleForString("password")
+                .notBlank("密码不能为空！")
+                .matches(PatternConsts.PASSWORD, "密码格式错误！");
+        this.ruleForCollection("roles")
+                .notEmpty("角色列表不能为空！");
+        this.withRule(m -> Objects.equals(m.get("password"), m.get("password2")),
+                "两次输入的密码不一样！");
+    }
+    static final RegisterParamsValidator INSTANCE = new RegisterParamsValidator();
+}

src/test/java/xyz/zhouxy/plusone/validator2/test/ValidatorTests.java

@@ -2,9 +2,7 @@ package xyz.zhouxy.plusone.validator2.test;
 
 import static xyz.zhouxy.plusone.commons.constant.PatternConsts.*;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
+import java.util.*;
 import java.util.regex.Pattern;
 
 import org.apache.commons.lang3.StringUtils;
@@ -61,6 +59,47 @@ class ValidatorTests {
         registerCommandValidator.validate(registerCommand);
         System.out.println(registerCommand);
     }
+    @Test
+    void testValidateMap() {
+        Map<String, Object> params = new HashMap<>();
+        params.put("username", "zhouxy");
+        params.put("account", "zhouxy@code108.cn");
+        params.put("password", "89wy7G78gu7ggahB2");
+        params.put("age", 25);
+        params.put("roles", Arrays.asList("", "admin"));
+
+        Validator<Map<String, Object>> registerCommandValidator = new Validator<Map<String, Object>>()
+                // 传入 predicate 和 Function<T, E extends RuntimeException>
+                .addRule(command -> {
+                    String username = (String) command.get("username");
+                    return Objects.nonNull(username)
+                            && StringUtils.isNotEmpty(username)
+                            && StringUtils.isNotBlank(username)
+                            && RegexUtil.matches(username, USERNAME);
+                }, command -> new IllegalArgumentException(String.format("用户名【%s】不符合规范", command.get("username"))))
+                // 传入 predicate 和 error message
+                .addRule(command -> Predicates
+                        .<String>of(Objects::nonNull)
+                        .and(account -> RegexUtil.matchesOne(account, new Pattern[] { EMAIL, MOBILE_PHONE }))
+                        .test((String) command.get("account")),
+                        "请输入邮箱地址或手机号")
+                // 传入 rule
+                .addRule(command -> {
+                    String password = (String) command.get("password");
+                    Preconditions.checkArgument(StringUtils.isNotEmpty(password), "密码不能为空");
+                    Preconditions.checkArgument(RegexUtil.matches(password, PASSWORD), "密码不符合规范");
+                })
+                // 传入 predicate 和 Supplier<E extends RuntimeException>
+                .addRule(command -> MoreCollections.isNotEmpty((List<String>) command.get("roles")),
+                        () -> new RuntimeException("角色列表不能为空"))
+                .addRule(command -> {
+                    Integer age = (Integer) command.get("age");
+                    Preconditions.checkNotNull(age);
+                    Preconditions.checkArgument(18 < age && 60 >= age);
+                });
+        registerCommandValidator.validate(params);
+        System.out.println(params);
+    }
 }
 
 /**