Javaのtry-with-resourcesでclose漏れを防ぐ方法を解説する記事のアイキャッチ。

実装・エラー解決

Javaのtry-with-resourcesとは|close漏れを防ぐ書き方

C#のusingと同じように、ブロックを抜けるときにリソースを閉じるには、Javaではtry-with-resourcesを使います。try (...)の丸括弧内にAutoCloseableのリソースを置くと、正常終了でも例外でもclose()が呼ばれます。

この記事でわかること

try-with-resourcesは、tryの丸括弧内で取得したAutoCloseableを、正常終了でも例外でも自動的にcloseする構文です。finallyの手動closeより閉じ忘れや例外の上書きを防ぎやすくなります。複数リソースは宣言と逆順で閉じられ、本文とcloseの両方で例外が起きた場合、close側はsuppressed exceptionとして保持されます。ただし、フレームワークから借りたリソースを自分で閉じるかは所有者の契約を確認します。

新人SE
新人SE
finallyでcloseを書けば十分なのに、try-with-resourcesを使う理由は何ですか?
ポンコツSE
ポンコツSE
例外時にもcloseを呼び、close側の例外で元の原因を失いにくくするためです。コードも短くなります。

ファイル、ストリーム、JDBC接続などは、使い終わったらcloseする必要があります。閉じ忘れるとファイルを開けない、DB接続プールを使い切る、メモリやOS資源を消費するといった障害につながります。

try-with-resourcesを使えば多くの後始末をJavaへ任せられます。ただし、何でもcloseすればよいわけではありません。自分が生成して所有するリソースか、フレームワークから管理を委ねられたものかを確認します。

この記事のポイント

  • AutoCloseableを自動でcloseする構文
  • 正常時と例外時の両方でcloseされる
  • 複数リソースは宣言と逆順で閉じる
  • 先行する主例外があれば、close例外はsuppressedとして残る
  • リソースの所有者を確認してから閉じる

実行サンプル

Reader単体の読み取り失敗を試す補助例です。新しい一式にも元と同じsrc/main/java/ReaderFailureDemo.javaを収録しています。展開先でmvn testを実行した後、java -cp target/classes ReaderFailureDemoで動かします。UncheckedIOExceptionの原因とReaderのcloseを確認する例で、後の複数リソースの6ケースとは別です。

基本の書き方

tryの丸括弧内でリソースを宣言し、そのリソースをtryブロック内で使います。ブロックを抜けると自動的にcloseされます。

try (BufferedReader reader = Files.newBufferedReader(path)) {
    return reader.lines().toList();
}

正常にreturnしたときも、ストリームの読み取りが失敗したときも、readerはcloseされます。上のreader.lines().toList()では、読み取り時のIOExceptionはUncheckedIOExceptionの原因に入ります。Files.newBufferedReaderの段階で開けない場合は、IOExceptionがそのまま発生します。

構文の仕様は、C#のusingステートメントとJava 17のtry-with-resourcesで確認できます。

AutoCloseableが対象

try-with-resourcesへ置けるのはAutoCloseableを実装した型です。InputStream、Reader、Writer、JDBCのConnection・Statement・ResultSetなどが該当します。

final class TemporaryDirectory implements AutoCloseable {
    private final Path path;

    @Override
    public void close() throws IOException {
        deleteRecursively(path);
    }
}

独自クラスへAutoCloseableを実装する場合、複数回closeしても安全か、close例外をどう扱うか、ライフサイクルが本当にブロック単位かを設計します。単なる後処理メソッドへ無条件に付けません。

finallyで手動closeする問題

古い書き方ではリソースを外側へ宣言し、finallyでnullチェックしてcloseします。コードが長く、close自体の例外が本文の例外を隠す可能性があります。

BufferedReader reader = null;
try {
    reader = Files.newBufferedReader(path);
    return reader.readLine();
} finally {
    if (reader != null) {
        reader.close();
    }
}

Java 7以降でAutoCloseableなら、原則としてtry-with-resourcesへ置き換えます。既存案件のJavaバージョンとコーディング規約は確認します。

上の手動finallyは書き方を示す断片です。以下の6ケースは実際のtry-with-resources構文を使い、主例外と後始末の例外がどう残るかを確認します。手動finallyと同じコードを実行した結果ではありません。

複数リソースは逆順で閉じる

セミコロンで複数リソースを宣言できます。closeは最後に宣言したものから逆順です。外側のWriterが内側のOutputStreamへバッファを流すような構造で重要です。

