Hibernate One to Many Annotation Tutorial

1. Introduzione

Questo rapido tutorial su Hibernate ci porterà attraverso un esempio di mappatura uno-a-molti utilizzando le annotazioni JPA, un'alternativa all'XML.

Impareremo anche cosa sono le relazioni bidirezionali, come possono creare incongruenze e come l'idea di proprietà può aiutare.

2. Descrizione

In poche parole, la mappatura uno-a-molti significa che una riga in una tabella viene mappata a più righe in un'altra tabella.

Diamo un'occhiata al seguente diagramma delle relazioni tra entità per vedere un'associazione uno-a-molti :

Per questo esempio, implementeremo un sistema di carrelli in cui abbiamo una tabella per ogni carrello e un'altra tabella per ogni articolo. Un carrello può contenere molti articoli, quindi qui abbiamo una mappatura uno-a-molti .

Il modo in cui funziona a livello di database è che abbiamo un cart_id come chiave primaria nella tabella del carrello e anche un cart_id come chiave esterna negli articoli .

Il modo in cui lo facciamo nel codice è con @OneToMany .

Mappiamo la classe Cart all'oggetto Items in un modo che rifletta la relazione nel database:

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

Possiamo anche aggiungere un riferimento al carrello negli articoli utilizzando @ManyToOne , rendendo questa relazione bidirezionale. Bidirezionale significa che siamo in grado di accedere agli articoli dai carrelli e anche ai carrelli dagli articoli .

La proprietà mappedBy è ciò che usiamo per dire a Hibernate quale variabile stiamo usando per rappresentare la classe genitore nella nostra classe figlia.

Le seguenti tecnologie e librerie vengono utilizzate per sviluppare un'applicazione Hibernate di esempio che implementa l' associazione uno-a-molti :

  • JDK 1.8 o successivo
  • Ibernazione 5
  • Maven 3 o versioni successive
  • Database H2

3. Configurazione

3.1. Configurazione del database

Di seguito è riportato il nostro script di database per le tabelle Carrello e Articoli . Usiamo il vincolo di chiave esterna per la mappatura uno-a-molti :

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;

La configurazione del nostro database è pronta, quindi passiamo alla creazione del progetto di esempio Hibernate.

3.2. Dipendenze di Maven

Aggiungeremo quindi le dipendenze dei driver Hibernate e H2 al nostro file pom.xml . La dipendenza Hibernate utilizza la registrazione JBoss e viene automaticamente aggiunta come dipendenze transitive:

  • Hibernate versione 5 .2.7.Final
  • Driver H2 versione 1 .4.197

Visita il repository centrale di Maven per le ultime versioni di Hibernate e le dipendenze H2.

3.3. Configurazione di ibernazione

Ecco la configurazione di Hibernate:

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

3.4. HibernateAnnotationUtil Class

Con la classe HibernateAnnotationUtil , dobbiamo solo fare riferimento al nuovo file di configurazione di 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. I modelli

Le configurazioni relative alla mappatura verranno eseguite utilizzando le annotazioni JPA nelle classi del modello:

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

Si noti che l' annotazione @OneToMany viene utilizzata per definire la proprietà nella classe Items che verrà utilizzata per mappare la variabile mappedBy . Questo è il motivo per cui abbiamo una proprietà denominata " carrello " nella classe Items :

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

È anche importante notare che l' annotazione @ManyToOne è associata alla variabile di classe Cart . L' annotazione @JoinColumn fa riferimento alla colonna mappata.

5. In azione

Nel programma di test, stiamo creando una classe con un metodo main () per ottenere la sessione Hibernate e salvando gli oggetti del modello nel database implementando l' associazione uno-a-molti :

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.