TOC

Ruhezustand - Many-to-Many-Beispiel (XML-Zuordnung)

Ruhezustand - Viele-zu-Viele-Beispiel (XML-Zuordnung)

Viele-zu-viele-Beziehungen treten auf, wenn jeder Datensatz in einer Entität möglicherweise viele verknüpfte Datensätze in einer anderen Entität enthält und umgekehrt.

In diesem Tutorial zeigen wir Ihnen, wie Sie mit einer Many-to-Many-Tabellenbeziehung in Hibernate über eine XML-Zuordnungsdatei (hbm) arbeiten.

Note
Für viele bis viele mit zusätzlichen Spalten in der Verknüpfungstabelle lesen Sie bitte diesetutorial.

In diesen Tutorials verwendete Tools und Technologien:

  1. Ruhezustand 3.6.3.Final

  2. MySQL 5.1.15

  3. Maven 3.0.3

  4. Eclipse 3.6

Projektstruktur

Projektstruktur dieses Tutorials.

many to many project folder

Projektabhängigkeit

Holen Sie sich die neuestenhibernate.jar aus dem JBoss-Repository.

Datei: pom.xml 



    
        
            JBoss repository
            http://repository.jboss.org/nexus/content/groups/public/
        
    

    

        
        
            mysql
            mysql-connector-java
            5.1.15
        

        
            org.hibernate
            hibernate-core
            3.6.3.Final
        

        
            javassist
            javassist
            3.12.1.GA

1. Beispiel „viele zu viele“

Dies ist ein Viele-zu-Viele-Beziehungstabellenentwurf, eine STOCK-Tabelle hat mehr als eine KATEGORIE und KATEGORIE kann zu mehr als einem STOCK gehören, die Beziehung ist mit einer dritten Tabelle namens STOCK_CATEGORY verknüpft.

Die Tabelle STOCK_CATEGORY besteht nur aus zwei Primärschlüsseln sowie einer Fremdschlüsselreferenz auf STOCK und CATEGORY.

many to many ER diagram

MySQL-Tabellenskripte 

CREATE TABLE `stock` (
  `STOCK_ID` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `STOCK_CODE` varchar(10) NOT NULL,
  `STOCK_NAME` varchar(20) NOT NULL,
  PRIMARY KEY (`STOCK_ID`) USING BTREE,
  UNIQUE KEY `UNI_STOCK_NAME` (`STOCK_NAME`),
  UNIQUE KEY `UNI_STOCK_ID` (`STOCK_CODE`) USING BTREE
)

CREATE TABLE `category` (
  `CATEGORY_ID` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `NAME` varchar(10) NOT NULL,
  `DESC` varchar(255) NOT NULL,
  PRIMARY KEY (`CATEGORY_ID`) USING BTREE
)

CREATE TABLE  `stock_category` (
  `STOCK_ID` int(10) unsigned NOT NULL,
  `CATEGORY_ID` int(10) unsigned NOT NULL,
  PRIMARY KEY (`STOCK_ID`,`CATEGORY_ID`),
  CONSTRAINT `FK_CATEGORY_ID` FOREIGN KEY (`CATEGORY_ID`) REFERENCES `category` (`CATEGORY_ID`),
  CONSTRAINT `FK_STOCK_ID` FOREIGN KEY (`STOCK_ID`) REFERENCES `stock` (`STOCK_ID`)
)

2. Hibernate Model Class

Erstellen Sie zwei Modellklassen -Stock.java undCategory.java, um die obigen Tabellen darzustellen. Es ist nicht erforderlich, eine zusätzliche Klasse für die Tabelle 'stock_category' zu erstellen.

Datei: Stock.java 

package com.example.stock;

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

public class Stock implements java.io.Serializable {

    private Integer stockId;
    private String stockCode;
    private String stockName;
    private Set categories = new HashSet(0);

    //getter, setter and constructor
}

Datei: Category.java 

package com.example.stock;

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

public class Category implements java.io.Serializable {

    private Integer categoryId;
    private String name;
    private String desc;
    private Set stocks = new HashSet(0);

    //getter, setter and constructor
}

3. Ruhezustand XML-Zuordnung

Erstellen Sie nun zwei Hibernate-Zuordnungsdateien (hbm) -Stock.hbm.xml undCategory.hbm.xml. Sie werden feststellen, dass die dritte Tabelle "stock_category" über das Tag "many-to-many" referenziert wird.

Datei: Stock.hbm.xml

Datei: Category.hbm.xml

4. Ruhezustand-Konfigurationsdatei

Setzt nunStock.hbm.xml undCategory.hbm.xml und MySQL-Details inhibernate.cfg.xml.

Datei: hibernate.cfg.xml 






    com.mysql.jdbc.Driver
    jdbc:mysql://localhost:3306/exampledb
    root
    password
    org.hibernate.dialect.MySQLDialect
    true
    true

5. Starte es

Wenn Sie es ausführen, fügt Hibernate einen Datensatz in die Tabelle STOCK, zwei Datensätze in die Tabelle CATEGORY und zwei Datensätze in die Tabelle STOCK) CATEGORY ein.

Datei: App.java 

package com.example;

import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import com.example.stock.Category;
import com.example.stock.Stock;
import com.example.util.HibernateUtil;

public class App {
    public static void main(String[] args) {

        System.out.println("Hibernate many to many (XML Mapping)");
    Session session = HibernateUtil.getSessionFactory().openSession();

    session.beginTransaction();

    Stock stock = new Stock();
        stock.setStockCode("7052");
        stock.setStockName("PADINI");

        Category category1 = new Category("CONSUMER", "CONSUMER COMPANY");
        Category category2 = new Category("INVESTMENT", "INVESTMENT COMPANY");

        Set categories = new HashSet();
        categories.add(category1);
        categories.add(category2);

        stock.setCategories(categories);

        session.save(stock);

    session.getTransaction().commit();
    System.out.println("Done");
    }
}

Ausgabe… Ergebnis sollte selbsterklärend sein 

Hibernate many to many (XML Mapping)
Hibernate:
    insert
    into
        exampledb.stock
        (STOCK_CODE, STOCK_NAME)
    values
        (?, ?)
Hibernate:
    insert
    into
        exampledb.category
        (NAME, `DESC`)
    values
        (?, ?)
Hibernate:
    insert
    into
        exampledb.category
        (NAME, `DESC`)
    values
        (?, ?)
Hibernate:
    insert
    into
        stock_category
        (STOCK_ID, CATEGORY_ID)
    values
        (?, ?)
Hibernate:
    insert
    into
        stock_category
        (STOCK_ID, CATEGORY_ID)
    values
        (?, ?)
Done

Hibernate Annotation
Für viele-zu-viele-Annotationen im Ruhezustand lesen Sie bitte dieseexample.

Laden Sie es herunter -Hibernate-many-to-many-xml-mapping.zip (10 KB)

Referenz

  1. Hibernate-Dokumentation - viele zu viele Beziehungen.

Related