Java 异常处理：try-with-resources 自动关闭资源详解

三、实战案例

场景 1：基础场景 —— 文件读写（对比传统写法）

传统 try-finally 写法（冗余易出错）

import java.io.FileInputStream;
import java.io.IOException;

public class TraditionalResourceDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("test.txt");
            int data = fis.read();
            System.out.println("读取数据：" + data);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 手动关闭资源，需判断非空 + 捕获异常
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

try-with-resources 写法（简洁安全）

import java.io.FileInputStream;
import java.io.IOException;

public class TryWithResourcesDemo {
    public static void main(String[] args) {
        // 资源声明在 try 括号内，自动关闭
        try (FileInputStream fis = new FileInputStream("test.txt")) {
            int data = fis.read();
            System.out.println("读取数据：" + data);
        } catch (IOException e) {
            e.printStackTrace(); // 统一处理读取和关闭异常
        }
    }
}

场景 2：进阶场景 —— 多资源自动关闭

多个资源用 ; 分隔，JVM 会按声明逆序自动关闭，无需手动控制顺序：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class MultiResourceDemo {
    public static void main(String[] args) {
        // 声明两个资源：输入流 + 输出流
        try (FileInputStream fis = new FileInputStream("source.txt"); 
             FileOutputStream fos = new FileOutputStream("target.txt")) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, len); // 复制文件
            }
            System.out.println("文件复制完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 自动关闭顺序：fos 先关闭，再关闭 fis
    }
}

场景 3：自定义 AutoCloseable 资源

自定义资源类实现 AutoCloseable，即可被 try-with-resources 管理：

public class CustomResource implements AutoCloseable {
    public CustomResource() {
        System.out.println("资源初始化");
    }
    
    public void doWork() {
        System.out.println("执行业务逻辑");
    }

    // 实现 close() 方法，自动被调用
    @Override
    public void close() throws Exception {
        System.out.println("自定义资源关闭（释放连接/资源）");
    }

    public static void main(String[] args) {
        try (CustomResource resource = new CustomResource()) {
            resource.doWork();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 输出顺序：资源初始化 → 执行业务逻辑 → 自定义资源关闭
    }
}

场景 4：Java 9+ 简化写法（复用外部资源）

Java 9+ 无需在 try 括号内重新创建资源，可直接使用外部已声明的变量（非 final 也可）：

import java.io.FileInputStream;
import java.io.IOException;

public class Java9PlusDemo {
    public static void main(String[] args) throws IOException {
        // 外部声明资源
        FileInputStream fis = new FileInputStream("test.txt");
        // 直接复用资源变量
        try (fis) {
            int data = fis.read();
            System.out.println("读取数据：" + data);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 资源已自动关闭，无需手动操作
    }
}

四、易错点与避坑指南

易错点 1：资源未实现 AutoCloseable 接口

错误代码：

// 自定义资源未实现 AutoCloseable
class InvalidResource {
    public void close() {}
}
// 编译报错：InvalidResource cannot be converted to AutoCloseable
try (InvalidResource resource = new InvalidResource()) {
    resource.close();
}

正确代码：

// 实现 AutoCloseable 接口
class ValidResource implements AutoCloseable {
    @Override
    public void close() throws Exception {
        System.out.println("资源关闭");
    }
}
try (ValidResource resource = new ValidResource()) {
    // 业务逻辑
} catch (Exception e) {
    e.printStackTrace();
}

原因分析：try-with-resources 仅支持实现 AutoCloseable 接口的资源，编译时会严格校验，未实现则直接报错。

易错点 2：忽略 close() 方法抛出的异常

错误代码：

try (FileInputStream fis = new FileInputStream("test.txt")) {
    fis.read();
} // 未捕获异常，编译报错（要求处理 checked 异常）

正确代码：

try (FileInputStream fis = new FileInputStream("test.txt")) {
    fis.read();
} catch (IOException e) {
    // 处理读取或关闭时的异常（含 close() 抛出的异常）
    e.printStackTrace();
    // 进阶：获取被抑制的异常（close() 异常可能被核心异常抑制）
    Throwable[] suppressed = e.getSuppressed();
    for (Throwable t : suppressed) {
        System.out.println("被抑制异常：" + t);
    }
}

原因分析：AutoCloseable.close() 抛出 Exception（checked 异常），要求必须通过 catch 捕获或 throws 声明，否则编译失败；且 close() 异常可能被业务异常抑制，需通过 getSuppressed() 获取。

易错点 3：多个资源关闭顺序导致的依赖问题

错误代码：

// 错误顺序：先声明依赖资源，后声明被依赖资源
try (OutputStream os = new FileOutputStream("test.txt"); 
     BufferedOutputStream bos = new BufferedOutputStream(os)) {
    bos.write("data".getBytes());
}

正确代码：

// 正确顺序：先声明被依赖资源（os），后声明依赖资源（bos）
try (FileOutputStream os = new FileOutputStream("test.txt"); 
     BufferedOutputStream bos = new BufferedOutputStream(os)) {
    bos.write("data".getBytes());
}

原因分析：多个资源关闭顺序为'声明逆序'（先关 bos，再关 os）。若顺序颠倒，先关 os 再关 bos 时，bos 依赖的 os 已关闭，会抛出 IOException。

易错点 4：Java 9 之前复用外部资源（语法错误）

错误代码（Java 8 及以下）：

FileInputStream fis = new FileInputStream("test.txt");
try (fis) { // Java 8 及以下编译报错：资源变量必须在 try 括号内声明
    fis.read();
}

正确代码（兼容 Java 8+）：

// Java 8 及以下需在 try 括号内重新声明
try (FileInputStream fis = new FileInputStream("test.txt")) {
    fis.read();
}

原因分析：Java 9 才支持复用外部资源变量，Java 8 及以下要求资源必须在 try(...) 内显式声明并初始化；若需兼容低版本，需采用传统声明方式。

易错点 5：误认为 try-with-resources 可替代所有资源关闭

错误代码：

// 非 AutoCloseable 资源（如 Socket 的 InputStream）
try (Socket socket = new Socket("localhost", 8080)) {
    InputStream is = socket.getInputStream();
    is.read(); // 流未被自动关闭，导致资源泄漏
}

正确代码：

try (Socket socket = new Socket("localhost", 8080); 
     InputStream is = socket.getInputStream()) {
    // 流也声明为资源
    is.read();
}

原因分析：try-with-resources 仅自动关闭括号内声明的资源，括号外创建的资源（即使实现 AutoCloseable）不会被处理；仍需将所有需关闭的资源显式声明在 try(...) 内。

五、总结与扩展

本文核心：try-with-resources 通过实现 AutoCloseable 接口自动关闭资源，简化代码、避免泄漏。核心要点：资源需实现 AutoCloseable、多资源逆序关闭、Java 9+ 支持复用外部变量。

扩展方向：

1. 处理被抑制异常（getSuppressed()）；
2. 自定义 AutoCloseable 实现复杂资源管理；
3. 框架中应用（如 Spring Boot 的 Resource 接口）。

面试高频提问

1. try-with-resources 的核心依赖是什么接口？该接口的核心方法是什么？
2. try-with-resources 的底层实现原理是什么？与传统 try-finally 的区别？
3. Java 9 对 try-with-resources 做了哪些优化？
4. 多个资源被 try-with-resources 管理时，关闭顺序是什么？
5. try-with-resources 中，业务异常和 close() 方法抛出的异常如何处理？