java - 对于大型验证任务，责任链模式是一个不错的选择吗？

Question

我需要构建一个流程来根据约 200 条验证规则验证记录。一条记录可以是大约 10 种类型之一。从验证规则到记录类型有一些分割，但存在很多重叠，这使我无法干净地对验证规则进行分类。

在我的设计过程中，我正在考虑所有验证规则的责任链模式。这是个好主意还是有更好的设计模式？

Answer 1

验证通常是一种复合模式。当你分解它时，你想将你想要的什么与你想要做的如何分开，你会得到:

如果 foo 有效然后做点什么。

这里我们有抽象是有效的 -- 警告:此代码是从当前的类似示例中提取的，因此您可能会发现缺少符号系统等。但这是你得到的图片。此外，

Result

对象包含有关失败的消息以及简单的状态(真/假)。这使您可以选择只询问“它通过了吗？” vs.“如果失败了，请告诉我原因”

QuickCollection

和

QuickMap

是方便的类，用于获取任何类并通过仅分配给委托(delegate)来快速将它们转换为那些受人尊敬的类型。对于此示例，这意味着您的复合 validator 已经是一个集合并且可以迭代，例如。

您的问题中有一个次要问题:“完全绑定(bind)”，如“Type A”-> rules{a,b,c}”和“Type B”-> rules{c,e,z}”

这可以通过 map 轻松管理。不完全是 Command pattern但关闭

Map<Type,Validator> typeValidators = new HashMap<>();

为每种类型设置 validator ，然后创建类型之间的映射。如果您使用的是 Java 但绝对使用dependency injection，那么这确实最好作为 bean 配置来完成。

    public interface Validator<T>{
    
    
        public Result validate(T value);
    
    
        public static interface Result {
    
            public static final Result OK = new Result() {
                @Override
                public String getMessage() {
                    return "OK";
                }
    
                @Override
                public String toString() {
                    return "OK";
                }
    
                @Override
                public boolean isOk() {
                    return true;
                }
            };
    
            public boolean isOk();
    
            public String getMessage();
        }
    }

现在一些简单的实现来说明这一点:

public class MinLengthValidator implements Validator<String> {
    
    private final SimpleResult FAILED;
    
    private Integer minLength;
    
    public MinLengthValidator() {
        this(8);
    }
    
    public MinLengthValidator(Integer minLength) {
        this.minLength = minLength;
        FAILED = new SimpleResult("Password must be at least "+minLength+" characters",false);
    }
    
    @Override
    public Result validate(String newPassword) {
        return newPassword.length() >= minLength ? Result.OK : FAILED;
    }
    
    @Override
    public String toString() {
        return this.getClass().getSimpleName();
    }
}

这是我们要结合的另一个

    public class NotCurrentValidator implements Validator<String> {
    
        @Autowired
        @Qualifier("userPasswordEncoder")
        private PasswordEncoder encoder;
    
        private static final SimpleResult FAILED = new SimpleResult("Password cannot be your current password",false);
    
        @Override
        public Result validate(String newPassword) {
            boolean passed = !encoder.matches(newPassword,user.getPassword());
            return (passed ? Result.OK : FAILED);
        }
    
        @Override
        public String toString() {
            return this.getClass().getSimpleName();
        }
    
    }

现在这是一个合成:

public class CompositePasswordRule extends QuickCollection<Validator> implements Validator<String> {


public CompositeValidator(Collection<Validator> rules) {
    super.delegate = rules;
}

public CompositeValidator(Validator<?>... rules) {
    super.delegate = Arrays.asList(rules);
}



@Override
public CompositeResult validate(String newPassword) {
    CompositeResult result = new CompositeResult(super.delegate.size());
    for(Validator rule : super.delegate){
        Result temp = rule.validate(newPassword);
        if(!temp.isOk())
            result.put(rule,temp);
    }

    return result;
}


    public static class CompositeResult extends QuickMap<Validator,Result> implements Result {
        private Integer appliedCount;

        private CompositeResult(Integer appliedCount) {
            super.delegate = VdcCollections.delimitedMap(new HashMap<PasswordRule, Result>(), "-->",", ");
            this.appliedCount = appliedCount;
        }

        @Override
        public String getMessage() {
            return super.delegate.toString();
        }

        @Override
        public String toString() {
            return super.delegate.toString();
        }

        @Override
        public boolean isOk() {
            boolean isOk = true;
            for (Result r : delegate.values()) {
                isOk = r.isOk();
                if(!isOk)
                    break;
            }
            return isOk;
        }
        public Integer failCount() {
            return this.size();
        }

        public Integer passCount() {
            return appliedCount - this.size();
        }
    }
}

现在是一个使用片段:

private Validator<String> pwRule = new CompositeValidator<String>(new MinLengthValidator(),new NotCurrentValidator());

Validator.Result result = pwRule.validate(newPassword);
if(!result.isOk())
    throw new PasswordConstraintException("%s", result.getMessage());

user.obsoleteCurrentPassword();
user.setPassword(passwordEncoder.encode(newPassword));
user.setPwExpDate(DateTime.now().plusDays(passwordDaysToLive).toDate());
userDao.updateUser(user);