最近在看hibernate，看到了实体关联关系这一部分内容，说实话，这部分内容我花了很多时间才理解（当然也可能保证完全理解）。这篇博客主要讲解多对多关联关系的理解与实践，我们开始吧！
hibernate中多对多关联关系主要是对应数据库中的多对多的关系，其实这是一种非常常见的关系，这里以用户（user）和角色（role）为例进行讲解。
使用开发工具：
IDE：eclipse
数据库：MySql
【以下使用的源码下载地址：http://download.csdn.net/detail/liu_005/9167161】
1、建表：（方法一）
这里我们用sql语句建表（下面有另外的方法，可以不使用sql语句建表），当然建立数据库的语句就不在这里写了，你自己随便建个数据库就行（记得等下在hibernate.cfg.xml中修改成对应数据库就行），sql语句如下：
用户表
DROP TABLE IF EXISTS `tab_user`;
CREATE TABLE `tab_user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=latin1;
角色表
DROP TABLE IF EXISTS `tab_role`;
CREATE TABLE `tab_role` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`rolename` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=latin1;
配对表（将用户与角色之间的对应关系在该表中记录）
DROP TABLE IF EXISTS `tab_mapping`;
CREATE TABLE `tab_mapping` (
`role_id` int(11) NOT NULL,
`user_id` int(11) NOT NULL,
PRIMARY KEY (`user_id`,`role_id`),
KEY `FKgarvx4edqdm58m0stotn9kutb` (`role_id`),
CONSTRAINT `FKgarvx4edqdm58m0stotn9kutb` FOREIGN KEY (`role_id`) REFERENCES `tab_role` (`id`),
CONSTRAINT `FKhrxh8j64aqyejuryam8phih4c` FOREIGN KEY (`user_id`) REFERENCES `tab_user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;2、数据表建完后，我们开始编辑配置文件：
（1）编写hibernate全局配置文件
<?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="hibernate.cache.use_second_level_cache">true</property>
<!-- 指定缓存产品提供商 -->
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
<!-- 数据库驱动 -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 数据库连接的URL -->
<property name="connection.url">jdbc:mysql://localhost:3306/test</property>
<!-- 数据库连接用户名 -->
<property name="connection.username">root</property>
<!-- 数据库连接密码 -->
<property name="connection.password">123</property>
<!-- Hibernate方言 -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 打印SQL语句 -->
<property name="show_sql">true</property>
<!-- 映射文件 -->
<mapping resource="com/mr/role/Role.hbm.xml"/>
<mapping resource="com/mr/user/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>【提醒】请修改相应的数据库驱动、URL、用户名以及密码
（2）定义HibernateInitialize类
这个类主要是初始化sessionFactory和定义获取session的方法，主要是为了后面使用方便。
package com.mr.hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateInitialize {
private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();// ThreadLocal对象
private static SessionFactory sessionFactory = null;// SessionFactory对象
// 静态块
static {
try {
// 加载Hibernate配置文件
Configuration cfg = new Configuration().configure();
sessionFactory = cfg.buildSessionFactory();
} catch (Exception e) {
System.err.println("创建会话工厂失败");
e.printStackTrace();
}
}
/**
* 获取Session
*
* @return Session
* @throws HibernateException
*/
public static Session getSession() throws HibernateException {
Session session = (Session) threadLocal.get();
if (session == null || !session.isOpen()) {
if (sessionFactory == null) {
rebuildSessionFactory();
}
session = (sessionFactory != null) ? sessionFactory.openSession(): null;
threadLocal.set(session);
}
return session;
}
/**
* 重建会话工厂
*/
public static void rebuildSessionFactory() {
try {
// 加载Hibernate配置文件
Configuration cfg = new Configuration().configure();
sessionFactory = cfg.buildSessionFactory();
} catch (Exception e) {
System.err.println("创建会话工厂失败");
e.printStackTrace();
}
}
/**
* 获取SessionFactory对象
*
* @return SessionFactory对象
*/
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
/**
* 关闭Session
*
* @throws HibernateException
*/
public static void closeSession() throws HibernateException {
Session session = (Session) threadLocal.get();
threadLocal.set(null);//
if (session != null) {
session.close();// 关闭Session
}
}
}
（3）定义【用户】类
package com.mr.user;
import java.util.Set;
import com.mr.role.Role;
public class User {
private Integer id;// 唯一性标识
private String name;// 用户名称
private Set<Role> roles;// 引用的权限实体对象集合
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<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
}
（4）编写【用户】配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- User实体对象 -->
<hibernate-mapping>
<class name="com.mr.user.User" table="tab_user">
<!-- 主键id -->
<id name="id">
<generator class="native"/>
</id>
<!-- 用户名称 -->
<property name="name" not-null="true" />
<set name="roles" table="tab_mapping" cascade="all">
<key column="user_id"></key>
<many-to-many class="com.mr.role.Role" column="role_id"/>
</set>
</class>
</hibernate-mapping>
【提醒】class中的table字段是对应数据库中产品表名（如果你是按以上提供的建表语句生成的数据表的话，这里就不用修改了，否则请做相应修改）
（5）定义【角色】类
package com.mr.role;
import java.util.Set;
import com.mr.user.User;
public class Role {
private Integer id;// 唯一性标识
private String roleName;// 权限名称
private Set<User> users;// 引用的用户实体对象集合
public Integer getId() {
return id;
}
public void setId(Integer 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;
}
}
（6）编写【角色】配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Role实体对象 -->
<hibernate-mapping>
<class name="com.mr.role.Role" table="tab_role">
<!-- 主键id -->
<id name="id">
<generator class="native"/>
</id>
<!-- 权限名称 -->
<property name="roleName" not-null="true">
<column name="rolename"/>
</property>
<set name="users" table="tab_mapping" cascade="all">
<key column="role_id"></key>
<many-to-many class="com.mr.user.User" column="user_id"/>
</set>
</class>
</hibernate-mapping>
【提醒】class中的table字段是对应数据库中产品表名（如果你是按以上提供的建表语句生成的数据表的话，这里就不用修改了，否则请做相应修改）
如果你已经使用了第一步中的sql语句建表的话，这里就不用建表了。当然你也可以删除以前建的表尝试一下这种方式。
3、建表：（方法二）
定义以下类并运行就可以根据以上的配置文件进行建表
package com.mr.main;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.boot.spi.MetadataImplementor;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.hbm2ddl.SchemaExport;
public class createTable
{
public static void main(String[] args)
{
ServiceRegistry serviceRegistry = (ServiceRegistry) new StandardServiceRegistryBuilder()
.configure().build();
MetadataImplementor metadataImplementor = (MetadataImplementor) new MetadataSources(
serviceRegistry).buildMetadata();
SchemaExport export = new SchemaExport(serviceRegistry,
metadataImplementor);
export.create(true, true);//第一个参数是是否输出到控制台，第二个参数是是否输出到数据库建表
}
}4、测试：
如果还没用数据的话，先将插入部分代码去除注释运行。然后可以将插入部分注释，然后将查询部分注释去除进行测试。
package com.mr.main;
import org.hibernate.Session;
import com.mr.hibernate.HibernateInitialize;
public class Manger {
public static void main(String[] args) {
Session session = null; // 声明一个Session对象
try {
// Hibernate的持久化操作
session = HibernateInitialize.getSession();// 获取Session
session.beginTransaction();// 事务开启
/***** 查询 ******/
// User user = (User) session.get(User.class, new Integer("1"));
// Set<Role> roles = user.getRoles();
// System.out.println(user.getName() + "用户所拥有的权限为：");
// //通过迭代输出权限信息
// for (Iterator<Role> it = roles.iterator(); it.hasNext();) {
// Role roles2 = (Role) it.next();
// System.out.print(roles2.getRoleName()+"||");
// }
// System.out.println("---------------------------------");
// Role rol = (Role)session.get(Role.class, new Integer("2"));
// //获取用户名称集合
// Set<User> users = rol.getUsers();
// System.out.println(rol.getRoleName() + "权限被赋予用户：");
// // 通过迭代输出用户信息
// for (Iterator<User> it = users.iterator(); it.hasNext();) {
// User users2 = (User) it.next();
// System.out.print(users2.getName()+"||");
// }
System.out.println("---------------------------------");
System.out.println("*********************************");
System.out.println("---------------------------------");
/******插入******/
// User user1 = new User();
// user1.setName("userNameX");
// user1.setRoles(new HashSet<Role>());
//
// User user2 = new User();
// user2.setName("userNameY");
// user2.setRoles(new HashSet<Role>());
//
//
// Role role1 = new Role();
// role1.setRoleName("roleNameX");
//
// Role role2 = new Role();
// role2.setRoleName("roleNameY");
//
// user1.getRoles().add(role1);
// user1.getRoles().add(role2);
//
// user2.getRoles().add(role2);
//
//
// session.save(user1);
// session.save(user2);
session.getTransaction().commit();// 事务提交
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();// 事务回滚
} finally{
HibernateInitialize.closeSession();// 关闭Session
}
}
}
以上内容如有错误之处，欢迎各位指正。如有问题，可以与我讨论。
扫一扫
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
