Java Academy · Pelajaran

Transaksi

Commit dan rollback

Pelajaran 3 daripada 413 langkah

Transaksi ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Java Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Apakah Transaksi?

Transaksi mengumpulkan beberapa operasi SQL sebagai satu unit tunggal yang sama ada berjaya sepenuhnya atau gagal sepenuhnya.

Sama ada setiap pernyataan berjaya dan perubahan ditetapkan secara kekal (commit), atau sesuatu gagal lalu semuanya dibatalkan (rollback). Ini memastikan pangkalan data kekal konsisten.

ACID dalam Satu Minit

Transaksi menyediakan jaminan ACID:

Keatomikan — semuanya atau tiada apa-apa.
Ketekalan — memindahkan pangkalan data daripada satu keadaan sah kepada keadaan sah yang lain.
Pengasingan — transaksi serentak tidak merosakkan satu sama lain.
Ketahanan — selepas commit, perubahan kekal walaupun berlaku kerosakan.

Mod Commit Automatik

Secara lalai, sambungan JDBC berjalan dalam mod commit automatik: setiap pernyataan menjadi transaksinya sendiri dan terus commit.

Ini sesuai untuk pernyataan tunggal, tetapi tidak berguna apabila beberapa operasi tulis mesti berjaya bersama-sama. Untuk mengawal transaksi sendiri, matikan commit automatik.

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

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/bank";
        try (Connection conn = DriverManager.getConnection(url, "app", "secret")) {
            System.out.println("Default auto-commit: " + conn.getAutoCommit());
            conn.setAutoCommit(false);
            System.out.println("Now manual: " + conn.getAutoCommit());
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
}

Commit dan Rollback

Apabila commit automatik dimatikan, Anda menentukan sempadannya:

conn.commit() menjadikan semua perubahan yang menunggu kekal.
conn.rollback() membuang perubahan tersebut.

Contoh klasik ialah pemindahan wang: debit satu akaun dan kredit akaun yang lain. Kedua-duanya mesti berlaku, atau kedua-duanya tidak boleh berlaku.

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

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/bank";
        String debit = "UPDATE account SET balance = balance - ? WHERE id = ?";
        String credit = "UPDATE account SET balance = balance + ? WHERE id = ?";
        try (Connection conn = DriverManager.getConnection(url, "app", "secret")) {
            conn.setAutoCommit(false);
            try (PreparedStatement d = conn.prepareStatement(debit);
                 PreparedStatement c = conn.prepareStatement(credit)) {
                d.setInt(1, 100); d.setInt(2, 1); d.executeUpdate();
                c.setInt(1, 100); c.setInt(2, 2); c.executeUpdate();
                conn.commit();
                System.out.println("Transfer committed");
            } catch (SQLException ex) {
                conn.rollback();
                System.out.println("Rolled back: " + ex.getMessage());
            }
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
}

Corak Rollback apabila Berlaku Kegagalan

Struktur yang perlu dihafal:

Matikan commit automatik.
Lakukan kerja di dalam try dalaman.
Jika berjaya, panggil commit().
Dalam catch, panggil rollback() dan lemparkan semula ralat atau rekodkannya.

Tanpa rollback, kegagalan boleh menyebabkan pangkalan data dikemas kini separuh sahaja.

Simulasi Keatomikan

Inilah idea semuanya atau tiada apa-apa yang dimodelkan dalam Java biasa supaya dapat dijalankan secara kendiri. Kami menggunakan dua kemas kini pada satu salinan keadaan; jika salah satu gagal, kami memulihkan salinan tersebut.

public class Main {
    public static void main(String[] args) {
        int[] balances = {500, 300};
        int[] backup = balances.clone();
        try {
            balances[0] -= 200;
            if (balances[0] < 0) throw new IllegalStateException("insufficient funds");
            balances[1] += 200;
            System.out.println("Commit: " + balances[0] + ", " + balances[1]);
        } catch (RuntimeException e) {
            balances = backup;
            System.out.println("Rollback: " + balances[0] + ", " + balances[1]);
        }
    }
}

Titik Simpanan

Titik simpanan ialah penanda di dalam transaksi. Anda boleh melakukan rollback kepadanya tanpa membuang keseluruhan transaksi.

Savepoint sp = conn.setSavepoint()
conn.rollback(sp) hanya membatalkan kerja selepas titik tersebut.

Berguna untuk pemulihan sebahagian dalam transaksi yang panjang.

Tahap Pengasingan

Pengasingan mengawal perkara yang dapat dilihat oleh satu transaksi daripada kerja transaksi lain yang belum commit. JDBC mentakrifkan tahap melalui conn.setTransactionIsolation(...):

TRANSACTION_READ_COMMITTED — lalai yang biasa digunakan.
TRANSACTION_REPEATABLE_READ
TRANSACTION_SERIALIZABLE — paling kukuh dan paling perlahan.

Pengasingan yang lebih tinggi menghalang anomali tetapi mengurangkan keserentakan.

Anomali Bacaan

Pengasingan yang lebih rendah boleh membenarkan:

Bacaan kotor — melihat perubahan transaksi lain yang belum commit.
Bacaan tidak berulang — satu baris berubah antara dua bacaan.
Bacaan hantu — baris baharu muncul dan sepadan dengan pertanyaan sebelumnya.

Pilih tahap terendah yang masih menghalang anomali yang tidak dapat diterima oleh logik Anda.

Pulihkan Commit Automatik

Jika Anda meminjam sambungan daripada kumpulan, pulihkan keadaan asalnya sebelum memulangkannya.

Selepas transaksi manual, tetapkan conn.setAutoCommit(true) semula (atau tetapkan semula kepada nilai yang Anda lihat semasa meminjam) supaya pengguna seterusnya tidak terkejut dengan tetapan Anda.

Pastikan Transaksi Ringkas

Transaksi memegang kunci sehingga ia melakukan commit atau rollback. Transaksi yang panjang menyekat kerja lain dan meningkatkan risiko kebuntuan.

Jangan lakukan panggilan rangkaian yang perlahan atau paparkan gesaan pengguna di dalam transaksi yang sedang dibuka.
Kumpulkan data dahulu, kemudian buka sambungan, tulis, dan lakukan commit dengan cepat.

Transaksi yang ringkas dan terarah lebih mudah diskalakan.

Semakan Pantas

Apakah kesan memanggil connection.rollback()?

Jawab dalam pelajaran interaktif

Ringkasan

Transaksi memberikan keselamatan sama ada semuanya atau tiada apa-apa:

Matikan commit automatik dengan setAutoCommit(false).
Panggil commit() apabila berjaya dan rollback() apabila gagal.
Gunakan titik simpanan untuk rollback sebahagian.
Laraskan tahap pengasingan untuk mengimbangi ketepatan dan keserentakan.
Pulihkan commit automatik sebelum memulangkan sambungan daripada kumpulan.

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 104
Pelajaran: 374

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Transaksi” percuma?

Ya — teks penuh “Transaksi” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Java Academy, tingkat taraf kepada CoddyKit PRO. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Transaksi”?

Commit dan rollback Anda berlatih Java Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Java Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Java Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Transaksi” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy