如何在Java中链接检查

考虑下面的类

public class MyClass {

    private Integer myField;
    private Result result;
    // more global variables

    public MyResult check(Integer myParameter) {
        init(myParameter);

        if (myField < 0) {
            result.setErrorMessage("My error message");
            return result;
        }

        // a lot more 'checks' like above where something may be written
        // to the error message and the result gets returned.
    }

    private void init(Integer myParameter) {
        result = new Result();
        result.setExistsAnnouncement(/*search a certain object via crudService with myParameter*/);
        // initialize other global variables including myField
    }

}

问题是上面的检查方法太长了,并且有很多return语句.我想到了一些重构,但是仍然不确定该怎么做.我在考虑类似连锁模式的东西.然后,我将实现几个检查器类,它们要么调用链中的下一个检查器,要么返回带有相应errorMessage的结果.

但是后来我有了一个更好的主意(至少我是这么认为的)：为什么表现得不像Java 8？我想到使用类似Try-Success-Failure-Pattern的东西.但是我不知道如何实现这一点.我在想类似的东西：

entrancePoint.check(firstChecker)
    .check(secondChecker)
    .check // and so on

这个想法是：当检查失败时,它的行为类似于Optional.map()并返回类似Optional.EMPTY的内容(或者在这种情况下,返回诸如Failure的内容).检查成功后,应继续进行下一次检查(返回成功).

您有做类似事情的经验吗？

解决方法:

当我们考虑验证时,通常是复合模式.它大致描述为：

如果这是有效的,则执行某些操作.

而且,正如您所强加的那样,您希望将多个检查器链接在一起以在其区域中执行验证,因此可以实施“责任链”模式.

考虑一下：

您可以拥有一个Result对象,该对象可以包含有关失败的消息以及简单的true / false.

您可以具有一个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对象的集合,同时是Validator本身的实例.话虽如此,您不能再使用Result对象来检查规则的验证结果.您将需要一个复合Result对象,该对象可以将结果保留为{Validator = Result}.看起来不是HashMap< Validator,Result>的实现吗？是的,因为是.

现在,您可以将Rule和CompositeResult实现为：

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");

简单而整洁.

我上传了一个example in my public repo,供您玩耍.

标签：chaining,java,refactoring
来源： https://codeday.me/bug/20191026/1933868.html