try (OutputStream output = Files.newOutputStream(path);
     BufferedWriter writer = new BufferedWriter(
             new OutputStreamWriter(output, StandardCharsets.UTF_8))) {
    writer.write("hello");
}

ラッパー側のcloseが内部リソースも閉じる場合、両方を宣言する必要がないこともあります。API契約を確認し、所有関係を分かりやすくします。

Aを取得し、Bを取得してから、本文へ進む

配布するResourceScenarios.runの中心部分です。A・Bは順番と例外を観察する独立した自作リソースで、前のWriterとOutputStreamのラッパー関係を再現したものではありません。Scenarioで失敗する場所を切り替え、同じtry構文へ渡します。

public static Outcome run(Scenario scenario) {
    List<String> trace = new ArrayList<>();
    try (RecordingResource a = RecordingResource.open(
                "A", false, scenario.aCloseFails, trace);
         RecordingResource b = RecordingResource.open(
                "B", scenario.bOpenFails, scenario.bCloseFails, trace)) {
        trace.add("body");
        if (scenario.bodyFails) {
            throw new IOException("body");
        }
    } catch (IOException failure) {
        return new Outcome(List.copyOf(trace), failure);
    }
    return new Outcome(List.copyOf(trace), null);
}

括弧内はA→Bの順で取得を試み、両方を取得できたらbodyへ進みます。終了時にcloseを呼ぶ順はB→Aです。Bのcloseが例外になっても、Aのcloseを呼ぶ処理は続きます。traceのopen:Bは取得の試行、close:Bはcloseの呼出しを記録し、成功を示す記録ではありません。

このrunは、try-with-resourcesからcatchへ届いた例外を、traceとともに比較用のOutcomeへ格納します。実業務で失敗を正常終了へ変える実装を勧めるものではありません。対象2クラスの全文は、後のテストの節で開けます。

suppressed exceptionを確認する

try本文とcloseの両方で例外が起きた場合、本文の例外が主例外として投げられ、close側はsuppressed exceptionに格納されます。元の障害原因を維持しやすい仕組みです。

catch (IOException e) {
    log.error("ファイル処理に失敗", e);
    for (Throwable suppressed : e.getSuppressed()) {
        log.warn("close時にも例外", suppressed);
    }
}

通常はロガーがsuppressedもスタックトレースへ出します。独自ログ整形で省略していないか、障害時の実ログを確認します。

本文が成功した場合は、最初のclose失敗が主例外になる

6ケースの違いを先に表へ揃えます。body・close:B・open:Bは、この教材のIOExceptionに付けたメッセージです。すべてをcloseの失敗や、同じ例外の扱いにしないでください。

表は横にスクロールできます。

条件主例外のメッセージsuppressedの順
NORMAL:すべて成功なしなし
BODY_FAIL:本文だけ失敗bodyなし
BODY_CLOSE_FAIL:本文とA/B close失敗bodyclose:B → close:A
CLOSE_FAIL:本文成功、A/B close失敗close:Bclose:A
ACQUIRE_CLOSE_FAIL:B取得とA close失敗open:Bclose:A
ACQUIRE_FAIL:B取得失敗、A close成功open:Bなし

BODY_CLOSE_FAILは本文が先に失敗するので、主例外はbodyのままです。closeで失敗したBとAは、その主例外へB→Aの順にsuppressedとして付きます。対してCLOSE_FAILでは本文が成功しており、最初のclose失敗Bが主例外、続くAの失敗がsuppressedです。

ACQUIRE_CLOSE_FAILとACQUIRE_FAILはBの取得に失敗します。Bを取得できていないのでtry本文へ入らず、Bのcloseも呼びません。取得済みAだけを閉じ、Aも失敗すればopen:Bへclose:Aがsuppressedとして付きます。

配布一式でmvn testを実行した後、java -cp target/classes ResourceScenariosで次の6行を表示できます。main=はこの表示で使う主例外のラベルで、noneは例外なしです。Javaのmainメソッド名とは別です。suppressed=は抑制例外の配列順、trace=は取得試行・本文・close呼出しの順を示します。

NORMAL main=none suppressed=[] close=[B, A] trace=[open:A, open:B, body, close:B, close:A]
BODY_FAIL main=body suppressed=[] close=[B, A] trace=[open:A, open:B, body, close:B, close:A]
BODY_CLOSE_FAIL main=body suppressed=[close:B, close:A] close=[B, A] trace=[open:A, open:B, body, close:B, close:A]
CLOSE_FAIL main=close:B suppressed=[close:A] close=[B, A] trace=[open:A, open:B, body, close:B, close:A]
ACQUIRE_CLOSE_FAIL main=open:B suppressed=[close:A] close=[A] trace=[open:A, open:B, close:A]
ACQUIRE_FAIL main=open:B suppressed=[] close=[A] trace=[open:A, open:B, close:A]

