Spring's @transactional hanya menggulung kembali untuk RuntimeException secara lalai. 2. Adalah perlu untuk menentukan bahawa pengecualian juga dilancarkan melalui rollbackfor. 3. Tingkah laku penyebaran yang diperlukan adalah nilai lalai. Memerlukan_new akan menggantung transaksi semasa. 4. Panggilan diri akan menyebabkan urus niaga gagal disebabkan kegagalan proksi. 5. Adalah disyorkan untuk menggunakan urus niaga deklaratif di lapisan perkhidmatan dan mengekalkan urus niaga pendek untuk meningkatkan prestasi. Akhirnya, tingkah laku urus niaga perlu disahkan melalui ujian untuk memastikan konsistensi data.

Menguruskan urus niaga dengan betul adalah kejam untuk mengekalkan integriti data dalam aplikasi Java, terutamanya ketika bekerja dengan pangkalan data. Dalam aplikasi perusahaan, urus niaga biasanya melibatkan pelbagai operasi yang mesti berjaya -atau, jika ada yang gagal, segala -galanya mesti dilancarkan kembali untuk mengekalkan konsistensi. Java dan Rangka Kerja Spring menyediakan alat yang berkuasa untuk mengendalikan pengurusan urus niaga dengan berkesan. Berikut adalah panduan praktikal untuk memahami dan melaksanakan pengurusan transaksi di Java dan Spring.

1. Apakah Pengurusan Transaksi?

Urus niaga adalah urutan operasi yang dilakukan sebagai unit kerja logik tunggal. Ia mesti memenuhi sifat asid:

• Atomicity : Semua operasi dalam transaksi berjaya atau gagal bersama -sama.
• Konsistensi : Pangkalan data kekal dalam keadaan yang konsisten sebelum dan selepas transaksi.
• Pengasingan : Urus niaga serentak tidak mengganggu satu sama lain.
• Ketahanan : Setelah dilakukan, perubahan kekal.

Di Java, pengurusan urus niaga boleh dikendalikan sama ada secara programatik (dengan kawalan eksplisit) atau deklaratif (menggunakan anotasi atau konfigurasi), dengan musim bunga yang memihak kepada yang terakhir.

2. Pengurusan Transaksi di Java Plain (JDBC)

Sebelum musim bunga, JDBC mentah biasanya digunakan, di mana urus niaga diuruskan secara manual menggunakan objek Connection .

 Sambungan conn = datasource.getConnection ();
Cuba {
    conn.setAutocommit (false); // Mula transaksi

    // melaksanakan operasi db
    jdbctemplate.update ("Kemas kini akaun set baki = baki -? Where id =?", 100, 1);
    jdbctemplate.update ("Kemas kini akaun set baki = baki? Di mana id =?", 100, 2);

    conn.commit (); // komit jika semua berjaya
} menangkap (pengecualian e) {
    conn.rollback (); // rollback atas kesilapan
    membuang e;
} akhirnya {
    conn.setautocommit (true);
    conn.close ();
}

Isu dengan Transaksi JDBC Manual :

• Rawan ralat (mudah dilupakan rollback atau tutup).
• Kod boilerplate.
• Sukar untuk mengekalkan dan menguji.

Di sinilah abstraksi Spring menjadi berharga.

3. Abstraksi Transaksi Spring

Spring menyediakan model urus niaga yang konsisten yang menyokong kedua -dua pengaturcaraan dan pengurusan transaksi deklaratif , menghilangkan API transaksi yang mendasari (JDBC, JPA, JTA, dll.).

Komponen utama:

• PlatformTransactionManager : antara muka teras (misalnya, DataSourceTransactionManager , JpaTransactionManager ).
• @Transactional : Anotasi untuk penandaan transaksi deklaratif.
• TransactionTemplate : Untuk kawalan programatik.

4. Pengurusan Transaksi Deklaratif dengan @Transactional

Ini adalah pendekatan yang paling biasa dan disyorkan pada musim bunga.

Langkah 1: Dayakan pengurusan transaksi

Tambah @EnableTransactionManagement ke kelas konfigurasi anda (biasanya tidak diperlukan dalam boot musim bunga, kerana ia dikonfigurasi auto).

 @Configuration
@EnableTransactionManagement
Transaksi Kelas Awam Konfigurasi {
    @Bean
    platform awamTransactionManager TransactionManager (DataSource DataSource) {
        kembali DataSourCetRansActionManager baru (DataSource);
    }
}

Langkah 2: Gunakan @Transactional pada kaedah perkhidmatan

 @Service
Bankservice kelas awam {

    @Autowired
    Jdbctemplate swasta jdbctemplate;

    @Transactional
    public void TransferMoney (Long FromID, Long Toid, Double Amaun) {
        jdbctemplate.update ("Kemas kini akaun set baki = baki -? di mana id =?", amaun, dari id);
        jdbctemplate.update ("Kemas kini akaun set baki = baki? Where id =?", Amaun, toid);
        // Sekiranya pengecualian berlaku, kedua -dua kemas kini dilancarkan
    }
}

Bagaimana ia berfungsi:

• Spring mencipta proksi di sekitar kacang BankService .
• Apabila transferMoney() dipanggil, proksi memulakan transaksi.
• Jika kaedah selesai secara normal → transaksi dilakukan.
• Sekiranya pengecualian yang diperiksa atau tidak terkawal dilemparkan → Transaksi Rolls kembali (secara lalai, hanya untuk pengecualian yang tidak terkawal).

