🛡️

Javaの例外処理：5つの鉄則 - 実践ガイド

2025/03/23に公開

Javaの例外処理：5つの鉄則

はじめに

プログラミングにおいて、エラーや例外は避けられないものです。優れた開発者は、エラーを恐れるのではなく、適切に処理する方法を知っています。「過ちは人間のもの、しかしコードは完璧であるべき」という言葉があるように、適切な例外処理はアプリケーションの品質を大きく左右します。

この記事では、Javaにおける例外処理の5つの鉄則を紹介し、実際のコード例を通じて実装方法を解説します。これらの原則を理解し適用することで、より堅牢で保守性の高いコードを書くことができるようになります。

例外処理の基本

Javaにおける例外の階層は以下のようになっています：

Throwable
├── Error         // 通常回復不可能なシステムエラー
└── Exception
    ├── RuntimeException  // 非チェック例外
    └── その他の例外      // チェック例外

チェック例外：コンパイル時に処理が強制される例外（例：IOException, SQLException）
非チェック例外：コンパイル時に処理が強制されない例外（例：NullPointerException, IllegalArgumentException）
エラー：通常、アプリケーションで回復することが期待されていない深刻な問題（例：OutOfMemoryError）

基本的な例外処理の構文：

try {
    // 例外が発生する可能性のあるコード
} catch (ExceptionType1 e1) {
    // ExceptionType1の例外を処理するコード
} catch (ExceptionType2 e2) {
    // ExceptionType2の例外を処理するコード
} finally {
    // 例外の発生有無にかかわらず実行されるコード
}

Java 7以降では、マルチキャッチも可能です：

try {
    // 例外が発生する可能性のあるコード
} catch (ExceptionType1 | ExceptionType2 e) {
    // ExceptionType1またはExceptionType2の例外を処理するコード
}

では、Javaの例外処理における5つの鉄則を見ていきましょう。

鉄則1：状況に合った例外クラスを選びましょう

適切な例外の種類を選択することは、コードの明確さと維持性を向上させる上で重要です。

悪い例

public void badExample(String filePath) {
    try {
        // ファイル操作のコード
        byte[] content = Files.readAllBytes(Paths.get(filePath));
        // 処理続行...
    } catch (Exception e) {
        // 汎用的な例外をキャッチ - これは避けるべき
        throw new RuntimeException("ファイル読み込みエラー", e);
    }
}

良い例

public void goodExample(String filePath) throws IOException {
    try {
        // ファイル操作のコード
        byte[] content = Files.readAllBytes(Paths.get(filePath));
        // 処理続行...
    } catch (NoSuchFileException e) {
        // ファイルが存在しない場合の具体的な処理
        throw new FileNotFoundException("指定されたファイルが見つかりません: " + filePath);
    } catch (IOException e) {
        // その他のIO例外の処理
        throw new IOException("ファイル読み込み中にエラーが発生しました: " + filePath, e);
    }
}

ガイドライン

具体的な例外を使う: できるだけ具体的な例外クラスを使用して、問題の性質を明確にします。
チェック例外と非チェック例外を適切に使い分ける:
- チェック例外: 回復可能でクライアントに処理を強制したい例外
- 非チェック例外: プログラミングエラーや回復が難しい状況
標準例外を再利用する: 既存のJava標準例外クラスで適切なものがあれば使用します。

鉄則2：例外は必要な範囲でまとめて扱いましょう

例外処理の粒度は、コードの可読性と保守性に大きく影響します。適切な場所で適切なレベルの例外を処理しましょう。

悪い例（細かすぎる例外処理）

public void tooFineGrained() {
    FileInputStream fis = null;
    try {
        fis = new FileInputStream("config.txt");
    } catch (FileNotFoundException e) {
        System.err.println("ファイルが見つかりません");
        return;
    }
    
    try {
        Properties props = new Properties();
        props.load(fis);
    } catch (IOException e) {
        System.err.println("プロパティ読み込みエラー");
        return;
    }
    
    try {
        fis.close();
    } catch (IOException e) {
        System.err.println("ファイルクローズエラー");
    }
}

