Les exceptions vérifiées de Java ont été une amélioration majeure par rapport au mécanisme de gestion des erreurs de C. Au fur et à mesure que le temps a passé et que l'expérience s'est accumulée, nous avons conclu collectivement que nous n'étions pas encore là. Java 8 a apporté des lambdas après la tendance "les exceptions vérifiées sont grandes". Aucune des méthodes d'interface fonctionnelle n'accepte une exception vérifiée. Dans ce post, je vais démontrer trois approches différentes pour rendre votre code de lancement d'exceptions hérité compatible avec lambdas. Le problème est dans le code. Considérez une méthode simple d'exception-jet. public class Foo {
    public String throwing(String input) throws IOException {
        return input;                          //1
    }
}
 
 
 Le corps est là à des fins de compilation ; son contenu exact est sans importance. La méthode accepte a et retourne a Il a la forme d'un Nous pouvons l’utiliser comme tel : String String Function<I, O> var foo = new Foo();
List.of("One", "Two").stream()
    .map(string -> foo.throwing(string))
    .toList();
 Le code ci-dessus échoue avec une erreur de compilation : unreported exception IOException; must be caught or declared to be thrown
            .map(string -> foo.throwing(string)).toList();
                                       ^
1 error
 Pour résoudre l'erreur, nous devons envelopper le code de lancement dans un bloc d'essai : List.of("One", "Two").stream()
    .map(string -> {
        try {
            return foo.throwing(string);
        } catch (IOException e) {
            return "";
        }
    }).toList();
 À ce stade, le code compile, mais bat le but principal des lambdas : être concis et lisible. Une meilleure approche. Nous pouvons définitivement améliorer le design en modelant un Avec un jet . Function apply() interface ThrowingFunction<I, O, E extends Exception> {
    O apply(I i) throws E;
}
 Nous pouvons alors fournir un enveloppeur pour transformer un tel lancement Dans un régulier . Function Function class LambdaUtils {
    public static <I, O, E extends Exception> Function<I, O> safeApply(ThrowingFunction<I, O, E> f) {
        return input -> {
            try {
                return f.apply(input);
            } catch (Exception e) {
                return "";
            }
        };
    }
}
 Avec ce qui précède, le code d'appel peut être amélioré comme ceci: var foo = new Foo();
List.of("One", "Two").stream()
    .map(string -> LambdaUtils.safeApply(foo::throwing))     //1
    .toList();
 
 
 Un nouveau code concis Bibliothèques pour le sauvetage. La façon la plus simple d'appeler un code d'exception dans un lambda consiste à utiliser une bibliothèque. Deux bibliothèques que je connais offrent cette fonctionnalité: 
 
 
 Apache Commons Lang 3 Vavre Voici comment nous pouvons réécrire le code ci-dessus en utilisant le code Commons Lang 3 : var foo = new Foo();
