Java工程师必备——try-with资源管理语句

1.引言

在Java开发过程中，资源管理是一个重要的方面。传统的资源管理方式需要手动调用close()方法来释放资源，但这种方式往往容易出现遗漏或错误释放资源的情况。Java从JDK7版本开始引入了一种新的资源管理方式——try-with资源管理语句（try-with-resources statement）。通过使用该语句，开发人员可以更加方便地管理资源，提高代码的可读性和可维护性。本文将详细介绍try-with资源管理语句的用法、原理及注意事项。

2. 传统资源管理方式存在的问题

在理解try-with资源管理语句之前，我们先来了解一下传统的资源管理方式存在的问题。

2.1 遗漏或错误释放资源

在传统方式下，我们需要手动调用close()方法来释放资源，如文件IO中的close()方法。然而，在实际开发中，由于种种原因，我们可能会忘记调用该方法，导致资源无法正确释放。这不仅会导致资源的浪费，还可能造成一些隐患，如文件操作没有及时关闭可能会造成文件锁定、数据库连接没有关闭可能会造成连接池满、网络连接没有关闭可能会造成资源泄露等问题。

2.2 代码冗余

传统方式下，我们需要在finally块中调用close()方法来释放资源。如果我们同时使用多个资源，就需要在finally块中对每个资源进行处理，导致代码的冗余。比如：

InputStream inputStream = null;
OutputStream outputStream = null;

