Directives sur la propagation des exceptions (en Java)

Existe-t-il des directives sur la propagation des exceptions en Java?

Quand ajoutez-vous une exception à la signature de la méthode? Par exemple: si une exception est lancée uniquement lorsqu’une ressource de programme essentielle est manquante et ne peut être gérée qu’au niveau supérieur, est-ce que je la propage par toutes les méthodes utilisant cette exception via toutes les méthodes utilisant la méthode erring?

Y a-t-il de bonnes pratiques? Des mauvaises pratiques?

Je suis désolé si je suis vague, mais je cherche simplement des conseils (généraux) sur le style de programmation concernant les exceptions.

Les directives qui m’ont aidé dans le passé incluent:

  • Lancez des exceptions lorsque la méthode ne peut pas gérer l’exception et, plus important encore, qu’elle doit être traitée par l’appelant. Un bon exemple de cela se produit dans l’API Servlet – doGet () et doPost () lancent une exception ServletException ou IOException dans certaines circonstances où la demande n’a pas pu être lue correctement. Aucune de ces méthodes n’est en mesure de gérer l’exception, mais le conteneur est (ce qui entraîne la page d’erreur 50x dans la plupart des cas).
  • Bulle l’exception si la méthode ne peut pas la gérer . Ceci est un corollaire de ce qui précède, mais applicable aux méthodes qui doivent capturer l’exception. Si l’exception interceptée ne peut pas être traitée correctement par la méthode, il est alors préférable de la mettre en bulle.
  • Lancez l’exception immédiatement . Cela peut sembler vague, mais si un scénario d’exception est rencontré, il est conseillé de lancer une exception indiquant le sharepoint défaillance initial, au lieu d’essayer de gérer l’échec via des codes d’erreur, jusqu’à ce qu’un point réputé approprié pour lancer l’exception soit détecté. . En d’autres termes, essayez de minimiser la gestion des exceptions de mélange avec la gestion des erreurs.
  • Enregistrez l’exception ou faites-la bouillonner, mais ne faites pas les deux . La journalisation d’une exception indique souvent que la stack d’exceptions a été complètement déroulée, indiquant qu’aucune propagation de l’exception ne s’est produite. Par conséquent, il n’est pas recommandé de faire les deux en même temps, car cela conduit souvent à une expérience frustrante dans le débogage.
  • Utilisez des sous-classes de java.lang.Exception (exceptions vérifiées), sauf si l’appelant gère l’exception . Cela entraîne le message d’erreur du compilateur si l’appelant ne gère pas l’exception. Attention cependant, cela se traduit généralement par des développeurs “avalant” des exceptions dans le code.
  • Utilisez des sous-classes de java.lang.RuntimeException (exceptions non vérifiées) pour signaler des erreurs de programmation . Les classes d’exception recommandées ici incluent IllegalStateException , IllegalArgumentException , UnsupportedOperationException , etc.
  • Utilisez des hiérarchies de classes d’exceptions pour communiquer des informations sur les exceptions sur différents niveaux . En implémentant une hiérarchie, vous pouvez généraliser le comportement de gestion des exceptions dans l’appelant. Par exemple, vous pouvez utiliser une exception racine telle que DomainException qui comporte plusieurs sous-classes telles que InvalidCustomerException, InvalidProductException, etc. Le problème est que votre hiérarchie des exceptions peut exploser très rapidement si
  • Évitez d’attraper des exceptions que vous ne pouvez pas gérer . Assez évident, mais beaucoup de développeurs tentent d’attraper java.lang.Exception ou java.lang.Throwable. Comme toutes les exceptions sous-classées peuvent être interceptées, le comportement d’exécution de l’application peut souvent être vague lorsque des classes d’exception “globales” sont interceptées. Après tout, on ne voudrait pas attraper OutOfMemoryError – comment gérer une telle exception?
  • Enveloppez les exceptions avec soin . La retransmission d’une exception réinitialise la stack d’exceptions. À moins que la cause originale ait été fournie au nouvel object d’exception, elle est perdue pour toujours. Afin de préserver la stack des exceptions, il faudra fournir l’object exception d’origine au constructeur de la nouvelle exception.
  • Convertir les exceptions vérifiées en celles non vérifiées uniquement lorsque cela est nécessaire . Lors de l’encapsulation d’une exception, il est possible d’encapsuler une exception cochée et d’en lancer une non cochée. Cela est utile dans certains cas, en particulier lorsque l’intention est d’abandonner le thread en cours d’exécution. Toutefois, dans d’autres scénarios, cela peut causer un peu de peine, car les vérifications du compilateur ne sont pas effectuées. Par conséquent, l’adaptation d’une exception vérifiée à une exception non contrôlée ne doit pas être effectuée à l’aveuglette.

Vous devez gérer la méthode dès que possible, mais cela doit avoir un sens. Si l’exception n’a pas de sens pour être déclenchée par votre méthode, mais que vous ne pouvez pas la gérer, placez-la dans une autre exception et lancez cette nouvelle exception.

Une mauvaise pratique concernant les exceptions est de les attraper tous (ce n’est pas du Pokemon, c’est du java!), Donc évitez les catch(Exception e) ou les catch(Throwable t) plus mauvaises catch(Throwable t) .