Tutoriel d'annotation Hibernate One to Many

1. Introduction

Ce rapide tutoriel Hibernate nous emmènera à travers un exemple de mappage un-à-plusieurs utilisant des annotations JPA, une alternative à XML.

Nous découvrirons également ce que sont les relations bidirectionnelles, comment elles peuvent créer des incohérences et comment l'idée de propriété peut aider.

2. Description

En termes simples, le mappage un-à-plusieurs signifie qu'une ligne d'une table est mappée à plusieurs lignes d'une autre table.

Examinons le diagramme de relation d'entité suivant pour voir une association un-à-plusieurs :

Pour cet exemple, nous allons implémenter un système de panier dans lequel nous avons une table pour chaque panier et une autre table pour chaque article. Un panier peut contenir plusieurs articles, nous avons donc ici un mappage un-à-plusieurs .

La façon dont cela fonctionne au niveau de la base de données est que nous avons un cart_id comme clé primaire dans la table cart et également un cart_id comme clé étrangère dans les éléments .

La façon dont nous le faisons dans le code est avec @OneToMany .

Mappons la classe Cart à l' objet Items d'une manière qui reflète la relation dans la base de données:

public class Cart { //... @OneToMany(mappedBy="cart") private Set items; //... }

Nous pouvons également ajouter une référence à Cart dans Items en utilisant @ManyToOne , ce qui en fait une relation bidirectionnelle. Bidirectionnel signifie que nous pouvons accéder aux articles à partir de chariots , ainsi qu'aux chariots à partir d' articles .

La propriété mappedBy est ce que nous utilisons pour indiquer à Hibernate quelle variable nous utilisons pour représenter la classe parente dans notre classe enfant.

Les technologies et bibliothèques suivantes sont utilisées pour développer un exemple d'application Hibernate qui implémente une association un-à-plusieurs :

