Javaのfinallyでreturnするとtryの戻り値と例外が消える危険を解説する記事のアイキャッチ。

実装・エラー解決

Javaのfinallyでreturnしてはいけない理由|tryの戻り値と例外が消える

tryでAを返したはずなのにBが返る。名前を取得できなかったはずなのに、例外が出ずguestと表示される。Javaのfinallyにあるreturnは、先に決まった戻り値だけでなく、呼び出し元へ伝える途中の例外も上書きします。

この記事は、try・catchは読めるものの「finallyへreturnを移すと何が変わるか」を説明できない人向けです。短いクイズから始め、保存済みなのにfalseが返る例、取得失敗がguestへ変わる例、後片付けの失敗で元の原因が消える例を、危険版と修正版の同じ入力で比べます。

この記事でわかること

  • try・catchで決めた結果がfinallyで上書きされる順序
  • 正常の戻り値と、例外が外へ届く経路を両方保つ修正
  • closeやdeleteも失敗するときに、元の原因を残す方法
  • 危険なreturnが戻った変更を検出するJUnitの書き方

まずはXのJavaクイズを確認する

tryでAをreturnし、finallyでBをreturnするJavaコードについて、どちらが返るかを問うクイズ画像。
tryとfinallyの両方にreturnがある場合、どちらが返るでしょうか。
// Xクイズと同じgetValue。意図的な不良例。
public static String getValue() {
    try {
        return "A";
    } finally {
        return "B";
    }
}

答えはBです。tryでAを返そうとした後、finallyが実行され、そこでBをreturnするため、呼び出し元が受け取る値はBになります。

finallyのreturnがtryの戻り値を上書きし、答えはBになると説明するJavaクイズの回答画像。
finallyのreturnが、先に決まっていたtryの戻り値を上書きします。

元のクイズは、Xの出題ポストと回答ポストでも確認できます。

returnしてもfinallyが終わるまでは戻らない

returnの式が評価されると、返す値が決まります。finallyがある場合、その値を呼び出し元へ渡す前にfinallyを実行します。次は、処理順をeventsへ残す修正版のメソッドです。eventsは呼び出し側が渡すListです。

public static String getValueAfterCleanup(List<String> events) {
    Objects.requireNonNull(events, "events");
    try {
        return "A";
    } finally {
        events.add("cleanup");
    }
}

JUnitとMainは、呼び出し後に戻り値がAで、eventsへcleanupが記録されていることを確認します。finallyが正常に終わればAを返せます。finallyにreturnを置く危険版との違いは、後処理の有無ではなく、後処理で別の終了結果を決めているかです。

「finallyは必ず実行される」とだけ覚えず、ここでは通常のJavaの制御がこのtryから抜ける場合を扱います。JVMの強制終了やプロセス停止まで後処理を保証する仕組みではありません。

finallyのreturnが危険な本当の理由

tryの戻り値が上書きされる

OrderServiceの危険版では、saveが正常に戻ってtryがtrueを返そうとしても、finallyのfalseが最終結果になります。RecordingOrderRepositoryはメモリ上で呼び出し回数を数える実装で、実DBへのコミットを試したものではありません。

public boolean updateOrderBroken() {
    try {
        repository.save();
        return true;
    } finally {
        audit.record();
        return false;
    }
}
public boolean updateOrder() {
    try {
        repository.save();
        return true;
    } finally {
        audit.record();
    }
}

同じ正常入力で、危険版はfalse・保存1回、修正版はtrue・保存1回です。falseだけを見て再実行すると同じ保存処理をもう一度呼ぶおそれがあります。Repositoryが例外を投げる入力では、修正版は例外を呼び出し元へ伝えます。監査処理はこの比較では正常に終わる設定にし、後処理そのものの失敗は後の章で分けます。

例外が外へ伝わらなくなる

名前取得の契約を「正常ならnullではない名前を返す。取得失敗は例外を伝える」とします。下の危険版と修正版は同じNameRepositoryを使います。DB接続失敗というメッセージは、Repositoryから意図的に投げる例外の文面です。実DBを停止した検証ではありません。

public String loadNameBroken() {
    try {
        return repository.loadName();
    } finally {
        audit.record();
        return "guest";
    }
}
public String loadName() {
    try {
        return Objects.requireNonNull(repository.loadName(), "repository returned null");
    } finally {
        audit.record();
    }
}

取得時にIllegalStateException("DB connection failed")が発生しても、危険版ではguestが返ります。修正版は同じ例外を伝えるため、呼び出し元で取得失敗と判断できます。guestを返すことが要件なら、回復可能な例外をどこで既定値へ変えるかという別の契約を決めます。finallyへ置くことで暗黙に回復扱いにしてはいけません。

nullは「取得失敗」や「見つからない」を表す値として採用していません。今回のNameServiceでは不正なRepository結果として拒否します。不存在を通常の結果にするAPIなら、その戻り値の契約とテストを別に定めてください。

修正して例外が見えるようになったら、今度は原因と呼び出し箇所を追います。スタックのどこから読めばよいかは、次の記事で確認できます。

関連記事Javaのスタックトレースの読み方|Caused byの後、どのコードを開けばいい? 例外名だけでなく、causeと呼び出し位置を調査する方法を確認します。 記事を読む

catchの判断まで上書きされる

次のoperationはfail=trueで例外を投げます。危険版・修正版のどちらも実際にcatchへ入る入力を用意し、RecordingAudit.caughtCalls()で通過回数も検証します。catchが書かれているだけの未到達な例にしません。

public static int executeBroken(boolean fail, RecordingAudit audit) {
    Objects.requireNonNull(audit, "audit");
    try {
        operation(fail);
        return 0;
    } catch (RuntimeException exception) {
        audit.recordCatch();
        return 1;
    } finally {
        audit.record();
        return 9;
    }
}
public static int execute(boolean fail, RecordingAudit audit) {
    Objects.requireNonNull(audit, "audit");
    try {
        operation(fail);
        return 0;
    } catch (RuntimeException exception) {
        audit.recordCatch();
        return 1;
    } finally {
        audit.record();
    }
}
private static void operation(boolean fail) {
    if (fail) {
        throw new IllegalStateException("operation failed");
    }
}

正常入力の修正版は0、例外入力はcatchで決めた1です。危険版はfinallyの9に変わります。まずこの二つの入力を並べ、tryとcatchの両方を守れるかを確認します。

finallyには何を書けばよいか

ロックは、取得できた後にtryへ入り、finallyで解除します。更新処理をRunnableとして渡すので、正常処理と意図的に例外を投げる処理を同じメソッドで試せます。

public static void update(ReentrantLock lock, Runnable updateSharedState) {
    Objects.requireNonNull(lock, "lock");
    Objects.requireNonNull(updateSharedState, "updateSharedState");
    lock.lock();
    try {
        updateSharedState.run();
    } finally {
        lock.unlock();
    }
}

テストでは、更新が正常に終わる場合と失敗する場合の両方でロックが保持されていないことを確認します。失敗時には同じ例外が外へ届くことも検査します。「解除された」と「業務処理が成功した」を同じ判定にしません。ロックの取得に失敗したのにunlockする経路は作らず、lock()の後からtryを始めています。

close処理はtry-with-resourcesを優先する

自分で取得したAutoCloseableを自分の処理で使い終えるなら、try-with-resourcesを使います。ファイルの入口はUTF-8でBufferedReaderを開き、読取用メソッドへ渡します。配布コードでは、そのBufferedReaderを読取用メソッドが閉じる所有関係です。

クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/ResourceExamples.java
package info.syachiku.finallyreturn;

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public final class ResourceExamples {
    private ResourceExamples() {
    }

    public static List<String> readLines(Path path) throws IOException {
        Objects.requireNonNull(path, "path");
        return readLines(Files.newBufferedReader(path, StandardCharsets.UTF_8));
    }

    // 受け取ったreaderをこのメソッドが所有し、終了時にcloseする契約。
    public static List<String> readLines(BufferedReader reader) throws IOException {
        Objects.requireNonNull(reader, "reader");
        try (reader) {
            List<String> lines = new ArrayList<>();
            String line;
            while ((line = reader.readLine()) != null) {
                lines.add(line);
            }
            return List.copyOf(lines);
        }
    }
}

ここではreadLine()で最後まで読み、読み取り失敗をcheckedのIOExceptionとして伝えます。reader.lines()で読んだ途中のIOExceptionがUncheckedIOExceptionへ包まれる例とは実装を分けています。入口でファイルを開けない失敗と、開いた後の読取・closeの失敗も区別してください。

読取close呼び出し元に届くもの閉じる操作
成功成功読み取った行のList呼ばれる
失敗成功読取のIOException呼ばれる
成功失敗closeのIOException。Listは返らない呼ばれるが成功しない
失敗失敗読取のIOException。close失敗はgetSuppressed()へ呼ばれるが成功しない

「closeを実行した」ことは「closeが成功した」ことを意味しません。closeだけが失敗すれば、正常なListを返そうとしていても呼び出し元は例外を受け取ります。読取とcloseが別々のIOExceptionで失敗した今回の例では、読取の原因を主例外として残し、close側を抑制例外で確認できます。フレームワークから借りた接続まで独自に閉じる方針には広げず、所有者の契約を確認します。

finally内の処理も例外を起こす可能性がある

一時ファイルの取込が失敗し、その後の削除も失敗したら、最後のdeleteだけが見える実装があります。次は、取込と削除をそれぞれRunnableとして渡す比較です。配布サンプルのRunnableはメモリ上で回数を記録し、例外を投げます。実ファイルを取り込んで削除する試験ではありません。同じ実行入口で「両方失敗」「削除だけ失敗」の制御と例外を比べます。

public static void importWithoutSuppression(Runnable importOrders, Runnable deleteTemporaryFile) {
    Objects.requireNonNull(importOrders, "importOrders");
    Objects.requireNonNull(deleteTemporaryFile, "deleteTemporaryFile");
    try {
        importOrders.run();
    } finally {
        deleteTemporaryFile.run();
    }
}
// RuntimeException同士の優先方針を示す例。checked例外/Error全般の共通部品ではない。
public static void importPreservingFailure(Runnable importOrders, Runnable deleteTemporaryFile) {
    Objects.requireNonNull(importOrders, "importOrders");
    Objects.requireNonNull(deleteTemporaryFile, "deleteTemporaryFile");
    RuntimeException failure = null;
    try {
        importOrders.run();
    } catch (RuntimeException exception) {
        failure = exception;
        throw exception;
    } finally {
        try {
            deleteTemporaryFile.run();
        } catch (RuntimeException cleanupError) {
            if (failure != null) {
                if (failure != cleanupError) {
                    failure.addSuppressed(cleanupError);
                }
            } else {
                throw cleanupError;
            }
        }
    }
}

importPreservingFailureは、取込と削除がそれぞれRuntimeExceptionで失敗する契約のサンプルです。取込が失敗していればその例外を主として投げ、別の削除例外をaddSuppressedで付けます。取込が正常なら削除の失敗を投げます。Errorやchecked例外を含むあらゆる後処理へそのまま転用する汎用部品ではありません。

取込削除危険版修正版
成功成功正常終了正常終了
失敗成功取込の例外取込の同じ例外
成功失敗削除の例外削除の同じ例外
失敗失敗削除の例外だけ取込の同じ例外+削除の抑制例外

closeに置き換えられる所有リソースなら、先のtry-with-resourcesを優先します。手書きで保持する場合は、同じ例外オブジェクトを二重に渡したときの自己抑制も避けます。正常時だけを通して「元例外を残せた」と判断しないでください。

JUnitで戻り値と例外を固定する

