Comment gérer les exceptions vérifiées dans les flux Java 8 Lambda ?

Java 8 : flux Lambda et gestion des exceptions

En Java 8, les expressions lambda apportent de nombreux avantages au traitement des flux. Cependant, lorsqu'ils utilisent des méthodes qui génèrent des exceptions vérifiées, telles que IOException, les développeurs peuvent rencontrer des erreurs de compilation.

Considérez le code suivant :

<code class="java">class Bank {
    public Set<String> getActiveAccountNumbers() throws IOException {
        Stream<Account> s = accounts.values().stream();
        s = s.filter(a -> a.isActive());
        Stream<String> ss = s.map(a -> a.getNumber());
        return ss.collect(Collectors.toSet());
    }
}</code>

Le code vise à récupérer un ensemble d'exceptions activées. numéros de compte. Cependant, la compilation échoue car les méthodes isActive et getNumber renvoient des IOExceptions, qui doivent être interceptées ou déclarées dans la signature.

Capture des exceptions vérifiées dans les expressions Lambda

Pour Pour résoudre ce problème, les exceptions vérifiées doivent être gérées dans l'expression lambda elle-même. Cependant, placer simplement un bloc try-catch dans le lambda ne suffit pas. L'exception doit être interceptée avant d'échapper à la portée du lambda.

Utilisation d'un wrapper UncheckedIOException

Une approche consiste à utiliser une classe wrapper personnalisée, UncheckedIOException, qui convertit les exceptions vérifiées. à ceux qui ne sont pas contrôlés. Cela permet au lambda de lever l'exception non vérifiée et d'être gérée par les opérations ultérieures du flux.

<code class="java">s = s.filter(a -> {
    try {
        return a.isActive();
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
});</code>

Utiliser un wrapper d'exception générique

Une autre option consiste à utiliser un méthode wrapper générique, uncheckCall, qui intercepte tout type d'exception et la renvoie comme une exception non vérifiée.

<code class="java">return s.filter(a -> uncheckCall(a::isActive))
        .map(Account::getNumber)
        .collect(toSet());</code>

Dans ce cas, les opérations ultérieures du flux recevront l'exception non vérifiée et pourront être traitées en conséquence.

Désamorcer la vérification des exceptions du compilateur

Une approche plus avancée consiste à utiliser une méthode qui désactive efficacement la vérification des exceptions du compilateur. Cela nécessite toutefois de la prudence et une compréhension claire des risques potentiels. Dans cette approche, le code suivant est utilisé :

<code class="java">public static <T> T uncheckCall(Callable<T> callable) {
    try {
        return callable.call();
    } catch (Exception e) {
        sneakyThrow(e);
        return null; // Unreachable but needed to satisfy compiler
    }
}</code>

Avec cette méthode, l'exception vérifiée est interceptée et renvoyée en tant qu'exception d'exécution. Cependant, il est important de noter que cette approche peut conduire à un comportement inattendu si les exceptions sont censées être gérées sur le site d'exécution du lambda.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!