Analisis mendalam pemetaan asosiasi satu-ke-satu dalam kerangka hibernasi Java

Sebagai kerangka kerja ORM, Hibernate juga harus memenuhi kebutuhan kita untuk mengimplementasikan hubungan antara tabel. Implementasi hibernate dalam metode asosiasi sangat sederhana. Mari kita lihat pendekatan satu-satu:
Tanpa basa -basi lagi, mari kita unggah kode:
Dua kelas entitas, Tuser dan Tpassport:

 Tuser kelas publik mengimplementasikan serial {private static final long serialversionuid = 1l; Private Int ID; usia int pribadi; nama string pribadi; Paspor Tpassport Pribadi; // hilangkan metode get/atur} kelas publik tpassport mengimplementasikan serializable {private static final long serialversionuid = 1l; Private Int ID; Serial String Pribadi; kedaluwarsa int pribadi; Pengguna Tuser Pribadi; // hilangkan metode get/atur}

Mari kita lihat perbedaan antara file pemetaan:

 <Paket pemetaan hibernate = "org.hibernate.tutorial.domain4"> <class name = "tuser" table = "user4"> <id name = "id" column = "id"> <generator/> </d> <nama properti = "name" type = "java" java "java.string" kolom = "name" <"name =" name "=" java "JAVA" kolom = "usia"/> <satu-ke-satu nama = "paspor" cascade = "all" outer-join = "true"/> </class> </hibernate-mapping>

Di sini kita melihat label baru, satu-ke-satu, yang menunjukkan bahwa kelas saat ini dan kelas yang sesuai adalah satu-ke-satu, Cascade adalah hubungan kaskade, semua menunjukkan bahwa apa pun situasinya, yaitu, ketika beroperasi pada kelas Tuser, Tpassport juga akan melakukan operasi yang sesuai. Luar-join mengacu pada apakah akan menggunakan pernyataan gabungan luar.
Mari kita lihat file pemetaan tpassport lain:

 <Hibernate-Mapping Package = "org.hibernate.tutorial.domain4"> <class name = "tpassport" table = "passport4"> <id name = "id" kolom = "id"> <generator> <param name = "properti"> Pengguna </param> </generator> </id </id </id a name = "jav" type = "JAV" = "JAV" </Generator> </id </id </id name = "SERIAL" TYPE "JAVE =" JAV "=" JAV "=" SERIAL "=" SERIAL "=" JAV ". name = "Expiry" type = "java.lang.integer" kolom = "Expiry"/> <One-to-One Name = "user" dibatasi = "true"/> </class> </hibernate-mapping>

Di sini kami fokus pada nilai kelas generator. Ini menunjukkan tombol asing referensi untuk asing, dan referensi mana yang ditentukan oleh param, yang menunjukkan ID dari kelas pengguna referensi. Ada properti terbatas tambahan dalam tag satu-ke-satu, yang memberi tahu Hibernate bahwa ada kendala kunci asing di kelas saat ini, yaitu, ID kelas saat ini dihasilkan berdasarkan ID tuser.
Mari kita langsung mengunggah kelas tes. Kali ini, kelas tes tidak menggunakan JUnit tetapi langsung datang dengan metode utama:

 public static void main (string [] args) {configuration cfg = new configuration (). configure (); SessionFactory sessionFactory = cfg.buildsessionFactory (); Sesi sesi = sessionfactory.opensession (); session.begintransaction (); Tuser user = tuser baru (); user.setage (20); user.setname ("shuntest"); Tpassport paspor = tpassport baru (); paspor.setExpiry (20); paspor.setserial ("123123123"); passport.setUser (pengguna); user.setPassport (paspor); session.save (pengguna); session.getTransaction (). Commit (); }

Kode ini sangat sederhana, jadi saya tidak akan membicarakannya. Mari kita lihat terutama di sini:

 session.save (pengguna);

Mengapa kita hanya menelepon satu simpan di sini? Alasannya adalah bahwa properti Cascade dalam file pemetaan tuser kami diatur ke semua, yang berarti bahwa ketika kami menyimpan, memperbarui, menghapus, dll. Pada Tuser, Tpassport juga akan melakukan operasi yang sesuai, jadi kami tidak perlu menulis sesi. Kami melihat latar belakang:

 Hibernate: Masukkan ke dalam nilai User4 (nama, usia) (?,?) Hibernate: masukkan ke dalam nilai paspor4 (serial, kedaluwarsa, id) (?,?,?)

Hibernate: Ini mencetak dua pernyataan, membuktikan bahwa Hibernate telah melakukan pekerjaan ini untuk kita.


Mari kita ambil kelas tes lain dan uji kueri:

 public static void main (string [] args) {configuration cfg = new configuration (). configure (); SessionFactory sessionFactory = cfg.buildsessionFactory (); Sesi sesi = sessionfactory.opensession (); Tuser user = (tuser) session.load (tuser.class, integer baru (3)); System.out.println (user.getName ()+":"+user.getPassport (). GetSerial ()); }

Di sini kami menanyakan kelas Tuser dan mendapatkan objek TPassport.
Kita dapat melihat bahwa pernyataan SQL Hibernate adalah:
Salinan kode adalah sebagai berikut:
Hibernate:
select tuser0_.id as id0_1_, tuser0_.name as name0_1_, tuser0_.age as age0_1_, tpassport1_.id as id1_0_, tpassport1_.serial as serial1_0_, tpassport1_.expiry as expiry1_0_ from USER4 tuser0_ left outer join passport4 tpassport1_ on tuser0_.id = tpassport1_.id di mana tuser0_.id =?

Kami melihat gabungan luar kiri dalam pernyataan itu, karena kami mengatur luar-join = "true" dalam satu-ke-satu. Kami mencoba mengubahnya menjadi salah. Pernyataan SQL adalah sebagai berikut:
Salinan kode adalah sebagai berikut:
Hibernate:
Pilih tuser0_.id sebagai id0_0_, tuser0_.name as name0_0_, tuser0_.age as Age0_0_ dari user4 tuser0_ di mana tuser0_.id =? Hibernate:
Pilih tpassport0_.id sebagai ID1_0_, tpassport0_.serial sebagai serial1_0_, tpassport0_.expiry sebagai kedaluwarsa1_0_ dari paspor4 tpassport0_ di mana tpassport0_.id =?

Sekarang kami telah membaginya menjadi dua item untuk memeriksanya, dan kemudian menemukannya berdasarkan ID yang ditemukan di item pertama dan kemudian ke item kedua.

Mungkin banyak orang akan bertanya mengapa mereka tidak menggunakan tpassport untuk mencari tahu pengganggu selama pengujian. Bahkan, itu juga mungkin, karena mereka adalah hubungan satu-ke-satu, dan semua orang yang memeriksanya akan sama.

Asosiasi Kunci Asing
Sekarang mari kita lihat asosiasi satu-ke-satu yang membuat asosiasi melalui kunci asing.
Masih sama dengan contohnya: kami menulis dua kelas entitas, tgroup dan tuser

 TGroup kelas publik mengimplementasikan serial {private static final long serialversionuid = 1l; Private Int ID; nama string pribadi; Pengguna Tuser Pribadi; // hilangkan metode get/atur} tuser kelas publik mengimplementasikan serializable {private static final long serialversionuid = 1l; Private Int ID; usia int pribadi; nama string pribadi; grup tgroup pribadi; // hilangkan metode get/atur}

Setelah kelas entitas selesai, mari kita lihat file pemetaan:

 <package pemetaan hibernate = "org.hibernate.tutorial.domain5"> <class name = "tuser" table = "user5"> <id name = "id" column = "id"> <generator/> </d> <nama properti = "name" type = "java" java "column ". "." name = "java" java "java" java "java" java "java. kolom = "usia"/> <banyak-ke-satu nama = "grup" kolom = "group_id" unik = "true"/> </slass> </hibernate-Mapping>

Di sini kita melihat bahwa tag banyak-ke-satu digunakan sebagai pengganti satu-ke-satu. Mengapa?
Saya tidak terlalu memperhatikannya ketika saya menggunakannya sebelumnya. Bagaimanapun, saya bisa menggunakannya. Tetapi setelah membaca buku Xia Xin kali ini, saya akhirnya mengerti bahwa pada kenyataannya, cara asosiasi ini melalui kunci asing hanyalah cara khusus dari banyak ke-satu. Kami membatasi itu melalui unik = "benar" yang hanya memiliki satu, yaitu, satu-satu asosiasi.
Selanjutnya, mari kita lihat file pemetaan TGroup:

 <hibernate-mapping package = "org.hibernate.tutorial.domain5"> <class name = "tgroup" table = "group5"> <id name = "id" column = "id"> <generator/> </d> <name> name = "type =" java.lang "kolom" colum = "name> <-name>" a-name "=" java.lang.string "kolom =" name "/name- name =" " </hibernate-Mapping>

Di sini, perhatikan bahwa kami menggunakan satu-ke-satu lagi, menunjukkan bahwa entitas dan tuser saat ini adalah satu-ke-satu. Di sini, kami tidak menggunakan banyak-ke-satu, tetapi menentukan atribut mana dalam entitas tuser untuk mengaitkan TGroup kelas saat ini. Di sini kami menentukan bahwa Tuser dikaitkan dengan Tuser melalui atribut grup. Properti-ref menentukan properti mana yang akan diasosiasikan.
Mari kita lihat kelas tes di bawah ini:

 kelas publik hibernatetest {public static void main (string [] args) {configuration cfg = new configuration (). configure (); SessionFactory sessionFactory = cfg.buildsessionFactory (); Sesi sesi = sessionfactory.opensession (); session.begintransaction (); Tgroup grup = tgroup baru (); group.setname ("testgroup"); Tuser user = tuser baru (); user.setage (23); user.setname ("test"); user.setgroup (grup); group.setUser (pengguna); session.save (grup); session.save (pengguna); session.getTransaction (). Commit (); session.close (); }}

Perhatikan bahwa kode kami perlu disimpan dua kali kali ini karena mereka memiliki korespondensi yang sesuai untuk satu sama lain. Menyimpan hanya satu tidak akan menyebabkan operasi apa pun di yang lain. Jadi kita perlu memanggil operasi yang disimpan dua kali. Akhirnya membuat kiriman.
Hibernate mencetak pernyataan:

 Hibernate: Masukkan ke dalam nilai grup5 (name) (?) Hibernate: masukkan ke dalam nilai user5 (nama, usia, group_id) (?,?,?)

Ini berarti bahwa kami dengan benar menyimpan dua nilai objek.

Kami menulis kelas tes tambahan untuk meminta:

 public static void main (string [] args) {configuration cfg = new configuration (). configure (); SessionFactory sessionFactory = cfg.buildsessionFactory (); Sesi sesi = sessionfactory.opensession (); Tuser user = (tuser) session.load (tuser.class, integer baru (1)); System.out.println ("Dari User Get Group:"+user.getGroup (). GetName ()); Tgroup grup = (tgroup) session.load (tgroup.class, integer baru (1)); System.out.println ("Dari grup dapatkan pengguna:" + group.getUser (). GetName ()); session.close (); }

Kami berdua bisa mendapatkan hasil yang benar, yang menunjukkan bahwa kami dapat mengambil nilai -nilai yang lain melalui dua objek, mencapai tujuan kami.
TGroup dan Tuser yang digunakan dalam contoh ini hanyalah contoh. Faktanya, pengguna dalam kehidupan nyata umumnya sesuai dengan banyak grup.