Javaトランザクション処理の全て！プログラミング初心者からプロへの10ステップ

はじめに

Javaでデータベース更新を扱うなら、複数のSQLをひとまとまりにして成功か失敗かをそろえる設計が必要になります。その設計の中心にあるのがトランザクション処理で、送金、注文、在庫更新、バッチ登録のように複数テーブルをまたぐ処理で特に差が出ます。

プログラミング初心者がつまずきやすいのは、commitとrollbackを単なる命令として覚え、どの範囲を一つの処理単位にするかを後回しにしてしまう点です。そのため、JavaのConnection、PreparedStatement、SQLException、Springの@Transactionalを、トランザクション管理の観点からつなげて整理するのが目安です。

公式ドキュメントによれば、JDBCのConnectionにはsetAutoCommit、commit、rollback、setTransactionIsolationなどのトランザクション制御用メソッドが用意されています。詳細はOracle Java SE 21 Connection API、Springの宣言的制御はSpring Framework Transaction Managementが一次情報になります。

Javaとは？

Javaは、仮想マシン上で動作するオブジェクト指向のプログラミング言語です。ソースコードをjavacでコンパイルすると.class形式のバイトコードになり、JVMが各OS上で実行するため、同じアプリケーションを複数環境へ展開しやすくなります。

その特徴は、Webアプリケーション、Android系アプリ、業務システム、バッチ処理、APIサーバーで広く利用される理由につながります。特にデータベースを扱うJavaアプリでは、JDBC、DataSource、EntityManager、TransactionManagerなどが関係し、トランザクション処理の理解が実装品質を左右するのがポイントです。

Javaの基本的な特徴

一般に、Javaの特徴は静的型付け、クラスベースの設計、自動メモリ管理、標準APIの厚さに整理できます。String、List、Map、Optional、Streamなどの標準的な型を組み合わせることで、業務ロジックを比較的読みやすく構成できます。

そのうえで、データベース操作ではtry、catch、finally、try-with-resourcesの扱いが欠かせません。接続を閉じ忘れるとconnection poolの枯渇につながり、トランザクション管理の失敗はロック保持時間やデッドロックの発生にも影響するのが一般的です。

これらの基礎を押さえると、プログラミング初心者でもサンプルコードの意味を追いやすくなります。Java List型の基礎やJavaアノテーションの考え方も合わせて読むと、後半の@Transactionalを理解しやすくなります。

Javaと他のプログラム言語（TypeScript, Python, JS）の違い

Javaはコンパイル時の型検査が強く、長く運用する業務システムで設計意図を保ちやすい言語です。一方、TypeScriptはJavaScriptに型を加える形でフロントエンドからバックエンドまで扱いやすく、ブラウザ周辺の開発と相性があるのが現実的です。

Pythonは記述量を抑えやすく、データ分析や自動化で利用されます。ただし、JavaはThread、ExecutorService、synchronized、CompletableFutureなどの並行処理APIと、データベース接続の仕組みを組み合わせた堅めのサーバー実装に向いています。

JavaScriptは主にブラウザとNode.jsで使われ、イベント駆動の処理に強みがあると整理できます。逆に、Javaは型、パッケージ、ビルド、テスト、デプロイの分離が明確で、トランザクション処理を含む業務ロジックを層に分けて保守しやすい構造を作れます。

トランザクション処理とは？

