Kata pengantar
Artikel ini terutama mencatat bagaimana Spring mendukung hal -hal, dan bagaimana hal itu hanya mengimplementasikan hal -hal database ketika Spring menggabungkan mybatis. Saya tidak akan banyak bicara tentang hal itu di bawah ini, mari kita lihat perkenalan yang terperinci bersama.
case1: hal -hal mendukung situasi dalam dua tabel
Pertama persiapkan dua tabel, satu tabel pengguna dan satu tabel cerita, strukturnya adalah sebagai berikut
Buat tabel `user` (` id` int (11) unsigned not null auto_increment, `name` varchar (20) not null default '' comment 'username',` pwd` varchar (26) bukan null default '' komentar ', `var` no (1) not null' 0, null '0, `non` no (1) not null ’null’, `noLAULT` not null (1) not null' null ’null’ nol ` `update` varchar (13) bukan null default '0', kunci primer (` id`), kunci `name` (` name`)) engine = innodb default charset = utf8mb4; buat tabel `story` (` id` int (11) unsign not null auto_increment, `userid` name '`name'` `` 20) tidak ada nol auto_increment `` user `` `` `` `` `` `` `name` `` `` name `` `name 'name` `` name' name `20) varchar (20) bukan null default '' komentar 'penulis', `title` varchar (26) not null default '' komentar 'kata sandi',` cerita` komentar teks 'konten cerita', `isdeleted` tinyint (1) not null default '0',` dibuat` varchar (13) not null default '0, `` `` `` `` varchar (13) not null default', `` `,` `,` ID `,` varchar (13) not null default ', ``, `` null `,` null null `,` null null ` `userid` (` userid`)) engine = innodb default charset = utf8mb4;
Situasi kami adalah bahwa ketika pengguna memodifikasi nama, nama -nama kedua tabel perlu dimodifikasi bersama, dan ketidakkonsistenan tidak diizinkan.
CASE2: Dukungan benda tabel tunggal
Transfer uang, satu pengguna mengurangi uang, pengguna lain meningkatkan uang
Buat tabel `money` (` id` int (11) Unsigned not null auto_increment, `name` varchar (20) bukan null default '' komentar 'nama pengguna',` money` int (26) bukan null default '0' money ', `isdeleted tinyInt (1) not null default' 0,` dEFORICE `nol` non nol `nol` nol `nol` nol `nol` nol `nol` nol varchar (13) bukan null default '0', kunci utama (`id`), tombol` name` (`name`)) engine = innodb default charset = utf8mb4;
Dibandingkan dengan kasus di atas, ini lebih sederhana. Contoh -contoh berikut terutama dijelaskan berdasarkan ini. Adapun kasus1, dibiarkan diperluas.
Pertama, terapkan DAO dan entitas yang sesuai
@DataPublic Class MoneyEntity mengimplementasikan serializable {private static final long serialversionuid = -7074788842783160025l; Private Int ID; nama string pribadi; uang int pribadi; intelitas pribadi; int private int dibuat; private int diperbarui;} antarmuka publik moneydao {moneyEntity queryMoney (@param ("id") int userid); // tambahkan uang, saat negatif, itu berarti mengurangi uang int incrementmoney (@param ("id") int userid, @param ("addmoney") int addmoney);}File mapper yang sesuai adalah
<? Xml Version = "1.0" encoding = "utf-8"?> <! Doctype mapper public "-// mybatis.org//dtd mapper 3.0 // en" "http://mybatis.org/dtd/mybatis-3-mapper namespace = "com.git.hui.demo.mybatis.mapper.moneydao"> <sql id = "moneyEntity"> id, `name`,` money`, `isdeleted`,` dibuat`, `updated` </sql> <pilih id =" queryon `` dibuat `</sql> <pilih id =" query `` buatan ` resultType = "com.git.hui.demo.mybatis.entity.moneyentity"> pilih <incerted refid = "moneyEntity"/> dari uang di mana id =#{id} </pilih> <update id = "incrementmoney"> Update money set = money = {addmoney} di mana id =#{orcrementmoney "> Money Set Money = Money +#{addMoney} di mana id =#{£ {{IncrementMoney"> Money = Money = Money +#{AddMoney} di mana id =#{oPrementMoney "Konfigurasi yang sesuai dari sumber data koneksi mybatis
<bean> <name properti = "lokasi"> <value> classpath*: jdbc.properties </ value> </prop Property> </ bean> <bean id = "DataSource" init-method = "init" dashing-method = "tutup"> <nama properti = "$" name = "name $" name="username" value="${username}"/> <property name="password" value="${password}"/> <property name="filters" value="stat"/> <property name="maxActive" value="20"/> <property name="initialSize" value="1"/> <property name="maxWait" value="60000"/> <property name="minIdle" value = "1"/> <name properti = "timebetweenevictionrunsmillis" value = "60000"/> <name properti = "minevictableIdletimeMillis" value = "300000"/> <name properti = "validationQuery" value "value" a fiure = "value =" value = "value" value = "ne property =" ne property "value =" ne property "value" ne property = "ne property" valide "ne property" ne property "value" value "value" valide "valide" ne property "valide" valide "valide" valide "valide" validle " name = "testonborrow" value = "false"/> <properti name = "testonreturn" value = "false"/> <name properti = "poolpreparedstatements" value = "true"/> <name properti = "maxpoolpreparedstatementPonnectionsion" value = "50"/</bean> <bean name iD = "SQ =" ACOCORCE = "SQ =" SQ = "SQ =" SQUSICE "" SQ = "SQ =" SQ = "SQ =" SQ = "SQ =" SQ = "SQ =" SQ = "SQ =" SQ = "SQ =" SQ = "SQUSICEPERPEOR" " Ref = "DataSource"/> <!-Tentukan file mapper-> <name properti = "mapperlocations" value = "classpath*: mapper/*. xml"/> </bean> <!-tentukan scan dao-> <bean> <properti name = "basepackage" value = "com.git.hui.demo.Melalui permintaan online, ada empat cara untuk mengelola hal -hal musim semi. Berikut adalah demonstrasi satu per satu, cara memainkan setiap metode, dan kemudian lihat bagaimana memilih dalam proyek yang sebenarnya
Programming Thing Management, yang mewujudkan manajemen hal dari beberapa operasi DB melalui TransactionTemplate
A. Pelaksanaan
Kemudian, case transfer kami dapat diimplementasikan sebagai berikut
@RepositoryPublic Class CodeDeMo1 {@Autowired Private Moneydao Moneydao; @Autowired Private TransactionTemplate TransactionTemplate; / ** * Transfer * * @param inuserid * @param outuserid * @param paymoney * @param status 0 menunjukkan transfer normal, 1 menunjukkan pengecualian dilemparkan secara internal, 2 menunjukkan utas baru, memodifikasi uang dari tidak ada di dalamnya, memodifikasi uang outuserid + 200 */ Public Transform (paying. Status) {TransactionTemplate.Execute (TransactionCallbackWithOUrtesult () {Protected void dointransactionwithOUrtesult (TransactionStatus TransactionStatus) {MoneyEntity Entity = Moneydao.queryMoney (outuserid); if (entity.getMoney ()> paymoney) {outuserid); if (entity.getMoney ()> paymoney () {outuserid); if mon money/ if mon mon money/ ifon (outity. moneydao.incrementMoney (outuserid, -paymoney); } // Berikut ini adalah semua kasus uji terkait testcase void pribadi (int int inuserid akhir, int outuserid akhir, status int akhir) {if (status == 1) {lempar baru ilegalArgumentException ("Transfer Exception !!!"); } lain jika (status == 2) {addMoney (inuserid); coba {thread.sleep (3000); } catch (InterruptedException e) {E.PrintStackTrace (); }} lain jika (status == 3) {addMoney (outuserid); coba {thread.sleep (3000); } catch (InterruptedException e) {E.PrintStackTrace (); }}} public void addMoney (final int userId) {System.out.printf ("AddMoney secara internal:" + System.currentTimeMillis ()); utas baru (runnable baru () {public void run () {moneydao.incrementMoney (userid, 200); System.out.println ("Sub Subs Success! Sekarang:" + System.CurrentTimeMillis ());}}). Mulai (); }}Terutama lihat metode transformasi di atas. Enkapsulasi berbagai hal diwujudkan melalui TransactionTemplate secara internal. Ada tiga operasi DB secara internal, satu kueri dan dua pembaruan. Analisis spesifik akan dijelaskan nanti.
Kode di atas relatif sederhana. Satu -satunya hal yang perlu Anda perhatikan adalah bagaimana TransactionTemplate Bean didefinisikan. Jika Anda tidak menempelkan file XML dan yang sebelumnya, cukup tempel kode kunci. Salah satunya adalah TransactionManager yang dibuat berdasarkan DataSource, dan yang lainnya adalah TransactionTemplate yang dibuat berdasarkan TransactionManager.
<!-Programming Things-> <bean id = "TransactionManager"> <properti name = "DataSource" ref = "DataSource"/> </bean> <bean id = "transactionTemplate"> <nama properti = "transactionManager" ref = "transactionManager"/</bean>
B. Kasus uji
Situasi demonstrasi normal, demonstrasi tidak memiliki pengecualian, dan situasi konkurensi tidak dipertimbangkan
@Runwith (springjunit4classrunner.class) @contextConfiguration ({"classpath*: spring/service.xml", "classpath*: test-datasource1.xml"}) code Public CodeDeMo1test {@Autowired private codedemo1 codedemo1; @Autowired Private Moneydao Moneydao; @Test public void testTransfor () {System.out.println ("----------------------"); System.out.println ("ID: 1 Money =" + Moneydao.QueryMoney (1) .getMoney ()); System.out.println ("ID: 2 Money =" + Moneydao.QueryMoney (2) .getMoney ()); codedemo1.transfor (1, 2, 10, 0); System.out.println ("-----------------------"); System.out.println ("ID: 1 Money =" + Moneydao.QueryMoney (1) .getMoney ()); System.out.println ("ID: 2 Money =" + Moneydao.QueryMoney (2) .getMoney ()); }}Outputnya adalah sebagai berikut, tidak ada masalah dengan uang dari kedua akun
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10000
ID: 2 uang = 50000
Transfer selesai! Sekarang: 1526130394266
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49990
Kelainan terjadi selama proses transfer, terutama ketika transferor telah mengurangi uang dan penerima belum menerima uang, yaitu situasi di mana status dalam kasus ini adalah 1.
// Pengecualian internal lemparan @testpublic void testTransForException () {System.out.println ("----------------------"); System.out.println ("ID: 1 Money =" + Moneydao.QueryMoney (1) .getMoney ()); System.out.println ("ID: 2 Money =" + Moneydao.QueryMoney (2) .getMoney ()); coba {codedemo1.transfor (1, 2, 10, 1); } catch (Exception e) {E.PrintStackTrace (); } System.out.println ("---------------------------"); System.out.println ("ID: 1 Money =" + Moneydao.QueryMoney (1) .getMoney ()); System.out.println ("ID: 2 Money =" + Moneydao.QueryMoney (2) .getMoney ());}Dalam hal ini, kami berharap dapat mengembalikan uang dari transferor, dan mengeluarkannya sebagai berikut. Kami menemukan bahwa tak satu pun dari uang itu telah berubah.
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49990
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
java.lang.illegalargumentException: Transfer Exception !!!
... // hilangkan informasi pengecualian
ID: 2 uang = 49990
Ketika status 2, itu berarti bahwa antara uang transferor telah dikurangkan dan uang penerima pembayaran belum diterima, seseorang dipindahkan 200 ke penerima pembayaran. Pada saat ini, menurut mekanisme penguncian MySQL, transfer orang lain harus segera diterima (karena akun penerima pembayaran tidak dikunci), dan seharusnya tidak ada masalah dengan jumlahnya.
Hasil output adalah sebagai berikut:
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49990
## Di sebelah kanan adalah catatan: Selama proses transfer, uang itu disimpan segera, dan uang itu ditambahkan di dalamnya tidak terkunci: 1526130827480
Sub Modifikasi Sukses! Sekarang: 1526130827500
## Transfer selesai setelah menghemat uang! Sekarang: 1526130830488
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10220
ID: 2 uang = 49980
Ketika statusnya adalah 3, itu berarti bahwa uang transferor telah dikurangkan dan uang penerima pembayaran belum diterima, dan seseorang dipindahkan 200 ke transferor. Pada saat ini, karena catatan transferor dan kunci tulis ditambahkan, ia hanya dapat menunggu transfer untuk mengirimkan transfer ke berhasil sebelum kesuksesan +200. Tentu saja, jumlah terakhir juga harus sama.
Hasil output adalah sebagai berikut
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10220
ID: 2 uang = 49980
## Di sebelah kanan adalah catatan: Saya menyimpan uang secara internal, tetapi tidak segera berhasil
## Tidak sampai transfer selesai, segera berhasil. Perhatikan menambahkan uang ke dua cap waktu: 1526131101046
Transfer selesai! Sekarang: 1526131104051
Sub Modifikasi Sukses! Sekarang: 1526131104053
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10230
ID: 2 uang = 50170
C. Ringkasan
Sejauh ini, pemrograman hal -hal telah ditunjukkan sebagai contoh. Dari proses di atas, itu memberi orang perasaan yang sama seperti menulis hal -hal yang berkaitan dengan SQL.
Mulai transaksi;
- Ini adalah logika di dalam metode transactionTemplate#Execute
- Artinya, satu set SQL yang mengharuskan hal-hal untuk dikelolamelakukan;
Tiga berikutnya adalah manajemen hal deklaratif, yang kurang digunakan karena masing -masing kelas manajemen perlu ditambahkan ke transactionproxyfactorybean
A. Pelaksanaan
Selain membunuh TransactionTemplate dan menghapus logika SQL internal, dibandingkan dengan yang sebelumnya, saya menemukan bahwa pada dasarnya tidak ada perbedaan.
Public Class FactoryBeandemo2 {@Autowired Private Moneydao Moneydao; / ** * Transfer * * @param inuserid * @param outuserid * @param paymoney * @param status 0 menunjukkan transfer normal, 1 menunjukkan pengecualian dilemparkan secara internal, 2 menunjukkan utas baru, memodifikasi uang interonid, inter final, memodifikasi uang outuserid + 200 */ paying payingid (paying payonid, payingonyon (paying payonon (paying payonon, paying -inton, memodifikasi uang outuserid + 200 */ Public Transfer (paying payonid (paying payonid, paymonony (paying payonon (paying payingony, paying -inpr final, memodifikasi uang outuserid + 200 */ Public Transfer (Public, status) {MoneyEntity Entity = Moneydao.QueryMoney (outUserID); if (entity.getMoney ()> paymoney) {// Anda dapat mentransfer uang // mengurangi uang pertama moneydao.incrementmoney (outuserid, -paymoney); testcase (tidak digunakan, outuserid, status); // tambahkan uang ke moneydao.incrementmoney (inuserid, paymoney); System.out.println ("Transfer selesai! Sekarang:" + System.currentTimemillis ()); }} private void testcase (int int inuserid, int outuserid akhir, status int akhir) {if (status == 1) {lempar baru ilegalargumentException ("Transfer Exception !!!"); } lain jika (status == 2) {addMoney (inuserid); coba {thread.sleep (3000); } catch (InterruptedException e) {E.PrintStackTrace (); }} lain jika (status == 3) {addMoney (outuserid); coba {thread.sleep (3000); } catch (InterruptedException e) {E.PrintStackTrace (); }}} public void addMoney (final int userId) {System.out.println ("Internal Add Money:" + System.CurrentTimeMillis ()); utas baru (runnable baru () {public void run () {moneydao.incrementMoney (userid, 200); System.out.println ("Sub Subs Success! Sekarang:" + System.CurrentTimeMillis ());}}). Mulai (); }}Poin kuncinya adalah kita perlu mengkonfigurasi TransactionProxyBeanFactory. Kita tahu bahwa beanfactory adalah sarana bagi kita untuk membuat kacang sendiri. Konfigurasi XML terkait adalah sebagai berikut
<!-Mrogramming Things-> <bean id = "transactionManager"> <properti name = "DataSource" ref = "DataSource"/> </ bean> <bean id = "factorybeandeMo2"/> <!-Konfigurasikan proxy untuk lapisan bisnis-> <bean id = "factorybeanDeMem ref="factoryBeanDemo2" /> <!-- Inject the transaction manager--> <property name="transactionManager" ref="transactionManager"/> <!-- Inject the properties of the transaction--> <property name="transactionAttributes"> <props> <!-- prop format: * PROPAGATION : Transaction propagation behavior* ISOTATION : Transaction isolation level* readOnly : Read-only * -EXCEPTION : Pengecualian mana yang memutar kembali transaksi* +Pengecualian: Pengecualian mana yang tidak memutar balik transaksi-> <!-Kunci ini sesuai dengan metode di kelas target-> <prop key = "transfer"> propagation_required </prop> <!-<prop key = "transfer"> propagation_required, readonly <//---<!-<! <!-<prop key = "transfer"> propagation_required,+java.lang.arithmeticException </prop>-> </props> </prop Property> </bean>
Melalui konfigurasi di atas, kita dapat secara kasar memahami bahwa TransactionProxyFactoryBean menciptakan kelas proxy dari pabrik yang menjadi. Kelas proxy ini merangkum logika yang terkait dengan hal -hal baik di dalam, yang dapat dianggap sebagai abstraksi umum sederhana dari pemrograman sebelumnya.
B. Tes
Kode uji pada dasarnya sama seperti sebelumnya. Satu -satunya perbedaan adalah bahwa kita harus menggunakan kacang yang dihasilkan oleh beanfactory di atas, daripada secara langsung menggunakan factorybeandemo2
Kasing demo normal:
@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration({"classpath*:spring/service.xml", "classpath*:test-datasource2.xml"})public class FactoryBeanDemo1Test { @Resource(name = "factoryBeanDemoProxy") private FactoryBeanDemo2 factoryBeanDemo2; @Autowired Private Moneydao Moneydao; @Test public void testTransfor () {System.out.println ("--------------------------"); System.out.println ("ID: 1 Money =" + Moneydao.QueryMoney (1) .getMoney ()); System.out.println ("ID: 2 Money =" + Moneydao.QueryMoney (2) .getMoney ()); factorybeandemo2.transfor (1, 2, 10, 0); System.out.println ("------------------------------"); System.out.println ("ID: 1 Money =" + Moneydao.QueryMoney (1) .getMoney ()); System.out.println ("ID: 2 Money =" + Moneydao.QueryMoney (2) .getMoney ()); }}Keluaran
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10000
ID: 2 uang = 50000
Transfer selesai! Sekarang: 1526132058886
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49990
Jika statusnya 1, dan pengecualian internal tidak terjadi, kami berharap tidak akan ada masalah dengan uang.
@Testpublic void testTransForException () {System.out.println ("---------------------------"); System.out.println ("ID: 1 Money =" + Moneydao.QueryMoney (1) .getMoney ()); System.out.println ("ID: 2 Money =" + Moneydao.QueryMoney (2) .getMoney ()); coba {factorybeandemo2.transfor (1, 2, 10, 1); } catch (Exception e) {System.out.println (e.getMessage ()) ;; } System.out.println ("--------------------------"); System.out.println ("ID: 1 Money =" + Moneydao.QueryMoney (1) .getMoney ()); System.out.println ("ID: 2 Money =" + Moneydao.QueryMoney (2) .getMoney ());}Outputnya
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49990
Transfer kelainan !!!
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49990
Saat status 2, hasil analisis harus sama seperti di atas, dan outputnya adalah sebagai berikut
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49950
Uang internal: 1526133325376
Sub Modifikasi Sukses! Sekarang: 1526133325387
Transfer selesai! Sekarang: 1526133328381
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10220
ID: 2 uang = 49940
Saat status 3, output
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10220
ID: 2 uang = 49940
Uang internal: 1526133373466
Transfer selesai! Sekarang: 1526133376476
Sub Modifikasi Sukses! Sekarang: 1526133376480
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10230
ID: 2 uang = 50130
C. Ringkasan
Gagasan TransactionProxyFactoryBean adalah menggunakan mode proxy untuk mengimplementasikan manajemen hal, menghasilkan kelas proxy, mencegat metode target, dan merangkum satu set operasi SQL ke dalam hal -hal; Dibandingkan dengan kode keras, itu non-invasif, dan mendukung metode konfigurasi yang fleksibel.
Kerugiannya juga jelas, masing -masing perlu dikonfigurasi, yang cukup rumit
Musim semi memiliki dua karakteristik utama: IOC dan AOP. Untuk hal -hal seperti ini, dapatkah kita menggunakan AOP untuk melakukannya?
Untuk metode yang perlu dihidupkan, mencegat, memulai hal -hal sebelum dieksekusi, mengirimkan hal -hal setelah dieksekusi, dan mundur ketika terjadi pengecualian.
Dari perspektif ini, rasanya cukup menjanjikan, dan dua postur berikut dimainkan dengan cara ini, sehingga ketergantungan aspek diperlukan.
<dependency> <GroupId> org.aspectj </groupid> <ArTifactId> aspekjweaver </artifactid> <version> 1.8.7 </version> </dependency>
A. Pelaksanaan
Kelas Java persis sama dengan tipe kedua, dan hanya perubahan XML
<!-Pertama tambahkan namespace-> xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: aop = "http://www.springframework.org/schema" xsi: schemalation = "..." http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd. ID = "TXAdvice" Transaction-Manager = "TransactionManager"> <TX: Atribut> <!-Propagasi: Transaksi Perilaku Propagasi Isolasi: Tingkat Isolasi Transaksi Hanya Baca: Rollback-Rollback-For-For: Pengecualian yang Ditransfer-"Tidak ada apa-apa:" Tidak ada informasi: "Tidak ada apa-apa:" Tidak ada informasi: "Tidak ada-" Tidak ada informasi: "Tidak ada-" Tidak ada informasi: "Tidak ada informasi:" Tidak ada informasi: "Tidak ada-" Tidak ada: "Tidak ada informasi." </tx: Atribut> </tx: Saran> <!-Bagian Konfigurasi-> <aop: config> <!-point-cut point-> <aop: pointcut ekspresi = "eksekusi (* com.git.hui.demo.mybatis.repository.transaction.xmldemo3. <AOP: Advisor Advice-Ref = "TXAdvice" pointcut-ref = "pointcut1"/> </aop: config>
Amati konfigurasi di atas dan pikirkan metode kedua. Idenya hampir sama, tetapi metode ini jelas lebih umum. Melalui bagian dan titik pemotongan, sejumlah besar konfigurasi dapat dikurangi.
B. Tes
@Runwith (springjunit4classrunner.class) @contextConfiguration ({"classpath*: spring/service.xml", "classpath*: test-datasource3.xml"}) kelas publik xmlbeantest {@Autowired private xmldemo3 xmldemo; @Autowired Private Moneydao Moneydao; @Test public void testTransfor () {System.out.println ("---------------------"); System.out.println ("ID: 1 Money =" + Moneydao.QueryMoney (1) .getMoney ()); System.out.println ("ID: 2 Money =" + Moneydao.QueryMoney (2) .getMoney ()); xmldemo.transfor (1, 2, 10, 0); System.out.println ("------------------------"); System.out.println ("ID: 1 Money =" + Moneydao.QueryMoney (1) .getMoney ()); System.out.println ("ID: 2 Money =" + Moneydao.QueryMoney (2) .getMoney ()); }}Tes ini tidak berbeda dari metode penulisan umum, dan lebih sederhana dari metode injeksi pabrik kedua
Output normal
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10000
ID: 2 uang = 50000
Transfer selesai! Sekarang: 1526135301273
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49990
status = 1 saat pengecualian terjadi, outputnya
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49990
Transfer kelainan !!!
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49990
Status = 2 Skenario menghemat uang selama proses transfer, output konsisten dengan harapan sebelumnya.
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10010
ID: 2 uang = 49990
Uang internal: 1526135438403
Sub Modifikasi Sukses! Sekarang: 1526135438421
Transfer selesai! Sekarang: 1526135441410
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10220
ID: 2 uang = 49980
Output status = 3 konsisten dengan harapan sebelumnya
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10220
ID: 2 uang = 49980
Uang internal: 1526135464341
Transfer selesai! Sekarang: 1526135467349
Sub Modifikasi Sukses! Sekarang: 1526135467352
-----------------------------------------------------------------------------------------------------------------------------
ID: 1 uang = 10230
ID: 2 uang = 50170
Ini untuk menghilangkan XML dan menggunakan anotasi untuk melakukannya, yaitu untuk menggantikan konfigurasi di XML sebelumnya dengan anotasi @transactional.
A. Pelaksanaan
@RepositoryPublic kelas annodemo4 {@autowired private moneydao moneydao; /** * Transfer * * @param inuserid * @param outuserid * @param paymoney * @param status 0 menunjukkan transfer normal, 1 menunjukkan pengecualian dilemparkan secara internal, 2 menunjukkan utas baru, memodifikasi uang yang diatasionasi: Proporasi Transaksi, memodifikasi uang dari outuserid + 200 * *. level readOnly: read-only* rollbackFor :What exceptions have occurred noRollbackFor :What exceptions have occurred not to rollback* rollbackForClassName Rollback according to the exception class name*/ @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, readOnly = false) public void transform(final int inUserId, final int outUserId, final int payMoney, final int status) { Entitas MoneyEntity = Moneydao.QueryMoney (OutUserID); if (entity.getMoney ()> paymoney) {// Anda dapat mentransfer uang // mengurangi uang pertama moneydao.incrementmoney (outuserid, -paymoney); testcase (tidak digunakan, outuserid, status); // tambahkan uang ke moneydao.incrementmoney (inuserid, paymoney); System.out.println ("Transfer selesai! Sekarang:" + System.currentTimemillis ()); }} private void testcase (int int inuserid, int outuserid akhir, status int akhir) {if (status == 1) {lempar baru ilegalargumentException ("Transfer Exception !!!"); } lain jika (status == 2) {addMoney (inuserid); coba {thread.sleep (3000); } catch (InterruptedException e) {E.PrintStackTrace (); }} lain jika (status == 3) {addMoney (outuserid); coba {thread.sleep (3000); } catch (InterruptedException e) {E.PrintStackTrace (); }}} private void addMoney (final int userId) {System.out.println ("Di dalam Add Money:" + System.CurrentTimeMillis ()); utas baru (runnable baru () {public void run () {moneydao.incrementMoney (userid, 200); System.out.println ("Sub Subs Success! Sekarang:" + System.CurrentTimeMillis ());}}). Mulai (); }}Oleh karena itu, perlu untuk mengkonfigurasinya di XML untuk memungkinkan anotasi hal -hal
<!-Programming Things-> <bean id = "TransactionManager"> <properti name = "DataSource" ref = "DataSource"/> </bean> <tx: anotasi-digerakkan transaksi-manager = "transactionManager"/>
Ini membuatnya lebih jelas. Dalam proyek aktual, metode XML dan anotasi juga merupakan skenario yang paling umum digunakan.
B. Uji kasus
Itu persis sama dengan test case ketiga, dan hasil outputnya sama, dan dihilangkan secara langsung
Pembicaraan di atas tentang empat cara untuk menggunakan hal -hal di musim semi. Di antara mereka, metode kode keras mungkin merupakan pemahaman terbaik, yang setara dengan secara langsung menerjemahkan metode menggunakan hal-hal di SQL ke dalam kode Java yang sesuai; dan metode pabrik setara dengan memperlakukan keadaan khusus dan memperlakukan setiap hal dengan kelas proxy untuk meningkatkan fungsi berbagai hal; Dua prinsip terakhir hampir diimplementasikan menggunakan Notification Thing (AOP) untuk menentukan titik tangen dan informasi terkait.
Pemrograman:
transactionTemplate#execute MethodProxy Beanfactory:
Konfigurasi XML:
Metode anotasi:
tx:annotation-driven transaction-manager="transactionManager"/>dokumen
Empat cara manajemen transaksi musim semi
Kode Sumber
Di atas adalah seluruh konten artikel ini. Saya berharap konten artikel ini memiliki nilai referensi tertentu untuk studi atau pekerjaan semua orang. Jika Anda memiliki pertanyaan, Anda dapat meninggalkan pesan untuk berkomunikasi. Terima kasih atas dukungan Anda ke wulin.com.