TOC

Hibernate - Exemple plusieurs à plusieurs (mappage XML)

Hibernate - Exemple plusieurs-à-plusieurs (mappage XML)

Les relations plusieurs-à-plusieurs se produisent lorsque chaque enregistrement d'une entité peut avoir plusieurs enregistrements liés dans une autre entité et vice-versa.

Dans ce didacticiel, nous vous montrons comment travailler avec une relation de table plusieurs à plusieurs dans Hibernate, via un fichier de mappage XML (hbm).

Note
Pour plusieurs à plusieurs avec des colonnes supplémentaires dans la table de jointure, veuillez vous référer à cetutorial.

Outils et technologies utilisés dans ces didacticiels:

  1. Hibernate 3.6.3.Final

  2. MySQL 5.1.15

  3. Maven 3.0.3

  4. Eclipse 3.6

Structure du projet

Structure du projet de ce tutoriel.

many to many project folder

Dépendance du projet

Obtenez les derniershibernate.jar du référentiel JBoss.

Fichier: 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. Exemple «plusieurs à plusieurs»

Il s'agit d'une conception de table de relations plusieurs-à-plusieurs, une table STOCK a plusieurs CATÉGORIES et CATEGORY peut appartenir à plusieurs STOCK, la relation est liée à une troisième table appelée STOCK_CATEGORY.

La table STOCK_CATEGORY se compose uniquement de deux clés primaires, ainsi que d'une référence de clé étrangère vers STOCK et CATEGORY.

many to many ER diagram

Scripts de table MySQL 

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. Classe de modèle Hibernate

Créez deux classes de modèle -Stock.java etCategory.java, pour représenter les tables ci-dessus. Pas besoin de créer une classe supplémentaire pour la table «stock_category».

Fichier: 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
}

Fichier: 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. Hibernate XML Mapping

Maintenant, créez deux fichiers de mappage Hibernate (hbm) -Stock.hbm.xml etCategory.hbm.xml. Vous remarquerez que la troisième table «stock_category» est une référence via la balise «many-to-many».

Fichier: Stock.hbm.xml

Fichier: Category.hbm.xml

4. Hibernate Configuration File

Maintenant, metStock.hbm.xml etCategory.hbm.xml et les détails MySQL danshibernate.cfg.xml.

Fichier: hibernate.cfg.xml 






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

5. Exécuter

Exécutez-le, Hibernate insérera un enregistrement dans la table STOCK, deux enregistrements dans la table CATEGORY et également deux enregistrements dans la table STOCK) CATEGORY.

Fichier: 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");
    }
}

Extrant… le résultat doit être explicite 

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
Pour l'annotation plusieurs-à-plusieurs dans Hibernate, veuillez vous référer à ceexample.

Téléchargez-le -Hibernate-many-to-many-xml-mapping.zip (10 Ko)

Référence

  1. Documentation Hibernate - relation plusieurs à plusieurs.

Related