Hoje vamos analisar o Mapeamento Many to Many do Hibernate usando configurações XML e de anotação. Anteriormente, vimos como implementar o One To One e o mapeamento One To Many no Hibernate.
O Mapeamento Many to Many do Hibernate
Many-to-Many é geralmente implementado no banco de dados usando uma Tabela de Junção. Por exemplo, podemos ter as tabelas Cart e Item e a tabela Cart_Items para o mapeamento many-to-many. Cada carrinho pode ter vários itens e cada item pode fazer parte de vários carrinhos, então temos um mapeamento many to many aqui.
Configuração do Banco de Dados para Mapeamento Many to Many do Hibernate
O script abaixo pode ser usado para criar as tabelas de exemplo many-to-many do nosso banco de dados, esses scripts são para o banco de dados MySQL. Se você estiver usando outro banco de dados, talvez seja necessário fazer pequenas alterações para que funcione.
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;
Observe que a tabela Cart_Items não possui colunas extras, na verdade não faz muito sentido ter colunas extras em uma tabela de mapeamento muitos para muitos. Mas se você tiver colunas extras, a implementação muda um pouco e vamos analisar isso em outra postagem. O diagrama abaixo mostra o relacionamento de entidade entre essas tabelas. 
Nossa configuração de banco de dados está pronta agora, vamos avançar para criar o projeto de mapeamento muitos para muitos do Hibernate.
Estrutura do Projeto de Mapeamento Muitos para Muitos do Hibernate
Crie um projeto Maven no Eclipse ou no seu IDE favorito, a imagem abaixo mostra a estrutura e diferentes componentes na aplicação. 
Primeiro vamos analisar as implementações de mapeamento baseadas em XML e depois passar para o uso de anotações JPA.
Dependências do Maven do Hibernate
4.3.5.Final
“`
O nosso ficheiro final `pom.xml` contém as dependências do Hibernate com a versão mais recente 4.3.5.Final e as dependências do driver MySQL. pom.xml
<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>
Classes de Configuração XML Hibernate Many to Many Model
Cart.java
package com.journaldev.hibernate.model;
import java.util.Set;
public class Cart {
private long id;
private double total;
private Set<Item> 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<Item> getItems() {
return items;
}
public void setItems(Set<Item> 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<Cart> 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<Cart> getCarts() {
return carts;
}
public void setCarts(Set<Cart> carts) {
this.carts = carts;
}
}
Note que `Cart` tem um conjunto de `Item` e `Item` tem um conjunto de `Cart`, desta forma estamos a implementar associações bidirecionais. Significa que podemos configurar para salvar `Item` quando salvamos `Cart` e vice-versa. Para o mapeamento unidirecional, geralmente temos um conjunto numa das classes de modelo. Vamos usar anotações para o mapeamento unidirecional.
Mapeamento XML Hibernate Many To Many
Vamos criar ficheiros de configuração XML do Hibernate many-to-many para `Cart` e `Item`. Vamos implementar um mapeamento many-to-many bidirecional. 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">
<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>
Note que o conjunto de itens está mapeado para a tabela `CART_ITEMS`. Como `Cart` é o objeto principal, `cart_id` é a chave e o mapeamento many-to-many está a usar a coluna `item_id` da classe `Item`. 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">
<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>
Como você pode ver acima, o mapeamento é muito semelhante às configurações de mapeamento do Carrinho.
Configuração do Hibernate para Mapeamento Many-to-Many Baseado em XML
Nosso arquivo de configuração do Hibernate parece assim. 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>
<property name="hibernate.show_sql">true</property>
<mapping resource="cart.hbm.xml" />
<mapping resource="item.hbm.xml" />
</session-factory>
</hibernate-configuration>
Classe Utilitária do Hibernate SessionFactory para Mapeamento Baseado em XML
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 {
// Cria a SessionFactory a partir do hibernate.cfg.xml
Configuration configuration = new Configuration();
configuration.configure("hibernate.cfg.xml");
System.out.println("Hibernate Configuration loaded");
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.applySettings(configuration.getProperties()).build();
System.out.println("Hibernate serviceRegistry created");
SessionFactory sessionFactory = configuration
.buildSessionFactory(serviceRegistry);
return sessionFactory;
} catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
ex.printStackTrace();
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
if (sessionFactory == null)
sessionFactory = buildSessionFactory();
return sessionFactory;
}
}
É uma classe utilitária simples que funciona como uma fábrica para SessionFactory.
Programa de Teste de Configuração XML de Mapeamento Many-to-Many do Hibernate
Nosso setup de mapeamento de muitos para muitos do hibernate está pronto, vamos testá-lo. Escreveremos dois programas, um para salvar o Carrinho e ver que as informações de Item e Carrinho_Itens também estão sendo salvas. Outro para salvar dados do item e verificar se os Carrinhos correspondentes e Carrinho_Itens são salvos. 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 {
//Salvando muitos para muitos onde Carrinho é primário
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("Before committing transaction");
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();
}
}
}
Ao executar o exemplo de programa de mapeamento de muitos para muitos do hibernate acima, obtemos a seguinte saída.
Hibernate Configuration loaded
Hibernate serviceRegistry created
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 (?)
Before committing transaction
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
Observe que, uma vez que os dados do item são salvos através do primeiro carrinho, o item_id é gerado e, ao salvar o segundo carrinho, ele não é salvo novamente. Outro ponto importante a notar é que os dados da tabela de junção muitos para muitos estão sendo salvos quando estamos confirmamos a transação. Isso é feito para melhorar o desempenho caso optemos por reverter a transação. 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 {
//Salvando muitos para muitos onde Item é primário
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();
}
}
}
A saída do programa acima é:
Hibernate Configuration loaded
Hibernate serviceRegistry created
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
Você pode facilmente relacioná-lo ao programa de teste anterior, já que configuramos o mapeamento bidirecional, podemos salvar Item ou Carrinho e os dados mapeados serão salvos automaticamente.
Mapeamento de Muitos para Muitos do Hibernate com Anotações
Agora que vimos como configurar o mapeamento many-to-many usando configurações XML do Hibernate, vamos ver um exemplo de implementação através de anotações. Implementaremos um mapeamento many-to-many unidirecional usando anotações JPA.
Arquivo XML de Configuração do Hibernate
Nosso arquivo de configuração do Hibernate baseado em anotações parece assim. 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>
<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>
Classe de Utilidade do SessionFactory do Hibernate
Nossa classe de utilidade para criar a SessionFactory parece assim. 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 {
// Crie a SessionFactory a partir do hibernate-annotation.cfg.xml
Configuration configuration = new Configuration();
configuration.configure("hibernate-annotation.cfg.xml");
System.out.println("Hibernate Annotation Configuration loaded");
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
System.out.println("Hibernate Annotation serviceRegistry created");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
}
catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
ex.printStackTrace();
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
if(sessionFactory == null) sessionFactory = buildSessionFactory();
return sessionFactory;
}
}
Modelo de Classes de Mapeamento Many to Many do Hibernate com Anotações
Esta é a parte mais importante para o mapeamento baseado em anotações, vamos primeiro olhar para a classe modelo da tabela Item e depois veremos a classe modelo da tabela 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;
// Métodos Getter Setter
}
A classe Item1 parece simples, não há mapeamento relacional aqui. 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;
// Métodos Getter Setter
}
A parte mais importante aqui é o uso da anotação ManyToMany e da anotação JoinTable, onde fornecemos o nome da tabela e as colunas a serem usadas para o mapeamento muitos para muitos.
Programa de Teste de Mapeamento de Anotação Hibernate Many To Many
Aqui está um programa de teste simples para nossa configuração de mapeamento muitos para muitos do Hibernate baseada em anotações. 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<Item1> items = new HashSet<Item1>();
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("Before committing transaction");
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();
}
}
}
Ao executarmos o programa acima, ele produz a seguinte saída.
Hibernate Annotation Configuration loaded
Hibernate Annotation serviceRegistry created
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 (?, ?)
Before committing transaction
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
É claro que salvar o carrinho também está salvando dados na tabela Item e Cart_Items. Se você salvar apenas informações do item, perceberá que os dados do Carrinho e Cart_Items não estão sendo salvos. Isso é tudo para o exemplo de mapeamento Hibernate Many-To-Many, você pode baixar o projeto de exemplo no link abaixo e brincar com ele para aprender mais.
Source:
https://www.digitalocean.com/community/tutorials/hibernate-many-to-many-mapping-join-tables