TOC

Tutoriel Annotation entre plusieurs annotations Hibernate

Hibernate Didacticiel d'annotation de plusieurs à plusieurs

1. introduction

Dans ce rapide didacticiel, nous verrons rapidement comment l'annotation@ManyToMany peut être utilisée pour spécifier ce type de relations dans Hibernate.

2. Un exemple typique

Commençons par un simple diagramme de relations d'entité - qui montre l'association plusieurs-à-plusieurs entre deux entitésemployee etproject:

image

Dans ce scénario, toutemployee donné peut être affecté à plusieurs projets et unproject peut avoir plusieurs employés travaillant pour lui, conduisant à une association plusieurs-à-plusieurs entre les deux.

Nous avons une tableemployee avecemployee_id comme clé primaire et une tableproject avecproject_id comme clé primaire. Une table de jointureemployee_project est requise ici pour connecter les deux côtés.

3. Configuration de la base de données

Supposons que nous ayons une base de données déjà créée avec le nomspring_hibernate_many_to_many.

Nous devons également créer les tablesemployee etproject avec la table de jointureemployee_project avecemployee_id etproject_id comme clés étrangères: 

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;

Avec la base de données configurée, la prochaine étape serait la préparation des dépendances Maven et de la configuration Hibernate. Pour plus d'informations à ce sujet, reportez-vous à l'article surGuide to Hibernate4 with Spring

4. Les classes modèles

Les classes de modèleEmployee etProject doivent être créées avec des annotations 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
}

Comme nous pouvons le voir,both the Employee class and Project classes refer to one another, which means that the association between them is bidirectional.

Afin de mapper une association plusieurs-à-plusieurs, nous utilisons les annotations@ManyToMany,@JoinTable et@JoinColumn. Examinons-les de plus près.

L'annotation@ManyToMany est utilisée dans les deux classes pour créer la relation plusieurs-à-plusieurs entre les entités.

This association has two sides i.e. the owning side and the inverse side. Dans notre exemple, le côté propriétaire estEmployee donc la table de jointure est spécifiée du côté propriétaire en utilisant l'annotation@JoinTable dans la classeEmployee. Le@JoinTable est utilisé pour définir la table de jointure / liaison. Dans ce cas, c'estEmployee_Project.

L'annotation@JoinColumn est utilisée pour spécifier la colonne de jointure / liaison avec la table principale. Ici, la colonne de jointure estemployee_id etproject_id est la colonne de jointure inverse puisqueProject est du côté inverse de la relation.

Dans la classeProject, l'attributmappedBy est utilisé dans l'annotation@ManyToMany pour indiquer que la collectionemployees est mappée par la collectionprojects du côté propriétaire .

5. Exécution

Pour voir les annotations plusieurs à plusieurs en action, nous pouvons écrire le test JUnit suivant: 

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

    // ...
}

Nous pouvons voir la relation plusieurs-à-plusieurs entre les deux entités créées dans la base de données: les tablesemployee,project etemployee_project avec des exemples de données représentant la relation.

6. Conclusion

Dans ce didacticiel, nous avons vu comment créer des mappages à l'aide des annotations plusieurs à plusieurs d'Hibernate, ce qui est un équivalent plus pratique que la création de fichiers de mappage XML.

Le code source de ce tutoriel peut être trouvéover on GitHub.

Related