[JAVA] Ausnahmebehandlung mit einer Fluidschnittstelle

Es ist immer mühsam, Ausnahmebehandlungen zu schreiben, deshalb habe ich es ein wenig arrangiert.

Methode, die eine aktivierte Ausnahme auslöst

void raiseIOEx1(String s) throws IOException {
    if (s.equals("nagare")) {
        System.out.println("Excellent!");
        return;
    }
    throw new IOException("invalid input :".concat(s));
}

Es ist rau, aber wenn es eine Methode wie die oben genannte gibt (abgesehen davon, warum IOException?)

Normales Schreiben

void usually_try_style() {
    try {
        raiseIOEx1("nagare");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Arrangiertes Schreiben

void nagare_try_style() {
    Try.throwable(this::raiseIOEx1)
            .ifCatch(IOException::printStackTrace)
            .accept("nagare");
}

Sie können so schreiben.

Sie können auch Folgendes für eine Methode schreiben, die einen Wert zurückgibt.

Methode 2, die eine aktivierte Ausnahme auslöst

String raiseIOEx2(String s) throws IOException {
    if (s.equals("nagare")) {
        return "Excellent!";
    }
    throw new IOException("invalid input :".concat(s));
}

Normales Schreiben

void usually_returnable_try_style() {
    try {
        String s = raiseIOEx2("nagare");
        System.out.println(s);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Arrangiertes Schreiben

void nagare_returnable_try_style() {
    Optional<String> s = Try.throwable(this::raiseIOEx2)
            .ifCatch(IOException::printStackTrace)
            .apply("nagare");
    s.ifPresent(System.out::println);

    // or
    Try.throwable(this::raiseIOEx2)
            .ifCatch(IOException::printStackTrace)
            .apply("nagare");
            .ifPresent(System.out::println);
}

Es wird nicht empfohlen, es auf Unternehmensebene zu verwenden. Die obige Beschreibung kann jedoch durch Hinzufügen der folgenden 4 Klassen vorgenommen werden.

public class Try {
    public static <X, A, E extends Exception> ThrowableFunc<X, A, E> throwable(
            ThrowableFunc<X, A, E> f) {
        return f;
    }

    public static <X, E extends Exception> ThrowableSpender<X, E> throwable(
            ThrowableSpender<X, E> s) {
        return s;
    }
}

@FunctionalInterface
public interface ThrowableSpender<X, E extends Exception> {
    void accept(X x) throws E;

    default Consumer<X> ifCatch(ExHandler<E> handler) {
        return (X x) -> {
            try {
                accept(x);
            } catch (Exception e) {
                @SuppressWarnings("unchecked")
                E typedE = (E) e; // is type safe
                handler.handle(typedE);
            }
        };
    }
}

@FunctionalInterface
public interface ThrowableFunc<X, A, E extends Exception> {
    A apply(X x) throws E;

    default Function<X, Optional<A>> ifCatch(ExHandler<E> handler) {
        return x -> {
            try {
                return Optional.of(apply(x));
            } catch (Exception e) {
                @SuppressWarnings("unchecked")
                E typedE = (E) e; // is type safe
                handler.handle(typedE);
            }
            return Optional.empty();
        };
    }
}

@FunctionalInterface
public interface ExHandler<E extends Exception> {
    void handle(E e);
}

Wie Sie sehen können, indem Sie den Code lesen, betrüge ich ein wenig "catch".

try {
    accept(x);
} catch (E e) {
    handler.handle(e);
}

Wenn Sie so schreiben können, können Sie mehrere Ausnahmen nur mit der Benutzeroberfläche schreiben, was große Fortschritte zu machen scheint, aber es ist eine Schande. Ich hoffe du kannst in java9 schreiben.

https://github.com/mt-village/nagare

Referenz

• Wie man Ausnahmen mit Java 8 Stream und optional kühl behandelt