次の図はBODY_CLOSE_FAILのケースです。本文の例外が主になり、closeで失敗したBとAがその直接のsuppressedとして順に残ります。

A、Bの順で取得後に本文で例外が起き、close B、close Aも失敗する流れ。主例外は本文の失敗、suppressedの0番はB、1番はAのclose失敗として直接残る図。
本文と両方のcloseが失敗したケースです。B、Aの順にcloseを試み、本文の例外へBとAのclose例外をこの順で残します。

いずれもJavaのtry-with-resources構文が例外を保持しており、サンプルがaddSuppressedを呼んで作った結果ではありません。取得順と逆順close、先行する例外への抑制例外の追加はJava 17言語仕様のtry-with-resourcesで確認できます。closeが呼ばれても、その処理が正常に完了したとは限りません。

既存変数も利用できる

Java 9以降では、実質finalな既存変数をtryの丸括弧内へ書けます。ただし、どこで生成され誰が閉じるかが分散すると所有者が分かりにくくなります。

BufferedReader reader = Files.newBufferedReader(path);
try (reader) {
    return reader.readLine();
}

可能なら取得とclose範囲を近づけます。呼び出し元から渡されたリソースをメソッド内で閉じるかはAPI契約に明記します。

JDBCでの利用例

JDBCを直接使う場合、Connection、PreparedStatement、ResultSetのcloseが必要です。DataSourceから取得したConnectionはcloseによってプールへ返却されることが多いです。

try (Connection connection = dataSource.getConnection();
     PreparedStatement statement = connection.prepareStatement(SQL)) {
    statement.setString(1, userId);
    try (ResultSet result = statement.executeQuery()) {
        return result.next() ? map(result) : Optional.empty();
    }
}

一方、SpringのJdbcTemplateや@Transactionalが管理する接続を低い層で勝手にcloseしないでください。フレームワークAPIを使う場合は、その管理契約に従います。

Streamを返すメソッドの注意

Files.lines(path)のStreamをtryの丸括弧に置いた場合、returnでもメソッドを抜けるときに閉じます。下の例はlines.toList()を先に実行し、読み終えた行をListとして返します。戻り値の型をStream<String>にしてreturn lines;に変えると、呼び出し元のtoList()でIllegalStateExceptionになります。2行だけのファイルでもこの違いを確かめられます。

List<String> readAll(Path path) throws IOException {
    try (Stream<String> lines = Files.lines(path)) {
        return lines.toList();
    }
}

大量の行を順に読みたいなど、Streamを返す理由があるなら、取得するメソッドからFiles.lines(path)を直接返し、呼び出し元でその戻り値をtryの丸括弧に置きます。filterやcountはそのブロック内で実行し、ブロックを抜けるとファイルが閉じます。BufferedReader.lines()を使う場合は、元のReaderを使い終えるまで開いた状態に保ち、Reader自体を閉じます。

Files.linesも、ファイルを開く時点の失敗と、終端操作で読み取る時点の失敗を分けて扱います。配布サンプルはBufferedReader.lines()で後者を再現し、UncheckedIOExceptionの原因がIOExceptionであることと、失敗後にReaderが閉じていることを検証します。

テストでcloseを確認する

次のResourceScenariosTest.javaは、上の対象を呼び出すテスト全文です。MethodSourceの6行を1ケースずつ実行し、取得試行・本文・close呼出しのtrace全体と、主例外・suppressedの順を比較します。close例外が出るケースではclose成功を期待せず、呼出し順と残された例外を確認します。

ResourceScenariosTest.java の全文
import java.io.IOException;
import java.util.List;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import static org.junit.jupiter.api.Assertions.*;

class ResourceScenariosTest {
    static Stream<Arguments> cases() {
        List<String> both = List.of("open:A", "open:B", "body", "close:B", "close:A");
        List<String> partial = List.of("open:A", "open:B", "close:A");
        return Stream.of(
                Arguments.of(ResourceScenarios.Scenario.NORMAL, both, "none", List.of()),
                Arguments.of(ResourceScenarios.Scenario.BODY_FAIL, both, "body", List.of()),
                Arguments.of(ResourceScenarios.Scenario.BODY_CLOSE_FAIL, both, "body",
                        List.of("close:B", "close:A")),
                Arguments.of(ResourceScenarios.Scenario.CLOSE_FAIL, both, "close:B",
                        List.of("close:A")),
                Arguments.of(ResourceScenarios.Scenario.ACQUIRE_CLOSE_FAIL, partial, "open:B",
                        List.of("close:A")),
                Arguments.of(ResourceScenarios.Scenario.ACQUIRE_FAIL, partial, "open:B", List.of())
        );
    }

