Instruction try-with-resources de Java

Java 9 新特性Nouveautés de Java 9

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 gestionfinallydes 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.

Declaration Phase Declaration / Initialization res1 Connection ① res2 Statement ② res3 ResultSet Execute try block Execute try { ... } Closing Phase Auto-close (Reverse Order) close res3 ResultSet close res2 Statement close res1 Connection Close arrow ③ ④ ⑤ try block to close arrow try block ends

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

public class DatabaseConnection implements AutoCloseable {
    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().

try block try { ... } Throws Exception A (Business exception) close() Throws Exception B (Closing exception) Connect try → close Triggers Primary exception Primary exception Exception A Suppressed exception Suppressed exception Exception B Arrow Attach suppressed addSuppressed() catch block catch (Exception e) Catches primary exception A e.getSuppressed() Retrieve suppressed Exception B Connect to catch

Exemple

try (ResourceWithException res = new ResourceWithException()) {
    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

BufferedReader br = new BufferedReader(new StringReader("hello"));
try (BufferedReader br1 = br) {    // ← Il faut déclarer une nouvelle variable br1
    System.out.println(br1.readLine());
}

Java 9+ — Réutilisation directe

BufferedReader br = new BufferedReader(new StringReader("hello"));
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)

BufferedReader br = null;
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)

try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    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.

Java 9 新特性Nouveautés de Java 9

Autres extensions