5. Memahami tingkah laku @Transactional

@Transactional mempunyai beberapa atribut dengan tingkah laku yang baik:

Contoh: Rollback pada pengecualian yang diperiksa

Secara lalai, Spring hanya menggulung kembali untuk pengecualian yang tidak terkawal (subclass RuntimeException ). Untuk memasukkan pengecualian yang diperiksa:

 @Transactional (rollbackfor = exception.class)
public void TransferMoney (rentetan, rentetan ke, jumlah ganda) melemparkan ioException {
    // logik perniagaan
    jika (jumlah <= 0) membuang ioException baru ("jumlah tidak sah");
}

Sekarang, IOException akan mencetuskan pengembalian semula.

6. Tingkah laku penyebaran: mengendalikan panggilan bersarang

Salah satu aspek yang paling disalahpahami ialah penyebaran transaksi .

Nilai Biasa:

• REQUIRED (lalai): Gunakan transaksi sedia ada, atau buat yang baru.
• REQUIRES_NEW : Sentiasa menangguhkan transaksi semasa dan memulakan yang baru.
• SUPPORTS : Jalankan dalam transaksi jika wujud, jika tidak transaksional.

Contoh: Menggunakan REQUIRES_NEW

 @Service
Kelas Public Paymentservice {

    @Autowired
    Auditservice Auditservice peribadi;

    @Transactional
    Processpayment void public () {
        // bahagian urus niaga luar
        jdbctemplate.update ("masukkan ke dalam pembayaran ...");

        // Memulakan transaksi baru; Sekiranya ini gagal, luar masih boleh melakukan
        auditService.logPayment ();

        // Teruskan transaksi luar
    }
}

@Service
Auditservice kelas awam {

    @Transactional (penyebaran = propagation.requires_new)
    public void logPayment () {
        jdbctemplate.update ("Masukkan ke dalam audit_log ...");
        // walaupun ini gagal, pemprosesan pembayaran mungkin masih dilakukan
    }
}

Penggunaan REQUIRES_NEW dengan teliti -terutamanya jika anda memerlukan konsistensi yang kuat.

7. Perangkap biasa dan amalan terbaik

? Pencegahan diri memecahkan proksi

Jika kaedah dalam kelas yang sama memanggil kaedah @Transactional secara langsung, urus niaga tidak digunakan kerana ia memintas proksi.

 @Service
kelas awam selfcallproblem {

    metoda void awam () {
        kaedahBB (); // Tiada transaksi! Panggilan langsung, tiada proksi
    }

    @Transactional
    kaedah void publicb () {
        // tidak transaksional apabila dipanggil dari metoda
    }
}

? Betulkan : Suntikan perkhidmatan ke dalam logik sendiri atau reflektor.

? Amalan terbaik

• Sapukan @Transactional pada lapisan perkhidmatan , bukan DAO/repositori.
• Pastikan urus niaga pendek dan fokus untuk mengurangkan pertarungan kunci.
• Lebih suka deklaratif atas pengurusan pengaturcaraan.
• Gunakan readOnly = true untuk kaedah pertanyaan untuk meningkatkan prestasi.
• Berhati -hati dengan REQUIRES_NEW -it boleh menyebabkan kegagalan separa.
• Ujian Tingkah Laku Transaksi Menggunakan TestTransaction dalam ujian integrasi.

8. Pengurusan Transaksi Programmatik (apabila anda memerlukan lebih banyak kawalan)

Kadang-kadang anda memerlukan kawalan halus. Gunakan TransactionTemplate :

 @Service
kelas awam CustomTransactionService {

    @Autowired
    TransactionTemplate TransactionTemplate;

    public void processData () {
        TransactionTemplate.Execute (status -> {
            Cuba {
                jdbctemplate.update ("masukkan ke ...");
                kembali benar;
            } menangkap (pengecualian e) {
                status.setrollBackOnly ();
                kembali palsu;
            }
        });
    }
}

Berguna untuk logik bersyarat atau apabila @Transactional terlalu tegar.

9. Pengurusan Transaksi di Spring Boot

Spring Boot Auto-Configures Pengurusan Transaksi Jika ia mengesan:

• DataSource
• Data Spring JPA atau serupa

Tambah sahaja:

 <geterlihat>
    <groupId> org.springframework.boot </groupId>
    <stifactid> Spring-Boot-Starter-Data-JPA </artifactid>
</ketergantungan>

Kemudian gunakan @Transactional secara bebas -tidak ada persediaan tambahan yang diperlukan.

Pemikiran terakhir

Pengurusan Transaksi Spring sangat memudahkan bekerja dengan operasi yang mematuhi asid. Dengan menggunakan @Transactional dengan bijak dan memahami penyebaran, pengasingan, dan peraturan rollback, anda boleh membina aplikasi yang mantap dan boleh dipelihara.

Kuncinya adalah:

• Gunakan transaksi deklaratif secara lalai.
• Faham bagaimana proksi berfungsi.
• Elakkan urus niaga jangka panjang.
• Kes -kes kelebihan ujian yang melibatkan pengecualian dan panggilan bersarang.

Dengan amalan ini, anda akan mengelakkan ketidakkonsistenan data biasa dan membina sistem yang lebih dipercayai.

Pada asasnya, biarkan Spring mengendalikan boilerplate -jadi anda boleh memberi tumpuan kepada logik perniagaan.

Atas ialah kandungan terperinci Panduan Pengurusan Transaksi di Jawa dan Rangka Kerja Spring. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!