我需要构建一个流程来根据大约 200 条验证规则验证记录。记录可以是约 10 种类型之一。从验证规则到记录类型有一些分段，但存在很多重叠，这使我无法干净地对验证规则进行分类。
在我的设计过程中，我正在考虑所有验证规则的责任链模式。这是个好主意还是有更好的设计模式？
【问题讨论】：
标签： java design-patterns chain-of-responsibility
验证通常是一种复合模式。当你分解它时，你想将你想要的 what 与你想要做的 how 分开，你会得到：
如果 foo 有效 然后做点什么。
这里我们有抽象是有效的 -- 警告：此代码是从当前的类似示例中提取的，因此您可能会发现缺少符号系统等。但这是为了让你得到图片。此外，
Result
对象包含有关失败的消息以及简单的状态（真/假）。 这使您可以选择只询问“它通过了吗？”与“如果失败，请告诉我原因”
QuickCollection
和
QuickMap
是方便类，用于获取任何类并通过仅分配给委托来快速将它们转换为那些受人尊敬的类型。对于此示例，这意味着您的复合验证器已经是一个集合，并且可以进行迭代。
您的问题中有一个次要问题：“完全绑定”，如“A 型”-> 规则{a,b,c}”和“B 型”-> 规则{c,e,z}”
这可以通过地图轻松管理。不完全是Command pattern，但很接近
Map<Type,Validator> typeValidators = new HashMap<>();
为每种类型设置验证器，然后创建类型之间的映射。如果您使用 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();
}
}
}
现在是一个使用的sn-p：
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);
【讨论】：
责任链意味着验证必须有一个顺序。我可能会使用类似于策略模式的东西，其中您有一组应用于特定类型记录的验证策略。然后，您可以使用工厂检查记录并应用正确的验证集。
【讨论】：