[JAVA] Bedingte Verzweigung mit fließender Schnittstelle

Annahme

• java8 oder höher

Bedingte Verzweigung in Frage

Diese Art der Verarbeitung, die Sie oft sehen.

//Wenn die Zeichenfolge nicht leer ist und niedrigere Alphabete enthält
//Und
//Wenn die Verarbeitungskategorie entweder registriert oder geändert wird
if ((StringUtils.isNotEmpty(str) && StringUtils.isAlpha(str)
        && StringUtils.isAllLowerCase(str))
        && (processDivision.isRegister() || processDivision.isChange())) {
    //Etwas zu verarbeiten
}

Auf einen Blick ist es schwer zu sagen, wie die Bedingungen sind, und es ist leicht, Fehler in der Position von Klammern zu machen. Auf diesem Niveau mag es noch besser sein, aber ich werde verzweifeln, wenn die Bedingungen steigen ...

Gelöst mit einer Flüssigkeitsschnittstelle

Erstellen Sie die folgende Klasse.

Assume.java

public final class Assume<T> {

    private T obj;

    public static <T> Assume<T> that(T obj) {

        Assume<T> assume = new Assume<>();
        assume.obj = obj;

        return assume;
    }

    public AnyMatch<T> satisfiesAnyOf(Predicate<T> method) {

        AnyMatch<T> anyOf = new AnyMatch<>(obj, method);

        return anyOf;

    }

    public AllMatch<T> satisfiesAllOf(Predicate<T> method) {

        AllMatch<T> allOf = new AllMatch<>(obj, method);

        return allOf;

    }

}

AnyMatch.java

public final class AnyMatch<T> {

    private T obj;

    private boolean match;

    protected AnyMatch(T obj, Predicate<T> checkMethod) {
        this.match = checkMethod.test(obj);
        this.obj = obj;
    }

    public AnyMatch<T> or(Predicate<T> checkMethod) {

        if (match) {
            return this;
        }

        this.match = checkMethod.test(obj);
        return this;
    }

    public boolean check() {

        return match;
    }
}

AllMatch.java

public class AllMatch<T> {

    private T obj;

    private boolean match;

    protected AllMatch(T obj, Predicate<T> checkMethod) {
        this.match = checkMethod.test(obj);
        this.obj = obj;
    }

    public AllMatch<T> and(Predicate<T> checkMethod) {

        if (!match) {
            return this;
        }

        this.match = checkMethod.test(obj);
        return this;
    }

    public boolean check() {
        return match;
    }

}

Mit diesen drei kann der Prozess am Anfang wie folgt geschrieben werden.

//Wenn die Zeichenfolge nicht leer ist und niedrigere Alphabete enthält
//Und
//Wenn die Verarbeitungskategorie entweder registriert oder geändert wird
if (Assume.that(str)
        .satisfiesAllOf(StringUtils::isNotEmpty)
        .and(StringUtils::isAlpha)
        .and(StringUtils::isAllLowerCase).check()
        && Assume.that(processDivision)
                 .satisfiesAnyOf(ProcessDivision::isRegister)
                 .or(ProcessDivision::isChange).check()) {
    //Etwas zu verarbeiten
}

Die Beschreibung ist länger, aber es ist einfacher zu verstehen, was Sie tun. Sollte sein.

Weitere Verbesserung

Schreiben Sie eine dritte If-Anweisung, die weder eine if-Anweisung noch ein ternärer Operator ist Weitere Verbesserung in Bezug auf den Artikel in.

AnyMatch.java

public final class AnyMatch<T> {
    
    ...

    public <A> Else<A> then(Supplier<A> a1) {
        return (Supplier<A> a2) -> match ? a1.get() : a2.get();
    }
}

Hinzufügen,

Else.java

public interface Else<A> {
    A orElse(Supplier<A> a2);
}

Wenn Sie sich vorbereiten

String hoge = Assume.that(str)
        .satisfiesAllOf(StringUtils::isNotEmpty)
        .and(StringUtils::isAlpha)
        .and(StringUtils::isAllLowerCase).then(() -> "aaa").orElse(() -> "bbb");

Sie können dies auch tun.

Referenz

• Schreiben Sie eine dritte If-Anweisung, die weder eine if-Anweisung noch ein ternärer Operator ist