当我们考虑验证时,它通常是复合模式。它大致被描述为:
如果这是有效的,那么就做一些事情.
当您强加时,您想要将多个检查器链接在一个链中以在其区域中执行验证,您可以实现一个责任链图案。
考虑一下:
你可以有一个Result
对象,可以包含有关失败的消息以及简单的真/假。
你可以有一个Validator
对象,执行所需的任何验证并返回一个实例Result
.
public interface Result {
public boolean isOk();
public String getMessage();
}
// We make it genric so that we can use it to validate
// any type of Object that we want.
public interface Validator<T> {
public Result validate(T value);
}
现在,当您说要使用多个检查器验证“X”时,您是在强加一个验证规则那只不过是一个集合Validator
对象同时是一个实例Validator
本身。话虽如此,您不能再使用Result
对象检查规则的验证结果。你将需要一个复合材料Result
可以将结果保持为的对象{Validator=Result}
。它看起来不像是一个实现HashMap<Validator, Result>
?是的,因为确实如此。
现在您可以实施您的Rule
and CompositeResult
as:
public class Rule extends ArrayList<Validator> implements Validator {
public Rule(Validator<?> ... chain) {
addAll(Arrays.asList(chain));
}
public Object validate(Object target) {
CompositeResult result = new CompositeResult(size());
for (Validator rule : this) {
Result tempResult = rule.validate(value);
if (!tempResult.isOk())
result.put(rule, tempResult);
}
return result;
}
}
public class CompositeResult extends HashMap<Validator, Result> implements
Result {
private Integer appliedCount;
public CompositeResult(Integer appliedCount) {
this.appliedCount = appliedCount;
}
@Override
public boolean isOk() {
boolean isOk = true;
for (Result r : values()) {
isOk = r.isOk();
if (!isOk)
break;
}
return isOk;
}
@Override
public String getMessage() {
return toString();
}
public Integer failCount() {
return size();
}
public Integer passCount() {
return appliedCount - size();
}
}
就是这样!现在,要实现您的检查器:
public class Checker1 implements Validator<Integer> {
/* Implementation */
}
public class CheckerN implements Validator<Integer> {
/* Implementation */
}
现在是进行验证的时候了:
Validator<Integer> checkingRule = new Rule(new Checker1(), new CheckerN());
CompositeResult result = checkingRule.validate(yourParameter);
if (result.isOk())
System.out.println("All validations passed");
else
System.out.println(result.getFailedCount() + " validations failed");
简单又整洁。
我已经上传了一个我的公共仓库中的示例供你玩耍。