Java try-with-resources Statement

Java 9 New Features

try-with-resources is a concise resource management approach introduced in Java 7, suitable for resources that need to be automatically closed after use (such as files, database connections, network connections, etc.).

try-with-resources makes it easy to close resources used in try-catch statement blocks. A so-called resource refers to an object that must be closed after the program completes.

The try-with-resources statement ensures that each resource is closed at the end of the statement.

All objects that implement the java.lang.AutoCloseable interface (which includes all objects implementing java.io.Closeable) can be used as resources.

Advantages:

• Simplified code: Eliminates manual resource-closing code, making the logic clearer.
• Fewer errors: Automatically handles resource closing, avoiding forgotten resource closures or handlingfinallyexceptions that occur in the block.
• Improved performance: Reduces resource leaks and saves system resources.

Execution Flow

The key to understanding try-with-resources lies in grasping the resource lifecycle and the control flow when exceptions occur.

Basic Syntax

The try-with-resources syntax is as follows:

try (ResourceType resource = new ResourceType()) {
    // 使用资源
} catch (ExceptionType e) {
    // 处理异常
}

Resources declared in the try block are automatically closed after the code finishes executing, and are safely closed even when an exception occurs.

Multiple Resource Management (Closed in Reverse Order of Declaration):

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();
}

Close order:

rs → stmt → conn（声明顺序的逆序）

Close order:Multiple resources are closed in reverse order of their declaration, meaning resources declared later are closed first. This is consistent with stack-based (LIFO) management, ensuring that resources with dependencies are released correctly.

Using the AutoCloseable Interface

Any custom class that wants to be managed by try-with-resources only needs to implement the java.lang.AutoCloseable (or java.io.Closeable) interface and implement its close() method.

Output:

连接已建立: jdbc:mysql://localhost/mydb
执行查询: SELECT * FROM users
连接已关闭: jdbc:mysql://localhost/mydb

Exception Handling and Suppressed Exceptions

When both the business logic in the try block and close() throw exceptions, try-with-resources adopts a special strategy: the business exception propagates upward as the primary exception, while the exception thrown by close() is suppressed and attached to the primary exception, retrievable via getSuppressed().

Output:

主异常: Exception in doSomething
抑制异常: Exception in close

Note:In traditional try-finally, an exception in the finally block overrides the business exception, causing the original error to be lost. try-with-resources solves this classic pitfall through the suppressed exception mechanism.

Java 9 Enhancement: Reusing External Variables

Before Java 9, try-with-resources required resources to be redeclared in the try() block.

Java 9 removed this restriction: as long as the variable is effectively final, it can be referenced directly in try() without redeclaration.

effectively final：If a variable is not reassigned after initialization, the compiler automatically treats it as final. There is no need to explicitly write the final keyword.

Comparison with try-finally

Common Use Cases

When dealing with any resource that requires explicit closing, prefer try-with-resources over try-finally. The compiler guarantees that resources are always closed, the code is more concise, exception information is more complete, and it is the best practice for Java resource management.

Java 9 New Features