Hibernate Many to Many Annotation Tutorial

1. Perkenalan

Dalam tutorial singkat ini, kita akan melihat sekilas bagaimana anotasi @ManyToMany dapat digunakan untuk menentukan jenis hubungan ini dalam Hibernate.

2. Contoh Khas

Mari kita mulai dengan Diagram Relasi Entitas sederhana - yang menunjukkan asosiasi banyak ke banyak antara dua entitas karyawan dan proyek:

Dalam skenario ini, setiap karyawan tertentu dapat ditugaskan ke beberapa proyek dan proyek mungkin memiliki banyak karyawan yang bekerja untuk itu, yang mengarah ke asosiasi banyak ke banyak di antara keduanya.

Kami memiliki tabel karyawan dengan employee_id sebagai kunci utamanya dan tabel proyek dengan project_id sebagai kunci utamanya. Sebuah tabel gabungan employee_project diperlukan di sini untuk menghubungkan kedua sisi.

3. Pengaturan Basis Data

Mari kita asumsikan kita memiliki database yang sudah dibuat dengan nama spring_hibernate_many_to_many.

Kita juga perlu membuat karyawan dan proyek tabel bersama dengan employee_project bergabung meja dengan employee_id dan project_id sebagai kunci asing:

CREATE TABLE `employee` ( `employee_id` int(11) NOT NULL AUTO_INCREMENT, `first_name` varchar(50) DEFAULT NULL, `last_name` varchar(50) DEFAULT NULL, PRIMARY KEY (`employee_id`) ) ENGINE=InnoDB AUTO_INCREMENT=17 DEFAULT CHARSET=utf8; CREATE TABLE `project` ( `project_id` int(11) NOT NULL AUTO_INCREMENT, `title` varchar(50) DEFAULT NULL, PRIMARY KEY (`project_id`) ) ENGINE=InnoDB AUTO_INCREMENT=18 DEFAULT CHARSET=utf8; CREATE TABLE `employee_project` ( `employee_id` int(11) NOT NULL, `project_id` int(11) NOT NULL, PRIMARY KEY (`employee_id`,`project_id`), KEY `project_id` (`project_id`), CONSTRAINT `employee_project_ibfk_1` FOREIGN KEY (`employee_id`) REFERENCES `employee` (`employee_id`), CONSTRAINT `employee_project_ibfk_2` FOREIGN KEY (`project_id`) REFERENCES `project` (`project_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 

Dengan penyetelan database, langkah selanjutnya adalah persiapan dependensi Maven dan konfigurasi Hibernate. Untuk informasi tentang ini, silakan merujuk ke artikel di Panduan Hibernate4 dengan Musim Semi

4. Kelas Model

Kelas model Karyawan dan Proyek perlu dibuat dengan anotasi JPA:

@Entity @Table(name = "Employee") public class Employee { // ... @ManyToMany(cascade = { CascadeType.ALL }) @JoinTable( name = "Employee_Project", joinColumns = { @JoinColumn(name = "employee_id") }, inverseJoinColumns = { @JoinColumn(name = "project_id") } ) Set projects = new HashSet(); // standard constructor/getters/setters }
@Entity @Table(name = "Project") public class Project { // ... @ManyToMany(mappedBy = "projects") private Set employees = new HashSet(); // standard constructors/getters/setters }

Seperti yang bisa kita lihat, baik kelas Karyawan maupun kelas Proyek saling mengacu satu sama lain, yang berarti bahwa hubungan di antara keduanya adalah dua arah.

Untuk memetakan asosiasi banyak ke banyak, kami menggunakan anotasi @ManyToMany , @JoinTable , dan @JoinColumn . Mari kita lihat lebih dekat.

The @ManyToMany penjelasan digunakan di kedua kelas untuk menciptakan hubungan banyak-ke-banyak antara entitas.

Asosiasi ini memiliki dua sisi yaitu sisi pemilik dan sisi terbalik. Dalam contoh kami, sisi yang memiliki adalah Karyawan sehingga tabel gabungan ditentukan di sisi yang memiliki dengan menggunakan anotasi @JoinTable di kelas Karyawan . The @JoinTable digunakan untuk mendefinisikan tabel bergabung / link. Dalam hal ini, Employee_Project.

The @JoinColumn penjelasan digunakan untuk menentukan bergabung / menghubungkan kolom dengan tabel utama. Di sini, kolom gabungan adalah employee_id dan project_id adalah kolom gabungan terbalik karena Project berada di sisi terbalik dari hubungan tersebut.

Di kelas Proyek , atribut mappedBy digunakan dalam anotasi @ManyToMany untuk menunjukkan bahwa koleksi karyawan dipetakan oleh kumpulan proyek dari sisi pemilik.

5. Eksekusi

Untuk melihat anotasi banyak-ke-banyak beraksi, kita dapat menulis pengujian JUnit berikut:

public class HibernateManyToManyAnnotationMainIntegrationTest { private static SessionFactory sessionFactory; private Session session; // ... @Test public void givenData_whenInsert_thenCreatesMtoMrelationship() { String[] employeeData = { "Peter Oven", "Allan Norman" }; String[] projectData = { "IT Project", "Networking Project" }; Set projects = new HashSet(); for (String proj : projectData) { projects.add(new Project(proj)); } for (String emp : employeeData) { Employee employee = new Employee(emp.split(" ")[0], emp.split(" ")[1]); assertEquals(0, employee.getProjects().size()); employee.setProjects(projects); session.persist(employee); assertNotNull(employee); } } @Test public void givenSession_whenRead_thenReturnsMtoMdata() { @SuppressWarnings("unchecked") List employeeList = session.createQuery("FROM Employee") .list(); assertNotNull(employeeList); for(Employee employee : employeeList) { assertNotNull(employee.getProjects()); } } // ... }

Kita bisa melihat hubungan banyak-ke-banyak antara dua entitas dibuat dalam database: yang karyawan , proyek , dan employee_project tabel dengan data sampel yang mewakili hubungan.

6. Kesimpulan

Dalam tutorial ini, kami melihat cara membuat pemetaan menggunakan anotasi banyak-ke-banyak Hibernate, yang merupakan mitra yang lebih nyaman dibandingkan dengan membuat file pemetaan XML.

Kode sumber dari tutorial ini dapat ditemukan di GitHub.