良い例

public Properties loadProperties(String fileName) throws ConfigurationException {
    try (FileInputStream fis = new FileInputStream(fileName)) {
        Properties props = new Properties();
        props.load(fis);
        return props;
    } catch (FileNotFoundException e) {
        throw new ConfigurationException("設定ファイルが見つかりません: " + fileName, e);
    } catch (IOException e) {
        throw new ConfigurationException("設定ファイルの読み込みエラー: " + fileName, e);
    }
}

ガイドライン

関連する操作をまとめて処理する: 密接に関連する操作は同じtryブロック内で処理します。
例外をアプリケーション層で変換する: 低レベルの例外を高レベルの抽象化された例外に変換します。
適切なレイヤーで例外を処理する: 例外を処理するのに最も適したレイヤーで行います。

鉄則3：リソースは確実に片付けましょう

リソースのクリーンアップは、メモリリークやその他のリソース問題を防ぐために重要です。Java 7以降では、try-with-resources構文を使用することをお勧めします。

悪い例

public void oldStyleResourceHandling(String filePath) {
    FileInputStream fis = null;
    BufferedReader reader = null;
    try {
        fis = new FileInputStream(filePath);
        reader = new BufferedReader(new InputStreamReader(fis));
        String line;
        while ((line = reader.readLine()) != null) {
            // 行の処理
            System.out.println(line);
        }
    } catch (IOException e) {
        System.err.println("ファイル読み込みエラー: " + e.getMessage());
    } finally {
        // クリーンアップコード - エラーが起きやすい
        try {
            if (reader != null) reader.close();
        } catch (IOException e) {
            System.err.println("リーダークローズエラー");
        }
        try {
            if (fis != null) fis.close();
        } catch (IOException e) {
            System.err.println("ストリームクローズエラー");
        }
    }
}

良い例

public void modernResourceHandling(String filePath) {
    try (
        FileInputStream fis = new FileInputStream(filePath);
        BufferedReader reader = new BufferedReader(new InputStreamReader(fis))
    ) {
        String line;
        while ((line = reader.readLine()) != null) {
            // 行の処理
            System.out.println(line);
        }
    } catch (IOException e) {
        System.err.println("ファイル読み込みエラー: " + e.getMessage());
    }
    // try-with-resources により自動的にクローズされるため、
    // finally ブロックは不要
}

ガイドライン

try-with-resources を使用する: Java 7以降では、AutoCloseableを実装したリソースに対してtry-with-resourcesを使用します。
複数リソースの適切な管理: 複数のリソースを操作する場合は、それぞれをtry-with-resources宣言内に含めます。
カスタムリソースにはAutoCloseableを実装: 独自のリソースクラスを作成する場合は、AutoCloseableインターフェースを実装します。

鉄則4：例外は必ず記録に残しましょう

例外の適切なログ記録は、問題のデバッグと解決に不可欠です。

悪い例

public void badLoggingExample(String filePath) {
    try {
        // ファイル操作
        processFile(filePath);
    } catch (IOException e) {
        // スタックトレースがないのでデバッグが困難
        LOGGER.log(Level.SEVERE, "ファイル処理エラー: " + e.getMessage());
    }
}

良い例

private static final org.slf4j.Logger SLF4J_LOGGER = LoggerFactory.getLogger(ExceptionLoggingExample.class);

public void goodLoggingExample(String filePath) {
    try {
        processFile(filePath);
    } catch (IOException e) {
        // 例外オブジェクトをログに含める
        SLF4J_LOGGER.error("ファイル処理中にエラーが発生しました: {}", filePath, e);
    }
}

コンテキスト情報を含めたログ記録の例