危険な挙動を記録する学習用テストと、修正版の契約を守るテストを分けます。guestが返ることを確認するテストは危険版を再現するためのものです。本番の正しい契約をguestへ変える根拠にはしません。

同じ例外を伝えたいテストではassertThrowsだけで終わらず、assertSameで元の例外オブジェクトとの一致も確認します。保存結果は戻り値と呼出し回数、catchは戻り値と通過回数、読取は主例外と抑制例外を対応させます。

クリックで全文を開く:src/test/java/info/syachiku/finallyreturn/FinallyExamplesTest.java
package info.syachiku.finallyreturn;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

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

class FinallyExamplesTest {
    @Test
    void F01_finallyReturn_overwritesTryValue() {
        assertEquals("B", FinallyExamples.getValue());
    }

    @Test
    void F02_cleanup_runsBeforeCallerReceivesA() {
        List<String> events = new ArrayList<>();
        String value = FinallyExamples.getValueAfterCleanup(events);
        events.add("caller=" + value);
        assertEquals("A", value);
        assertEquals(List.of("cleanup", "caller=A"), events);
    }

    @Test
    void F03_brokenOrder_savesButReturnsFalse() {
        RecordingOrderRepository repository = new RecordingOrderRepository(null);
        RecordingAudit audit = new RecordingAudit();
        assertFalse(new OrderService(repository, audit).updateOrderBroken());
        assertEquals(1, repository.saveCalls());
        assertEquals(1, repository.savedCount());
        assertEquals(1, audit.calls());
    }

    @Test
    void F04_fixedOrder_savesAndReturnsTrue() {
        RecordingOrderRepository repository = new RecordingOrderRepository(null);
        RecordingAudit audit = new RecordingAudit();
        assertTrue(new OrderService(repository, audit).updateOrder());
        assertEquals(1, repository.savedCount());
        assertEquals(1, audit.calls());
    }

    @Test
    void F05_brokenOrder_swallowsSaveFailure() {
        RecordingOrderRepository repository = new RecordingOrderRepository(
                new IllegalStateException("save failed"));
        RecordingAudit audit = new RecordingAudit();
        assertFalse(new OrderService(repository, audit).updateOrderBroken());
        assertEquals(1, repository.saveCalls());
        assertEquals(0, repository.savedCount());
        assertEquals(1, audit.calls());
    }

    @Test
    void F06_fixedOrder_propagatesSameSaveFailure() {
        IllegalStateException failure = new IllegalStateException("save failed");
        RecordingOrderRepository repository = new RecordingOrderRepository(failure);
        RecordingAudit audit = new RecordingAudit();
        assertSame(failure, assertThrows(IllegalStateException.class,
                () -> new OrderService(repository, audit).updateOrder()));
        assertEquals(0, repository.savedCount());
        assertEquals(1, audit.calls());
    }

    @Test
    void F07_brokenName_returnsGuestDespiteFailure() {
        RecordingAudit audit = new RecordingAudit();
        NameService service = new NameService(() -> {
            throw new IllegalStateException("DB connection failed");
        }, audit);
        assertEquals("guest", service.loadNameBroken());
        assertEquals(1, audit.calls());
    }

    @Test
    void F08_fixedName_propagatesFailureToCaller() {
        IllegalStateException failure = new IllegalStateException("DB connection failed");
        RecordingAudit audit = new RecordingAudit();
        NameService service = new NameService(() -> { throw failure; }, audit);
        IllegalStateException actual = assertThrows(IllegalStateException.class, service::loadName);
        assertSame(failure, actual);
        assertEquals("DB connection failed", actual.getMessage());
        assertEquals(1, audit.calls());
    }

    @Test
    void F09_fixedName_returnsActualName() {
        RecordingAudit audit = new RecordingAudit();
        assertEquals("Alice", new NameService(() -> "Alice", audit).loadName());
        assertEquals(1, audit.calls());
    }

    @Test
    void F10_fixedName_rejectsRepositoryNullInsteadOfFallback() {
        RecordingAudit audit = new RecordingAudit();
        NameService service = new NameService(() -> null, audit);
        NullPointerException actual = assertThrows(NullPointerException.class, service::loadName);
        assertEquals("repository returned null", actual.getMessage());
        assertEquals(1, audit.calls());
    }

    @Test
    void F11_brokenCatch_normalPathReturnsNine() {
        RecordingAudit audit = new RecordingAudit();
        assertEquals(9, CatchExamples.executeBroken(false, audit));
        assertEquals(0, audit.caughtCalls());
        assertEquals(1, audit.calls());
    }

    @Test
    void F12_brokenCatch_realFailureEntersCatchButReturnsNine() {
        RecordingAudit audit = new RecordingAudit();
        assertEquals(9, CatchExamples.executeBroken(true, audit));
        assertEquals(1, audit.caughtCalls());
        assertEquals(1, audit.calls());
    }

    @Test
    void F13_fixedCatch_normalPathReturnsZero() {
        RecordingAudit audit = new RecordingAudit();
        assertEquals(0, CatchExamples.execute(false, audit));
        assertEquals(0, audit.caughtCalls());
        assertEquals(1, audit.calls());
    }

    @Test
    void F14_fixedCatch_failureReturnsOneAfterActualCatch() {
        RecordingAudit audit = new RecordingAudit();
        assertEquals(1, CatchExamples.execute(true, audit));
        assertEquals(1, audit.caughtCalls());
        assertEquals(1, audit.calls());
    }

    @Test
    void F15_lock_isReleasedAfterSuccess() {
        ReentrantLock lock = new ReentrantLock();
        AtomicInteger updates = new AtomicInteger();
        LockExamples.update(lock, updates::incrementAndGet);
        assertEquals(1, updates.get());
        assertFalse(lock.isLocked());
    }

