Comment voulez-vous intercepter toutes les exceptions?

StackOverflow https://stackoverflow.com/questions/1509346

  •  19-09-2019
  •  | 
  •  

Question

Qu'est-ce que selon vous la façon la plus simple d'intercepter toutes les exceptions dans une application Java? AOP serait être nécessaire pour fournir ce type de fonctionnalité ou peut-il être fait avec des procurations dynamiques ou est-il une autre façon? Est la solution la plus simple aussi une bonne solution en ce qui concerne l'impact sur les performances d'exécution? Je voudrais entendre les solutions possibles de développeurs plus expérimentés que je suis en train de saisir le savoir-faire technique sur le sujet.

EDIT:

Merci pour les bons conseils déjà, mais ne concerne pas les conseils en cours uniquement aux exceptions vérifiées? Qu'en est-il des exceptions non contrôlées, comme NullPointerExceptions, ne serait-il utile que ceux-ci pourraient être pris et que l'application sur les attraper dépotoirs tas / pile pour vous fournir le contexte actuel de l'application au moment de s'écraser?

Était-ce utile?

La solution

Nate et Konamiman ... Qu'est-ce que vous proposez ne fonctionne pas du tout et ne répond pas à la question de l'OP.

Que faire si l'OP démarre un nouveau thread à l'intérieur de votre try / catch?

Par exemple: 

public static void main(String[] args) {
    try {
        final Thread t = new Thread( new Runnable() {
            public void run() {
                System.out.println( 3 / Math.min(0,4) );
            }
        } );
        t.start();
    catch(Throwable t) {
        ...
    }
}

Ensuite, vous n'êtes pas attraper l'exception.

La bonne façon de le faire est d'utiliser Thread.setDefaultUncaughtExceptionHandler.

Autres conseils

Quel est le but de vous vouloir intercepter toutes les exceptions - pour l'enregistrement, les rapports d'erreur

Intercepter chaque exception dans chaque ligne d'un programme Java est possible, mais engagerait probablement un certain impact sur les performances. Si elle est inévitable, il serait probablement préférable d'utiliser quelque chose comme AspectJ , qui peut fonctionner à la compilation (il « tisse » dans vos fichiers de classe) et en tant que telle est beaucoup plus rapide que les proxies dynamiques.

Mais il est quelque chose que je voudrais essayer d'éviter de faire à tout prix! En général, je dirais qu'il est préférable de limiter la portée des exceptions que vous voulez prendre. Aussi, vous voudrez peut-être regarder dans Thread.setDefaultUncaughtExceptionHandler , que je trouve utile pour l'affichage des boîtes de dialogue d'erreur dans les applications de l'interface graphique.

Tout comme la réponse de Phil, voici quelques exemples de code montrant comment utiliser le gestionnaire d'exception non interceptée. Cela fonctionne pour les deux exceptions non contrôlées et vérifiées.

Modifier. Mise à jour pour imprimer la trace de la pile en fonction des commentaires mis à jour dans la question 

import java.lang.Thread.UncaughtExceptionHandler;

public class Test {

    public static void main(String[] args) throws Exception {
        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {

            @Override
            public void uncaughtException(Thread t, Throwable e) {
                e.printStackTrace();
            }}

        );

        // throw new RuntimeException(); /* this works too */
        throw new Exception();
    }

}

public static void main(String[] args) {
    try {
        ...
    catch(Throwable t) {
        ...
    }
}

Plus important que d'attraper simplement toutes les exceptions est où vous attrapez l'exception:

  1. Ne pas attraper une exception à moins que vous pouvez faire quelque chose à ce sujet. Si vous ne pouvez rien faire à ce sujet, que ce soit le laisser bouillonner au niveau suivant ou l'attraper, réencapsulage comme une exception plus spécifique et re-jeter.

  2. Ayez toujours un bloc global de gestion des exceptions (comme dans la réponse de Nate) pour intercepter toutes les erreurs que vous ne pouvez pas gérer partout de sorte que vous pouvez échouer un peu avec élégance.

Si vous voulez simplement attraper une exception, un bloc try / catch suffit. Si vous voulez les empêcher d'être jetés ou faire l'enregistrement ou l'emballage de l'exception, vous aurez probablement besoin d'AOP pour ce faire. AspectJ traitera assez bien, mais méfiez-vous des goulots d'étranglement potentiels.

proxies dynamiques ne fonctionnent que lorsque la méthode est approximée, donc si une exception est levée et coincé à l'intérieur de l'exécution de l'objet proxy il n'y a aucun moyen pour les procurations pour intercepter l'exception.

Une chose à considérer est que si vous attrapez toutes les exceptions, ou seulement d'exceptions vérifiées. Pour attraper toutes les exceptions, around throwing de AspectJ ou after throwing conseils tisserait un certain traitement autour de chaque méthode, cela implique la création d'objets JoinPoint et des méthodes de synthèse à chaque appel de méthode. Ce n'est pas normalement un problème à moins que le processus est dans une boucle serrée, où la collecte des ordures peut passer par le toit.

Pour tous ceux questionnant la nécessité de prendre toutes les exceptions ...

Il y a un beaucoup de raisons valables pour attraper toutes les exceptions:

  • quelqu'un afficher une boîte de dialogue mentionné dans une application graphique indiquant le problème
  • travail autour des bugs dans une API 3rd Party vous avez vraiment besoin
  • travail autour des bogues dans la mise en œuvre JVM
  • logiciel d'auto-guérison.
  • les rapports d'exception en ligne automatique.

Notez que Java se ne intercepte toutes les exceptions à l'EDT (Discussion Dispatch Event) et génère un nouveau EDT lorsque l'EDT meurt. Vous pouvez considérer qu'une forme de logiciel « auto-guérison ». La mort EDT n'est pas quelque chose d'inouï et ne l'empêche pas exactement les applications de fonctionner correctement (au contraire). (Et, yup, Swing et AWT ont tout à fait quelques bugs, juste jeter un oeil à la parade de bug Sun;)

On pourrait faire valoir que toute auto-respect du logiciel devrait effectivement prendre en compte le cas d'une exception imprévue (sont tous les logiciels que vous expédiez bug 100% gratuit et ne fait jamais les nouveautés, les communiqués bug-fix?) Et faire quelque chose intelligent lorsque cette exception imprévue arrive.

Le « quelque chose d'intelligent » peut empêcher le logiciel de plantage (comme dans le cas EDT), avertissant l'utilisateur, l'envoi d'un rapport, etc.

Réponses Interrogatoire la nécessité de faire une telle chose ou ce qui suggère que le faire est une mauvaise pratique devrait être à mon humble avis modded bas.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top