public void processUserData(long userId, String data) {
    try {
        // ユーザーデータの処理
        validateAndProcessData(userId, data);
    } catch (ValidationException e) {
        // コンテキスト情報を含める
        SLF4J_LOGGER.warn("ユーザーデータの検証に失敗しました - userId: {}, error: {}", userId, e.getMessage());
    } catch (ProcessingException e) {
        // 重大なエラーの詳細なログ
        SLF4J_LOGGER.error("ユーザーデータの処理中に重大なエラーが発生しました - userId: {}", userId, e);
        // 必要に応じて通知やフォールバック処理
        notifyAdministrator(userId, e);
    }
}

ガイドライン

適切なロギングフレームワークを使用する: SLF4Jなどの柔軟なロギングフレームワークを使用します。
例外オブジェクトをログに含める: ログメッセージだけでなく、例外オブジェクトも記録してスタックトレースを保存します。
コンテキスト情報を提供する: ユーザーID、セッション情報、入力データなど、問題の診断に役立つコンテキスト情報を含めます。
適切なログレベルを使用する: 問題の重大度に応じた適切なログレベル（DEBUG, INFO, WARN, ERROR）を使用します。

鉄則5：独自の例外クラスを上手に使いましょう

カスタム例外は、アプリケーション固有のエラー状態を明確に表現するのに役立ちます。

基本的なカスタム例外クラス

public static class OrderNotFoundException extends Exception {
    private final long orderId;
    
    public OrderNotFoundException(long orderId) {
        super("注文が見つかりません: " + orderId);
        this.orderId = orderId;
    }
    
    public long getOrderId() {
        return orderId;
    }
}

例外の階層設計

// ビジネスロジック例外の基底クラス
public static class BusinessException extends Exception {
    public BusinessException(String message) {
        super(message);
    }
    
    public BusinessException(String message, Throwable cause) {
        super(message, cause);
    }
}

// 注文処理に関する例外
public static class OrderProcessingException extends BusinessException {
    public OrderProcessingException(String message) {
        super(message);
    }
    
    public OrderProcessingException(String message, Throwable cause) {
        super(message, cause);
    }
}

// 支払い失敗の例外
public static class PaymentFailedException extends OrderProcessingException {
    private final String paymentId;
    
    public PaymentFailedException(String paymentId, String message) {
        super(message);
        this.paymentId = paymentId;
    }
    
    public String getPaymentId() {
        return paymentId;
    }
}

使用例

public void processOrder(long orderId) throws BusinessException {
    try {
        Order order = findOrder(orderId);
        validateOrder(order);
        processPayment(order);
        updateInventory(order);
        sendConfirmation(order);
    } catch (OrderNotFoundException e) {
        throw new BusinessException("注文処理ができません", e);
    } catch (PaymentFailedException e) {
        // 支払い失敗の詳細な処理
        String paymentId = e.getPaymentId();
        logPaymentFailure(paymentId, e);
        throw new OrderProcessingException("支払い処理に失敗しました: " + paymentId, e);
    }
}

ガイドライン

意味のある階層を作る: 関連する例外をグループ化する階層を設計します。
適切な情報を含める: 例外には問題の診断に役立つデータを含めます。
チェック例外と非チェック例外を適切に選択する:
- ビジネスロジックの回復可能なエラーにはチェック例外
- プログラミングエラーや回復不可能な状態には非チェック例外
既存の例外クラスを拡張する: 新しい例外タイプを作成する前に、既存の例外クラスで十分かどうか検討します。

実践的なアンチパターンと解決策

例外処理でよく見られるアンチパターンと、その解決策を紹介します。

アンチパターン1: 空のcatchブロック

try {
    // 何らかの処理
    riskyOperation();
} catch (Exception e) {
    // 何もしない - 絶対に避けるべき
}

解決策

例外を捕捉する理由があるなら、適切に処理するか、少なくともログに記録しましょう。

アンチパターン2: 例外のprintStackTrace

