Hibernate viele bis viele Anmerkungs-Lernprogramme

Hibernate Many to Many Annotation Tutorial

1. Einführung

In diesem kurzen Tutorial sehen wir uns kurz an, wie die Annotation@ManyToManyzum Festlegen dieser Art von Beziehungen im Ruhezustand verwendet werden kann.

2. Ein typisches Beispiel

Beginnen wir mit einem einfachen Entitätsbeziehungsdiagramm, das die Viele-zu-Viele-Zuordnung zwischen zwei Entitätenemployee undproject: zeigt

In diesem Szenario können alleemployee mehreren Projekten zugewiesen werden, und beiproject können mehrere Mitarbeiter arbeiten, was zu einer Viele-zu-Viele-Zuordnung zwischen beiden führt.

Wir haben eineemployee-Tabelle mitemployee_id als Primärschlüssel und eineproject-Tabelle mitproject_id als Primärschlüssel. Hier ist eine Verknüpfungstabelleemployee_project erforderlich, um beide Seiten zu verbinden.

3. Datenbank-Setup

Nehmen wir an, wir haben eine bereits erstellte Datenbank mit dem Namenspring_hibernate_many_to_many.

Wir müssen auch die Tabellenemployee undproject zusammen mit der Verknüpfungstabelleemployee_project mitemployee_id undproject_id als Fremdschlüssel erstellen:

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;

Wenn die Datenbank eingerichtet ist, besteht der nächste Schritt in der Vorbereitung der Maven-Abhängigkeiten und der Konfiguration des Ruhezustands. Informationen hierzu finden Sie im Artikel zuGuide to Hibernate4 with Spring

4. Die Modellklassen

Die ModellklassenEmployee undProject müssen mit JPA-Anmerkungen erstellt werden:

@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
}

Wie wir sehen können,both the Employee class and Project classes refer to one another, which means that the association between them is bidirectional.

Um eine Viele-zu-Viele-Zuordnung abzubilden, verwenden wir die Annotationen@ManyToMany,@JoinTable und@JoinColumn. Schauen wir sie uns genauer an.

Die Annotation@ManyToMany wird in beiden Klassen verwendet, um die Viele-zu-Viele-Beziehung zwischen den Entitäten herzustellen.

This association has two sides i.e. the owning side and the inverse side. In unserem Beispiel ist die BesitzerseiteEmployee, sodass die Verknüpfungstabelle auf der Besitzerseite mithilfe der Annotation@JoinTable in der KlasseEmployee angegeben wird. Das@JoinTable wird verwendet, um die Join / Link-Tabelle zu definieren. In diesem Fall ist esEmployee_Project.

Die Annotation@JoinColumn wird verwendet, um die Verknüpfungs- / Verknüpfungsspalte mit der Haupttabelle anzugeben. Hier ist die Verknüpfungsspalteemployee_id undproject_id ist die inverse Verknüpfungsspalte, daProject auf der inversen Seite der Beziehung liegt.

In der KlasseProject wird das AttributmappedBy in der Annotation@ManyToMany verwendet, um anzugeben, dass die Sammlungemployees der Sammlungprojects der Besitzerseite zugeordnet ist .

5. Ausführung

Um die vielen Annotationen in Aktion zu sehen, können Sie den folgenden JUnit-Test schreiben:

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());
        }
    }

    // ...
}

Wir können die Viele-zu-Viele-Beziehung zwischen den beiden in der Datenbank erstellten Entitäten sehen: die Tabellenemployee,project undemployee_project mit Beispieldaten, die die Beziehung darstellen.

6. Fazit

In diesem Tutorial haben wir gesehen, wie Sie Zuordnungen mit den vielen-zu-vielen-Anmerkungen von Hibernate erstellen. Dies ist ein praktischeres Gegenstück zum Erstellen von XML-Zuordnungsdateien.

Der Quellcode dieses Tutorials befindet sich inover on GitHub.

TOC