Bonne façon de gérer les exceptions d'exécution en Java

Question

Je suis complètement nouveau à ce code et a commencé à remettre en question les choix de conception des développeurs d'origine.

J'ai une application Java multithread qui traite un certain nombre de tâches. Mon travail consiste à corriger la gestion des exceptions dans le code de sorte que lorsqu'une exception RuntimeException se produit (iBatis et/ou NullPointerException), les autres tâches sont exécutées à la place du thread qui se termine. Je veux savoir quelle est la meilleure façon de faire face à la gestion des exceptions ci-dessous:

public List<WorkUnit> performModule(List<WorkUnit> listOfInputs) 
      throws ModuleException { 

     List<WorkUnit> listOfOutputs = new ArrayList<WorkUnit>(); 
     for (WorkUnit mi : listOfInputs) { 
      WorkUnit mo=null; 
      try { 
       if (mi instanceof BulkOrder) { 
        mo = performModuleOperation(...); 
       } else if (mi instanceof Order) { 
        mo = performModuleOperation(...); 
       } else if (mi instanceof PreReleaseLoad) { 
        mo = performModuleOperation(...); 
       } else if (mi instanceof Load) { 
        mo = performModuleOperation(...); 
       } 
       listOfOutputs.add(mo); 
      } catch (OMSException e) { 
        if (e.shouldProcessFurther()) { 
         listOfOutputs.add((mo!=null) ? mo : mi); 
        } 
       //save error to database - code was removed 
        if (e.getExceptionType().equals(ExceptionType.TECHNICAL)) { 
         if (e instanceof ModuleException) { 
          throw (ModuleException) e; 
         } else { 
         throw new ModuleException(e); 
         } 
        } 
      } catch (Throwable th) { 
       ModuleException me = new ModuleException(th); 
       ExceptionHandler.logException(me, (WorkUnit)mi,orderDelegate); 
       throw me; 
      } 

     } 
     return listOfOutputs ; 
    } 

J'ai deux problèmes majeurs. 1) Le catch pour l'objet Throwable. Je comprends qu'ils veulent capturer des exceptions vérifiées et des exceptions non contrôlées. Je suppose qu'ils veulent aussi vérifier les erreurs, mais la documentation de Sun pour la gestion des exceptions précise que cela est fortement déconseillé. Dans le cas où vous obtenez une erreur vraiment grave comme la mémoire JVM à court de mémoire, vous ne pourrez peut-être pas récupérer. Cela pourrait être pris dans un fichier journal et je ne suis pas d'accord avec le fait qu'il a besoin d'être traité. Personnellement, si vous effectuez le suivi des erreurs techniques et des exceptions d'applications, cela ne semble pas être quelque chose que vous surveilleriez comme toute autre exception. Je peux me tromper ...

2) Il n'est pas clair comment les exceptions sont traitées. Dans le code ci-dessous, le, que l'exception renvoie au code ci-dessus enveloppe une exception régulière, qu'elle soit cochée ou non dans une exception personnalisée et lève cela. Le code ci-dessus recherche une exception OMSException qui est le parent de chaque exception personnalisée dans l'application entière. Est-ce un bon design? Vous pouvez voir où ils incluent un ExceptionType à l'objet d'exception personnalisé. Il semble déjà y avoir une fonctionnalité intégrée dans le traitement des exceptions existant de Java. S'il s'agit d'une exception d'application, lancez une exception personnalisée. S'il s'agit d'une exception technique, quelque chose est null quand il n'est pas supposé être ou un problème de connexion à la base de données, alors attraper une exception non vérifiée de Java et réagir en conséquence. Toute cette affaire semble confuse. Je veux juste savoir ce que les autres pensent de tout ça.

public Order performModuleOperation(Order order) 
      throws ModuleException {         

     try { 
      Map<String, Rule> rules = ...      

     }  
     catch (InductException ie) { 
      throw ie; 
     } 
     catch (Exception e) {  
      e.printStackTrace(); 
      throw new InductException(e.toString(),e); 
     } 
     return order; 
    } 

Answer 1

Il existe deux manières de traiter un thread qui s'exécute avec une exception non vérifiée. La première option consiste à exécuter le fil de avec dans un bloc try-catch qui attire toutes les erreurs et exceptions:

Thread t = new MyThread(); 
try { 
    lauchThreadHere(t); 
} catch (Throwable e) { 
    // log `e` or re-launch thread `t` or do something else. 
} 

Une autre façon est de mettre en œuvre Thread.UncaughtExceptionHandler:

public class MyUeh implements Thread.UncaughtExceptionHandler { 
    public void uncaughtException(Thread t, Throwable e) { 
     // log `e` or re-launch thread `t` or do something else. 
    } 
} 

Thread t = new MyThread(); 
t.setUncaughtExceptionHandler(new MyUeh()); 
lauchThreadHere(t);