    @ParameterizedTest
    @MethodSource("cases")
    void syntaxDeterminesPrimarySuppressedAndCloseOrder(
            ResourceScenarios.Scenario scenario, List<String> expectedTrace,
            String expectedPrimary, List<String> expectedSuppressed) {
        ResourceScenarios.Outcome outcome = ResourceScenarios.run(scenario);
        assertEquals(expectedTrace, outcome.trace());
        assertEquals(expectedPrimary, outcome.primaryMessage());
        assertEquals(expectedSuppressed, outcome.suppressedMessages());
        if (scenario == ResourceScenarios.Scenario.NORMAL) {
            assertNull(outcome.failure());
        } else {
            assertInstanceOf(IOException.class, outcome.failure());
            assertEquals(expectedSuppressed.size(), outcome.failure().getSuppressed().length);
        }
    }
}

対象クラスと実行設定の全文です。RecordingResource.openが取得とcloseの失敗を用意し、ResourceScenarios.runが同じ構文で比較します。JUnit6ケースは成功し、Mainの6行も配布ZIPを展開した実行結果と一致しました。

RecordingResource.java の全文
import java.io.IOException;
import java.util.List;

final class RecordingResource implements AutoCloseable {
    private final String name;
    private final boolean failOnClose;
    private final List<String> trace;

    private RecordingResource(String name, boolean failOnClose, List<String> trace) {
        this.name = name;
        this.failOnClose = failOnClose;
        this.trace = trace;
    }

    static RecordingResource open(String name, boolean failOnOpen,
                                  boolean failOnClose, List<String> trace) throws IOException {
        trace.add("open:" + name);
        if (failOnOpen) {
            throw new IOException("open:" + name);
        }
        return new RecordingResource(name, failOnClose, trace);
    }

    @Override
    public void close() throws IOException {
        trace.add("close:" + name);
        if (failOnClose) {
            throw new IOException("close:" + name);
        }
    }
}
ResourceScenarios.java の全文
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public final class ResourceScenarios {
    private ResourceScenarios() {}

    public enum Scenario {
        NORMAL(false, false, false, false),
        BODY_FAIL(true, false, false, false),
        BODY_CLOSE_FAIL(true, true, true, false),
        CLOSE_FAIL(false, true, true, false),
        ACQUIRE_CLOSE_FAIL(false, true, false, true),
        ACQUIRE_FAIL(false, false, false, true);

        final boolean bodyFails;
        final boolean aCloseFails;
        final boolean bCloseFails;
        final boolean bOpenFails;

        Scenario(boolean bodyFails, boolean aCloseFails,
                 boolean bCloseFails, boolean bOpenFails) {
            this.bodyFails = bodyFails;
            this.aCloseFails = aCloseFails;
            this.bCloseFails = bCloseFails;
            this.bOpenFails = bOpenFails;
        }
    }

    public record Outcome(List<String> trace, IOException failure) {
        public String primaryMessage() {
            return failure == null ? "none" : failure.getMessage();
        }

        public List<String> suppressedMessages() {
            return failure == null ? List.of() : Arrays.stream(failure.getSuppressed())
                    .map(Throwable::getMessage).toList();
        }

        public List<String> closeOrder() {
            return trace.stream().filter(event -> event.startsWith("close:"))
                    .map(event -> event.substring("close:".length())).toList();
        }
    }

    // BEGIN run
    public static Outcome run(Scenario scenario) {
        List<String> trace = new ArrayList<>();
        try (RecordingResource a = RecordingResource.open(
                    "A", false, scenario.aCloseFails, trace);
             RecordingResource b = RecordingResource.open(
                    "B", scenario.bOpenFails, scenario.bCloseFails, trace)) {
            trace.add("body");
            if (scenario.bodyFails) {
                throw new IOException("body");
            }
        } catch (IOException failure) {
            return new Outcome(List.copyOf(trace), failure);
        }
        return new Outcome(List.copyOf(trace), null);
    }
    // END run

    // BEGIN main
    public static void main(String[] args) {
        for (Scenario scenario : Scenario.values()) {
            Outcome outcome = run(scenario);
            System.out.printf("%s main=%s suppressed=%s close=%s trace=%s%n", scenario,
                    outcome.primaryMessage(), outcome.suppressedMessages(), outcome.closeOrder(), outcome.trace());
        }
    }
    // END main
}
pom.xml の全文
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>info.syachiku.samples</groupId>
  <artifactId>try-with-resources-exceptions-1954</artifactId>
  <version>1.0.0</version>
  <properties>
    <maven.compiler.release>17</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <junit.version>5.12.2</junit.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <version>3.2.0</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.5.6</version>
      </plugin>
    </plugins>
  </build>
