Java の try-with-resource サンプルコードの詳細な紹介-＆＃＆チュートリアル-php.cn

背景

ご存知のとおり、ストリーム、ファイル、ソケット接続などの開いたシステムリソースはすべて、開発者が手動で閉じる必要があります。そうしないと、プログラムの実行が継続するにつれてリソースリークが蓄積され、重大な運用上の事故が発生します。

Java の世界には、Finally と呼ばれるカンフーがあり、武道の練習中に気が狂ってしまった場合でも、ある程度の自己救助活動を行うことができます。古代では、リソースのクローズを処理するコードは通常、finally ブロックで書かれていました。ただし、複数のリソースを同時に開いている場合は、悪夢のようなシナリオが発生します。

public class Demo {
    public static void main(String[] args) {
        BufferedInputStream bin = null;
        BufferedOutputStream bout = null;
        try {
            bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
            bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")));
            int b;
            while ((b = bin.read()) != -1) {
                bout.write(b);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            if (bin != null) {
                try {
                    bin.close();
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
                finally {
                    if (bout != null) {
                        try {
                            bout.close();
                        }
                        catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

ログイン後にコピー

なんと！！！ ビジネスコードよりもリソースを閉じるためのコードの方がたくさんあります! ！！これは、BufferedInputStream を閉じる必要があるだけでなく、BufferedInputStream を閉じるときに例外が発生した場合、BufferedOutputStream も確実に閉じる必要があるためです。正しく閉じました。したがって、最終的にネストするfinallyメソッドに頼る必要があります。より多くのリソースが開かれるほど、最終的にはネストがより深くなることが想像できます。！！ BufferedInputStream，还需要保证如果关闭BufferedInputStream时出现了异常， BufferedOutputStream也要能被正确地关闭。所以我们不得不借助finally中嵌套finally大法。可以想到，打开的资源越多，finally中嵌套的将会越深！！！

更为可恶的是，Python程序员面对这个问题，竟然微微一笑很倾城地说：“这个我们一点都不用考虑的嘞~”：

但是兄弟莫慌！我们可以利用Java 1.7中新增的try-with-resource语法糖来打开资源，而无需码农们自己书写资源来关闭代码。妈妈再也不用担心我把手写断掉了！我们用try-with-resource来改写刚才的例子：

public class TryWithResource {
    public static void main(String[] args) {
        try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
             BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")))) {
            int b;
            while ((b = bin.read()) != -1) {
                bout.write(b);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ログイン後にコピー

是不是很简单？是不是很刺激？再也不用被Python程序员鄙视了！好了，下面将会详细讲解其实现原理以及内部机制。

动手实践

为了能够配合try-with-resource，资源必须实现AutoClosable接口。该接口的实现类需要重写close方法：

public class Connection implements AutoCloseable {
    public void sendData() {
        System.out.println("正在发送数据");
    }
    @Override
    public void close() throws Exception {
        System.out.println("正在关闭连接");
    }
}

ログイン後にコピー

调用类：

public class TryWithResource {
    public static void main(String[] args) {
        try (Connection conn = new Connection()) {
            conn.sendData();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ログイン後にコピー

运行后输出结果：

正在发送数据
正在关闭连接

ログイン後にコピー

通过结果我们可以看到，close方法被自动调用了。

原理

那么这个是怎么做到的呢？我相信聪明的你们一定已经猜到了，其实，这一切都是编译器大神搞的鬼。我们反编译刚才例子的class文件：

public class TryWithResource {
    public TryWithResource() {
    }
    public static void main(String[] args) {
        try {
            Connection e = new Connection();
            Throwable var2 = null;
            try {
                e.sendData();
            } catch (Throwable var12) {
                var2 = var12;
                throw var12;
            } finally {
                if(e != null) {
                    if(var2 != null) {
                        try {
                            e.close();
                        } catch (Throwable var11) {
                            var2.addSuppressed(var11);
                        }
                    } else {
                        e.close();
                    }
                }
            }
        } catch (Exception var14) {
            var14.printStackTrace();
        }
    }
}

ログイン後にコピー

看到没，在第15~27行，编译器自动帮我们生成了finally块，并且在里面调用了资源的close方法，所以例子中的close方法会在运行的时候被执行。

异常屏蔽

我相信，细心的你们肯定又发现了，刚才反编译的代码（第21行）比远古时代写的代码多了一个addSuppressed。为了了解这段代码的用意，我们稍微修改一下刚才的例子：我们将刚才的代码改回远古时代手动关闭异常的方式，并且在sendData和close方法中抛出异常：

public class Connection implements AutoCloseable {
    public void sendData() throws Exception {
        throw new Exception("send data");
    }
    @Override
    public void close() throws Exception {
        throw new MyException("close");
    }
}

ログイン後にコピー

修改main方法：

public class TryWithResource {
    public static void main(String[] args) {
        try {
            test();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static void test() throws Exception {
        Connection conn = null;
        try {
            conn = new Connection();
            conn.sendData();
        }
        finally {
            if (conn != null) {
                conn.close();
            }
        }
    }
}

ログイン後にコピー

运行之后我们发现：

basic.exception.MyException: close
	at basic.exception.Connection.close(Connection.java:10)
	at basic.exception.TryWithResource.test(TryWithResource.java:82)
	at basic.exception.TryWithResource.main(TryWithResource.java:7)
	......

ログイン後にコピー

好的，问题来了，由于我们一次只能抛出一个异常，所以在最上层看到的是最后一个抛出的异常——也就是close方法抛出的MyException，而sendData抛出的Exception被忽略了。这就是所谓的异常屏蔽。由于异常信息的丢失，异常屏蔽可能会导致某些bug变得极其难以发现，程序员们不得不加班加点地找bug，如此毒瘤，怎能不除！幸好，为了解决这个问题，从Java 1.7开始，大佬们为Throwable类新增了addSuppressed方法，支持将一个异常附加到另一个异常身上，从而避免异常屏蔽。那么被屏蔽的异常信息会通过怎样的格式输出呢？我们再运行一遍刚才用try-with-resource包裹的main方法：

java.lang.Exception: send data
	at basic.exception.Connection.sendData(Connection.java:5)
	at basic.exception.TryWithResource.main(TryWithResource.java:14)
	......
	Suppressed: basic.exception.MyException: close
		at basic.exception.Connection.close(Connection.java:10)
		at basic.exception.TryWithResource.main(TryWithResource.java:15)
		... 5 more

ログイン後にコピー

可以看到，异常信息中多了一个Suppressed的提示，告诉我们这个异常其实由两个异常组成，MyException是被Suppressed的异常。可喜可贺！

一个小问题

在使用try-with-resource的过程中，一定需要了解资源的close方法内部的实现逻辑。否则还是可能会导致资源泄露。

举个例子，在Java BIO中采用了大量的装饰器模式。当调用装饰器的close方法时，本质上是调用了装饰器内部包裹的流的close

さらにひどいのは、Python🎜プログラマーということです。この問題に直面して、彼は実際に笑顔で魅力的にこう言いました。「これについてはまったく考える必要はありません~」: 🎜🎜

🎜🎜でも、パニックにならないでください、兄弟！ Java 1.7 の新しい try-with-resource 構文シュガーを使用すると、プログラマがコードを閉じるためのリソースを自分で作成する必要がなく、リソースを開くことができます。お母さんはもう私の字が崩れるのを心配する必要はありません。 try-with-resource を使用して前の例を書き直してみましょう: 🎜

public class TryWithResource {
    public static void main(String[] args) {
        try (FileInputStream fin = new FileInputStream(new File("input.txt"));
                GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream(new File("out.txt")))) {
            byte[] buffer = new byte[4096];
            int read;
            while ((read = fin.read(buffer)) != -1) {
                out.write(buffer, 0, read);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ログイン後にコピー

🎜 とても簡単ですね?ワクワクしませんか？ Python プログラマーに見下されることはもうありません。さて、実装原理と内部機構については以下で詳しく説明します。 🎜🎜実践練習🎜🎜 try-with-resource と連携するには、リソースは AutoClosable インターフェイスを実装する必要があります。このインターフェースの実装クラスは、close メソッドをオーバーライドする必要があります: 🎜

public void close() throws IOException {
    if (!closed) {
        finish();
        if (usesDefaultDeflater)
            def.end();
        out.close();
        closed = true;
    }
}

ログイン後にコピー

🎜 呼び出しクラス: 🎜

public class TryWithResource {
    public static void main(String[] args) {
        try (FileInputStream fin = new FileInputStream(new File("input.txt"));
                FileOutputStream fout = new FileOutputStream(new File("out.txt"));
                GZIPOutputStream out = new GZIPOutputStream(fout)) {
            byte[] buffer = new byte[4096];
            int read;
            while ((read = fin.read(buffer)) != -1) {
                out.write(buffer, 0, read);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ログイン後にコピー

🎜 実行後の出力結果: 🎜rrreee🎜 この結果から、close メソッドが自動的に呼び出されることがわかります。。 🎜🎜原則🎜🎜それでは、これはどのように行われるのでしょうか?賢明な皆さんは、実際には、これらすべてがコンパイラマスターによって引き起こされていると推測しているはずです。先ほどの例のクラスファイルを逆コンパイルしましょう: 🎜rrreee🎜 15 ～ 27 行目で、コンパイラが自動的に Final ブロックを生成し、その中のリソースの close メソッドを呼び出したことがわかりましたか。例は実行時に実行されます。 🎜

例外シールド

🎜 注意深い人なら、逆コンパイルされたコード (21 行目) に、古代に書かれたコードよりも addSuppressed が 1 つ多いことに気づいたと思います。。このコードの目的を理解するために、今の例を少し変更してみましょう。今のコードを昔の手動で例外を閉じる方法に戻し、sendData と を使用します。 close メソッド内で、例外をスローします 🎜: 🎜rrreee🎜main を変更しますメソッド: 🎜rrreee🎜 実行後、次のことがわかりました: 🎜rrreee🎜 さて、ここで問題が発生します。一度に 1 つの例外しかスローできないため、最上位に表示されるのは最後にスローされた例外です。つまり、 >close メソッド MyException がスローされ、sendData によってスローされた Exception は無視されます。これは例外シールドと呼ばれます。例外情報が失われるため、例外マスキングによって特定のバグを見つけることが非常に困難になる可能性があります。そのようなガンをどうやって取り除くことができるでしょうか。幸いなことに、この問題を解決するために、大手企業は Java 1.7 以降、新しい addSuppressed メソッドを Throwable クラスに追加しました。このメソッドは、ある例外を別の例外に接続することをサポートします。したがって、例外マスキングを避けてください。では、ブロックされた例外情報はどのような形式で出力されるのでしょうか。 try-with-resource でラップされた main メソッドを再度実行してみましょう: 🎜rrreee🎜 例外情報に Suppressed プロンプトがあることがわかり、この例外が実際には 2 つの例外で構成されていることがわかります。 MyException は抑制された例外です。おめでとう！ 🎜

小さな問題

🎜 try-with-resource を使用するプロセスでは、リソースの close メソッドの内部実装ロジックを理解する必要があります。そうしないと、依然としてリソースが漏洩する可能性があります。 🎜🎜たとえば、Java BIO🎜 では、多数のデコレータパターンが使用されています。デコレータの close メソッドが呼び出されるとき、本質的にはデコレータ内でラップされたストリームの close メソッドを呼び出します。例: 🎜

public class TryWithResource {
    public static void main(String[] args) {
        try (FileInputStream fin = new FileInputStream(new File("input.txt"));
                GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream(new File("out.txt")))) {
            byte[] buffer = new byte[4096];
            int read;
            while ((read = fin.read(buffer)) != -1) {
                out.write(buffer, 0, read);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ログイン後にコピー

在上述代码中，我们从FileInputStream中读取字节，并且写入到GZIPOutputStream中。GZIPOutputStream实际上是FileOutputStream的装饰器。由于try-with-resource的特性，实际编译之后的代码会在后面带上finally代码块，并且在里面调用fin.close()方法和out.close()方法。我们再来看GZIPOutputStream类的close方法：

public void close() throws IOException {
    if (!closed) {
        finish();
        if (usesDefaultDeflater)
            def.end();
        out.close();
        closed = true;
    }
}

ログイン後にコピー

我们可以看到，out 变量实际上代表的是被装饰的FileOutputStream类。在调用out变量的close方法之前，GZIPOutputStream还做了finish操作，该操作还会继续往FileOutputStream中写压缩信息，此时如果出现异常，则会out.close()方法被略过，然而这个才是最底层的资源关闭方法。正确的做法是应该在try-with-resource中单独声明最底层的资源，保证对应的close方法一定能够被调用。在刚才的例子中，我们需要单独声明每个FileInputStream以及FileOutputStream：

public class TryWithResource {
    public static void main(String[] args) {
        try (FileInputStream fin = new FileInputStream(new File("input.txt"));
                FileOutputStream fout = new FileOutputStream(new File("out.txt"));
                GZIPOutputStream out = new GZIPOutputStream(fout)) {
            byte[] buffer = new byte[4096];
            int read;
            while ((read = fin.read(buffer)) != -1) {
                out.write(buffer, 0, read);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ログイン後にコピー

由于编译器会自动生成fout.close()的代码，这样肯定能够保证真正的流被关闭。