Gestion des exceptions Java dans les tâches non séquentielles (modèle/bonne pratique)

Question

Il y a des tâches qui ne doivent pas être effectuées en parallèle (par exemple ouvrir un fichier, lire, écrire et fermer, il y a un ordre sur cela. ..)

mais ... Certaines tâches sont plus comme une liste shoping, je veux dire qu'ils pourraient avoir un ordre souhaitable, mais ce n'est pas un must..example dans les pilotes de independient de communication ou de chargement etc ..

Pour ce genre de tâches, Je voudrais savoir une meilleure pratique java ou un modèle pour gérer les exceptions ..

La manière simple de java est:

getUFO { 
     try { 
      loadSoundDriver(); 
      loadUsbDriver(); 
      loadAlienDetectorDriver(); 
      loadKeyboardDriver();  
    } catch (loadSoundDriverFailed) { 
    doSomethingA; 
    } catch (loadUsbDriverFailed) { 
     doSomethingB; 
    } catch (loadAlienDetectorDriverFailed) { 
     doSomethingC; 
    } catch (loadKeyboardDriverFailed) { 
     doSomethingD; 
    } 
} 

Mais qu'en ayant une exception dans l'une des actions, mais vouloir essayer avec les prochains ??

J'ai pensé cette approche, mais ne semble être une bonne utilisation des exceptions Je ne sais pas pas si cela fonctionne, n'a pas d'importance, il est vraiment terrible !!

getUFO { 
     Exception ex=null; 
try { 
     try{ loadSoundDriver(); 
     }catch (Exception e) { ex=e; } 
     try{ loadUsbDriver(); 
     }catch (Exception e) { ex=e; } 
     try{ loadAlienDetectorDriver(); 
     }catch (Exception e) { ex=e; } 
     try{ loadKeyboardDriver() 
     }catch (Exception e) { ex=e; } 

     if(ex!=null) 
     { throw ex; 
     } 
    } catch (loadSoundDriverFailed) { 
    doSomethingA; 
    } catch (loadUsbDriverFailed) { 
     doSomethingB; 
    } catch (loadAlienDetectorDriverFailed) { 
     doSomethingC; 
    } catch (loadKeyboardDriverFailed) { 
     doSomethingD; 
    } 
} 

ne semble pas compliqué de trouver une meilleure pratique pour le faire .. Je ne l'ai pas encore

Merci pour tout conseil

Answer 1

OMI, pour votre cas, si l'exception est « ignorable » il est préférable que la méthode "loadSoundDriver" capture l'exception et renvoie simplement une erreur. Puis, dans la fonction qui charge les choses, vous pouvez enregistrer toutes les erreurs et, à la fin de la séquence, décider quoi en faire. [modifier] Quelque chose comme ceci:

// init 
MyError soundErr = loadSoundDriver(); 
MyError otherErr = loadOtherDriver(); 

if(soundErr!=null || otherErr !=null){ 
// handle the error(s) 
} 

Answer 2

Considérons le execute around idiom.

Une autre option (qui n'est pas vraiment différente, il suffit de les découpler davantage) consiste à faire chaque tâche dans un fil séparé.

Edit:

Voici le genre de chose que j'ai à l'esprit:

public interface LoadableDriver { 
    public String getName(); 
    public void loadDriver() throws DriverException; 
    public void onError(Throwable e); 
} 

public class DriverLoader { 
    private Map<String, Exception> errors = new HashMap<String, Exception>(); 

    public void load(LoadableDriver driver) { 
     try { 
      driver.loadDriver(); 
     } catch (DriverException e) { 
      errors.put(driver.getName(), e); 
      driver.onError(e); 
     } 
    } 

    public Map<String, Exception> getErrors() { return errors; } 
} 

public class Main { 
    public void loadDrivers() { 
      DriverLoader loader = new DriverLoader(); 
      loader.loadDriver(new LoadableDriver(){ 
       public String getName() { return "SoundDriver"; } 
       public void loadDriver() { loadSoundDriver(); } 
       public void onError(Throwable e) { doSomethingA(); } 
      }); 
      //etc. Or in the alternative make a real class that implements the interface for each driver. 
      Map<String, Exception> errors = loader.getErrors(); 
      //react to any specific drivers that were not loaded and try again. 
     } 
} 

Edit: Voici ce qu'est une version Java propre regarderait en fin de compte comme si vous mis à exécution les pilotes comme des classes (qui est ce que le paradigme Java OO attendrait ici IMHO). La méthode Main.loadDrivers() changeraient comme ceci:

 public void loadDrivers(LoadableDriver... drivers) { 
      DriverLoader loader = ... 
      for(LoadableDriver driver : drivers) { 
       loader.load(driver); 
      } 
      //retry code if you want. 
      Set<LoadableDriver> failures = loader.getErrors(); 
      if(failures.size() > 0 && tries++ > MAX_TRIES) { 
       //log retrying and then: 
       loadDrivers(drivers.toArray(new LoadableDriver[0])); 
      } 
     } 

Bien sûr, je n'utilise plus une carte parce que les objets seraient autonomes (vous pouvez vous débarrasser de la méthode getName() aussi, mais probablement devrait surcharger toString()), donc les erreurs sont juste renvoyées dans un ensemble à réessayer. Vous pourriez rendre le code de réessai encore plus simple si chaque pilote était responsable de savoir à quelle fréquence il devrait réessayer. Java ne sera pas aussi beau qu'un gabarit C++ bien fait, mais c'est le choix du langage Java - préférez la simplicité aux fonctionnalités de langage complexes qui peuvent rendre le code difficile à maintenir dans le temps s'il n'est pas fait correctement.

Answer 3

Essayez ceci:

protected void loadDrivers() { 
    loadSoundDriver(); 
    loadUsbDriver(); 
    loadAlienDetectorDriver(); 
    loadKeyboardDriver();  
} 

Puis:

protected void loadSoundDriver() { 
    try { 
    // original code ... 
    } 
    catch(Exception e) { 
    soundDriverFailed(e); 
    } 
} 

protected void soundDriverFailed(Exception e) { 
    log(e); 
} 

Cela donne une chance de sous-classes changer le comportement. Par exemple, une sous-classe pourrait implémenter le chargement de chaque pilote dans un thread séparé. La classe principale n'a pas besoin de savoir comment les pilotes sont chargés, ni les utilisateurs de la classe principale.

Answer 4

Entourez simplement chaque opération de chargement avec son propre bloc try/catch.

try { 
    loadSoundDriver(); 
} catch (loadSoundDriverFailed) { 
    doSomethingA; 
} 

try { 
    loadUsbDriver(); 
} catch (loadUsbDriverFailed) { 
    doSomethingB; 
} 

    // ... 

Vous pouvez donc gérer toutes les exceptions et continuer le traitement des opérations.