    @Test
    void F16_lock_isReleasedAndSameFailurePropagates() {
        ReentrantLock lock = new ReentrantLock();
        IllegalStateException failure = new IllegalStateException("update failed");
        assertSame(failure, assertThrows(IllegalStateException.class,
                () -> LockExamples.update(lock, () -> { throw failure; })));
        assertFalse(lock.isLocked());
    }

    @Test
    void F17_resource_returnsLinesAndCallsCloseOnce() throws IOException {
        ProbeReader reader = new ProbeReader("line1\nline2\n", null, null);
        assertEquals(List.of("line1", "line2"), ResourceExamples.readLines(reader));
        assertEquals(1, reader.closeCalls());
    }

    @Test
    void F18_resource_readFailurePropagatesAndCloseRuns() {
        IOException failure = new IOException("read failed");
        ProbeReader reader = new ProbeReader("", failure, null);
        assertSame(failure, assertThrows(IOException.class, () -> ResourceExamples.readLines(reader)));
        assertEquals(1, reader.closeCalls());
    }

    @Test
    void F19_resource_closeFailureReplacesNormalReturn() {
        IOException close = new IOException("close failed");
        ProbeReader reader = new ProbeReader("line1", null, close);
        assertSame(close, assertThrows(IOException.class, () -> ResourceExamples.readLines(reader)));
        assertEquals(0, close.getSuppressed().length);
        assertEquals(1, reader.closeCalls());
    }

    @Test
    void F20_resource_bothFailuresKeepReadPrimaryAndSuppressClose() {
        IOException read = new IOException("read failed");
        IOException close = new IOException("close failed");
        ProbeReader reader = new ProbeReader("", read, close);
        IOException actual = assertThrows(IOException.class, () -> ResourceExamples.readLines(reader));
        assertSame(read, actual);
        assertArrayEquals(new Throwable[]{close}, actual.getSuppressed());
        assertEquals(1, reader.closeCalls());
    }

    @Test
    void F21_resource_emptyInputReturnsEmptyListNotNull() throws IOException {
        ProbeReader reader = new ProbeReader("", null, null);
        assertEquals(List.of(), ResourceExamples.readLines(reader));
        assertEquals(1, reader.closeCalls());
    }

    @Test
    void F22_path_readsRealUtf8File(@TempDir Path directory) throws IOException {
        Path path = directory.resolve("orders.txt");
        Files.writeString(path, "一行目\n二行目\n", StandardCharsets.UTF_8);
        assertEquals(List.of("一行目", "二行目"), ResourceExamples.readLines(path));
    }

    @Test
    void F23_path_openFailureRemainsCheckedIOException(@TempDir Path directory) {
        assertThrows(NoSuchFileException.class,
                () -> ResourceExamples.readLines(directory.resolve("missing.txt")));
    }

    @Test
    void F24_naiveCleanup_hidesImportFailure() {
        IllegalStateException read = new IllegalStateException("import failed");
        IllegalStateException cleanup = new IllegalStateException("delete failed");
        RuntimeException actual = assertThrows(RuntimeException.class,
                () -> ImportExamples.importWithoutSuppression(
                        () -> { throw read; }, () -> { throw cleanup; }));
        assertSame(cleanup, actual);
        assertEquals(0, actual.getSuppressed().length);
    }

    @Test
    void F25_preservingCleanup_keepsImportAndSuppressesDelete() {
        IllegalStateException read = new IllegalStateException("import failed");
        IllegalStateException cleanup = new IllegalStateException("delete failed");
        RuntimeException actual = assertThrows(RuntimeException.class,
                () -> ImportExamples.importPreservingFailure(
                        () -> { throw read; }, () -> { throw cleanup; }));
        assertSame(read, actual);
        assertArrayEquals(new Throwable[]{cleanup}, actual.getSuppressed());
    }

    @Test
    void F26_preservingCleanup_onlyDeleteFailurePropagates() {
        IllegalStateException cleanup = new IllegalStateException("delete failed");
        assertSame(cleanup, assertThrows(IllegalStateException.class,
                () -> ImportExamples.importPreservingFailure(() -> {}, () -> { throw cleanup; })));
        assertEquals(0, cleanup.getSuppressed().length);
    }

    @Test
    void F27_preservingCleanup_onlyImportFailurePropagatesAndDeleteRuns() {
        IllegalStateException read = new IllegalStateException("import failed");
        AtomicInteger deletes = new AtomicInteger();
        assertSame(read, assertThrows(IllegalStateException.class,
                () -> ImportExamples.importPreservingFailure(
                        () -> { throw read; }, deletes::incrementAndGet)));
        assertEquals(1, deletes.get());
        assertEquals(0, read.getSuppressed().length);
    }

    @Test
    void F28_preservingCleanup_bothActionsRunOnSuccess() {
        List<String> actions = new ArrayList<>();
        ImportExamples.importPreservingFailure(() -> actions.add("import"), () -> actions.add("delete"));
        assertEquals(List.of("import", "delete"), actions);
    }

    @Test
    void F29_preservingCleanup_avoidsSelfSuppressionForSameException() {
        IllegalStateException failure = new IllegalStateException("shared test instance");
        assertSame(failure, assertThrows(IllegalStateException.class,
                () -> ImportExamples.importPreservingFailure(
                        () -> { throw failure; }, () -> { throw failure; })));
        assertEquals(0, failure.getSuppressed().length);
    }

    @Test
    void F30_resource_rejectsNullInputs() {
        assertThrows(NullPointerException.class, () -> ResourceExamples.readLines((Path) null));
        assertThrows(NullPointerException.class, () -> ResourceExamples.readLines((BufferedReader) null));
    }
}

テスト対象・記録用の依存先・Main・POMも下に全文を載せます。未定義のserviceを手元で補う必要はありません。メソッド抜粋は共通のインデントを除いて、以下の同名ファイルと同じコードです。

クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/CatchExamples.java
package info.syachiku.finallyreturn;

import java.util.Objects;

public final class CatchExamples {
    private CatchExamples() {
    }

