web-dev-qa-db-fra.com

Essayez avec ressources vs Try-Catch

J'ai examiné le code et j'ai vu essayer avec des ressources. J'ai déjà utilisé l'instruction try-catch standard et il semble qu'ils fassent la même chose. Donc ma question est Essayez avec des ressources vs Try-Catch quelles sont les différences entre ceux-ci, et qui est le meilleur.

Voici un essai avec des ressources:

objects jar = new objects("brand");
objects can= new objects("brand");

try (FileOutputStream outStream = new FileOutputStream("people.bin")){
    ObjectOutputStream stream = new ObjectOutputStream(outStream);

    stream.writeObject(jar);
    stream.writeObject(can);

    stream.close();
} catch(FileNotFoundException e) {
    System.out.println("sorry it didn't work out");
} catch(IOException f) {
    System.out.println("sorry it didn't work out");
}
javatry-catchtry-with-resources
25
computerquest

Le point essentiel de l’essai avec les ressources est de s’assurer que les ressources sont fermées, sans que le code de l’application soit nécessaire. Il y a cependant quelques points à prendre en compte.

Lorsque vous n'utilisez pas try-with-resources, il y a un piège potentiel appelé masquage d'exception. Lorsque le code dans un bloc try lève une exception et que la méthode close dans le finale lève également une exception, l'exception levée par le bloc try est perdue et l'exception renvoyée dans le finally est propagée. C’est généralement dommage, car l’exception levée à la fermeture est quelque chose d’inutile alors que l’exception utile est l’information. Utiliser des ressources d’essai avec des ressources pour fermer vos ressources empêchera tout masquage d’exception.

Afin de s’assurer que le masquage des exceptions ne perdrait pas d’importantes informations sur les exceptions, lors du développement de l’essai avec ressources, ils devaient décider quoi faire des exceptions lancées avec la méthode close.

Avec try-with-resources, si le bloc try lève une exception et que la méthode close lève une exception, alors l'exception du bloc close est ajoutée à l'exception d'origine :

... il existe des situations où deux exceptions indépendantes peuvent être générées dans des blocs de code frères, notamment dans le bloc try d'une instruction try-with-resources et dans le bloc finally généré par le compilateur qui ferme la ressource. Dans ces situations, une seule des exceptions levées peut être propagée. Dans l'instruction try-with-resources, lorsqu'il existe deux exceptions de ce type, l'exception provenant du bloc try est propagée et l'exception du bloc finally est ajoutée à la liste des exceptions supprimées par l'exception du bloc try. En tant qu'exception qui décompose la pile, elle peut accumuler plusieurs exceptions supprimées. 

D'autre part, si votre code se termine normalement mais que la ressource que vous utilisez lève une exception à la fermeture, cette exception (qui sera supprimée si le code du bloc try a été jeté) est levée. Cela signifie que si vous avez du code JDBC dans lequel ResultSet ou PreparedStatement est fermé par try-with-resources, une exception résultant d'un problème d'infrastructure lorsqu'un objet JDBC est fermé peut être levée et peut annuler une opération qui, sinon, aurait abouti. .

Sans try-with-resources, le fait que l'exception de méthode close soit levée relève du code de l'application. S'il est lancé dans un bloc finally lorsque le bloc try lève une exception, l'exception du bloc finally masquera l'autre exception. Mais le développeur a la possibilité d’attraper l’exception levée de près et de ne pas la propager. 

39
Nathan Hughes台湾不在中国

Vous avez manqué quelque chose, le bloc finally. Le try-with-resouces en fera quelque chose comme,

FileOutputStream outStream = null;
try {
  outStream = new FileOutputStream("people.bin");
  ObjectOutputStream stream = new ObjectOutputStream(outStream);

  stream.writeObject(jar);
  stream.writeObject(can);

  stream.close();
} catch(FileNotFoundException e) {
    System.out.println("sorry it didn't work out");
} catch(IOException f) {
    System.out.println("sorry it didn't work out");
} finally {
  if (outStream != null) { 
    try { 
      outStream.close(); 
    } catch (Exception e) {
    } 
  }
}

Ce qui signifie que vous vouliez vraiment quelque chose comme (never avale des exceptions),

try (FileOutputStream outStream = new FileOutputStream("people.bin");
     ObjectOutputStream stream = new ObjectOutputStream(outStream);) {
  stream.writeObject(jar);
  stream.writeObject(can);
  // stream.close(); // <-- closed by try-with-resources.
} catch(FileNotFoundException e) {
    System.out.println("sorry it didn't work out");
    e.printStackTrace();
} catch(IOException f) {
    System.out.println("sorry it didn't work out");
    e.printStackTrace();
}
5
Elliott Frisch

La seule différence est que try-resource ajoute automatiquement resource.close();.__ comme vous le feriez dans le bloc finally.

1
Dima

Tout objet (la classe ou sa superclasse) qui implémente Java.lang.AutoCloseable ou Java.io.Closeable Ne peut être utilisé que dans la clause try-with-resource . L'interface autoClosable est l'interface parent et l'interface Closable étend l’interface AutoClosable. L’interface AutoClosable a une méthode close qui jette Exception, tandis que l’interface Closable a une méthode qui jette IOException . Nous pouvons également avoir un bloc catch et un bloc suivi par try-with-resource comme et finalement, le blocage n'est exécuté que lorsque la ressource déclarée dans la clause try-with-resource est fermée.

0
apurbojha