JavaのTry-Catchマスター講座：初心者からプロまで使いこなす7つの必須テクニック

try {
    // 例外が発生する可能性のあるコード
} catch (ExceptionType e) {
    // 例外が発生した場合の処理
}

public class SimpleTryCatchExample {
    public static void main(String[] args) {
        try {
            // 配列の範囲外アクセスを試みる
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[3]); // この行で例外が発生
        } catch (ArrayIndexOutOfBoundsException e) {
            // 例外をキャッチして処理
            System.out.println("エラーが発生しました: 配列の範囲外にアクセスしようとしました");
            System.out.println("例外メッセージ: " + e.getMessage());
        }
        System.out.println("プログラムは正常に終了しました");
    }
}

try {
    // 複数の例外が発生する可能性のあるコード
} catch (IOException | SQLException e) {
    // IOExceptionまたはSQLExceptionが発生した場合の処理
    System.out.println("エラーが発生しました: " + e.getMessage());
} catch (Exception e) {
    // その他の例外が発生した場合の処理
    System.out.println("予期せぬエラーが発生しました: " + e.getMessage());
}

FileInputStream fis = null;
try {
    fis = new FileInputStream("example.txt");
    // ファイルの読み込み処理
} catch (IOException e) {
    System.out.println("ファイルの読み込みエラー: " + e.getMessage());
} finally {
    if (fis != null) {
        try {
            fis.close(); // ファイルストリームを確実に閉じる
        } catch (IOException e) {
            System.out.println("ファイルのクローズに失敗しました: " + e.getMessage());
        }
    }
}

try (FileInputStream fis = new FileInputStream("example.txt");
     BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    System.out.println("ファイルの読み込みエラー: " + e.getMessage());
}
// リソースは自動的に閉じられるため、finallyブロックは不要

FileInputStream fis = new FileInputStream("example.txt");
try (fis) {
    // fis を使用した処理
} catch (IOException e) {
    System.out.println("エラー: " + e.getMessage());
}

public void processUserData(String userId) {
    User user = null;
    try {
        user = userRepository.findById(userId);
        validateUser(user);
        updateUserStatus(user);
    } catch (UserNotFoundException e) {
        logger.error("ユーザーが見つかりません: {}", userId, e);
        throw new ServiceException("ユーザー処理中にエラーが発生しました", e);
    } catch (ValidationException e) {
        logger.error("ユーザーデータが無効です: {}", userId, e);
        throw new ServiceException("ユーザー処理中にエラーが発生しました", e);
    }
}

try {
    // データベース操作
} catch (SQLException e) {
    throw new DataAccessException("データベース操作中にエラーが発生しました", e);
}

public class DataAccessException extends RuntimeException {
    public DataAccessException(String message, Throwable cause) {
        super(message, cause);
    }
}

ログレベルを適切に使い分ける：

try {
    // 重要な操作
} catch (CriticalException e) {
    logger.error("重大なエラーが発生しました: {}", e.getMessage(), e);
    // エラー通知や回復処理
} catch (NonCriticalException e) {
    logger.warn("警告：予期せぬ状況が発生しました: {}", e.getMessage(), e);
    // 代替処理や緩和策
}

コンテキスト情報を含める：

logger.error("ユーザーID: {}, 操作: {}, エラー: {}", userId, operation, e.getMessage(), e);

// アンチパターン
try {
    riskyOperation();
} catch (Exception e) {
    // 何もしない - 危険！
}

// 改善例
try {
    riskyOperation();
} catch (Exception e) {
    logger.error("リスクの高い操作中にエラーが発生しました", e);
    // 必要に応じて適切なエラーハンドリングを行う
}

// アンチパターン
public void riskyMethod() {
    try {
        // リスクの高い操作
    } catch (Exception e) {
        e.printStackTrace(); // 標準エラー出力に出力するだけでは不十分
    }
}

// 改善例
public void riskyMethod() throws CustomException {
    try {
        // リスクの高い操作
    } catch (Exception e) {
        logger.error("リスクの高い操作中にエラーが発生しました", e);
        throw new CustomException("操作に失敗しました", e);
    }
}

// アンチパターン：過剰なTry-Catch
try {
    openFile();
    try {
        readFile();
        try {
            processData();
        } catch (DataProcessingException e) {
            logger.error("データ処理エラー", e);
        }
    } catch (IOException e) {
        logger.error("ファイル読み込みエラー", e);
    }
} catch (FileNotFoundException e) {
    logger.error("ファイルが見つかりません", e);
}

// 改善例：例外のグループ化
try {
    openFile();
    readFile();
    processData();
} catch (FileNotFoundException e) {
    logger.error("ファイルが見つかりません", e);
    // ファイルが見つからない場合の適切な処理
} catch (IOException e) {
    logger.error("ファイル操作エラー", e);
    // I/Oエラーの適切な処理
} catch (DataProcessingException e) {
    logger.error("データ処理エラー", e);
    // データ処理エラーの適切な処理
}

// リソース管理の最適化例
try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        processLine(line);
    }
} catch (IOException e) {
    logger.error("ファイル読み込みエラー", e);
    // 適切なエラーハンドリング
}

public List<String> readLinesFromFile(String filePath) {
    List<String> lines = new ArrayList<>();
    Path path = Paths.get(filePath);

    try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {
        String line;
        while ((line = reader.readLine()) != null) {
            lines.add(line);
        }
    } catch (IOException e) {
        logger.error("ファイルの読み込み中にエラーが発生しました: {}", filePath, e);
        // 必要に応じて、カスタム例外をスローするか、デフォルト値を返す
        throw new FileProcessingException("ファイルの読み込みに失敗しました", e);
    }

    return lines;
}

