Hibernate第06课：多对一表关联映射

述User类和Group类,User类中的多个实例是属于Group中的某个实例.这个模型就表现多对一.这种关联我们称为many2one.因为是多个用户属于一个组,那肯定这个用户知道自己是哪个组的,所以,这个用户就应该持有这个组.先建立Group这个对象.因为这个Group不知道用户的存在,所以这个对象里面的属性都是常规属性.

考虑到测试方便,把这个id改成int类型,因为uuid是32位字符串看不清楚.以后使用还是建议用uuid.

package net.knight.hibernate;

public class Group {

	private int id;
	
	private String name;

	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;
	}
}

因为用户知道自己是属于哪个组,所以User类必定要持有Group这个对象.所以需要一个我们自定义的Group类.

package net.knight.hibernate;

public class User {

	private int id;
	
	private String name;
	
	private Group group;

	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 Group getGroup() {
		return group;
	}

	public void setGroup(Group group) {
		this.group = group;
	}
	
}

现在可以建立映射关系了.映射关系也是一样,因为Group只有基本类型,所以先建立Group的对象映射文件

Group.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="net.knight.hibernate.Group" table="t_group">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>

 现在建立User的映射关系.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>
	<class name="net.knight.hibernate.User" table="t_user">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		
		<!-- 使用这个标签映射多对一,user为多,group为一,
			 这个意思就是在user这张表中增加一个group字段
			 因为group是sql的关键字,所以需要重命名一下
		-->
		<many-to-one name="group" column="groupid" />
	</class>
</hibernate-mapping>

 建立这个映射关系之后,hibernate就会自动创建这个字段,并建立这个多对一的关系.

在将这些映射文件加入到hibernate配置文件.

<!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.connection.url">jdbc:mysql://localhost/hibernate</property>
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">root</property>
		<!-- 声明MySQL方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<!-- 是否在控制台显示SQL语句 -->
		<property name="hibernate.show_sql">true</property>

		<!-- 加载映射对象 -->
		<mapping resource="net/knight/hibernate/User.hbm.xml"/>
		<mapping resource="net/knight/hibernate/Group.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

好了,现在可以测试一下效果了.

1.打开MySQL客户端,创建数据库.Create table hibernate;

2.执行ExportDB导出表.我们可以看到在t_user表中自动加入了groupid这个外键关系.这个外键参照了t_group的id字段.

再看看存储能力,添加一条数据是否能保存到这两张表中.新建一个junit测试类

package net.knight.hibernate.test;

import net.knight.hibernate.Group;
import net.knight.hibernate.User;
import net.knight.hibernate.utils.HibernateUtils;

import org.hibernate.Session;
import org.hibernate.Transaction;

import junit.framework.TestCase;

public class many2oneTest extends TestCase{

	public void testSave() {
		Session session = null;
		Transaction ts = null;
		
		try {
			session = HibernateUtils.getSession();
			ts = HibernateUtils.getTransaction(session);
			
			// 组一
			Group group1 = new Group();
			group1.setName("销售部");
			
			User user1 = new User();
			user1.setName("张三");
			user1.setGroup(group1);
			
			User user2 = new User();
			user2.setName("李四");
			user2.setGroup(group1);
			
			// 组二
			Group group2 = new Group();
			group2.setName("行政部");
			
			User user3 = new User();
			user3.setName("王五");
			user3.setGroup(group2);
			
			User user4 = new User();
			user4.setName("赵六");
			user4.setGroup(group2);
			
			session.save(group1);
			session.save(group2);
			session.save(user1);
			session.save(user2);
			session.save(user3);
			session.save(user4);
			
			ts.commit();
		}catch(Exception e) {
			e.printStackTrace();
			ts.rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
}

输出结果正常.这里有一点要注意,save对象的时候要先保存group对象,因为user对象需要参照group.从session的生命周期中可以看到具体的原因.

还有一种更简单的方法也能达到上述的效果.

修改User对象的配置文件.

<?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="net.knight.hibernate.User" table="t_user">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		
		<!-- 增加cascade标签,这个标签的含义是级联,级联只对更新,删除,保存有作用.
			 删除对象的时候根据级联的内容逐个把有关系的对象也删除了.
			 级联的值有4种,可以参考说明文档.这4种分别是
			 all,none,save_update,delete
		-->
		<many-to-one name="group" column="groupid" cascade="all"/>
	</class>
</hibernate-mapping>

删除session.save(group);hibernate会自动帮我们保存group对象中的内容.不需要我们手工再去save了.

在使用的时候要注意级联的这个方法,因为自动处理了.在数据发生问题的时候要考虑这里会操作多个对象.

再试试manyToone的对象加载.

public void testLoad() {
		Session session = null;
		Transaction ts = null;
		
		try {
			session = HibernateUtils.getSession();
			ts = HibernateUtils.getTransaction(session);
			
			User user = (User)session.load(User.class, 5);
			System.out.println("user.getName = " + user.getName());
			System.out.println("user.getGroup.getName = " + user.getGroup().getName());
			
			ts.commit();
		}catch(Exception e) {
			e.printStackTrace();
			ts.rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}

一切正常.