結論から言うと、トランザクション処理は複数の操作を一つの単位として扱い、全て成功したら確定し、途中で失敗したら元に戻す仕組みです。JavaではautoCommitを切り替え、処理の最後にcommitまたはrollbackを呼ぶ形が基本になります。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class TransactionExample {
    public static void main(String[] args) {
        try {
            Connection connection = DriverManager.getConnection("jdbc:yourdatabaseurl", "username", "password");
            connection.setAutoCommit(false);

            // ここでデータベースの操作を行います

            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

結果: 期待される動きは、接続取得後に自動コミットが無効になり、明示的なcommitまで変更が確定しない状態になることです。

このサンプルコードは最小構成なので、例外時のrollbackや接続のクローズを省いています。そのため、実務的なJavaのトランザクション管理では、後述するtry-catch-finallyやtry-with-resourcesを組み合わせます。

トランザクション処理の必要性

銀行送金では、送金元から金額を減らす処理と送金先へ金額を増やす処理が対になると理解できます。片方だけが成功すると残高の整合性が崩れるため、トランザクション処理によって両方を成功または失敗にそろえます。

その考え方はECサイトの注文にも当てはまります。注文登録、在庫減算、決済記録、ポイント付与を別々に確定してしまうと、障害時に注文だけ残り在庫が減らない状態や、決済だけ成功して注文が存在しない状態が起こりえますし、ここがポイントです。

こうした不整合を避けるには、Javaのサービス層で処理範囲を決め、DBの制約とアプリケーションの例外処理をそろえる必要があります。トランザクション管理は単なるAPI呼び出しではなく、業務上どこまでを一つの成功条件にするかを表す設計です。

トランザクションの基本的なプロパティ

トランザクション処理の信頼性は、ACIDという性質で説明されます。Atomicityは全体の成功または取り消し、Consistencyは制約を満たす状態の維持、Isolationは同時実行時の見え方、Durabilityは確定後の永続性を表すると覚えるとよいでしょう。

プログラミング初心者は、ACIDを暗記語として扱うより、送金や在庫更新の失敗例に当てはめると理解しやすくなります。たとえばIsolationが弱い設定では、他のトランザクションの途中状態を読んだり、同時更新で待ちが増えたりする場合があります。

ただし、分離を強くすれば常に良いという話ではありません。TRANSACTION_SERIALIZABLEは整合性を強めますが、待ち時間やデッドロックの可能性が増えるため、読み取り中心か更新中心か、競合が多いか少ないかで選びますが、これは押さえたい点です。

💡 Tips: ACIDは個別の用語として覚えるより、失敗時に戻せるか、同時実行時に矛盾しないか、確定後に失われないかという観点で読むと整理しやすくなります。

Javaでのトランザクション処理の設計

Javaでトランザクション処理を設計するときは、DB接続、SQL実行、例外処理、確定、取り消し、リソース解放を一つの流れとして扱います。特にConnectionをどこで作り、どこで閉じるかは、トランザクション管理の境界そのものになります。

その境界が曖昧なまま複数メソッドへ処理を分散すると、あるSQLは確定され、別のSQLはロールバックされるような読みにくい構造になりがちです。Javaのサービス層では、業務上の一操作を表すメソッドにトランザクション境界を置く構成がよく使われますし、これが一つの目安です。

クラスとメソッドの準備

基本構成では、Connectionを取得し、setAutoCommit(false)で手動制御に切り替えます。その後、PreparedStatementでSQLを実行し、成功時にcommit、失敗時にrollbackを呼ぶ流れにします。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class TransactionExample {
    public static void main(String[] args) {
        try {
            Connection connection = DriverManager.getConnection("jdbc:yourdatabaseurl", "username", "password");
            connection.setAutoCommit(false);

            // ここでデータベースの操作を行います

            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

結果: 期待される動きは、トランザクション開始後の変更がcommitまで確定しない状態になることです。

このコードは元記事の基本例を保持したものです。ただし、例外時にrollbackが呼ばれないため、実運用に近いサンプルコードでは例外処理とクローズ処理を加える必要があります。

トランザクション処理の流れ

トランザクション処理の流れは、接続の取得、自動コミットの解除、SQLの実行、成功時の確定、失敗時の取り消しという順番になります。この順番が崩れると、例外時の復旧やデッドロック時の再試行を組み込みにくくなると考えられます。

1. データベースへの接続を確立します。
2. setAutoCommit(false)で自動コミットを止めます。
3. PreparedStatementで必要なSQLを実行すると言えるでしょう。
4. 全ての操作が成功した場合はcommit()で変更を確定します。
5. SQLExceptionなどが発生した場合はrollback()で開始前の状態へ戻します。

そのため、Javaのトランザクション管理では、正常系だけでなく異常系の設計を同時に書くことが欠かせません。Javaのエスケープ処理で文字列やSQL断片の扱いを整理しておくと、SQL生成時の事故も減らしやすくなるのが基本です。

実践！Javaでのトランザクション処理の基本的な使い方

Javaでトランザクション処理を実装する基本は、開始と終了を明示し、DB更新が成功した場合だけ確定することです。サンプルコードでは省略したDB定数をDB_URL、USER、PASSとして扱いるのが目安です。

具体的には、INSERT、SELECT、UPDATE、DELETEを同じ接続上で実行し、処理単位が終わったところでcommitします。プログラミング初心者は、SQLごとに接続を作り直さない点に注意すると流れを追いやすくなります。

トランザクションの開始と終了

デフォルトのJDBC接続は、多くの場合autoCommitが有効です。そのままだとSQLごとに確定されるため、複数SQLを一つのトランザクション処理として扱うにはsetAutoCommit(false)を呼びますが、覚えておくと役立つでしょう。

Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
conn.setAutoCommit(false); // トランザクションを開始
// 何らかのデータベース操作
conn.commit(); // トランザクションをコミット(終了)

結果: 期待される動きは、データベース操作がconn.commit()まで確定されず、同じ接続内で一つの処理単位として扱われることです。

この形は簡単ですが、例外時にrollbackがないため完成形ではありません。一方、開始と終了の位置を確認する最小のサンプルコードとしては、トランザクション処理の輪郭をつかみやすい構成です。

サンプルコード1：データの追加と取得

追加と取得を同じトランザクションで扱うと、登録したデータを同じ処理内で読み返す流れを確認できます。PreparedStatementの?に値を渡すことで、SQLと値を分離して扱えます。

Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
conn.setAutoCommit(false);

PreparedStatement psInsert = conn.prepareStatement("INSERT INTO users (name, age) VALUES (?, ?)");
psInsert.setString(1, "Tanaka");
psInsert.setInt(2, 25);
psInsert.executeUpdate();

PreparedStatement psSelect = conn.prepareStatement("SELECT name, age FROM users WHERE name = ?");
psSelect.setString(1, "Tanaka");
ResultSet rs = psSelect.executeQuery();

while(rs.next()){
    String name = rs.getString("name");
    int age = rs.getInt("age");
    System.out.println("Name: " + name + ", Age: " + age);
}

conn.commit();

結果: 期待される出力は、対象データが存在する場合にName: Tanaka, Age: 25という形式でコンソールへ表示されることです。

このサンプルコードでは、executeUpdateで登録し、executeQueryで取得しています。そのため、更新系SQLと参照系SQLでメソッドが異なる点も同時に確認できます。

サンプルコード2：データの更新と削除

更新と削除を同じトランザクションで扱う場合、どちらかが失敗したときに全体を取り消せる設計にするのがポイントです。削除前に更新する意味があるかは業務要件次第ですが、複数更新をまとめる例として読みやすい形です。

Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
conn.setAutoCommit(false);

// ユーザー情報の更新
PreparedStatement psUpdate = conn.prepareStatement("UPDATE users SET age = ? WHERE name = ?");
psUpdate.setInt(1, 26);
psUpdate.setString(2, "Tanaka");
psUpdate.executeUpdate();

// ユーザー情報の削除
PreparedStatement psDelete = conn.prepareStatement("DELETE FROM users WHERE name = ?");
psDelete.setString(1, "Tanaka");
psDelete.executeUpdate();

conn.commit();

結果: 期待される動きは、Tanakaの年齢更新と削除が同じ確定単位に入り、commit後に変更が保存されることです。

ただし、このコードにも例外時のrollbackとリソース解放が含まれていません。Javaで安全に扱うには、更新件数をint updatedとして受け取り、想定件数と違う場合に例外へつなげる設計も検討します。

サンプルコード3：エラーハンドリング

エラーハンドリングを入れると、トランザクション処理は実用に近づきます。SQLExceptionが発生した場合はrollbackし、最後にcloseで接続を解放する流れにするのが一般的です。

Connection conn = null;

try{
    conn = DriverManager.getConnection(DB_URL, USER, PASS);
    conn.setAutoCommit(false);

    // 何らかのデータベース操作

    conn.commit();
} catch(SQLException e) {
    if(conn != null) {
        conn.rollback(); // エラーが発生した場合はロールバック
    }
    e.printStackTrace();
} finally {
    if(conn != null) {
        conn.close();
    }
}

結果: 期待される動きは、正常時にcommitされ、SQLException発生時にはrollback後に接続が閉じられることです。

この形ではrollback自体がSQLExceptionを投げる可能性もあります。より堅く書くなら、rollback失敗時のログ出力、try-with-resources、アプリケーション例外への変換を組み合わせます。

トランザクション処理の注意点

トランザクション処理で注意したいのは、範囲を広げすぎないこと、ロックの順序をそろえること、分離レベルを目的に合わせることです。Javaコードだけを見ていても、DB側のロックや制約が関係するため、SQL設計と合わせて判断するのが現実的です。

そのため、デッドロック、タイムアウト、ロールバック条件、接続プールの設定は別々の問題ではありません。トランザクション管理の失敗は、処理遅延、再試行の増加、ユーザー操作の失敗として表面化します。

デッドロックの回避方法

デッドロックは、複数の処理が互いに相手のロック解放を待ち続ける状態です。Java側ではsynchronizedの取得順序、DB側では行ロックやテーブルロックの取得順序が影響します。

この状態を避けるには、複数リソースを扱う順番を統一すると整理できます。たとえば口座Aと口座Bを更新するなら、口座番号の小さい順にロックするなど、全処理で同じ規則を採用します。

public class TransactionExample {
    private Object Resource1 = new Object();
    private Object Resource2 = new Object();

    public void method1() {
        synchronized (Resource1) {
            // 一部の処理
            synchronized (Resource2) {
                // リソース1とリソース2を使用した処理
            }
        }
    }

    public void method2() {
        synchronized (Resource2) {
            // 一部の処理
            synchronized (Resource1) {
                // リソース2とリソース1を使用した処理
            }
        }
    }
}

結果: 期待される読み取り方は、method1とmethod2でロック取得順序が逆になっており、デッドロックの原因になりうる構造だと判断することです。

このサンプルコードは、避けたい設計例として扱うと理解しやすくなります。修正する場合は、両方のメソッドでResource1からResource2の順に取得するなど、順序を固定します。

イソレーションレベルの設定

イソレーションレベルは、同時に動くトランザクション同士の見え方を制御します。JavaではConnection.TRANSACTION_READ_COMMITTED、Connection.TRANSACTION_REPEATABLE_READ、Connection.TRANSACTION_SERIALIZABLEなどをsetTransactionIsolationへ渡します。

一方、利用できる分離レベルや既定値はDB製品で異なると覚えるとよいでしょう。そのため、Javaコードだけで判断せず、PostgreSQL、MySQL、Oracle Databaseなど対象DBの公式ドキュメントも確認します。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class IsolationLevelExample {
    public static void main(String[] args) {
        try {
            Connection conn = DriverManager.getConnection("jdbc:yourdatabaseurl", "username", "password");
            conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            // トランザクション処理
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

結果: 期待される動きは、取得したConnectionにTRANSACTION_SERIALIZABLEが設定され、以後のトランザクションで高い分離が要求されることです。

ただし、SERIALIZABLEは競合が増えやすく、待ち時間やデッドロックの原因になる場合があります。読み取りの整合性、更新頻度、レスポンス要件を見比べ、必要な範囲だけに適用します。

トランザクション処理のカスタマイズ方法

トランザクション処理のカスタマイズ方法は、手動でConnectionを制御する方法と、Springなどのフレームワークで宣言的に制御する方法に分かれますし、ここを基本と考えるとよいでしょう。Javaアプリ全体で統一するなら、サービス層に@Transactionalを置く設計がよく採用されます。

具体的なカスタマイズ方法としては、timeout、readOnly、rollbackFor、propagation、isolationの調整があります。これらは性能を上げる魔法ではなく、処理の性質をフレームワークへ伝えるための設定です。

カスタマイズの基本

読み取りだけの処理にはreadOnly = trueを付け、長時間化を避けたい処理にはtimeoutを設定すると考えられます。更新処理では、どの例外でロールバックするかをrollbackForで明示すると、検査例外を扱う処理でも意図が伝わりやすくなります。

その一方で、@TransactionalはSpringのプロキシを通して効く仕組みが一般的です。同じクラス内の自己呼び出しでは期待どおりにトランザクションが開始されない場合があるため、サービスの分割や呼び出し経路を設計段階で確認します。

カスタマイズ方法を決めるときは、読み取り系、単発更新、複数テーブル更新、外部API連携を分けて考えますし、ここがポイントです。外部API呼び出しをトランザクション内に入れるとロック時間が伸びるため、DB更新との順番や補償処理を設計します。

サンプルコード4：カスタムトランザクション属性の利用

Springの@Transactionalを使うと、メソッド単位でトランザクション属性を宣言できます。プログラミング初心者は、アノテーションを付ければ常に同じ動きになると考えず、属性ごとの意味を確認すると言えるでしょう。

import org.springframework.transaction.annotation.Transactional;

public class CustomTransactionService {

    @Transactional(timeout = 500, readOnly = true)
    public void readOnlyTransactionMethod() {
        // 読み取り専用のトランザクション処理をここで行います。
        // このメソッドは500ミリ秒以上かかるトランザクションを許可せず、読み取り専用として設定されています。
    }

    @Transactional(timeout = 500, readOnly = false, rollbackFor = Exception.class)
    public void writeTransactionMethod() throws Exception {
        // 書き込みを含むトランザクション処理をここで行いるのが基本です。
        // このメソッドは500ミリ秒以上かかるトランザクションを許可せず、例外が発生した場合にロールバックするのが基本です。
    }
}

結果: 期待される動きは、読み取り専用メソッドと書き込みメソッドで、timeout、readOnly、rollbackForの扱いが分かれることです。

このサンプルコードでは、読み取り処理にreadOnly = true、書き込み処理にrollbackFor = Exception.classを付けています。Springでは実行時例外が標準のロールバック対象になるため、検査例外も戻したい場合にrollbackForが役立ちます。

ただし、timeout = 500の単位や扱いは利用するトランザクションマネージャーの仕様に従いるのが目安です。実装時はSpringの公式ドキュメントと採用DBの仕様を確認し、過剰に短い値で正常処理まで失敗させないようにします。

Javaにおけるトランザクション処理の応用例

Javaにおけるトランザクション処理は、単純な登録画面だけでなく、大規模システムのバッチ、メッセージ処理、外部サービス連携にも関係します。応用では、どこまでをDBトランザクションで守り、どこからを再実行や補償処理で守るかを分けますが、これは押さえたい点です。

そのため、全てを一つの巨大なトランザクションに入れる設計は避けます。処理時間が長くなるほどロック保持時間が伸び、デッドロックやタイムアウトの発生確率も上がります。

事例1：大規模システムにおけるトランザクション処理

大規模システムでは、注文、請求、在庫、配送、通知のように複数の責務が連動するのがポイントです。単一DBの中で完結するなら一つのトランザクション処理で守れますが、外部決済やメッセージキューをまたぐ場合は分散トランザクションや補償トランザクションの検討が必要になります。

一般的には、DB更新を短いトランザクションで確定し、その後に非同期処理で通知や連携を行う構成が扱いやすくなります。JavaではSpring Batch、TaskExecutor、MessageListenerなどとトランザクション管理を組み合わせる場面があるのが一般的です。

このとき、失敗時に同じ処理を再実行しても結果が二重にならない冪等性も考えます。注文番号や処理IDにユニーク制約を付ける、処理済み状態をstatus列で管理する、更新件数を確認する、といった設計が候補になります。

サンプルコード5：バッチ処理でのトランザクション管理

バッチ処理では、全件を一度に確定するか、一定件数ごとに確定するかで障害時の戻し方が変わりますし、これが一つの目安です。大量データでは、チャンク単位でトランザクションを区切ると、ロック時間と再処理範囲を抑えやすくなります。

import javax.transaction.Transactional;

public class BatchProcessing {

    @Transactional
    public void executeTransaction() {
        try {
            // データベースへのデータ追加処理
            addData();
            // データベースからのデータ取得処理
            retrieveData();
        } catch (Exception e) {
            // エラーハンドリング処理
            handleException(e);
        }
    }

    private void addData() {
        // データ追加の具体的な処理を記述
    }

    private void retrieveData() {
        // データ取得の具体的な処理を記述
    }

    private void handleException(Exception e) {
        // エラーハンドリングの具体的な処理を記述
    }
}

結果: 期待される動きは、executeTransaction内の追加処理と取得処理が一つのトランザクション管理対象として扱われることです。

このコードは構造を示す簡易例ですが、catch内で例外を握りつぶすとフレームワークがロールバックを判断できない場合があります。そのため、エラー処理後に再スローするか、ロールバック専用の例外へ変換する設計を検討します。

サンプルコード6：try-with-resourcesで接続を閉じる

JDBCを直接扱う場合は、try-with-resourcesでConnectionやPreparedStatementを閉じる書き方も使えるのが現実的です。サンプルコードとして、更新後に成功なら確定し、失敗なら取り消す流れを示します。

try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASS)) {
    conn.setAutoCommit(false);

    try (PreparedStatement ps = conn.prepareStatement(
            "UPDATE users SET age = ? WHERE name = ?")) {
        ps.setInt(1, 27);
        ps.setString(2, "Tanaka");
        ps.executeUpdate();
    }

    conn.commit();
} catch (SQLException e) {
    // rollbackが必要な場合は、Connectionを外側で保持する設計にします。
    throw e;
}

結果: 期待される動きは、PreparedStatementとConnectionが自動的に閉じられ、成功時にはcommitされることです。

ただし、この形ではcatch側からconn.rollback()を呼びにくいため、ロールバックを明示するならConnection conn = nullの形を選ぶ場合もあると整理できます。Javaのサンプルコードは短さだけで選ばず、失敗時の扱いまで含めて比較します。

まとめ

Javaのトランザクション処理は、複数のデータベース操作を成功または失敗にそろえるための設計です。setAutoCommit(false)、commit、rollbackの基本を押さえると、JDBCの手動制御とSpringの宣言的制御をつなげて理解できます。

その理解を深めるには、ACID、分離レベル、デッドロック、タイムアウト、ロールバック条件を別々に暗記せず、実際の業務処理へ当てはめて考えるのが現実的です。プログラミング初心者は、サンプルコードの正常系だけでなく、失敗時にどのデータが戻るのかを読み取る習慣を付けると学習が進みますが、覚えておくと役立つでしょう。

トランザクション管理をカスタマイズする段階では、@TransactionalのreadOnly、timeout、rollbackFor、isolationを目的に合わせて使い分けます。カスタマイズ方法を誤ると、整合性を守るつもりで処理遅延やデッドロックを増やす場合があるため、DB仕様とフレームワーク仕様を合わせて確認します。

Javaの周辺知識として、条件分岐を使ったうるう年判定、オーバーライドの基礎、アノテーションの使い方も押さえると、サービス層やドメイン層の設計が読みやすくなると理解できます。トランザクション処理は単独の文法ではなく、Javaアプリケーション全体の責務分割と結び付く技術です。

関連記事

• Java List型完全ガイド！初心者でもマスターできる7つのステップ
• Javaアノテーションの12選！初心者から上級者まで徹底ガイド
• Javaでうるう年を判定！初心者でも分かる9ステップ解説
• Javaエスケープ処理の10ステップマスターガイド
• Javaでマスターする！オーバーライドのたった7つのステップ

※本記事は実在のエンジニア複数名で構成される Japanシーモア編集部が、AI支援を活用して作成・校正・公開しています。