Comment attraper plusieurs exceptions en Kotlin à la fois : guide complet avec code

Introduction : pourquoi ce sujet explose-t-il sur Stack Overflow ?

Si vous avez déjà écrit en Kotlin et avez eu besoin d'intercepter plusieurs exceptions différentes, vous savez que cela peut être douloureux. Surtout si vous venez de Java, où le multi-catch (catch (IOException | SQLException e)) est un standard depuis Java 7. En Kotlin, c'est différent, et de nombreux développeurs sont perdus.

La question "How to catch many exceptions at the same time in Kotlin?" sur Stack Overflow a recueilli des milliers de vues. Et ce n'est pas un hasard : la gestion des erreurs est quelque chose que tout le monde rencontre. Aujourd'hui, nous allons résoudre ce problème une fois pour toutes.

Dans cet article, vous apprendrez :

\n
• Pourquoi le multi-catch en Kotlin ne fonctionne pas comme en Java
\n
• Comment intercepter plusieurs exceptions de manière élégante et compacte
\n
• Quand utiliser when dans catch, et quand utiliser le bon vieux if
\n
• Des exemples concrets de code en production
\n

C'est parti !

Le problème : où est mon multi-catch ?

En Java, vous écrivez simplement :

try {\n    riskyOperation()\n} catch (IOException | SQLException e) {\n    // on traite de la même manière\n}\n

Beau, concis, clair. Mais en Kotlin, cette syntaxe n'existe pas. Si vous essayez d'écrire catch (IOException | SQLException e), le compilateur vous dira « non ».

Pourquoi ? Parce que Kotlin a fait le choix de la clarté et de la pureté. Les développeurs du langage ont décidé que le multi-catch avec une barre verticale n'est pas tout à fait dans le style de Kotlin. Mais cela ne signifie pas que vous ne pouvez pas attraper plusieurs exceptions. Cela se fait simplement différemment.

Examinons les trois principales méthodes.

Méthode 1 : blocs catch multiples (la plus évidente)

Le moyen le plus simple est d'ajouter plusieurs blocs catch à la suite. Kotlin le supporte parfaitement.

try {\n    val data = loadData()\n    processData(data)\n} catch (e: IOException) {\n    println("Erreur d'entrée-sortie : ${e.message}")\n} catch (e: SQLException) {\n    println("Erreur de base de données : ${e.message}")\n} catch (e: Exception) {\n    println("Erreur inconnue : ${e.message}")\n}\n

Avantages :

\n
• Extrêmement clair — chaque type d'exception est traité séparément
\n
• On peut donner une logique différente pour différentes erreurs
\n
• Très lisible pour les débutants
\n

Inconvénients :

\n
• Beaucoup de duplication de code si la logique de traitement est identique
\n
• Avec 5+ exceptions, le bloc devient volumineux
\n

Méthode 2 : catch avec when (élégant et flexible)

C'est là que Kotlin révèle toute sa splendeur. Au lieu du multi-catch, vous pouvez utiliser when à l'intérieur d'un seul bloc catch.

try {\n    val result = fetchFromNetwork()\n    saveToDatabase(result)\n} catch (e: Exception) {\n    when (e) {\n        is IOException -> handleNetworkError(e)\n        is SQLException -> handleDatabaseError(e)\n        is SecurityException -> logAndNotify(e)\n        else -> throw e // on relance si on ne sait pas comment traiter\n    }\n}\n

Cette approche est une véritable trouvaille. Elle permet :

\n
• De traiter différentes exceptions au même endroit
\n
• D'utiliser toutes les possibilités de when, y compris les vérifications de conditions
\n
• D'ajouter facilement de nouveaux types d'exceptions
\n

Voici un exemple plus avancé avec des conditions :

try {\n    connectToService()\n} catch (e: Exception) {\n    when {\n        e is IOException && e.message?.contains("timeout") == true -> \n            println("Délai d'attente de connexion, nouvel essai")\n        e is IOException -> \n            println("Erreur réseau : ${e.message}")\n        e is SQLException && e.errorCode == 1045 -> \n            println("Erreur d'authentification à la base de données")\n        else ->