Question

我有以下场景：两个验证助手

StringValidationHelper ...

public class StringValidationHelper {

    public static Validation<String> notNull = 
        SimpleValidation.from(s -> s != null, "must not be null.");

    public static Validation<String> moreThan(int size) {
        return SimpleValidation.from(
            s -> s.length() >= size, 
            String.format ("must have more than %s chars.", size));
    }
        ... // More methods (lessThan, etc)}

...和NumberValidationHelper。

public class NumberValidationHelper {

    public static Validation<Number> notNull = 
        SimpleValidation.from(n -> n != null, "must not be null");

    public static <N extends Number & Comparable<N>> Validation<N> lowerThan(N max){
        return SimpleValidation.from(
            n -> n.compareTo(max) == -1,
            String.format("must be lower than %s.", max));
    }
    ... // More methods like (greaterThan, etc)}

来自的方法是一个静态工厂方法，它接收谓词和最终验证失败的消息。

public class SimpleValidation<K> implements Validation<K>{ private Predicate<K> predicate; private String onErrorMessage; private SimpleValidation(Predicate<K> predicate, String onErrorMessage) { this.predicate = predicate; this.onErrorMessage = onErrorMessage; } public static <K> SimpleValidation<K> from(Predicate<K> predicate, String onErrorMessage){ return new SimpleValidation<>(predicate, onErrorMessage); } ... // Omitted for simplicity }

借助验证界面，您可以享受非常流畅的界面

@FunctionalInterface public interface Validation<K> { ... // Omitted for simplicity default Validation<K> and(Validation<K> other) { return param -> { ValidationResult firstResult = this.test (param); return ! firstResult.isValid()? firstResult: other.test(param); }; } ... // Omitted for simplicity }

所以我可以使用闭包notNull来开始验证。

示例：使用NumberValidationHelper

public class MyValidate { void validate(int toValidate) { notNull.and(lowerThan(100)).test(toValidate).isValid(); } }

我根据this文章开发了这个验证框架。

嗯，notNull包含一个独立于类型的行为，所以我想删除这两个帮助器的重复。在没有失去流体界面的情况下，我找不到明显的形状。

因为变量是静态的，所以不能使用泛型并扩展行为，例如。

public abstract class GenericHelper<K> { public static Validation<K> notNull = SimpleValidation.from(o -> o != null, "must not be null."); }

也不打扰我输入Validation with Object，如下所示：

public abstract class GenericHelper { public static Validation<Object> notNull = SimpleValidation.from(o -> o != null, "must not be null."); }

...因为在调用链接中，它会给出编译错误，因为notNull的结果将是验证＆lt;对象＆gt;并且将期待验证＆lt;整数＆gt;

notNull.and(lowerThan(100)).test(toValidate).isValid(); //Does not compile

有没有什么办法可以使用Java 8功能，让这个界面保持流畅，远离我上面尝试过的解决方案？

感谢

Answer 1

您应该放宽and的通用签名，允许Validation<T>更具体T作为参数，以产生Validation<T>作为结果：

default <T extends K> Validation<T> and(Validation<T> other) {
    return param -> {
        ValidationResult firstResult = this.test(param);
        return ! firstResult.isValid()? firstResult: other.test(param);
    };
}

坚持你的例子，你仍然无法写

void validate(int toValidate) {
    notNull.and(moreThan(100)).test(toValidate).isValid();
}

因为moreThan会返回Validation<String> test int，但发现此类错误是Generics的全部内容（我想，你还有另一个{{}} moreThan 1}}实际代码库中的方法，你没有在你的问题中包含）。但以下内容现在适用于您的示例：

void validate(int toValidate) {
    notNull.and(lowerThan(100)).test(toValidate).isValid();
}

有时，您需要在更通用的验证之前测试更具体类型的验证，这仍然不适用于上面显示的方法。一种解决方案是使用与JDK开发人员相同的路径，并使用Function.andThen(after)扩充Function.compose(before)，允许交换角色

default <T extends K> Validation<T> compose(Validation<T> other) {
    return param -> {
        ValidationResult firstResult = other.test(param);
        return ! firstResult.isValid()? firstResult: this.test(param);
    };
}

或者您创建了一个static方法，它允许两个参数的类型比生成的Validation更广泛：

static <T> Validation<T> and(Validation<? super T> first, Validation<? super T> second) {
    return param -> {
        ValidationResult firstResult = first.test(param);
        return ! firstResult.isValid()? firstResult: second.test(param);
    };
}

请注意，static方法可以与方便的实例方法结合使用，这样调用者只需要在达到通用签名的限制时求助于static方法：

@FunctionalInterface
public interface Validation<K> {
    ValidationResult test(K item);

    default <T extends K> Validation<T> and(Validation<T> other) {
        return and(this, other);
    }
    static <T> Validation<T> and(Validation<? super T> first,Validation<? super T> second){
        return param -> {
            ValidationResult firstResult = first.test(param);
            return ! firstResult.isValid()? firstResult: second.test(param);
        };
    }
}

所以你仍然可以写

notNull.and(lowerThan(100)).test(toValidate).isValid();

但是在达到限制时，例如

Validation<Object> anotherCriteria;
…
lowerThan(100).and(anotherCriteria).test(toValidate).isValid();

不起作用，你可以诉诸

Validation.and(lowerThan(100), anotherCriteria).test(toValidate).isValid();

如何推广静态clousure？

1 个答案: