1. Pengenalan
Dalam tutorial ringkas ini, kita akan melihat bagaimana penjelasan @ManyToMany dapat digunakan untuk menentukan jenis hubungan ini di Hibernate.
2. Contoh Lazim
Mari kita mulakan dengan Diagram Perhubungan Entiti ringkas - yang menunjukkan perkaitan antara pekerja dan projek dua entiti :
Dalam senario ini, mana-mana pekerja yang diberikan boleh ditugaskan untuk beberapa projek dan satu projek mungkin mempunyai banyak pekerja yang bekerja untuknya, yang menyebabkan banyak hubungan antara keduanya.
Kami mempunyai pekerja meja dengan employee_id sebagai kunci utamanya dan projek meja dengan PROJECT_ID sebagai kunci utamanya. Projek jadual pekerja_sukan diperlukan di sini untuk menghubungkan kedua-dua belah pihak.
3. Penyediaan Pangkalan Data
Anggaplah kita mempunyai pangkalan data yang sudah dibuat dengan nama spring_hibernate_many_to_many.
Kita juga perlu untuk mewujudkan pekerja dan projek jadual bersama-sama dengan employee_project menyertai 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 pangkalan data yang disiapkan, langkah seterusnya adalah penyediaan kebergantungan Maven dan konfigurasi Hibernate. Untuk maklumat mengenai perkara ini, sila rujuk artikel mengenai Panduan Hibernate4 dengan Spring
4. Kelas Model
Kelas model Pekerja dan Projek 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 dapat kita lihat, kedua-dua kelas Pekerja dan kelas Projek merujuk satu sama lain, yang bermaksud bahawa hubungan antara mereka adalah dua arah.
Untuk memetakan persatuan banyak-banyak, kami menggunakan anotasi @ManyToMany , @JoinTable dan @JoinColumn . Mari kita perhatikan dengan lebih dekat.
The @ManyToMany anotasi digunakan dalam kedua-dua kelas untuk mewujudkan hubungan banyak-ke-banyak antara entiti.
Pergaulan ini mempunyai dua sisi iaitu sisi pemilik dan sisi songsang. Dalam contoh kami, sisi pemilik adalah Karyawan sehingga jadual bergabung ditentukan di sisi pemilik dengan menggunakan anotasi @JoinTable di kelas Pekerja . Jadual @JoinTable digunakan untuk menentukan jadual bergabung / pautan. Dalam kes ini, ia adalah Employee_Project.
The @JoinColumn anotasi digunakan untuk menentukan menyertai / menghubungkan ruangan dengan meja utama. Di sini, menyertai lajur adalah employee_id dan PROJECT_ID adalah songsang menyertai ruangan sejak Projek berada di sebelah songsang hubungan.
Di kelas Projek , atribut mappedBy digunakan dalam anotasi @ManyToMany untuk menunjukkan bahawa koleksi pekerja dipetakan oleh koleksi projek dari pihak pemilik.
5. Pelaksanaan
Untuk melihat anotasi banyak-ke-banyak dalam tindakan, kita dapat menulis ujian 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 dapat melihat hubungan banyak-ke-banyak antara kedua-dua entiti dicipta di dalam pangkalan data: yang pekerja , projek , dan employee_project jadual dengan data sampel yang mewakili hubungan.
6. Kesimpulannya
Dalam tutorial ini, kami melihat cara membuat pemetaan menggunakan anotasi Hibernate yang banyak hingga banyak, yang merupakan rakan sejawat yang lebih senang dibandingkan dengan membuat fail pemetaan XML.
Kod sumber tutorial ini boleh didapati di GitHub.