关联是类（类的实例）之间的关系，表示有意义和值得关注的连接。
本系列将介绍Hibernate中主要的几种关联映射
Hibernate一对一主键单向关联
Hibernate一对一主键双向关联
Hibernate一对一外键单向关联
Hibernate一对一外键双向关联
Hibernate多对一单向关联
Hibernate多对一双向关联
Hibernate多对多关联
代码都写有注释，主要包括（核心配置文件，实体映射文件，实体类，测试类，数据库）主要操作有增删改查。
本篇主要介绍Hibernate多对多关联：
hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 配置数据库连接驱动类 -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 配置数据库连接字符串 -->
<property name="connection.url"><![CDATA[jdbc:mysql://localhost:3306/test111?useUnicode=true&characterEncoding=utf8]]></property>
<!-- 配置数据库连接用户名 -->
<property name="connection.username">root</property>
<!-- 配置数据库连接密码 -->
<property name="connection.password">123456</property>
<!-- 配置数据库方言 -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 配置数据库表生成策略 -->
<!--<property name="hibernate.hbm2ddl.auto">update</property> -->
<!-- 配置是否打印显示SQL语句 -->
<property name="show_sql">true</property>
<!-- 配置是否格式化显示SQL语句 -->
<property name="format_sql">true</property>
<!-- 配置hibernate是否自动提交事务 -->
<!--<property name="hibernate.connection.autocommit">true</property> -->
<!--多对多关联 -->
<mapping resource="com/great/entity6/User.hbm.xml"></mapping>
<mapping resource="com/great/entity6/Role.hbm.xml"></mapping>
</session-factory>
</hibernate-configuration>
User.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.great.entity6">
<class name="User" table="user1">
<id name="id" column="id" type="int">
<generator class="native">
</generator>
</id>
<property name="name" column="name" type="string"></property>
<set name="roles" table="mapping1">
<key column="user_id"></key>
<many-to-many class="com.great.entity6.Role" column="role_id"></many-to-many>
</set>
</class>
</hibernate-mapping>
Role.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.great.entity6">
<class name="Role" table="role1">
<id name="id" column="id" type="int">
<generator class="native">
</generator>
</id>
<property name="roleName" column="roleName" type="string"></property>
<set name="users" table="mapping1">
<key column="role_id"></key>
<many-to-many class="com.great.entity6.User" column="user_id"></many-to-many>
</set>
</class>
</hibernate-mapping>
User.java
package com.great.entity6;
import java.util.Set;
public class User {
private int id;
private String name;
private Set<Role> roles;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
}
Role.java
package com.great.entity6;
import java.util.Set;
public class Role {
private int id;
private String roleName;
private Set<User> users;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public Set<User> getUsers() {
return users;
}
public void setUsers(Set<User> users) {
this.users = users;
}
}
TestManyToMany.java
package com.great.test;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import com.great.entity6.Role;
import com.great.entity6.User;
public class TestManyToMany {
static Session session;
// 多表对多表关联
@BeforeClass
public static void setUpBeforeClass() throws Exception {
// 加载hibernate主配置文件
Configuration cfg = new Configuration().configure();
// 构建session工厂
SessionFactory sf = cfg.buildSessionFactory();
// 打开session
session = sf.openSession();
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
// 关闭session，释放资源
session.close();
}
// select1 ，通过User查询数据
@Test
public void testManyToManySelect1() {
User user = (User) session.get(User.class, 1);
System.out.println("用户姓名是：" + user.getName());
System.out.println("用户的权限有：");
Set<Role> roles = user.getRoles();
Iterator<Role> it = roles.iterator();
while (it.hasNext()) {
System.out.print(it.next().getRoleName() + " ");
}
}
// select2 ，通过Role查询数据
@Test
public void testManyToManySelect2() {
Role role = (Role) session.get(Role.class, 1);
System.out.println("权限名称为：" + role.getRoleName());
System.out.println("拥有此权限的人有：");
Set<User> users = role.getUsers();
Iterator<User> it = users.iterator();
while (it.hasNext()) {
System.out.print(it.next().getName() + " ");
}
}
/*
* insert1，通过User插入数据 [发出七条语句，insert role1,insert role2,insert user,insert
* mapping1 2条,role1表中保存2条数据，user1表中保存1条数据，mapping1表中保存2条数据]
*/
@Test
public void testManyToManySave1() {
Transaction ts = session.beginTransaction();
User user = new User();
user.setName("王小胖");
Role role1 = new Role();
role1.setRoleName("删帖权限1");
Role role2 = new Role();
role2.setRoleName("管理员权限2");
Set<Role> roles = new HashSet<Role>();
Set<User> user1 = new HashSet<User>();
Set<User> user2 = new HashSet<User>();
roles.add(role1);
roles.add(role2);
user1.add(user);
user2.add(user);
user.setRoles(roles);// 和save2区别的地方
session.save(role1);
session.save(role2);
session.save(user);
ts.commit();
}
/*
* insert2，通过Role插入数据 [发出七条语句，insert role1,insert role2,insert user,insert
* mapping1 2条,role1表中保存2条数据，user1表中保存1条数据，mapping1表中保存2条数据]
*/
@Test
public void testManyToManySave2() {
Transaction ts = session.beginTransaction();
User user = new User();
user.setName("王6胖");
Role role1 = new Role();
role1.setRoleName("删帖权限44");
Role role2 = new Role();
role2.setRoleName("管理员权限44");
Set<Role> roles = new HashSet<Role>();
Set<User> user1 = new HashSet<User>();
Set<User> user2 = new HashSet<User>();
roles.add(role1);
roles.add(role2);
user1.add(user);
user2.add(user);
role1.setUsers(user1);// 和save1区别的地方
role2.setUsers(user2);
session.save(role1);
session.save(role2);
ts.commit();
}
/*
* delete1,通过User删除用户数据，通过发出一条select语句，两条delete语句，先delete mapping1,再delete
* user1。
*/
@Test
public void testManyToManyDelete1() {
Transaction ts = session.beginTransaction();
User user = (User) session.get(User.class, 8);
session.delete(user);
ts.commit();
}
/*
* delete2,通过Role删除权限数据，通过发出一条select语句，两条delete语句，先delete mapping1,再delete
* role1。
*/
@Test
public void testManyToManyDelete2() {
Transaction ts = session.beginTransaction();
Role role = (Role) session.get(Role.class, 5);
session.delete(role);
ts.commit();
}
/* update1,通过User更新用户数据,添加权限, update user1,insert mapping1 */
@Test
public void testManyToManyUpdate1() {
Transaction ts = session.beginTransaction();
User user = (User) session.get(User.class, 4);
user.setName("张二");
// 获得权限
Role role = (Role) session.get(Role.class, 1);
Set<Role> roles = user.getRoles();
roles.add(role);
user.setRoles(roles);
session.save(user);
ts.commit();
}
/* update2,通过Role更新权限,添加此权限的拥有者, update role1,insert mapping1 */
@Test
public void testManyToManyUpdate2() {
Transaction ts = session.beginTransaction();
User user = (User) session.get(User.class, 4);
// 获得权限
Role role = (Role) session.get(Role.class, 2);
role.setRoleName("系统权限");
Set<User> users = role.getUsers();
users.add(user);
role.setUsers(users);
session.save(role);
ts.commit();
}
}
数据库：
user1表
两个字段：id name
mapping1表
三个字段：id user_id role_id
role1表
两个字段： id roleName
注意：在mapping表上建立两个外键关系，user_id和role_id。