public void updateUserStatus(int userId, String newStatus) {
    String sql = "UPDATE users SET status = ? WHERE id = ?";

    try (Connection conn = dataSource.getConnection();
         PreparedStatement pstmt = conn.prepareStatement(sql)) {

        conn.setAutoCommit(false); // トランザクション開始

        pstmt.setString(1, newStatus);
        pstmt.setInt(2, userId);
        int affectedRows = pstmt.executeUpdate();

        if (affectedRows == 0) {
            throw new SQLException("ユーザーの更新に失敗しました。ユーザーID: " + userId);
        }

        conn.commit(); // トランザクションコミット
        logger.info("ユーザーステータスが正常に更新されました。ユーザーID: {}", userId);

    } catch (SQLException e) {
        logger.error("データベース操作中にエラーが発生しました", e);
        throw new DatabaseException("ユーザーステータスの更新に失敗しました", e);
    }
}

public String fetchDataFromApi(String apiUrl) {
    HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(10))
        .build();

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(apiUrl))
        .timeout(Duration.ofSeconds(30))
        .GET()
        .build();

    try {
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() == 200) {
            return response.body();
        } else {
            throw new ApiException("APIリクエストが失敗しました。ステータスコード: " + response.statusCode());
        }
    } catch (IOException e) {
        logger.error("ネットワークエラーが発生しました", e);
        throw new NetworkException("APIとの通信中にエラーが発生しました", e);
    } catch (InterruptedException e) {
        logger.error("APIリクエストが中断されました", e);
        Thread.currentThread().interrupt(); // 割り込みステータスを再設定
        throw new NetworkException("APIリクエストが中断されました", e);
    }
}

public String callUserService(int userId) {
    CircuitBreaker circuitBreaker = circuitBreakerFactory.create("userService");

    try {
        return circuitBreaker.run(() -> userServiceClient.getUserInfo(userId),
            throwable -> fallbackForUserInfo(userId, throwable));
    } catch (Exception e) {
        logger.error("ユーザーサービスの呼び出し中にエラーが発生しました", e);
        throw new ServiceException("ユーザー情報の取得に失敗しました", e);
    }
}

private String fallbackForUserInfo(int userId, Throwable throwable) {
    logger.warn("ユーザーサービスがダウンしています。フォールバック処理を実行します", throwable);
    return "ユーザー情報は現在利用できません";
}

public CompletableFuture<String> processDataAsync(String data) {
    return CompletableFuture.supplyAsync(() -> {
        try {
            // 長時間実行される処理
            return processData(data);
        } catch (Exception e) {
            logger.error("データ処理中にエラーが発生しました", e);
            throw new CompletionException(e);
        }
    }).exceptionally(ex -> {
        logger.warn("非同期処理が失敗しました", ex);
        return "デフォルト値";
    });
}

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

public class FileReaderTest {

    @Test
    void testReadFile_FileNotFound() {
        FileReader reader = new FileReader();

        assertThrows(FileNotFoundException.class, () -> {
            reader.readFile("non_existent_file.txt");
        });
    }

    @Test
    void testReadFile_IOError() {
        FileReader reader = new FileReader();

        Exception exception = assertThrows(IOException.class, () -> {
            reader.readFile("corrupt_file.txt");
        });

        String expectedMessage = "ファイルの読み込みに失敗しました";
        String actualMessage = exception.getMessage();
        assertTrue(actualMessage.contains(expectedMessage));
    }
}

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

class UserServiceTest {

    @Test
    void testUpdateUser_DatabaseTimeout() {
        // データベース接続をモック
        Connection mockConnection = mock(Connection.class);
        DataSource mockDataSource = mock(DataSource.class);

        try {
            when(mockDataSource.getConnection()).thenThrow(new SQLTimeoutException("接続タイムアウト"));
        } catch (SQLException e) {
            fail("モックの設定に失敗しました");
        }

        UserService userService = new UserService(mockDataSource);

        assertThrows(DatabaseException.class, () -> {
            userService.updateUser(1, "新しい名前");
        });

        // ロールバックが呼び出されたことを確認
        try {
            verify(mockConnection, times(1)).rollback();
        } catch (SQLException e) {
            fail("ロールバックの検証に失敗しました");
        }
    }
}

BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
try (BufferedReader r = reader) {
    // リソースを使用
}

BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
try (reader) {
    // リソースを使用
}

モジュール固有の例外： モジュール内で定義された例外クラスを、そのモジュールの公開APIの一部として明示的にエクスポートできます。

module com.myapp.core {
    exports com.myapp.core.exception;
}

例外の封じ込め： モジュール内部で使用される例外を外部に漏らさないようにすることで、APIの安定性を高めることができます。

Java 10： 局所変数型推論（var）

try {
    var connection = DriverManager.getConnection(url, user, password);
    // connectionの型はConnectionとして推論される
} catch (SQLException e) {
    // エラー処理
}

Java 14： スイッチ式と例外処理の組み合わせ

int result = switch (obj) {
    case Integer i -> i;
    case String s -> Integer.parseInt(s);
    default -> throw new IllegalArgumentException("Unsupported type");
};

Java 16以降： パターンマッチングとinstanceofの改善

try {
    // 何らかの処理
} catch (Exception e) {
    if (e instanceof SQLException sql && sql.getSQLState().equals("23505")) {
        System.out.println("一意制約違反: " + sql.getMessage());
    } else {
        throw e;
    }
}

堅牢なエラーハンドリングは、優れたJava開発者となるための重要な一歩です。ここで学んだ内容を基に、自信を持って次のプロジェクトに臨んでください。エラーに適切に対処できるアプリケーションは、ユーザーとデベロッパーの両方に価値をもたらします。頑張って、堅牢なJavaアプリケーションの開発に取り組んでいきましょう！