    public static int executeBroken(boolean fail, RecordingAudit audit) {
        Objects.requireNonNull(audit, "audit");
        try {
            operation(fail);
            return 0;
        } catch (RuntimeException exception) {
            audit.recordCatch();
            return 1;
        } finally {
            audit.record();
            return 9;
        }
    }

    public static int execute(boolean fail, RecordingAudit audit) {
        Objects.requireNonNull(audit, "audit");
        try {
            operation(fail);
            return 0;
        } catch (RuntimeException exception) {
            audit.recordCatch();
            return 1;
        } finally {
            audit.record();
        }
    }

    private static void operation(boolean fail) {
        if (fail) {
            throw new IllegalStateException("operation failed");
        }
    }
}
クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/FinallyExamples.java
package info.syachiku.finallyreturn;

import java.util.List;
import java.util.Objects;

public final class FinallyExamples {
    private FinallyExamples() {
    }

    // Xクイズと同じgetValue。意図的な不良例。
    public static String getValue() {
        try {
            return "A";
        } finally {
            return "B";
        }
    }

    public static String getValueAfterCleanup(List<String> events) {
        Objects.requireNonNull(events, "events");
        try {
            return "A";
        } finally {
            events.add("cleanup");
        }
    }
}
クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/ImportExamples.java
package info.syachiku.finallyreturn;

import java.util.Objects;

public final class ImportExamples {
    private ImportExamples() {
    }

    public static void importWithoutSuppression(Runnable importOrders, Runnable deleteTemporaryFile) {
        Objects.requireNonNull(importOrders, "importOrders");
        Objects.requireNonNull(deleteTemporaryFile, "deleteTemporaryFile");
        try {
            importOrders.run();
        } finally {
            deleteTemporaryFile.run();
        }
    }

    // RuntimeException同士の優先方針を示す例。checked例外/Error全般の共通部品ではない。
    public static void importPreservingFailure(Runnable importOrders, Runnable deleteTemporaryFile) {
        Objects.requireNonNull(importOrders, "importOrders");
        Objects.requireNonNull(deleteTemporaryFile, "deleteTemporaryFile");
        RuntimeException failure = null;
        try {
            importOrders.run();
        } catch (RuntimeException exception) {
            failure = exception;
            throw exception;
        } finally {
            try {
                deleteTemporaryFile.run();
            } catch (RuntimeException cleanupError) {
                if (failure != null) {
                    if (failure != cleanupError) {
                        failure.addSuppressed(cleanupError);
                    }
                } else {
                    throw cleanupError;
                }
            }
        }
    }
}
クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/LockExamples.java
package info.syachiku.finallyreturn;

import java.util.Objects;
import java.util.concurrent.locks.ReentrantLock;

public final class LockExamples {
    private LockExamples() {
    }

    public static void update(ReentrantLock lock, Runnable updateSharedState) {
        Objects.requireNonNull(lock, "lock");
        Objects.requireNonNull(updateSharedState, "updateSharedState");
        lock.lock();
        try {
            updateSharedState.run();
        } finally {
            lock.unlock();
        }
    }
}
クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/Main.java
package info.syachiku.finallyreturn;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public final class Main {
    private Main() {
    }

    public static void main(String[] args) throws IOException {
        System.out.println("quiz=" + FinallyExamples.getValue());
        List<String> events = new ArrayList<>();
        String value = FinallyExamples.getValueAfterCleanup(events);
        events.add("caller=" + value);
        System.out.println("events=" + events);

        RecordingOrderRepository repository = new RecordingOrderRepository(null);
        boolean result = new OrderService(repository, new RecordingAudit()).updateOrderBroken();
        System.out.println("order broken result=" + result + " saved=" + repository.savedCount());
        RecordingOrderRepository fixedRepository = new RecordingOrderRepository(null);
        boolean fixedResult = new OrderService(fixedRepository, new RecordingAudit()).updateOrder();
        System.out.println("order fixed result=" + fixedResult + " saved=" + fixedRepository.savedCount());
        RecordingAudit nameAudit = new RecordingAudit();
        NameService service = new NameService(() -> {
            throw new IllegalStateException("DB connection failed");
        }, nameAudit);
        System.out.println("name broken=" + service.loadNameBroken());
        try {
            service.loadName();
        } catch (RuntimeException failure) {
            System.out.println("name fixed=" + failure.getClass().getSimpleName()
                    + ": " + failure.getMessage() + " cleanupTotal=" + nameAudit.calls());
        }
        RecordingAudit brokenAudit = new RecordingAudit();
        int brokenNormal = CatchExamples.executeBroken(false, brokenAudit);
        int brokenFailure = CatchExamples.executeBroken(true, brokenAudit);
        System.out.println("catch broken normal=" + brokenNormal + " failed=" + brokenFailure
                + " catchCalls=" + brokenAudit.caughtCalls());
        RecordingAudit fixedAudit = new RecordingAudit();
        int fixedNormal = CatchExamples.execute(false, fixedAudit);
        int fixedFailure = CatchExamples.execute(true, fixedAudit);
        System.out.println("catch fixed normal=" + fixedNormal + " failed=" + fixedFailure
                + " catchCalls=" + fixedAudit.caughtCalls());

        ProbeReader reader = new ProbeReader("line1\nline2\n", null, null);
        List<String> lines = ResourceExamples.readLines(reader);
        System.out.println("resource normal=" + lines + " closeCalls=" + reader.closeCalls());
        ProbeReader failingReader = new ProbeReader("", new IOException("read failed"),
                new IOException("close failed"));
        try {
            ResourceExamples.readLines(failingReader);
        } catch (IOException failure) {
            System.out.println("resource both primary=" + failure.getMessage()
                    + " suppressed=" + suppressedMessages(failure)
                    + " closeCalls=" + failingReader.closeCalls());
        }
        try {
            ImportExamples.importWithoutSuppression(
                    () -> { throw new IllegalStateException("import failed"); },
                    () -> { throw new IllegalStateException("delete failed"); });
        } catch (RuntimeException failure) {
            System.out.println("import naive primary=" + failure.getMessage()
                    + " suppressed=" + suppressedMessages(failure));
        }
        try {
            ImportExamples.importPreservingFailure(
                    () -> { throw new IllegalStateException("import failed"); },
                    () -> { throw new IllegalStateException("delete failed"); });
        } catch (RuntimeException failure) {
            System.out.println("import preserved primary=" + failure.getMessage()
                    + " suppressed=" + suppressedMessages(failure));
        }
    }

    private static List<String> suppressedMessages(Throwable failure) {
        return Arrays.stream(failure.getSuppressed()).map(Throwable::getMessage).toList();
    }
}
クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/NameRepository.java
package info.syachiku.finallyreturn;