try {
    riskyOperation();
} catch (Exception e) {
    // この方法は避ける - 適切なロギングを使用すべき
    e.printStackTrace();
}

解決策

適切なロギングフレームワークを使用して、構造化されたログを残しましょう。

アンチパターン3: 過度に広い例外のキャッチ

try {
    riskyOperation();
} catch (Exception e) {
    // 具体的な例外タイプを使用すべき
    System.err.println("エラーが発生しました: " + e.getMessage());
}

解決策

具体的な例外タイプをキャッチして、それぞれに適切な処理を行いましょう。

アンチパターン4: 例外を使った制御フロー

public int findIndexUsingException(List<String> list, String target) {
    try {
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals(target)) {
                return i;
            }
        }
        throw new NotFoundException("項目が見つかりません: " + target);
    } catch (NotFoundException e) {
        return -1; // 例外を使用して-1を返す - 悪い方法
    }
}

解決策

通常の条件分岐を使用しましょう。

public int findIndexProperly(List<String> list, String target) {
    for (int i = 0; i < list.size(); i++) {
        if (list.get(i).equals(target)) {
            return i;
        }
    }
    return -1; // 例外を使わずに-1を返す - 良い方法
}

アンチパターン5: 例外メッセージの連結

try {
    riskyOperation();
} catch (Exception e) {
    // 元の例外情報が失われる
    throw new RuntimeException("操作に失敗しました: " + e.getMessage());
}

解決策

原因例外を保持する例外チェーンを使用しましょう。

try {
    riskyOperation();
} catch (Exception e) {
    // 原因例外を保持する
    throw new RuntimeException("操作に失敗しました", e);
}

まとめ

Javaの例外処理における5つの鉄則を理解し適用することで、より堅牢で保守しやすいコードを書くことができます：

状況に合った例外クラスを選びましょう：問題の性質に合った具体的な例外クラスを使用します。
例外は必要な範囲でまとめて扱いましょう：関連する操作をまとめて処理し、適切なレイヤーで例外を変換します。
リソースは確実に片付けましょう：try-with-resourcesを活用して、リソースリークを防ぎます。
例外は必ず記録に残しましょう：例外の詳細と十分なコンテキスト情報をログに残し、問題の診断を容易にします。
独自の例外クラスを上手に使いましょう：アプリケーション固有のエラー状態を明確に表現するカスタム例外を設計します。

効果的な例外処理は、エラーが発生した場合でもアプリケーションが優雅に動作し続けるための鍵です。「過ちは人間のもの、しかしコードは完璧であるべき」という考え方のもと、適切な例外処理によって、予期せぬ状況にも対応できる堅牢なシステムを構築することができます。

これらの原則を日々の開発作業に取り入れることで、メンテナンス性が高く、デバッグしやすい、そして何よりも信頼性の高いJavaアプリケーションを作成することができるでしょう。

Javaの例外処理：5つの鉄則

はじめに

例外処理の基本

鉄則1：状況に合った例外クラスを選びましょう

悪い例

良い例

ガイドライン

鉄則2：例外は必要な範囲でまとめて扱いましょう

悪い例（細かすぎる例外処理）

良い例

ガイドライン

鉄則3：リソースは確実に片付けましょう

悪い例

良い例

ガイドライン

鉄則4：例外は必ず記録に残しましょう

悪い例

良い例

コンテキスト情報を含めたログ記録の例

ガイドライン

鉄則5：独自の例外クラスを上手に使いましょう

基本的なカスタム例外クラス

例外の階層設計

使用例

ガイドライン

実践的なアンチパターンと解決策

アンチパターン1: 空のcatchブロック

解決策

アンチパターン2: 例外のprintStackTrace

解決策

アンチパターン3: 過度に広い例外のキャッチ

解決策

アンチパターン4: 例外を使った制御フロー

解決策

アンチパターン5: 例外メッセージの連結

解決策

まとめ

Discussion