</project>

通常は展開先でmvn test、対象クラスを限定するならmvn -Dtest=ResourceScenariosTest testを使います。確認環境はJava 17.0.8、Maven 3.9.16、JUnit Jupiter 5.12.2です。既存依存キャッシュを利用し、空のキャッシュからの初回依存取得や別JDK・OSは確認していません。

Reader補助例の1行はexception=UncheckedIOException, cause=IOException, closed=trueです。新しい6ケースとは別の読み取り失敗・close成功の例で、今回の6件がStreamを返す設計や実DBの接続管理まで検証したことにはなりません。

現場レビューでよくある指摘

リソース処理のレビューではtry-with-resourcesの構文だけでなく、誰が取得し、誰が閉じ、いつまで有効かという所有権を確認します。

// レビューコメント例
BufferedReaderはAutoCloseableです。手動finallyではなく
try-with-resourcesで取得とclose範囲をまとめてください。

// レビューコメント例
Files.linesのStreamを返しており、呼び出し側でcloseされません。
このメソッド内で終端操作まで行うか、close責務をAPIへ明記してください。

// レビューコメント例
このConnectionはSpringのトランザクション管理対象です。
Repository内で独自にcloseすると処理全体へ影響するため、管理契約を確認してください。

close漏れの修正では、正常終了だけでなく例外経路と繰り返し実行を確認します。接続プールやファイルハンドルの監視値が戻ることも結合環境で確認します。

提出前のセルフチェック

レビュー前に確認すること

  • 対象がAutoCloseableか
  • try-with-resourcesを使えるか
  • 正常時と例外時にcloseされるか
  • 複数リソースの所有関係とclose順を確認したか
  • suppressed exceptionがログへ残るか
  • 外から渡されたリソースを勝手に閉じていないか
  • フレームワーク管理の接続ではないか
  • Streamをclose前に外へ返していないか

Javaの例外とリソース管理を学ぶ参考書

try-with-resourcesは例外処理、ファイルI/O、JDBCと関係します。実践編でまとまって確認すると、構文だけでなく所有者と例外経路を判断しやすくなります。

書籍「スッキリわかるJava入門 実践編 第5版」の表紙
商品画像:Amazon.co.jp
PR Java基礎学習後の若手向け

スッキリわかるJava入門 実践編 第5版

中山 清喬 (著), 株式会社フレアリンク (監修)

基礎文法の次に必要な、現場寄りのJava知識を補う。

コレクション、ジェネリクス、ラムダ式、ストリームなど、業務コードで出会いやすい機能を入門編の次に学べます。

  • Java基礎の次に何を学ぶか迷っている
  • コレクションやStreamを整理したい

当サイトはAmazonアソシエイト・プログラムの参加者です。価格・在庫・配送条件はAmazonでご確認ください。

この記事とあわせて読みたい

関連記事Javaのfinallyでreturnしてはいけない理由|tryの戻り値と例外が消える 手動後処理で戻り値や例外を失う危険を解説します。 記事を読む 関連記事Javaのスタックトレースの読み方|Caused byの後、どのコードを開けばいい? 例外名だけでなく、causeと呼び出し位置を調査する方法を確認します。 記事を読む 関連記事SLF4Jでスタックトレースが出ない原因|e.getMessage()と例外の渡し方 リソース処理の例外を調査できる形でログへ残す方法を確認できます。 記事を読む

まとめ

try-with-resourcesは、AutoCloseableを正常時と例外時の両方で自動closeする構文です。手動finallyより閉じ忘れを防ぎ、先に主例外があればclose例外をsuppressedとして保持します。

複数リソースのclose順、Streamの遅延評価、JDBCやSpringの管理契約も確認してください。取得した側が閉じる原則を基準にしつつ、フレームワークが所有するリソースを勝手に閉じないことが重要です。

-実装・エラー解決
-,