@FunctionalInterface
public interface NameRepository {
    // 戻り値は非null。取得失敗はRuntimeException。nullは契約違反。
    String loadName();
}
クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/NameService.java
package info.syachiku.finallyreturn;

import java.util.Objects;

public final class NameService {
    private final NameRepository repository;
    private final RecordingAudit audit;

    public NameService(NameRepository repository, RecordingAudit audit) {
        this.repository = Objects.requireNonNull(repository, "repository");
        this.audit = Objects.requireNonNull(audit, "audit");
    }

    public String loadNameBroken() {
        try {
            return repository.loadName();
        } finally {
            audit.record();
            return "guest";
        }
    }

    public String loadName() {
        try {
            return Objects.requireNonNull(repository.loadName(), "repository returned null");
        } finally {
            audit.record();
        }
    }
}
クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/OrderService.java
package info.syachiku.finallyreturn;

import java.util.Objects;

public final class OrderService {
    private final RecordingOrderRepository repository;
    private final RecordingAudit audit;

    public OrderService(RecordingOrderRepository repository, RecordingAudit audit) {
        this.repository = Objects.requireNonNull(repository, "repository");
        this.audit = Objects.requireNonNull(audit, "audit");
    }

    public boolean updateOrderBroken() {
        try {
            repository.save();
            return true;
        } finally {
            audit.record();
            return false;
        }
    }

    public boolean updateOrder() {
        try {
            repository.save();
            return true;
        } finally {
            audit.record();
        }
    }
}
クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/ProbeReader.java
package info.syachiku.finallyreturn;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;

// read/closeの失敗を別々に注入するローカルモデル。
public final class ProbeReader extends BufferedReader {
    private final IOException readFailure;
    private final IOException closeFailure;
    private int closeCalls;

    public ProbeReader(String content, IOException readFailure, IOException closeFailure) {
        super(new StringReader(content));
        this.readFailure = readFailure;
        this.closeFailure = closeFailure;
    }

    @Override
    public String readLine() throws IOException {
        if (readFailure != null) {
            throw readFailure;
        }
        return super.readLine();
    }

    @Override
    public void close() throws IOException {
        closeCalls++;
        super.close();
        if (closeFailure != null) {
            throw closeFailure;
        }
    }

    public int closeCalls() {
        return closeCalls;
    }
}
クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/RecordingAudit.java
package info.syachiku.finallyreturn;

// この教材の記録器。外部ログ送信や失敗する後処理をモデル化しない。
public final class RecordingAudit {
    private int calls;
    private int caughtCalls;

    public void record() {
        calls++;
    }

    public void recordCatch() {
        caughtCalls++;
    }

    public int calls() {
        return calls;
    }

    public int caughtCalls() {
        return caughtCalls;
    }
}
クリックで全文を開く:src/main/java/info/syachiku/finallyreturn/RecordingOrderRepository.java
package info.syachiku.finallyreturn;

// ローカルの保存モデル。DBやネット接続は使わない。
public final class RecordingOrderRepository {
    private final RuntimeException saveFailure;
    private int saveCalls;
    private int savedCount;

    public RecordingOrderRepository(RuntimeException saveFailure) {
        this.saveFailure = saveFailure; // nullは「保存成功」のテスト入力。
    }

    public void save() {
        saveCalls++;
        if (saveFailure != null) {
            throw saveFailure;
        }
        savedCount++;
    }

    public int saveCalls() {
        return saveCalls;
    }

    public int savedCount() {
        return savedCount;
    }
}
クリックで全文を開く:pom.xml
<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>finally-return-1829</artifactId><version>1.0.0</version>
  <properties><maven.compiler.release>17</maven.compiler.release><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties>
  <dependencies><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter</artifactId><version>5.12.2</version><scope>test</scope></dependency></dependencies>
  <build><plugins>
    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-resources-plugin</artifactId><version>3.3.1</version></plugin>
    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.14.0</version></plugin>
    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-surefire-plugin</artifactId><version>3.5.3</version></plugin>
  </plugins></build>
</project>
クリックで全文を開く:README.md
# finallyのreturnで消える戻り値・例外を実行する

Java17の小さな実行一式です。Spring・DB・HTTPサーバー・デバッガは使いません。RecordingOrderRepositoryは保存回数のモデル、RecordingAuditは失敗しないメモリ上の記録器です。

## 最初の実行

ZIPを展開しpom.xmlがあるフォルダーで実行します。

```sh
mvn clean test
java -cp target/classes info.syachiku.finallyreturn.Main
```

JDK17.0.8 / Maven3.9.16 / JUnit5.12.2で確認しています。全30件が成功します。意図的な不良例の危険な挙動も、教材として期待値を固定したテストを含みます。実行時は既存Mavenキャッシュのofflineモードでした。初回依存取得にはネット接続が必要です。空キャッシュの初回取得、別JDK、Windowsは未確認です。

## まず見る比較