try {
    inputStream = new FileInputStream("input.txt");
    outputStream = new FileOutputStream("output.txt");
    // 进行文件读写操作
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (inputStream != null) {
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if (outputStream != null) {
        try {
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码中，我们使用了两个资源——输入流和输出流。在finally块中，我们分别对这两个资源调用了close()方法。如果有更多的资源需要处理，就需要继续增加代码，导致代码冗余。

3. try-with资源管理语句的用法

在JDK7之后，我们可以使用try-with资源管理语句来简化资源的管理。try-with资源管理语句使用try关键字时，紧跟一个或多个资源的声明，这些资源的类型必须实现了AutoCloseable接口。在try代码块执行完毕后，会自动调用资源的close()方法。如果有多个资源，可以使用分号进行分隔。

3.1 单个资源的使用

下面是使用try-with资源管理语句处理单个资源的示例代码：

try (InputStream inputStream = new FileInputStream("input.txt")) {
    // 进行文件读取操作
}

在以上代码中，我们使用了一个输入流资源。在try代码块执行完毕后，会自动调用输入流的close()方法释放资源。

3.2 多个资源的使用

我们也可以使用try-with资源管理语句处理多个资源。多个资源的声明之间使用分号进行分隔。下面是一个同时处理输入流和输出流的示例代码：

try (InputStream inputStream = new FileInputStream("input.txt");
     OutputStream outputStream = new FileOutputStream("output.txt")) {
    // 进行文件读写操作
}

在以上代码中，我们使用了一个输入流和一个输出流资源。在try代码块执行完毕后，会依次调用输入流和输出流的close()方法释放资源。

3.3 处理异常

使用try-with资源管理语句时，如果在try代码块中出现异常，那么会先处理异常，然后再调用资源的close()方法。这样可以保证资源的正常释放。下面是一个示例代码：

try (InputStream inputStream = new FileInputStream("input.txt")) {
    // 进行文件读取操作
    throw new IOException("Explicitly throwing an exception");
} catch (IOException e) {
    e.printStackTrace();
}

在以上代码中，try代码块中抛出了一个IOException，然后catch块中捕获并处理了该异常，同时也会自动调用输入流的close()方法释放资源。

4. try-with资源管理语句的原理

了解了try-with资源管理语句的用法后，我们来看一下它的原理。

在Java编译器中，try-with资源管理语句会被转换成一个带有finally块的传统try-catch-finally语句。原理如下：

try (Resource resource = new Resource()) {
    // do something
} catch (Exception e) {
    // exception handling
} finally {
    resource.close();
}

在编译后，上述代码会被转换为以下形式：

Resource resource = new Resource();
try {
    // do something
} catch (Exception e) {
    // exception handling
} finally {
    if (resource != null) {
        resource.close();
    }
}

可以看到，在转换后的代码中，资源的声明与try块的内容是分离的，资源的close()方法在finally块中调用。这样可以保证在异常发生时，资源仍然能够得到正确的释放。

5. try-with资源管理语句的注意事项

在使用try-with资源管理语句时，需要注意以下事项：

5.1 资源需要实现AutoCloseable接口

在使用try-with资源管理语句时，被管理的资源必须实现了AutoCloseable接口或其子接口Closeable。这两个接口定义了一个close()方法，用于释放资源。如果资源没有实现这两个接口，是无法使用try-with资源管理语句的。

5.2 声明的资源必须在小括号内初始化

在try-with资源管理语句中，资源的声明必须放在小括号内进行初始化。这意味着我们不能在try代码块内部再次对资源进行初始化，例如以下代码是错误的：

try (InputStream inputStream = new FileInputStream("input.txt")) {
    // do something
    inputStream = new FileInputStream("other.txt"); // 错误，不能再次初始化资源
} catch (IOException e) {
    e.printStackTrace();
}

5.3 catch和finally块可选

与传统的try-catch-finally语句相比，try-with资源管理语句可以省略catch和finally块。这是因为在资源释放前，会自动调用资源的close()方法。

try (InputStream inputStream = new FileInputStream("input.txt")) {
    // do something
}

在以上代码中，我们省略了catch和finally块，因为在资源释放前会自动调用输入流的close()方法。

5.4 资源的关闭顺序

当使用多个资源时，资源的关闭顺序与声明的顺序相反。也就是说，最后声明的资源会最先关闭，倒数第二个资源会在最后一个资源关闭后关闭，以此类推。

try (InputStream inputStream = new FileInputStream("input.txt");
     OutputStream outputStream = new FileOutputStream("output.txt")) {
    // do something
}

在以上代码中，outputStream资源会先于inputStream资源关闭。

5.5 异常处理

在try-with资源管理语句中，如果同时出现了try块和catch块中的异常，那么在finally块中抛出的异常将会“掩盖”掉try、catch块中的异常。因此，在异常处理时，我们需要注意可能因为资源关闭导致的异常。可以使用Throwable.getSuppressed()方法获取在关闭资源时抛出的异常。

try (ResourceA resourceA = new ResourceA();
     ResourceB resourceB = new ResourceB()) {
    // do something
} catch (Exception e) {
    Throwable[] suppressed = e.getSuppressed();
    for (Throwable throwable : suppressed) {
        throwable.printStackTrace();
    }
}

在以上代码中，我们同时使用了ResourceA和ResourceB两个资源。如果在关闭资源时，它们分别抛出了异常，这些异常会被捕获并存储在getSuppressed()方法返回的Throwable数组中，我们可以对这些异常进行处理。

6. 示例代码演示

为了更好地理解try-with资源管理语句的用法和效果，下面是一个示例代码演示。

class Resource implements AutoCloseable {

    private String name;

    public Resource(String name) {
        this.name = name;
        System.out.println("Resource " + name + " opened.");
    }

    public void doSomething() {
        System.out.println("Doing something with Resource " + name);
    }

    @Override
    public void close() throws Exception {
        System.out.println("Resource " + name + " closed.");
    }
}

public class Main {

    public static void main(String[] args) {
        try (Resource resource1 = new Resource("1");
             Resource resource2 = new Resource("2");
             Resource resource3 = new Resource("3")) {
            resource1.doSomething();
            resource2.doSomething();
            resource3.doSomething();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

以上代码中，我们定义了一个Resource类，实现了AutoCloseable接口。在Main类的main方法中，我们使用了try-with资源管理语句同时使用了三个资源对象。

运行以上代码，输出结果如下：

Resource 1 opened.
Resource 2 opened.
Resource 3 opened.
Doing something with Resource 1
Doing something with Resource 2
Doing something with Resource 3
Resource 3 closed.
Resource 2 closed.
Resource 1 closed.

可以看到，资源的打开和关闭操作都在预期的时机发生，且按照声明的逆序关闭。