  • JDK 1.8 ou version ultérieure
  • Hibernation 5
  • Maven 3 ou version ultérieure
  • Base de données H2

3. Configuration

3.1. Configuration de la base de données

Vous trouverez ci-dessous notre script de base de données pour les tables Cart et Items . Nous utilisons la contrainte de clé étrangère pour le mappage un-à-plusieurs :

CREATE TABLE `Cart` ( `cart_id` int(11) unsigned NOT NULL AUTO_INCREMENT, PRIMARY KEY (`cart_id`) ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8; CREATE TABLE `Items` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `cart_id` int(11) unsigned NOT NULL, PRIMARY KEY (`id`), KEY `cart_id` (`cart_id`), CONSTRAINT `items_ibfk_1` FOREIGN KEY (`cart_id`) REFERENCES `Cart` (`cart_id`) ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

Notre configuration de base de données est prête, passons donc à la création du projet d'exemple Hibernate.

3.2. Dépendances de Maven

Nous ajouterons ensuite les dépendances des pilotes Hibernate et H2 à notre fichier pom.xml . La dépendance Hibernate utilise la journalisation JBoss, et elle est automatiquement ajoutée en tant que dépendances transitives:

  • Hibernate version 5 .2.7.Final
  • Pilote H2 version 1 .4.197

Veuillez visiter le dépôt central de Maven pour les dernières versions d'Hibernate et les dépendances H2.

3.3. Configuration de la mise en veille prolongée

Voici la configuration d'Hibernate:

  org.h2.Driver   jdbc:h2:mem:spring_hibernate_one_to_many sa org.hibernate.dialect.H2Dialect thread true  

3.4. Classe HibernateAnnotationUtil

Avec la classe HibernateAnnotationUtil , il suffit de référencer le nouveau fichier de configuration Hibernate:

private static SessionFactory sessionFactory; private SessionFactory buildSessionFactory() { ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder(). configure("hibernate-annotation.cfg.xml").build(); Metadata metadata = new MetadataSources(serviceRegistry).getMetadataBuilder().build(); SessionFactory sessionFactory = metadata.getSessionFactoryBuilder().build(); return sessionFactory; } public SessionFactory getSessionFactory() { if(sessionFactory == null) sessionFactory = buildSessionFactory(); return sessionFactory; }

4. Les modèles

Les configurations liées au mappage seront effectuées à l'aide d'annotations JPA dans les classes de modèle:

@Entity @Table(name="CART") public class Cart { //... @OneToMany(mappedBy="cart") private Set items; // getters and setters }

Veuillez noter que l' annotation @OneToMany est utilisée pour définir la propriété dans la classe Items qui sera utilisée pour mapper la variable mappedBy . C'est pourquoi nous avons une propriété nommée « panier » dans la classe Items :

@Entity @Table(name="ITEMS") public class Items { //... @ManyToOne @JoinColumn(name="cart_id", nullable=false) private Cart cart; public Items() {} // getters and setters } 

Il est également important de noter que l' annotation @ManyToOne est associée à la variable de classe Cart . L' annotation @JoinColumn fait référence à la colonne mappée.

5. En action

Dans le programme de test, nous créons une classe avec une méthode main () pour obtenir la session Hibernate, et enregistrons les objets du modèle dans la base de données implémentant l'association un-à-plusieurs :

sessionFactory = HibernateAnnotationUtil.getSessionFactory(); session = sessionFactory.getCurrentSession(); System.out.println("Session created"); tx = session.beginTransaction(); session.save(cart); session.save(item1); session.save(item2); tx.commit(); System.out.println("Cartitem1, Foreign Key Cartitem2, Foreign Key Cartmany-to-one">6. The @ManyToOne Annotation

As we have seen in section 2, we can specify a many-to-one relationship by using the @ManyToOne annotation. A many-to-one mapping means that many instances of this entity are mapped to one instance of another entity – many items in one cart.

The @ManyToOne annotation lets us create bidirectional relationships too. We'll cover this in detail in the next few subsections.

6.1. Inconsistencies and Ownership

Now, if Cart referenced Items, but Items didn't in turn reference Cart, our relationship would be unidirectional. The objects would also have a natural consistency.

In our case though, the relationship is bidirectional, bringing in the possibility of inconsistency.

Let's imagine a situation where a developer wants to add item1 to cart and item2 to cart2, but makes a mistake so that the references between cart2 and item2 become inconsistent:

Cart cart1 = new Cart(); Cart cart2 = new Cart(); Items item1 = new Items(cart1); Items item2 = new Items(cart2); Set itemsSet = new HashSet(); itemsSet.add(item1); itemsSet.add(item2); cart1.setItems(itemsSet); // wrong!

As shown above, item2 references cart2, whereas cart2 doesn't reference item2, and that's bad.

How should Hibernate save item2 to the database? Will item2 foreign key reference cart1 or cart2?

We resolve this ambiguity using the idea of an owning side of the relationship; references belonging to the owning side take precedence and are saved to the database.

6.2. Items as the Owning Side

As stated in the JPA specification under section 2.9, it's a good practice to mark many-to-one side as the owning side.

In other words, Items would be the owning side and Cart the inverse side, which is exactly what we did earlier.

So how did we achieve this?

By including the mappedBy attribute in the Cart class, we mark it as the inverse side.

At the same time, we also annotate the Items.cart field with @ManyToOne, making Items the owning side.

Going back to our “inconsistency” example, now Hibernate knows that the item2‘s reference is more important and will save item2‘s reference to the database.

Let's check the result:

item1 ID=1, Foreign Key Cart ID=1 item2 ID=2, Foreign Key Cart ID=2

Although cart references item2 in our snippet, item2‘s reference to cart2 is saved in the database.

6.3. Cart as the Owning Side

It's also possible to mark the one-to-many side as the owning side, and many-to-one side as the inverse side.

Although this is not a recommended practice, let's go ahead and give it a try.

The code snippet below shows the implementation of one-to-many side as the owning side:

public class ItemsOIO { // ... @ManyToOne @JoinColumn(name = "cart_id", insertable = false, updatable = false) private CartOIO cart; //.. } public class CartOIO { //.. @OneToMany @JoinColumn(name = "cart_id") // we need to duplicate the physical information private Set items; //.. } 

Notice how we removed the mappedBy element and set the many-to-one @JoinColumn as insertable and updatable to false.

If we run the same code, the result will be the opposite:

item1 ID=1, Foreign Key Cart ID=1 item2 ID=2, Foreign Key Cart ID=1

As shown above, now item2 belongs to cart.

7. Conclusion

We have seen how easy it is to implement the one-to-many relationship with the Hibernate ORM and H2 database using JPA annotations.

Additionally, we learned about bidirectional relationships and how to implement the notion of an owning side.

The source code in this article can be found over on GitHub.