En pratique, la gestion des exceptions ne se résume pas à la simple connaissance de la syntaxe. Écrire du code robuste est davantage un art et dans cet article, les meilleures pratiques de gestion des exceptions Java seront abordées. Ces bonnes pratiques Java suivent les bibliothèques JDK standard et plusieurs codes open source pour la gestion des erreurs et des exceptions. C'est également un manuel pratique permettant aux programmeurs Java d'écrire du code robuste. Meilleures pratiques pour la gestion des exceptions dans la programmation Java
Voici ma collection de 10 bonnes pratiques pour la gestion des exceptions dans la programmation Java. Il existe des éloges et des critiques concernant les exceptions vérifiées dans la programmation Java. La gestion forcée des exceptions est une fonction du langage. Dans cet article, nous essaierons de minimiser l'utilisation des exceptions vérifiées et d'apprendre à utiliser les exceptions vérifiées et non vérifiées dans la programmation Java.
1) Utilisez des exceptions vérifiées pour les erreurs récupérables et des erreurs non vérifiées pour les erreurs de programmation.
Choisir des exceptions cochées ou non est toujours déroutant pour les programmeurs Java. Les exceptions vérifiées garantissent que vous fournissez un code de gestion des exceptions pour les conditions d'erreur. C'est une manière du langage de vous forcer à écrire du code robuste, mais cela introduit également beaucoup d'encombrement et le rend illisible. Bien sûr, détecter les exceptions et faire quelque chose pour y remédier semble raisonnable si vous disposez d'une stratégie de remplacement et de récupération. Choisissez entre les exceptions vérifiées ou les exceptions d'exécution dans la programmation Java. Pour plus d'informations, voir Exceptions vérifiées et non vérifiées.
2) Fermez ou libérez des ressources dans le bloc final
Il s'agit d'une bonne pratique bien connue en programmation Java et équivaut à une norme en matière de classes réseau et d'E/S. La fermeture des ressources dans le bloc final garantit une libération raisonnable des ressources précédemment disponibles et rares dans des conditions d'exécution normales et anormales, ce qui est garanti par le bloc final. À partir de Java 7, le langage dispose d'une fonctionnalité plus intéressante : l'automatisation de la gestion des ressources ou les blocs ARM peuvent implémenter cette fonctionnalité. Néanmoins, nous devons toujours nous rappeler de fermer les ressources dans le bloc final, ce qui est important pour libérer des ressources limitées telles que les FileDescriptors, qui sont utilisés dans les situations de programmation de sockets et de fichiers.
3) Inclure la cause de l'exception dans la trace de la pile
Souvent, les bibliothèques Java et le code open source encapsulent une exception dans une autre lorsqu'une exception provoquée par une autre exception est levée. La journalisation et l’impression des exceptions racine deviennent très importantes. La classe d'exception Java fournit la méthode getCause() pour récupérer la cause de l'exception, qui peut fournir plus d'informations sur la cause racine de l'exception. Cette pratique Java est très utile lors du débogage ou du dépannage. N'oubliez jamais que si vous encapsulez une exception dans une autre exception, vous devez transmettre l'exception source lors de la construction d'une nouvelle exception.
4) Fournissez toujours des informations significatives et complètes sur l'exception
Les informations sur les exceptions sont l’endroit le plus important car c’est le premier endroit que voit le programmeur et c’est là que vous pouvez trouver la cause première du problème. Des informations précises et authentiques sont toujours fournies ici. Par exemple, comparez les deux messages d'exception de l'exception IllegalArgumentException :
Message 1 : « Argument incorrect pour la méthode »
Message 2 : « Valeur illégale pour ${argument} : ${value}
Le premier message indique uniquement que le paramètre est illégal ou incorrect, mais le deuxième message inclut le nom du paramètre et la valeur illégale, ce qui est important pour trouver la cause de l'erreur. Suivez toujours cette bonne pratique Java lorsque vous écrivez du code de gestion des exceptions dans la programmation Java.
5) Évitez la surutilisation des exceptions vérifiées
Les exceptions vérifiées présentent certains avantages pour renforcer l'exécution, mais elles cassent également le code et le rendent moins lisible en masquant la logique métier. Tant que vous n'abusez pas des exceptions vérifiées, vous pouvez minimiser ces situations et le résultat est un code plus propre. Vous pouvez également utiliser les nouvelles fonctionnalités de Java 7 comme un bloc catch pour plusieurs exceptions et la gestion automatique des ressources pour supprimer les doublons.
6) Convertir les exceptions vérifiées en exceptions d'exécution
C'est l'une des techniques utilisées pour limiter l'utilisation des exceptions vérifiées dans la plupart des frameworks comme Spring. La plupart des exceptions vérifiées de JDBC sont enveloppées dans DataAccessException, et l'exception (DataAccessException) est une exception non vérifiée. C'est l'avantage apporté par les meilleures pratiques Java. Les exceptions spécifiques sont limitées à des modules spécifiques, tels que SQLException, qui est placé dans la couche DAO, et les exceptions d'exécution ayant une signification claire sont renvoyées à la couche client.
7) N'oubliez pas que les exceptions coûtent cher aux performances
Une chose à retenir est que les exceptions coûtent cher et ralentissent votre code. Si vous disposez d'une méthode qui lit à partir d'un ResultSet, elle lèvera souvent une SQLException sans passer à l'élément suivant, ce qui s'exécutera beaucoup plus lentement que le code normal qui ne lève pas d'exception. Par conséquent, les captures et les mouvements d’exceptions inutiles sont minimisés, lorsqu’il n’y a pas de raison fixe. Au lieu de simplement lancer et intercepter des exceptions, vous pouvez obtenir une solution plus propre et plus performante si vous pouvez utiliser des variables booléennes pour représenter les résultats d'exécution. Corrigez la source de l’erreur et évitez la capture d’exceptions inutiles.
8) Évitez que le bloc catch soit vide
Il n'y a rien de pire qu'un bloc catch vide, car non seulement il masque les erreurs et les exceptions, mais il peut également laisser vos objets dans un état inutilisable ou sale. Un bloc catch vide ne peut perdre de sens que si vous êtes absolument certain que l'exception ne continuera pas à affecter l'état de l'objet de quelque manière que ce soit, mais la journalisation des erreurs pendant l'exécution du programme reste la meilleure option. Il ne s'agit pas seulement d'une bonne pratique Java, mais de la pratique la plus courante pour écrire du code de gestion des exceptions dans la programmation Java.
9) Utiliser les exceptions standards
Notre neuvième bonne pratique recommande d’utiliser des exceptions Java standard et intégrées. Utiliser des exceptions standard au lieu de créer les nôtres à chaque fois est le meilleur choix pour la maintenabilité et la cohérence, maintenant et dans le futur. La réutilisation des exceptions standard rend le code plus lisible car la plupart des développeurs Java sont familiers avec les exceptions standard telles que RuntimeException, IllegalStateException, IllegalArgumentException ou NullPointerException qui proviennent du JDK, et ils peuvent connaître chaque exception en un coup d'œil. exceptions définies dans le code ou dans la documentation.
10) Enregistrez les exceptions levées par n’importe quelle méthode
Java fournit les mots-clés throw et throws pour lancer des exceptions. Utilisez @throw dans javadoc pour enregistrer toutes les exceptions pouvant être levées par n'importe quelle méthode. Cela devient très important si vous écrivez des API ou des interfaces publiques. Toute exception levée par une méthode doit être documentée afin que vous puissiez inconsciemment alerter toute personne qui l'utilise. Ce sont toutes les meilleures pratiques qui doivent être suivies lors de la gestion des exceptions dans la programmation Java. Faites-nous savoir quelles sont les pratiques à suivre lors de l'écriture du code de gestion des exceptions dans la programmation Java.