| 対象 | 入力 | 不良例 | 修正版 | テスト |
| --- | --- | --- | --- | --- |
| return | tryでAを返す | getValueはB | getValueAfterCleanupはcleanupを記録してA | F01/F02 |
| 注文保存 | 保存成功 | falseなのに保存1回/1件 | trueで1件 | F03/F04 |
| 注文保存 | saveが例外 | falseで例外が隠れる | 同じ例外が呼び出し元へ届く | F05/F06 |
| 名前取得 | DB connection failedをthrow | guestで失敗が隠れる | 同じIllegalStateExceptionが届く | F07/F08 |
| 名前取得 | Alice/null | finallyが値を決めてしまう | Aliceを返す/nullは契約違反としてNPE | F09/F10 |
| catch | operation正常/例外 | 両方9、例外側はcatch到達1回 | 正常0/例外1、例外側のcatch到達1回 | F11〜F14 |
| ロック | 更新正常/例外 | — | どちらもunlock、失敗時は同じ例外 | F15/F16 |

CatchExamples.operation(true)は実際にIllegalStateExceptionを投げます。単にtryでreturn0を書いただけの、catchへ入ることのない例ではありません。caughtCalls()とfinallyのcalls()を別に確認しています。

OrderServiceのRepositoryはメモリ上のモデルです。falseを見て再実行してよいとは言えない理由を示しますが、DBコミットやトランザクションを実行した教材ではありません。

## 名前と戻り値nullの契約

NameRepository.loadNameは非null文字列かRuntimeExceptionを返す契約です。取得失敗をguestやnullへ変換しません。NameService.loadNameは違反したnullをNullPointerException("repository returned null")として拒否し、そのときもauditは1回実行します。空文字禁止という追加仕様は設けていません。

getValueAfterCleanupのeventsには変更可能なArrayListを渡します。この教材のcleanup記録が正常に終わる条件で、呼び出し元がAを受け取る前にcleanupが記録されることを確認します。変更不能リストへのaddが成功する契約ではありません。

## readとcloseの優先順位は別の表で確認する

ResourceExamples.readLines(Path)はUTF8ファイルを開き、readLines(BufferedReader)へ渡します。後者は渡されたreaderの所有権を受け取り、try-with-resourcesで閉じます。共有されているreaderを渡してよいAPIではありません。

| 読取 | close | 呼び出し元の結果 | suppressed | close呼出し | テスト |
| --- | --- | --- | --- | --- | --- |
| 正常 | 正常 | 読んだ行のList | なし | 1回 | F17 |
| IOException | 正常 | 同じ読取IOException | 0件 | 1回 | F18 |
| 正常 | IOException | 同じclose IOException(Listは返らない) | 0件 | 1回 | F19 |
| IOException | 別のIOException | 読取IOExceptionが主例外 | close IOExceptionが1件 | 1回 | F20 |

closeを**呼び出すこと**と、closeが**成功すること**は別です。ProbeReaderはStringReader上にread/close失敗を注入し、closeCallsを数えるモデルです。実OSのclose障害を起こしていません。F22では一時ディレクトリへ実UTF8ファイルを書いてPath版も読みます。

readLineはEOFでnullを返しますが、このメソッドの戻り値Listはnullにしません。空ファイルは空List(F21)、null path/readerはNPE拒否(F30)です。開く時点で存在しないパスならNoSuchFileException(IOException)を返します(F23)。取得に成功していないreaderのcloseを検証したとは扱いません。

旧断片のreader.lines()は、読取中のIOExceptionをUncheckedIOExceptionへ包む仕様があります。この版はreadLineループへ揃えたため、上表の読取例外はchecked IOExceptionで統一しています。どちらも同じ例外型と説明してはいけません。

## importとdeleteが両方失敗する手書きfinally

ImportExamplesの2つのRunnableは、メモリ上で取込処理・後処理の呼出しと失敗をモデル化します。実ファイルの取込/削除は行いません。

| 取込 | 削除 | 素朴版importWithoutSuppression | 保持版importPreservingFailure | テスト |
| --- | --- | --- | --- | --- |
| RuntimeException | 別のRuntimeException | 削除例外が表に出て取込例外を隠す | 取込が主、削除をsuppressedへ保持 | F24/F25 |
| 正常 | RuntimeException | — | 削除例外が表に出る | F26 |
| RuntimeException | 正常 | — | 同じ取込例外、削除呼出し1回 | F27 |
| 正常 | 正常 | — | import→deleteの順で各1回 | F28 |
| 同じ例外インスタンスを両方がthrow | 同じインスタンス | — | 自分自身をsuppressedへ追加せず元を維持 | F29 |

保持版はRuntimeException同士の優先方針を説明する範囲です。checked例外やErrorまで吸収する汎用ライブラリとはしていません。F29の自己抑制ガードは手書き版の方針であり、try-with-resourcesのすべての組合せを再実装したものではありません。AutoCloseableにできるリソースはtry-with-resourcesを優先します。

## テストが誤変更を検出するか

元プロジェクトをコピーして試してください。

1. NameService.loadNameのfinallyのaudit.record()直後だけに`return "guest";`を追加します。

```sh
mvn test '-Dtest=FinallyExamplesTest#F08*'
```

DB例外を期待しているのにguestで正常終了するため失敗します。追加したreturnを戻し、同じテストを成功へ戻してください。

2. 別コピーのCatchExamples.executeBrokenの`operation(fail);`だけを消します。

```sh
mvn test '-Dtest=FinallyExamplesTest#F12*'
```

戻り値9は同じでも、catch到達expected1/actual0で失敗します。操作呼出しを戻し、同じテストを成功へ戻してください。配布ZIPは正常版です。

3. 別コピーのImportExamples.importPreservingFailureで`failure.addSuppressed(cleanupError);`だけを消します。

```sh
mvn test '-Dtest=FinallyExamplesTest#F25*'
```

主例外は同じでも、suppressedの削除例外1件が失われて失敗します。元のaddSuppressedを戻し、同じテストを成功へ戻してください。

## 配布範囲と資料

