Maximale Performance bei minimalen Kosten. Jetzt Server in Sekunden starten!

    Hibernate Many-to-Many-Mapping mit XML- und Annotationskonfigurationen

    Heute werfen wir einen Blick auf Many-to-Many-Mapping mit XML- und Annotationskonfigurationen. Zuvor haben wir untersucht, wie One-to-One- und One-to-Many-Mapping in Hibernate implementiert werden können.

    Hibernate Many-to-Many

    Many-to-Many-Mapping wird in der Regel in einer Datenbank mithilfe einer Join-Tabelle implementiert. Zum Beispiel können wir eine Warenkorb-Tabelle (Cart) und eine Artikel-Tabelle (Item) sowie eine Cart_Items-Tabelle für das Many-to-Many-Mapping haben. Jeder Warenkorb kann mehrere Artikel enthalten, und jeder Artikel kann Teil mehrerer Warenkörbe sein, wodurch wir hier ein Many-to-Many-Mapping haben.

    Datenbank-Setup

    Das folgende Skript kann verwendet werden, um unsere Datenbanktabellen für das Many-to-Many-Mapping-Beispiel zu erstellen. Diese Skripte sind für MySQL-Datenbanken. Wenn Sie eine andere Datenbank verwenden, müssen Sie möglicherweise kleine Änderungen vornehmen, damit es funktioniert.

    Code kopieren 
    

    DROP TABLE IF EXISTS `Cart_Items`;
DROP TABLE IF EXISTS `Cart`;
DROP TABLE IF EXISTS `Item`;

CREATE TABLE `Cart` (
  `cart_id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `cart_total` decimal(10,0) NOT NULL,
  PRIMARY KEY (`cart_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

CREATE TABLE `Item` (
  `item_id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `item_desc` varchar(20) NOT NULL,
  `item_price` decimal(10,0) NOT NULL,
  PRIMARY KEY (`item_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `Cart_Items` (
  `cart_id` int(11) unsigned NOT NULL,
  `item_id` int(11) unsigned NOT NULL,
  PRIMARY KEY (`cart_id`,`item_id`),
  CONSTRAINT `fk_cart` FOREIGN KEY (`cart_id`) REFERENCES `Cart` (`cart_id`),
  CONSTRAINT `fk_item` FOREIGN KEY (`item_id`) REFERENCES `Item` (`item_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    Beachten Sie, dass die Cart_Items-Tabelle keine zusätzlichen Spalten hat. Tatsächlich ergibt es wenig Sinn, zusätzliche Spalten in einer Many-to-Many-Mapping-Tabelle zu haben. Wenn Sie jedoch zusätzliche Spalten haben, ändert sich die Implementierung ein wenig, und wir werden dies in einem anderen Beitrag betrachten. Das folgende Diagramm zeigt die Entitätsbeziehung zwischen diesen Tabellen.

    Unser Datenbank-Setup ist jetzt bereit. Lassen Sie uns mit der Erstellung des Hibernate-Many-to-Many-Mapping-Projekts fortfahren.

    Many-to-Many-Mapping-Projektstruktur

    Erstellen Sie ein Maven-Projekt in Eclipse oder Ihrer bevorzugten IDE. Das folgende Bild zeigt die Struktur und die verschiedenen Komponenten in der Anwendung.

    Wir werden zunächst die Implementierungen auf Basis von XML-Mapping betrachten und dann zu JPA-Annotationen übergehen.

    Hibernate Maven-Abhängigkeiten

    Unsere endgültige pom.xml enthält Hibernate-Abhängigkeiten mit der neuesten Version 4.3.5.Final und MySQL-Treiber-Abhängigkeiten.

    Code kopieren 
    

    <project xmlns=“https://maven.apache.org/POM/4.0.0″ xmlns:xsi=“https://www.w3.org/2001/XMLSchema-instance“
    
xsi:schemaLocation=“https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd“>
    
<modelVersion>4.0.0</modelVersion>
    
<groupId>com.journaldev.hibernate</groupId>
    
<artifactId>HibernateManyToManyMapping</artifactId>
    
<version>0.0.1-SNAPSHOT</version>
    

    <dependencies>
    
<dependency>
    
<groupId>org.hibernate</groupId>
    
<artifactId>hibernate-core</artifactId>
    
<version>4.3.5.Final</version>
    
</dependency>
    
<dependency>
    
<groupId>mysql</groupId>
    
<artifactId>mysql-connector-java</artifactId>
    
<version>5.0.5</version>
    
</dependency>
    
</dependencies>
    

    </project>

    Hibernate Many-to-Many XML-Konfigurationsmodellklassen

    Cart.java

    Code kopieren 
    

    package com.journaldev.hibernate.model;

import java.util.Set;

public class Cart {

    private long id;
    private double total;

    private Set items;

    public double getTotal() {
        return total;
    }

    public void setTotal(double total) {
        this.total = total;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public Set getItems() {
        return items;
    }

    public void setItems(Set items) {
        this.items = items;
    }

}

    Item.java

    Code kopieren 
    

    package com.journaldev.hibernate.model;

import java.util.Set;

public class Item {

    private long id;
    private double price;
    private String description;

    private Set carts;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Set getCarts() {
        return carts;
    }

    public void setCarts(Set carts) {
        this.carts = carts;
    }
}

    Beachten Sie, dass die Klasse Cart eine Menge von Item-Objekten enthält und die Klasse Item eine Menge von Cart-Objekten. Auf diese Weise implementieren wir eine bidirektionale Assoziation. Das bedeutet, dass wir konfigurieren können, dass ein Artikel gespeichert wird, wenn wir einen Warenkorb speichern, und umgekehrt. Für ein unidirektionales Mapping hätten wir normalerweise nur eine Menge in einer der Modellklassen.

    Many-to-Many-Mapping XML-Konfiguration

    Erstellen wir nun die Hibernate-Many-to-Many-Mapping-XML-Konfigurationsdateien für Cart und Item. Wir werden ein bidirektionales Many-to-Many-Mapping implementieren.

    cart.hbm.xml

    Code kopieren 
    

    <?xml version=“1.0″?>
    

    <!DOCTYPE hibernate-mapping PUBLIC „-//Hibernate/Hibernate Mapping DTD 3.0//EN“
    

     „https://hibernate.org/dtd/hibernate-mapping-3.0.dtd“>
    

    

    <hibernate-mapping package=“com.journaldev.hibernate.model“>
    

     <class name=“Cart“ table=“CART“>
    

     <id name=“id“ type=“long“>
    

     <column name=“cart_id“ />
    

     <generator class=“identity“ />
    

     </id>
    

     <property name=“total“ type=“double“ column=“cart_total“ />
    

    

     <set name=“items“ table=“CART_ITEMS“ fetch=“select“ cascade=“all“>
    

     <key column=“cart_id“ />
    

     <many-to-many class=“Item“ column=“item_id“ />
    

     </set>
    

     </class>
    

    

    </hibernate-mapping>
    

    

    
			
    
        
    

    Beachten Sie, dass das Set von Items auf die Tabelle CART_ITEMS abgebildet ist. Da Cart das primäre Objekt ist, ist cart_id der Schlüssel, und das Many-to-Many-Mapping verwendet die Klasse Item und die Spalte item_id.
    

    item.hbm.xml
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    <?xml version=“1.0″ encoding=“UTF-8″?>
    

     
    

    <!DOCTYPE hibernate-mapping PUBLIC „-//Hibernate/Hibernate Mapping DTD 3.0//EN“
    

     
    

    „https://hibernate.org/dtd/hibernate-mapping-3.0.dtd“ >
    

     
    

    

     
    

    <hibernate-mapping package=“com.journaldev.hibernate.model“>
    

     
    

    

     
    

     <class name=“Item“ table=“ITEM“>
    

     
    

     <id name=“id“ type=“long“>
    

     
    

     <column name=“item_id“ />
    

     
    

     <generator class=“identity“ />
    

     
    

     </id>
    

     
    

     <property name=“description“ type=“string“ column=“item_desc“ />
    

     
    

    

     
    

     <property name=“price“ type=“double“ column=“item_price“ />
    

     
    

    

     
    

     <set name=“carts“ table=“CART_ITEMS“ fetch=“select“ cascade=“all“>
    

     
    

     <key column=“item_id“ />
    

     
    

     <many-to-many class=“Cart“ column=“cart_id“ />
    

     
    

     </set>
    

     
    

    

     
    

     </class>
    

     
    

    

     
    

    </hibernate-mapping>
    

     
    

    
			
    
        
    

    Wie Sie sehen, ist das Mapping für die Klasse Item der Konfiguration für Cart sehr ähnlich.
    

    Hibernate-Konfiguration für XML-basiertes Many-to-Many-Mapping
    

    Unsere Hibernate-Konfigurationsdatei sieht wie folgt aus.
    

    hibernate.cfg.xml
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    <?xml version=“1.0″ encoding=“UTF-8″?>
    

    <!DOCTYPE hibernate-configuration PUBLIC
    

     „-//Hibernate/Hibernate Configuration DTD 3.0//EN“
    

     „https://hibernate.org/dtd/hibernate-configuration-3.0.dtd“>
    

    <hibernate-configuration>
    

     <session-factory>
    

     <property name=“hibernate.connection.driver_class“>com.mysql.jdbc.Driver</property>
    

     <property name=“hibernate.connection.password“>pankaj123</property>
    

     <property name=“hibernate.connection.url“>jdbc:mysql://localhost/TestDB</property>
    

     <property name=“hibernate.connection.username“>pankaj</property>
    

     <property name=“hibernate.dialect“>org.hibernate.dialect.MySQLDialect</property>
    

    

     <property name=“hibernate.current_session_context_class“>thread</property>
    

     <property name=“hibernate.show_sql“>true</property>
    

    

     <mapping resource=“cart.hbm.xml“ />
    

     <mapping resource=“item.hbm.xml“ />
    

     </session-factory>
    

    </hibernate-configuration>
    

    

    
			
    
        
    

    Hibernate SessionFactory Utility-Klasse für XML-basiertes Mapping
    

    Hier ist eine Utility-Klasse, die als Factory für die SessionFactory dient.
    

    HibernateUtil.java
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    package com.journaldev.hibernate.util;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class HibernateUtil {

    private static SessionFactory sessionFactory;

    private static SessionFactory buildSessionFactory() {
        try {
            // Erstellen der SessionFactory aus hibernate.cfg.xml
            Configuration configuration = new Configuration();
            configuration.configure("hibernate.cfg.xml");
            System.out.println("Hibernate-Konfiguration geladen");

            ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
                    .applySettings(configuration.getProperties()).build();
            System.out.println("Hibernate-ServiceRegistry erstellt");

            SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);

            return sessionFactory;
        } catch (Throwable ex) {
            System.err.println("Erstellung der SessionFactory fehlgeschlagen." + ex);
            ex.printStackTrace();
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        if (sessionFactory == null)
            sessionFactory = buildSessionFactory();
        return sessionFactory;
    }
}

    

    
			
    
        
    

    Hibernate Many-to-Many-Mapping XML-Testprogramm
    

    Unser Hibernate-Many-to-Many-Mapping-Setup ist bereit. Lassen Sie uns dies testen. Wir schreiben zwei Programme: eines, um einen Warenkorb zu speichern und zu überprüfen, ob die Artikel- und Cart_Items-Informationen ebenfalls gespeichert werden, und ein weiteres, um Artikeldaten zu speichern und sicherzustellen, dass der entsprechende Warenkorb und die Cart_Items gespeichert werden.
    

    HibernateManyToManyMain.java
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    package com.journaldev.hibernate.main;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import com.journaldev.hibernate.model.Cart;
import com.journaldev.hibernate.model.Item;
import com.journaldev.hibernate.util.HibernateUtil;

public class HibernateManyToManyMain {

    // Many-to-Many speichern, wobei Cart primär ist
    public static void main(String[] args) {

        Item iphone = new Item();
        iphone.setPrice(100);
        iphone.setDescription("iPhone");

        Item ipod = new Item();
        ipod.setPrice(50);
        ipod.setDescription("iPod");

        Set items = new HashSet<>();
        items.add(iphone);
        items.add(ipod);

        Cart cart = new Cart();
        cart.setItems(items);
        cart.setTotal(150);

        Cart cart1 = new Cart();
        Set items1 = new HashSet<>();
        items1.add(iphone);
        cart1.setItems(items1);
        cart1.setTotal(100);

        SessionFactory sessionFactory = null;
        try {
            sessionFactory = HibernateUtil.getSessionFactory();
            Session session = sessionFactory.getCurrentSession();
            Transaction tx = session.beginTransaction();
            session.save(cart);
            session.save(cart1);
            System.out.println("Vor Commit der Transaktion");
            tx.commit();
            sessionFactory.close();

            System.out.println("Cart ID=" + cart.getId());
            System.out.println("Cart1 ID=" + cart1.getId());
            System.out.println("Item1 ID=" + iphone.getId());
            System.out.println("Item2 ID=" + ipod.getId());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (sessionFactory != null && !sessionFactory.isClosed())
                sessionFactory.close();
        }
    }
}

    

    
			
    
        
    

    Wenn wir das obige Hibernate-Many-to-Many-Mapping-Programm ausführen, erhalten wir die folgende Ausgabe:
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    Hibernate-Konfiguration geladen
Hibernate-ServiceRegistry erstellt
Hibernate: insert into CART (cart_total) values (?)
Hibernate: insert into ITEM (item_desc, item_price) values (?, ?)
Hibernate: insert into ITEM (item_desc, item_price) values (?, ?)
Hibernate: insert into CART (cart_total) values (?)
Vor Commit der Transaktion
Hibernate: insert into CART_ITEMS (cart_id, item_id) values (?, ?)
Hibernate: insert into CART_ITEMS (cart_id, item_id) values (?, ?)
Hibernate: insert into CART_ITEMS (cart_id, item_id) values (?, ?)
Cart ID=1
Cart1 ID=2
Item1 ID=1
Item2 ID=2

    

    
			
    
        
    

    HibernateBiDirectionalManyToManyMain.java
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    package com.journaldev.hibernate.main;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import com.journaldev.hibernate.model.Cart;
import com.journaldev.hibernate.model.Item;
import com.journaldev.hibernate.util.HibernateUtil;

public class HibernateBiDirectionalManyToManyMain {

    // Many-to-Many speichern, wobei Item primär ist
    public static void main(String[] args) {

        Item iphone = new Item();
        iphone.setPrice(100);
        iphone.setDescription("iPhone");

        Item ipod = new Item();
        ipod.setPrice(50);
        ipod.setDescription("iPod");

        Cart cart = new Cart();
        cart.setTotal(150);

        Cart cart1 = new Cart();
        cart1.setTotal(100);

        Set cartSet = new HashSet<>();
        cartSet.add(cart);
        cartSet.add(cart1);

        Set cartSet1 = new HashSet<>();
        cartSet1.add(cart);

        iphone.setCarts(cartSet1);
        ipod.setCarts(cartSet);

        SessionFactory sessionFactory = null;
        try {
            sessionFactory = HibernateUtil.getSessionFactory();
            Session session = sessionFactory.getCurrentSession();
            Transaction tx = session.beginTransaction();
            session.save(iphone);
            session.save(ipod);
            tx.commit();
            sessionFactory.close();

            System.out.println("Cart ID=" + cart.getId());
            System.out.println("Cart1 ID=" + cart1.getId());
            System.out.println("Item1 ID=" + iphone.getId());
            System.out.println("Item2 ID=" + ipod.getId());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (sessionFactory != null && !sessionFactory.isClosed())
                sessionFactory.close();
        }
    }
}

    

    
			
    
        
    

    Die Ausgabe des obigen Programms lautet:
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    Hibernate-Konfiguration geladen
Hibernate-ServiceRegistry erstellt
Hibernate: insert into ITEM (item_desc, item_price) values (?, ?)
Hibernate: insert into CART (cart_total) values (?)
Hibernate: insert into ITEM (item_desc, item_price) values (?, ?)
Hibernate: insert into CART (cart_total) values (?)
Hibernate: insert into CART_ITEMS (item_id, cart_id) values (?, ?)
Hibernate: insert into CART_ITEMS (item_id, cart_id) values (?, ?)
Hibernate: insert into CART_ITEMS (item_id, cart_id) values (?, ?)
Cart ID=3
Cart1 ID=4
Item1 ID=3
Item2 ID=4

    

    
			
    
        
    

    Sie können das leicht mit dem vorherigen Testprogramm vergleichen. Da wir ein bidirektionales Mapping konfiguriert haben, können wir entweder Item oder Cart speichern, und die zugehörigen Daten werden automatisch gespeichert.
    

    Hibernate Many-to-Many-Mapping mit Annotationen
    

    Jetzt, da wir gesehen haben, wie man Many-to-Many-Mapping mit Hibernate-XML-Konfigurationen einrichtet, werfen wir einen Blick auf ein Beispiel, wie dies mit Annotationen implementiert werden kann. Wir werden ein unidirektionales Many-to-Many-Mapping mit JPA-Annotationen implementieren.
    

    Hibernate-Konfigurationsdatei für Annotationen
    

    hibernate-annotation.cfg.xml
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    <?xml version=“1.0″ encoding=“UTF-8″?>
    

    <!DOCTYPE hibernate-configuration PUBLIC
    

     „-//Hibernate/Hibernate Configuration DTD 3.0//EN“
    

     „https://hibernate.org/dtd/hibernate-configuration-3.0.dtd“>
    

    <hibernate-configuration>
    

     <session-factory>
    

     <property name=“hibernate.connection.driver_class“>com.mysql.jdbc.Driver</property>
    

     <property name=“hibernate.connection.password“>pankaj123</property>
    

     <property name=“hibernate.connection.url“>jdbc:mysql://localhost/TestDB</property>
    

     <property name=“hibernate.connection.username“>pankaj</property>
    

     <property name=“hibernate.dialect“>org.hibernate.dialect.MySQLDialect</property>
    

    

     <property name=“hibernate.current_session_context_class“>thread</property>
    

     <property name=“hibernate.show_sql“>true</property>
    

    

     <mapping class=“com.journaldev.hibernate.model.Cart1″ />
    

     <mapping class=“com.journaldev.hibernate.model.Item1″ />
    

     </session-factory>
    

    </hibernate-configuration>
    

    

    
			
    
        
    

    Hibernate SessionFactory Utility-Klasse für Annotationen
    

    Unsere Utility-Klasse für die Erstellung der SessionFactory sieht wie folgt aus.
    

    HibernateAnnotationUtil.java
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    package com.journaldev.hibernate.util;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class HibernateAnnotationUtil {

    private static SessionFactory sessionFactory;

    private static SessionFactory buildSessionFactory() {
        try {
            // Erstellung der SessionFactory aus hibernate-annotation.cfg.xml
            Configuration configuration = new Configuration();
            configuration.configure("hibernate-annotation.cfg.xml");
            System.out.println("Hibernate-Annotation-Konfiguration geladen");

            ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
                    .applySettings(configuration.getProperties()).build();
            System.out.println("Hibernate-ServiceRegistry erstellt");

            SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);

            return sessionFactory;
        } catch (Throwable ex) {
            System.err.println("Initiale Erstellung der SessionFactory fehlgeschlagen." + ex);
            ex.printStackTrace();
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        if (sessionFactory == null)
            sessionFactory = buildSessionFactory();
        return sessionFactory;
    }
}

    

    
			
    
        
    

    Hibernate Many-to-Many-Mapping-Modelklassen mit Annotationen
    

    Dies ist der wichtigste Teil für Mapping auf Basis von Annotationen. Schauen wir uns zunächst die Modellklasse für die Tabelle Item an, und danach betrachten wir die Modellklasse für die Tabelle Cart.
    

    Item1.java
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    package com.journaldev.hibernate.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="ITEM")
public class Item1 {

    @Id
    @Column(name="item_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private long id;

    @Column(name="item_price")
    private double price;

    @Column(name="item_desc")
    private String description;

    // Getter- und Setter-Methoden
}

    

    
			
    
        
    

    Die Klasse Item1 sieht einfach aus, da es keine relationale Zuordnung gibt.
    

    Cart1.java
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    package com.journaldev.hibernate.model;

import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name = "CART")
public class Cart1 {

    @Id
    @Column(name = "cart_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(name = "cart_total")
    private double total;

    @ManyToMany(targetEntity = Item1.class, cascade = { CascadeType.ALL })
    @JoinTable(name = "CART_ITEMS",
            joinColumns = { @JoinColumn(name = "cart_id") },
            inverseJoinColumns = { @JoinColumn(name = "item_id") })
    private Set items;

    // Getter- und Setter-Methoden
}

    

    
			
    
        
    

    Der wichtigste Teil hier ist die Verwendung der Annotation @ManyToMany und der @JoinTable-Annotation, in der wir den Tabellennamen und die Spalten für das Many-to-Many-Mapping angeben.
    

    Hibernate Many-to-Many-Mapping-Annotationen-Testprogramm
    

    Hier ist ein einfaches Testprogramm für unsere Hibernate-Many-to-Many-Mapping-Annotationen-Konfiguration.
    

    HibernateManyToManyAnnotationMain.java
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    package com.journaldev.hibernate.main;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import com.journaldev.hibernate.model.Cart1;
import com.journaldev.hibernate.model.Item1;
import com.journaldev.hibernate.util.HibernateAnnotationUtil;

public class HibernateManyToManyAnnotationMain {

    public static void main(String[] args) {
        Item1 item1 = new Item1();
        item1.setDescription("Samsung");
        item1.setPrice(300);

        Item1 item2 = new Item1();
        item2.setDescription("Nokia");
        item2.setPrice(200);

        Cart1 cart = new Cart1();
        cart.setTotal(500);

        Set items = new HashSet<>();
        items.add(item1);
        items.add(item2);
        cart.setItems(items);

        SessionFactory sessionFactory = null;
        try {
            sessionFactory = HibernateAnnotationUtil.getSessionFactory();
            Session session = sessionFactory.getCurrentSession();
            Transaction tx = session.beginTransaction();
            session.save(cart);
            System.out.println("Vor Commit der Transaktion");
            tx.commit();
            sessionFactory.close();

            System.out.println("Cart ID=" + cart.getId());
            System.out.println("Item1 ID=" + item1.getId());
            System.out.println("Item2 ID=" + item2.getId());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (sessionFactory != null && !sessionFactory.isClosed())
                sessionFactory.close();
        }
    }
}

    

    
			
    
        
    

    Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe:
    

    
			
    
                
    
                    
    
                        
    
                        
    
                        
    
                    
    
                    
    
                        
                        Code kopieren
                        
                        
                    
    
                
    
                
    

    Hibernate-Annotation-Konfiguration geladen
Hibernate-ServiceRegistry erstellt
Hibernate: insert into CART (cart_total) values (?)
Hibernate: insert into ITEM (item_desc, item_price) values (?, ?)
Hibernate: insert into ITEM (item_desc, item_price) values (?, ?)
Vor Commit der Transaktion
Hibernate: insert into CART_ITEMS (cart_id, item_id) values (?, ?)
Hibernate: insert into CART_ITEMS (cart_id, item_id) values (?, ?)
Cart ID=5
Item1 ID=6
Item2 ID=5

    

    
			
    
        
    

    Es ist klar, dass das Speichern eines Warenkorbs auch die Daten in den Tabellen Item und Cart_Items speichert. Wenn Sie jedoch nur die Informationen zu den Artikeln speichern, werden die zugehörigen Daten für den Warenkorb und die Join-Tabelle nicht gespeichert.
    

    Fazit
    

    Hibernate Many-to-Many-Mapping bietet eine leistungsstarke Möglichkeit, komplexe Beziehungen in relationalen Datenbanken zu verwalten. Ob Sie XML-Konfigurationen oder Annotationen verwenden, Hibernate vereinfacht den Prozess der Handhabung bidirektionaler oder unidirektionaler Zuordnungen effizient. Durch den Einsatz von Werkzeugen wie @ManyToMany und @JoinTable können Entwickler die Datenpersistenz optimieren und die Integrität zwischen den zugehörigen Entitäten sicherstellen. Die Wahl zwischen XML und Annotationen hängt von den Projektanforderungen und persönlichen Vorlieben ab, aber beide Methoden bieten robuste Lösungen für die Verwaltung von Many-to-Many-Beziehungen. Wie demonstriert, ermöglicht Hibernate Flexibilität und Skalierbarkeit für fortschrittliche ORM-Konfigurationen und ist damit eine bevorzugte Wahl für Unternehmensanwendungen.
    

    

    Kostenlosen Account erstellen
    

    

    Registrieren Sie sich jetzt und erhalten Sie Zugang zu unseren Cloud Produkten.
    

    

    Jetzt loslegen
    

    Das könnte Sie auch interessieren:
    

    	
    
		
    
						
    centron Managed Cloud Hosting in Deutschland
    Java-Array: So prüfst du Werte effizient
    JavaScript
    Wie prüft man, ob ein Java Array einen Wert enthält? Es gibt viele Möglichkeiten, um zu überprüfen, ob ein Java Array einen bestimmten Wert enthält. Einfache Iteration mit einer for-Schleife…
    		
    
			
    
	
    
		
    
						
    centron Managed Cloud Hosting in Deutschland
    Wie berechnet man den BLEU-Score in Python?
    Python
    Wie berechnet man den BLEU-Score in Python? Der BLEU-Score in Python ist eine Metrik, die die Güte von maschinellen Übersetzungsmodellen misst. Ursprünglich wurde er nur für Übersetzungsmodelle entwickelt, wird jedoch…