Hibernează Tutorial de adnotare de la unu la mulți

1. Introducere

Acest tutorial rapid de hibernare ne va duce printr-un exemplu de mapare de la unu la mai multe folosind adnotări JPA, o alternativă la XML.

De asemenea, vom afla ce sunt relațiile bidirecționale, cum pot crea inconsecvențe și cum poate ajuta ideea de proprietate.

2. Descriere

Pur și simplu, cartografierea unu-la-mulți înseamnă că un rând dintr-un tabel este mapat pe mai multe rânduri dintr-un alt tabel.

Să vedem următoarea diagramă a relației entității pentru a vedea o asociere de la unu la mai mulți :

Pentru acest exemplu, vom implementa un sistem de coșuri în care avem un tabel pentru fiecare coș și un alt tabel pentru fiecare articol. Un singur coș poate avea multe articole, așa că aici avem o cartografiere de la unu la mai multe .

Modul în care funcționează la nivelul bazei de date este că avem un cart_id ca cheie principală în tabelul coșului și, de asemenea, un cart_id ca cheie străină în articole .

Modul în care o facem în cod este cu @OneToMany .

mapăm clasa Cart la obiectul Items într-un mod care să reflecte relația din baza de date:

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

De asemenea, putem adăuga o referință la Coș în articole folosind @ManyToOne , făcând din aceasta o relație bidirecțională. Bidirecțional înseamnă că putem accesa articole din cărucioare , precum și cărucioare din articole .

Proprietatea mappedBy este ceea ce folosim pentru a spune Hibernate ce variabilă folosim pentru a reprezenta clasa părinte din clasa noastră copil.

Următoarele tehnologii și biblioteci sunt utilizate pentru a dezvolta un eșantion de aplicație Hibernate care implementează o asociere de la unu la mai mulți :

  • JDK 1.8 sau o versiune ulterioară
  • Hibernează 5
  • Maven 3 sau o versiune ulterioară
  • Baza de date H2

3. Configurare

3.1. Configurarea bazei de date

Mai jos este scriptul bazei de date pentru tabelele Coș și articole . Folosim constrângerea cheii străine pentru cartografierea unu-la-mulți :

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;

Configurarea bazei noastre de date este gata, deci să trecem la crearea exemplului de proiect Hibernate.

3.2. Dependențe Maven

Vom adăuga apoi dependențele driverului Hibernate și H2 în fișierul nostru pom.xml . Dependența Hibernate folosește înregistrarea JBoss și se adaugă automat ca dependențe tranzitive:

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

Vă rugăm să vizitați depozitul central Maven pentru cele mai recente versiuni de Hibernate și dependențele H2.

3.3. Configurare hibernare

Iată configurația Hibernate:

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

3.4. HibernateAnnotationUtil Class

Cu clasa HibernateAnnotationUtil , trebuie doar să facem referire la noul fișier de configurare 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. Modelele

Configurările legate de mapare se vor face folosind adnotări JPA în clasele de model:

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

Vă rugăm să rețineți că adnotarea @OneToMany este utilizată pentru a defini proprietatea din clasa Items care va fi utilizată pentru maparea variabilei mappedBy . De aceea, avem o proprietate numită „ coș ” în clasa Items :

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

De asemenea, este important să rețineți că adnotarea @ManyToOne este asociată cu variabila de clasă Cart . Adnotarea @JoinColumn face referire la coloana mapată.

5. În acțiune

În programul de testare, creăm o clasă cu o metodă main () pentru obținerea sesiunii de hibernare și salvăm obiectele model în baza de date implementând asocierea unu-la-mulți :

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.