src/main/javaには全型・Main、src/test/javaには全30テスト、ルートにPOM・README・仕様とテスト対応表expected-results.jsonがあります。targetやMaven依存キャッシュは含めません。サーバーもデバッガも起動しません。

確認した一次資料:

- [JLS17 try/finally](https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.20.2)
- [JLS17 try-with-resources](https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.20.3.1)
- [BufferedReader Java17](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/BufferedReader.html)
- [Throwable.addSuppressed Java17](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Throwable.html#addSuppressed(java.lang.Throwable))
mvn clean test
java -cp target/classes info.syachiku.finallyreturn.Main

Mainは危険版と修正版を同じ条件で呼びます。次は実装を実行した標準出力です。nameのcleanupTotal=2は、同じNameServiceで危険版と修正版を1回ずつ呼んだ合計です。catchCalls=1は、正常と失敗を各1回呼んだうち、失敗入力がcatchへ入った回数です。

quiz=B
events=[cleanup, caller=A]
order broken result=false saved=1
order fixed result=true saved=1
name broken=guest
name fixed=IllegalStateException: DB connection failed cleanupTotal=2
catch broken normal=9 failed=9 catchCalls=1
catch fixed normal=0 failed=1 catchCalls=1
resource normal=[line1, line2] closeCalls=1
resource both primary=read failed suppressed=[close failed] closeCalls=1
import naive primary=delete failed suppressed=[]
import preserved primary=import failed suppressed=[delete failed]

原本とZIP展開先はどちらも30テスト成功を確認しました。自分でも誤変更を見つけられるか確かめるなら、必ず別コピーでNameService.loadName()のfinally内にreturn "guest"を追加し、次のF08だけを実行してください。例外が出ずguestが返るため、assertThrowsの検査が失敗します。loadNameBroken()を変更する演習ではありません。

mvn '-Dtest=FinallyExamplesTest#F08_fixedName_propagatesFailureToCaller' test

追加したreturnだけを戻すと同じF08が成功します。catchのoperation呼出しを消した場合はF12、元例外へのaddSuppressedを消した場合はF25が失敗することも別コピーで確認しました。最後は元の修正版に戻し、mvn clean testで全件を実行します。

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

// レビューコメント例
finallyのreturnがtryの戻り値と例外を上書きします。
finallyは後処理だけにし、戻り値はtryまたはメソッド末尾で決めてください。

// レビューコメント例
InputStreamはAutoCloseableなので、手動closeではなく
try-with-resourcesへ変更してください。

// レビューコメント例
後処理のdeleteが失敗すると、元の取込例外が見えなくなる可能性があります。
元例外を維持する扱いを確認してください。

レビューを受けたときは「結果が正しいので問題ない」と返すのではなく、例外経路まで確認します。finallyのreturnは、現在のテストデータでは問題が出なくても、障害時に最も困る種類の実装です。

提出前のセルフチェック

修正を提出する前に、少なくとも次の観測結果を説明できる状態にします。

  • tryの正常な戻り値と、失敗時の同じ例外を両方検査した
  • finallyへreturnを戻す変更で、修正版のテストが失敗する
  • 保存回数と戻り値を並べ、falseだけで未保存と判断していない
  • catchを実際に通る入力があり、想定した戻り値を確認した
  • ロックは正常時・例外時の両方で解除される
  • 読取失敗・close失敗・両方失敗を混同していない
  • 後処理失敗で主例外がすり替わらず、必要な抑制例外が残る
  • 名前取得がnullを返した場合の契約を決めている

このサンプルのRepositoryやauditは記録用の実装です。実運用のDBトランザクション、通知、監視の受信まで確認した結果ではありません。案件の後処理も失敗し得るなら、その境界に合わせた入力と観測点を追加します。

Javaの基本をコードで整理する参考書

returnで何が返るか、catchで何を回復するかの区別から復習したい人には『スッキリわかるJava入門 第5版』を案内します。第5章のメソッドと第17章の例外を軸に、正常な戻り値と異常時の伝わり方を整理するための一冊です。本書はJava 25対応、この記事の実行一式はJava 17で確認する別の教材です。

読むときは、例外をcatchする構文を覚えるだけで終えず、「この取得失敗をguestとして成功扱いにしてよいか」を自分の言葉で決めてみてください。その判断をloadNameの正常・例外・nullの入力へ戻すと、文法と業務の契約を結び付けられます。

書籍「スッキリわかるJava入門 第5版」の表紙
商品画像:Amazon.co.jp
PR Java初学者向け

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

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

変数・条件分岐から、クラスの基本まで学ぶ一冊。

豊富な図とサンプルで、変数、条件分岐、クラス、例外処理まで順番に学べます。Javaの最初の教科書を探している人向けです。

  • Javaを基礎から体系的に学びたい
  • Java 25 LTS対応の入門書を選びたい

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

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

関連記事JUnit 5入門|Mavenで最初のテストを実行し、失敗を直す 今回のJUnitを動かす準備で止まったら。Mavenで最初のテストを実行し、expectedとactualの違いを読み取る手順を確認できます。 記事を読む 関連記事Javaのログレベルはどう使い分ける?INFO・WARN・ERRORの現場ルール 例外をどの境界で、どのレベルで記録するかを整理できます。 記事を読む

まとめ

finallyのreturnは、tryやcatchで決めた戻り値と、呼び出し元へ投げる途中の例外を上書きします。finallyは後処理に使い、正常な戻り値と異常時の例外をそれぞれの経路で保ちます。

今回なら、取得失敗がguestへ変わらないこと、catchの0/1が9へ変わらないこと、読取とcloseの両方が失敗しても読取の原因が残ることを、同じ実装とJUnitで確認できます。「returnを消したから完了」ではなく、正常・業務失敗・後処理失敗のどの結果を呼び出し元へ伝えるかまで揃えてください。

Javaの終了順の定義:try-finallyの実行、try-with-resourcesの例外保持。

-実装・エラー解決
-, ,