[JAVA] Gestion des exceptions avec une interface fluide

C'est toujours un problème d'écrire la gestion des exceptions, alors je l'ai un peu arrangé.

Méthode qui déclenche une exception vérifiée

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

C'est difficile, mais quand il y a une méthode comme celle-ci (à part pourquoi IOException?)

Écriture normale

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

Style d'écriture arrangé

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

Vous pouvez écrire comme ça.

Vous pouvez également écrire ce qui suit pour une méthode qui renvoie une valeur.

Méthode 2 qui déclenche une exception vérifiée

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

Écriture normale

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

Style d'écriture arrangé

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

Il n'est pas recommandé de l'utiliser au niveau de l'entreprise, mais la description ci-dessus peut être faite en ajoutant les 4 classes suivantes.

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

Comme vous pouvez le voir en lisant le code, je triche un peu à «catch».

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

Si vous pouvez écrire comme ça, vous ne pourrez écrire plusieurs exceptions qu'avec l'interface, ce qui semble faire beaucoup de progrès, mais c'est dommage. J'espère que vous pourrez écrire en java9.

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

référence

• Comment gérer froidement les exceptions avec Java 8 Stream et en option