FailableFunction<String, String, IOException> throwingFunction = foo::throwing; //1
List.of("One", "Two").stream()
    .map(throwingFunction)
    .recover(e -> "")                                                           //2
    .toList();
 
 
 
 Commons Lang 3 modèles une fonction de lancement recover() imite la valeur définie dans le bloc catch précédent Les bibliothèques s’améliorent sur mon conception discutable ci-dessus, mais l’idée reste la même. La décision de déployer votre propre ou d'utiliser une bibliothèque dépend d'une variété de facteurs qui vont au-delà de cet article. pour vous aider. Quelques critères Suppression des exceptions vérifiées Les exceptions vérifiées sont une préoccupation du temps de compilation.La spécification de la langue Java stipule : 
 
 
 Un compilateur pour le langage de programmation Java vérifie, au moment de la compilation, qu'un programme contient des manipulateurs pour les exceptions vérifiées, en analysant quelles exceptions vérifiées peuvent résulter de l'exécution d'une méthode ou d'un constructeur. Pour chaque exception vérifiée qui est un résultat possible, la clause jette pour la méthode (§8.4.6) ou le constructeur (§8.8.5) doit mentionner la classe de cette exception ou l'une des superclasses de la classe de cette exception. 11.2 Compile-Time Vérification des exceptions Un compilateur pour le langage de programmation Java vérifie, au moment de la compilation, qu'un programme contient des manipulateurs pour , en analysant quelles exceptions vérifiées peuvent résulter de l'exécution d'une méthode ou d'un constructeur. La clause pour la méthode (§8.4.6) ou constructeur (§8.8.5) doit mentionner la classe de cette exception ou l'une des superclasses de la classe de cette exception.Ce contrôle de compilation-temps pour la présence de gestionnaires d'exceptions est conçu pour réduire le nombre d'exceptions qui ne sont pas traitées correctement. Exceptions vérifiées throws 11.2 Compile-Time Vérification des exceptions Nous pourrions potentiellement nous attacher au compilateur pour empêcher cette vérification via un plugin de compilateur. ou trouver une bibliothèque qui le fait. 
 
 
 
 
 Manifold est un plugin de compilateur Java. Utilisez-le pour compléter vos projets Java avec des fonctionnalités hautement productives. Des améliorations linguistiques puissantes améliorent la productivité des développeurs. 
 
 
 
 
 
 
 
 
 
 
 Méthodes d’extension Une véritable délégation Propriétés Paramètres optionnels (nouveau!) Les expressions doubles Opérateur surchargé Unité d’expression Moteur de template Java Un préprocesseur ...et plus encore Qu’est-ce que le Manifeste Manifold est un plugin de compilateur Java. Utilisez-le pour compléter vos projets Java avec des fonctionnalités hautement productives. Des améliorations linguistiques puissantes améliorent la productivité des développeurs. 
 
 
 
 
 
 
 
 
 
 
 Méthodes d’extension Une véritable délégation Propriétés Paramètres optionnels (nouveau!) Les expressions doubles Opérateur surchargé Unité d’expression Moteur de template Java Un préprocesseur ...et plus encore - - - Qu’est-ce que le Manifeste Disclaimer: Je ne prône pas l'utilisation de Manifold. Il rend la langue avec laquelle vous travaillez différente de Java. À ce stade, vous serez mieux d'utiliser Kotlin directement. Utiliser Manifold pour supprimer les exceptions vérifiées est un processus en deux étapes. Tout d'abord, nous ajoutons le temps d'exécution Manifold au projet: <dependency>
    <groupId>systems.manifold</groupId>
    <artifactId>manifold-rt</artifactId>
    <version>${manifold.version}</version>
    <scope>provided</scope>
</dependency>
 Ensuite, nous configurons le plugin compilateur : <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.0</version>
            <configuration>
                <source>11</source>
                <target>11</target>
                <encoding>UTF-8</encoding>
                <compilerArgs>
                    <arg>-Xplugin:Manifold</arg>
                </compilerArgs>
                <annotationProcessorPaths>
                    <path>
                        <groupId>systems.manifold</groupId>
                        <artifactId>manifold-exceptions</artifactId>
                        <version>${manifold.version}</version>
                    </path>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>
 À ce stade, nous pouvons traiter les exceptions vérifiées comme non vérifiées. var foo = new Foo();
List.of("One", "Two").stream()
        .map(string -> foo.throwing(string))       //1
        .toList();
 
 
 Compilé sans problème Conclusion Dans ce post, j'ai abordé le problème de l'intégration des exceptions vérifiées avec lambdas en Java. J'ai listé plusieurs options: le bloc try-catch, la fonction de lancement, la bibliothèque et Manifold. j'espère que vous pouvez trouver l'une qui convient à votre contexte parmi eux. To go further: 
 
 
 
 
 
 
 Apache Commons Lang 3 Vavre Exemples d'expressions Java Lambda Exceptions à l'expression Lambda en utilisant Vavr Dites adieu aux exceptions vérifiées Résoudre le fléau des exceptions vérifiées de Java Publié à A Java Geek le 18 janvier 2026 Le Java Geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Cet audio est produit dans la langue originale de l'histoire !

Comment rendre votre code d'exception-jet compatible avec Lambdas

About Author

COMMENTAIRES

ÉTIQUETTES

CET ARTICLE A ÉTÉ PARU DANS

Related Stories

Des forums aux flux : comment les algorithmes des réseaux sociaux façonnent l'interaction numérique

Valhalla de Floki se joint en tant que sponsor associé de la tournée indienne au Sri Lanka

Créer des produits cryptographiques centrés sur l'utilisateur : l'importance des retours clients

Télégramme : le pont de Crypto Island vers le continent

Des forums aux flux : comment les algorithmes des réseaux sociaux façonnent l'interaction numérique

Valhalla de Floki se joint en tant que sponsor associé de la tournée indienne au Sri Lanka

Créer des produits cryptographiques centrés sur l'utilisateur : l'importance des retours clients

Télégramme : le pont de Crypto Island vers le continent

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps