Hibernate Many-to-Many-Mapping: Join-Tabellen einfach erklärt

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.

Passende Infrastruktur bei centron

Java-Anwendungen im Dauerbetrieb: ccloud³ VMs ab 3,12 € im Monat mit vollem Root-Zugriff, stundengenau abgerechnet. Cloud Server mieten →

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.

SQL

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.

<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">

<groupId>com.journaldev.hibernate</groupId>

<artifactId>HibernateManyToManyMapping</artifactId>

<version>0.0.1-SNAPSHOT</version>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-core</artifactId>

<version>4.3.5.Final</version>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency>

</dependencies>

</project>

Code

Hibernate Many-to-Many XML-Konfigurationsmodellklassen

Cart.java

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

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

<?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">

</id>

<many-to-many column="item_id" />

</set>

</class>

</hibernate-mapping>

Code

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

<?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">

</id>

<many-to-many 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

<?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>

</session-factory>

</hibernate-configuration>

Code

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

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

HibernateUtil.java

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

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

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

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

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

<?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>

</session-factory>

</hibernate-configuration>

Code

Hibernate SessionFactory Utility-Klasse für Annotationen

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

HibernateAnnotationUtil.java

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

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

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

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

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.

Jetzt 200 € Guthaben sichern

Testen Sie Ihr Setup auf ccloud³

Registrieren Sie sich in der ccloud³ und erhalten Sie 200 € Startguthaben für Ihr Projekt – z. B. für eine PostgreSQL-VM mit automatischen Backups.

Jetzt loslegen

Hibernate Many-to-Many-Mapping: Join-Tabellen einfach erklärt