Hibernate-映射关系- 多对多关联关系

n-n 的关联必须使用连接表

单向 n-n：
与 1-n 映射类似，必须为 set 集合元素添加 key 子元素，指定 CATEGORIES_ITEMS 表中参照 CATEGORIES 表的外键为 CATEGORIY_ID.

与 1-n 关联映射不同的是，建立 n-n 关联时, 集合中的元素使用 many-to-many. many-to-many 子元素的 class 属性指定 items 集合中存放的是 Item 对象,

  column 属性指定  CATEGORIES_ITEMS 表中参照 ITEMS 表的外键为 ITEM_ID
双向 n-n：

双向 n-n 关联需要两端都使用集合属性

双向n-n关联必须使用连接表

集合属性应增加 key 子元素用以映射外键列, 集合元素里还应增加many-to-many子元素关联实体类

在双向 n-n 关联的两边都需指定连接表的表名及外键列的列名. 两个集合元素 set 的 table 元素的值必须指定，而且必须相同。set元素的两个子元素：key 和 many-to-    many 都必须指定 column 属性，其中，key 和 many-to-many 分别指定本持久化类和关联类在连接表中的外键列名，因此两边的
key 与 many-to-many 的column属性交叉相同。也就是说，一边的set元素的key的 cloumn值为a,many-to-many 的 column 为b；则另一边的 set 元素的 key 的 column 值 b,many-to-many的 column值为 a.  
       对于双向 n-n 关联, 必须把其中一端的 inverse 设置为 true, 否则两端都维护关联关系可能会造成主键冲突.

案例：商品和种类之间的关系就是多对多的关系：
实现代码如下：

Category.java

/*
* 文件名：Category.java
* 版权：Copyright by www.huawei.com
* 描述：
* 修改人：Cuigaochong
* 修改时间：2015-10-24
* 跟踪单号：
* 修改单号：
* 修改内容：
*/

package com.cgc.hibernate.n2n;

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

/**
* <一句话功能简述> <功能详细描述>
*
* @author 姓名 工号
* @version [版本号, 2015-10-24]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class Category
{
private Integer id;
private String name;
private Set<Item> items = new HashSet<Item>();
public Integer getId()
{
return id;
}
public void setId(Integer id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Set<Item> getItems()
{
return items;
}
public void setItems(Set<Item> items)
{
this.items = items;
}
}

Item.java

/*
* 文件名：Item.java
* 版权：Copyright by www.huawei.com
* 描述：
* 修改人：Cuigaochong
* 修改时间：2015-10-24
* 跟踪单号：
* 修改单号：
* 修改内容：
*/

package com.cgc.hibernate.n2n;

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

/**
* <一句话功能简述> <功能详细描述>
*
* @author 姓名 工号
* @version [版本号, 2015-10-24]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class Item
{
private Integer Id;
private String name;
private Set<Category> categories = new HashSet<Category>();

public Set<Category> getCategories()
{
return categories;
}
public void setCategories(Set<Category> categories)
{
this.categories = categories;
}
public Integer getId()
{
return Id;
}
public void setId(Integer id)
{
Id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}

Category.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.cgc.hibernate.n2n">

<class name="Category" table="CATEGORIES">

<id name="id" type="java.lang.Integer">
<column name="ID" />
<generator class="native" />
</id>

<property name="name" type="java.lang.String">
<column name="NAME" />
</property>

<!-- 指定中间表 -->
<set name="items" table="CATEGORIES_ITEMS">
<key>
<column name="C_ID" />
</key>
<!-- 使用many-to-many指定多对多的关联关系，column执行Set集合中的持久化类在中间表的外键列的名称 -->
<many-to-many class="Item" column="I_ID"></many-to-many>
</set>

</class>
</hibernate-mapping>

Item.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

<class name="com.cgc.hibernate.n2n.Item" table="ITEMS">

<id name="id" type="java.lang.Integer">
<column name="ID" />
<generator class="native" />
</id>

<property name="name" type="java.lang.String">
<column name="NAME" />
</property>
<!-- 只需要一方维护关联关系，如果两方都维护关联关系   会导致中间表的数据重复插入 -->
<set name="categories" table="CATEGORIES_ITEMS" inverse="true">
<key column="I_ID"></key>
<many-to-many class="com.cgc.hibernate.n2n.Category" column="C_ID"></many-to-many>
</set>

</class>
</hibernate-mapping>

调测类：

/*
* 文件名：HibernateTest.java
* 版权：Copyright by www.huawei.com
* 描述：
* 修改人：Cuigaochong
* 修改时间：2015-10-22
* 跟踪单号：
* 修改单号：
* 修改内容：
*/

package com.cgc.hibernate.n2n;

import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
* <一句话功能简述> <功能详细描述>
*
* @author 姓名 工号
* @version [版本号, 2015-10-22]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class HibernateTest
{
private SessionFactory sessionFactory;

private Session session;

private Transaction transaction;

@Before
public void init()
{
Configuration configuration = new Configuration().configure();
// 创建一个ServiceRegisttry对象：hibernate 4.x,新添加的对象，hibernate的任何配置和服务器都需要
// 在该配置中注册后才能生效
ServiceRegistry serviceRegistry =
new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();
sessionFactory = configuration.buildSessionFactory(serviceRegistry);
session = sessionFactory.openSession();
// 开启事物
transaction = session.beginTransaction();
}

@After
public void detory()
{
transaction.commit();
session.close();
sessionFactory.close();
}

@Test
public void testSave()
{
Category category00 = new Category();
category00.setName("AAA02");

Category category01 = new Category();
category01.setName("BBB02");

Item item00 = new Item();
item00.setName("MMM02");

Item item01 = new Item();
item01.setName("NNN02");

category00.getItems().add(item00);
category00.getItems().add(item01);

category01.getItems().add(item00);
category01.getItems().add(item01);

item00.getCategories().add(category00);
item00.getCategories().add(category01);

item01.getCategories().add(category00);
item01.getCategories().add(category01);

session.save(category00);
session.save(category01);

session.save(item00);
session.save(item01);
}

@Test
public void getTest()
{
Category category = (Category)session.get(Category.class, 181);
System.out.println(category.getName());
// 需要联合中间表 进行联合查询
Set<Item> items = category.getItems();
System.out.println(items.size());
}

}