Instruction try-with-resources de Java
try-with-resources est une approche concise de gestion des ressources introduite dans Java 7, adaptée aux ressources qui doivent être automatiquement fermées après utilisation (telles que les fichiers, les connexions à une base de données, les connexions réseau, etc.).
try-with-resources facilite la fermeture des ressources utilisées dans les blocs d'instructions try-catch. Une ressource désigne un objet qui doit être fermé une fois le programme terminé.
L'instruction try-with-resources garantit que chaque ressource est fermée à la fin de l'instruction.
Tous les objets qui implémentent l'interface java.lang.AutoCloseable (ce qui inclut tous les objets implémentant java.io.Closeable) peuvent être utilisés comme ressources.
Avantages :
- Code simplifié: Élimine le code de fermeture manuelle des ressources, rendant la logique plus claire.
- Moins d'erreurs: Gère automatiquement la fermeture des ressources, évitant les fermetures de ressources oubliées ou la gestion
finallydes exceptions qui se produisent dans le bloc. - Performances améliorées: Réduit les fuites de ressources et économise des ressources système.
Flux d'exécution
La clé pour comprendre try-with-resources réside dans la compréhension du cycle de vie des ressources et du flux de contrôle lorsque des exceptions se produisent.
Syntaxe de base
La syntaxe de try-with-resources est la suivante :
try (ResourceType resource = new ResourceType()) {
// 使用资源
} catch (ExceptionType e) {
// 处理异常
}
Les ressources déclarées dans le bloc try sont automatiquement fermées après la fin de l'exécution du code, et sont fermées en toute sécurité même lorsqu'une exception se produit.
Gestion de ressources multiples (fermeture dans l'ordre inverse de déclaration) :
try (Connection conn = DriverManager.getConnection(url);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql)) {
while (rs.next()) {
System.out.println(rs.getString(1));
}
} catch (SQLException e) {
e.printStackTrace();
}
Ordre de fermeture :
rs → stmt → conn(声明顺序的逆序)
Ordre de fermeture :Plusieurs ressources sont fermées dans l'ordre inverse de leur déclaration, ce qui signifie que les ressources déclarées plus tard sont fermées en premier. Cela est cohérent avec une gestion basée sur une pile (LIFO), garantissant que les ressources ayant des dépendances sont libérées correctement.
Utilisation de l'interface AutoCloseable
Toute classe personnalisée qui souhaite être gérée par try-with-resources n'a qu'à implémenter l'interface java.lang.AutoCloseable (ou java.io.Closeable) et implémenter sa méthode close().
Exemple
private final String url;
public DatabaseConnection(String url) {
this.url = url;
System.out.println("Connexion établie : " + url);
}
public void query(String sql) {
System.out.println("Exécution de la requête : " + sql);
}
@Override
public void close() {
System.out.println("Connexion fermée : " + url);
// Libérer les ressources de connexion sous-jacentes...
}
}
// Utilisation
try (DatabaseConnection db = new DatabaseConnection("jdbc:mysql://localhost/mydb")) {
db.query("SELECT * FROM users");
} catch (Exception e) {
e.printStackTrace();
}
Sortie :
连接已建立: jdbc:mysql://localhost/mydb 执行查询: SELECT * FROM users 连接已关闭: jdbc:mysql://localhost/mydb
Gestion des exceptions et des exceptions supprimées
Lorsque la logique métier dans le bloc try et close() lèvent tous deux des exceptions, try-with-resources adopte une stratégie spéciale : l'exception métier se propage vers le haut en tant qu'exception principale, tandis que l'exception levée par close() est supprimée et attachée à l'exception principale, récupérable via getSuppressed().
Exemple
res.doSomething(); // Lève Exception A (exception métier)
} catch (Exception e) {
System.out.println("Exception primaire : " + e.getMessage());
for (Throwable s : e.getSuppressed()) { // Récupérer l'exception B
System.out.println("Exception supprimée : " + s.getMessage());
}
}
Sortie :
主异常: Exception in doSomething 抑制异常: Exception in close
Remarque :Dans le try-finally traditionnel, une exception dans le bloc finally écrase l'exception métier, ce qui entraîne la perte de l'erreur d'origine. try-with-resources résout ce piège classique grâce au mécanisme des exceptions supprimées.
Amélioration Java 9 : réutilisation de variables externes
Avant Java 9, try-with-resources exigeait que les ressources soient redéclarées dans le bloc try().
Java 9 a supprimé cette restriction : tant que la variable est effectivement finale, elle peut être référencée directement dans try() sans redéclaration.
Java 7 / 8 — Redéclaration obligatoire
try (BufferedReader br1 = br) { // ← Il faut déclarer une nouvelle variable br1
System.out.println(br1.readLine());
}
Java 9+ — Réutilisation directe
try (br) { // ← Utiliser br directement, aucune redéclaration nécessaire
System.out.println(br.readLine());
}
effectively final:Si une variable n'est pas réassignée après initialisation, le compilateur la traite automatiquement comme final. Il n'est pas nécessaire d'écrire explicitement le mot-clé final.
Comparaison avec try-finally
| Dimension | try-finally | try-with-resources |
|---|---|---|
| Volume de code | Plus — nécessite d'appeler manuellement close() | Moins — fermeture automatique |
| Risque d'omettre close() | Élevé — un oubli humain provoque facilement des fuites de ressources | Zéro — garanti par le compilateur |
| Imbrication de ressources multiples | Imbrication profonde, faible lisibilité | Séparées par des points-virgules, à plat et claires |
| Gestion des exceptions | l'exception finally écrase l'exception métier | Mécanisme des exceptions supprimées, informations entièrement préservées |
| Périmètre d'application | Toute logique de nettoyage | Ressources implémentant AutoCloseable |
Approche try-finally (verbeuse et sujette aux erreurs)
try {
br = new BufferedReader(new FileReader("data.txt"));
String line;
while ((line = br.readLine()) != null) System.out.println(line);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null) { // Nécessite aussi une vérification de null
try { br.close(); } // close lui-même peut aussi lever une exception
catch (IOException e) { e.printStackTrace(); }
}
}
Approche try-with-resources (concise et sûre)
String line;
while ((line = br.readLine()) != null) System.out.println(line);
} catch (IOException e) {
e.printStackTrace();
}
Cas d'utilisation courants
| Catégorie | Classes/Interfaces courantes |
|---|---|
| 📁 E/S de fichiers | FileInputStream、FileOutputStream、BufferedReader、BufferedWriter、FileChannel |
| 🗄 Base de données | Connection、PreparedStatement、Statement、ResultSet、EntityManager |
| 🌐 Communication réseau | Socket、ServerSocket、HttpURLConnection、InputStream、OutputStream |
Lorsque vous manipulez une ressource nécessitant une fermeture explicite, préférez try-with-resources à try-finally. Le compilateur garantit que les ressources sont toujours fermées, le code est plus concis, les informations d'exception sont plus complètes, et c'est la meilleure pratique pour la gestion des ressources Java.
Autres extensions
Nouveautés de Java 9