Artikel ini terutama mempelajari semua isi kunci pesimistis hibernate dan kunci optimis, seperti yang dirinci di bawah ini.
Penguncian pesimistis biasanya diimplementasikan oleh mekanisme basis data. Selama seluruh proses, data terkunci (saat meminta). Selama hal -hal tidak dirilis (komit/rollback), tidak ada pengguna yang dapat melihat atau memodifikasinya.
Mari kita jelaskan melalui kasus di bawah ini.
Kasus: Misalkan inventaris barang adalah 1000, dan ketika akuntan 1 mengeluarkan data dan bersiap untuk modifikasi, tetapi ada sesuatu yang sementara, ia pergi. Selama periode ini, akuntansi 2 mengekstraksi data dan mengurangi jumlahnya dengan 200, dan kemudian akuntansi 1 kembali dan mengurangi jumlah yang baru saja dihapus oleh 200. Hal ini menyebabkan masalah. Akuntansi 1 tidak membuat modifikasi berdasarkan 800. Ini disebut kehilangan pembaruan, dan dapat diselesaikan dengan menggunakan kunci pesimistis.
Inventory.java:
inventaris kelas publik { /* nomor inventaris* / private string itemno; /* Nama Inventaris*/ Private String ItemName; /* Kuantitas inventaris*/ kuantitas int privat; // hilangkan metode setter dan getter}Inventory.hbm.xml:
<? Xml Version = "1.0"?> <! Doctype Hibernate-Mapping Public "-// Hibernate/Hibernate Mapping DTD 3.0 // EN" "http://hibernate.sourceForge.net/hibernate-papping-3.0.dtd"> <hibernate-papping> <class name = "coM." COM. "COM." TABLE = "T_InVENTORY"> <!-Penugasan manual kunci utama-> <id name = "itemno"> <generator // id> <!-pemetaan properti-> <nama properti = "itemName"/> <nama properti = "kuantitas"/> <class> </hibernate-phapping>
Kelas Tes:
Akuntan 1 memuat data melalui penguncian pesimistis dan memodifikasi data!
public void testload1 () {session session = null; coba {session = hibernateutils.getSession (); session.begintransaction (); /*Kunci pesimistis ditambahkan saat memuat, sehingga tidak mungkin bagi pengguna lain untuk mengakses*/ inventaris inv = (inventaris) session.load (inventory.class, "1001", lockmode.upgrade); /*Dapatkan data*/ system.out.println ("opt1-> itemno =" + inv.getItemno ()); System.out.println ("opt1-> itemName =" + inv.getItemname ()); System.out.println ("opt1-> kuantitas =" + inv.getquantity ()); /*Kuantitas dikurangi 200*/ inv.setquantity (inv.getquantity () - 200); session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); session.getTransaction (). rollback (); } akhirnya {hibernateutils.closesession (sesi); }}Akuntan 2 dan Akuntan 1 memiliki operasi yang sama, dan keduanya memodifikasi data dalam database!
public void testload2 () {session session = null; coba {session = hibernateutils.getSession (); session.begintransaction (); /*Tambahkan kunci saat memuat data, sehingga orang lain tidak bisa mendapatkan data*/ inventaris inv = (inventaris) session.load (inventory.class, "1001", lockmode.upgrade); /*Dapatkan data nyata*/ system.out.println ("opt2-> itemno =" + inv.getItemno ()); System.out.println ("opt2-> itemName =" + inv.getItemname ()); System.out.println ("opt2-> kuantitas =" + inv.getQuantity ()); /*Inventaris minus 200*/ inv.setquantity (inv.getquantity () - 200); session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); session.getTransaction (). rollback (); } akhirnya {hibernateutils.closesession (sesi); }}Catatan: Operasi yang dilakukan oleh dua akuntan adalah sama. Jika kunci pesimistis ditambahkan, akuntan mengeluarkan data dan memodifikasi data. Sebelum Akuntan 1 mengirimkan benda itu, Akuntan 2 tidak dapat mengakses data dan hanya dapat dalam keadaan menunggu. Hanya setelah mengetahui bahwa Akuntan 1 telah mengirimkannya, Akuntan 2 memiliki kesempatan untuk beroperasi pada data dalam database.
Melalui casing kunci pesimistis di atas, kita dapat menemukan bahwa keuntungan terbesar dari kunci pesimistis adalah bahwa ia dapat mencegah kerugian pembaruan. Ketika Calculator 1 memproses data, kalkulator 2 hanya dapat dalam keadaan menunggu. Hanya setelah Kalkulator 1 mengirimkan benda itu, Kalkulator 2 memiliki kesempatan untuk memodifikasi data. Tetapi ada juga masalah besar, yaitu, jika akuntan 1 menanyakan data dan pergi, maka yang lain harus menunggu hampir sepanjang hari, yang sangat membuang -buang waktu. Untuk mengatasi masalah ini, kita dapat menggunakan kunci optimis.
Kunci optimis bukanlah kunci dalam arti sebenarnya. Dalam kebanyakan kasus, mereka diimplementasikan dalam bentuk versi data. Secara umum, bidang versi ditambahkan ke database, dan versi dibacakan saat membaca data. Saat menyimpan data, itu menentukan apakah nilai versi lebih kecil dari nilai versi database. Jika kurang, itu tidak akan diperbarui, jika tidak, itu akan diperbarui.
Pengaturan Javabean di bawah kunci optimis, inventaris.java:
inventaris kelas publik { /*nomor inventaris* / private string itemno; /*Nama Inventaris*/ Private String ItemName; /*Kuantitas inventaris*/ kuantitas int privat; /*Versi Data*/ Versi int privat; // hilangkan metode setter dan getter}Inventory.hbm.xml:
<? XML Versi = "1.0"?> <! Doctype hibernate-mapping public "-// hibernate/hibernate pemetaan dtd 3.0 // en" "http://hibernate.sourceForge.net-class classion, classion-lock, tag class- name = "com.lixue.bean.inventory" Table = "t_inventory" optimistic-lock = "Versi"> <!-Pemetaan kunci utama-> <id name = "itemno"> <generator/> </d> <!-Versi data, harus ada di lokasi setelah properti utama-> <versi nama = "Version/</id! name = "kuantitas"/> </slass> </hibernate-Mapping>
Catatan: File pemetaan menggunakan kunci optimis menetapkan bahwa pemetaan bidang versi harus dipetakan terlebih dahulu setelah ID kunci utama.
Akuntan 1 memproses data dalam situasi kunci yang optimis:
public void testload1 () {session session = null; coba {session = hibernateutils.getSession (); session.begintransaction (); /*Muat data di bawah kunci optimis*/ inventaris inv = (inventaris) session.load (inventory.class, "1001"); /*Akuisisi data nyata*/ system.out.println ("opt1-> itemno =" + inv.getItemno ()); System.out.println ("opt1-> itemName =" + inv.getItemname ()); System.out.println ("opt1-> version =" + inv.getVersion ()); System.out.println ("opt1-> kuantitas =" + inv.getquantity ()); /*Kuantitas dikurangi 200*/ inv.setquantity (inv.getquantity () - 200); session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); session.getTransaction (). rollback (); } akhirnya {hibernateutils.closesession (sesi); }}Akuntan 2 memproses data di bawah penguncian optimis (akuntan 2 dapat memproses data tanpa mengirimkannya)
public void testload2 () {session session = null; coba {session = hibernateutils.getSession (); session.begintransaction (); /*Muat data di bawah kunci optimis*/ inventaris inv = (inventaris) session.load (inventory.class, "1001"); /*Akuisisi data nyata*/ system.out.println ("opt2-> itemno =" + inv.getItemno ()); System.out.println ("opt2-> itemName =" + inv.getItemname ()); System.out.println ("opt2-> version =" + inv.getVersion ()); System.out.println ("opt2-> kuantitas =" + inv.getQuantity ()); /*Kuantitas dikurangi 200*/ inv.setquantity (inv.getquantity () - 200); session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); session.getTransaction (). rollback (); } akhirnya {hibernateutils.closesession (sesi); }}Catatan: Pada premis bahwa akuntan mengambil data dan mengurangi nomor dengan 200 dan tidak mengirimkannya, akuntan 2 juga dapat mengoperasikan data. Ini berbeda dari kunci pesimistis. Ketika akuntan 2 mengoperasikan data dan mengirimkannya, versi versi data dalam database akan ditambahkan oleh 1. Kemudian ketika akuntan 1 kembali untuk mengirimkan benda itu, pesan kesalahan akan muncul bahwa data telah diperbarui, harap muat ulang.
Kunci pesimistis akan mempengaruhi konkurensi tinggi, sehingga lebih baik menggunakan kunci optimis.
Di atas adalah semua penjelasan terperinci tentang kunci pesimistis hibernate dan contoh kunci optimis dalam artikel ini. Saya harap ini akan membantu semua orang. Teman yang tertarik dapat terus merujuk ke topik terkait lainnya di situs ini. Jika ada kekurangan, silakan tinggalkan pesan untuk menunjukkannya. Terima kasih teman atas dukungan Anda untuk situs ini!