Hibernate基础学习(五)—对象-关系映射(下)

一、单向n-1

单向n-1关联只需从n的一端可以访问1的一端。

域模型: 从Order到Customer的多对一单向关联。Order类中定义一个Customer属性，而在Customer类不用存放Order对象的引用。

    

Order.java

public class Order{

	private Integer uid;
	private String name;

	private Customer cus;

	//省略get、set方法
}

Customer.java

public class Customer{

	private Integer uid;
	private String username;

	//省略get、set方法
}

Customer.hbm.xml

<hibernate-mapping>

	<class name="com.kiwi.domain.Customer" table="t_cus">
	
		<id name="uid">
			<generator class="native"/>
		</id>
		
		<property name="username"/>
		
	</class>

</hibernate-mapping> 

Order.hbm.xml

<hibernate-mapping>

	<class name="com.kiwi.domain.Order" table="t_order">
	
		<id name="uid">
			<generator class="native"/>
		</id>
		
		<property name="name"/>
		
		<many-to-one name="cus" class="com.kiwi.domain.Customer" column="cus_id"/>
		
	</class>

</hibernate-mapping> 

Test.java

			Customer c = new Customer();
			c.setUsername("AAA");
			
			Order o1 = new Order();
			o1.setName("order1");
			Order o2 = new Order();
			o2.setName("order2");
			
			//设置关联关系
			o1.setCus(c);
			o2.setCus(c);
			
			//顺序保存执行3条insert语句
			session.save(c);
			session.save(o1);
			session.save(o2);

结果:

t_cus                    t_order

二、双向1-n

双向1-n和双向n-1是完全相同的情形。

Order.java

public class Order{

	private Integer uid;
	private String name;

	private Customer cus;

	//省略get set方法
}

Customer.java

public class Customer{

	private Integer uid;
	private String username;

	private Set<Order> orders = new HashSet<Order>();
	
	//省略get set方法
}

Customer.hbm.xml

<hibernate-mapping>

	<class name="com.kiwi.domain.Customer" table="t_cus">

		<id name="uid">
			<generator class="native" />
		</id>

		<property name="username" />

		<!-- 1对多的映射 -->
		<set name="orders" table="t_order">
			<key column="cus_id" />
			<one-to-many class="com.kiwi.domain.Order" />
		</set>

	</class>

</hibernate-mapping> 

Order.hbm.xml

<hibernate-mapping>

	<class name="com.kiwi.domain.Order" table="t_order" >
	
		<id name="uid">
			<generator class="native"/>
		</id>
		
		<property name="name"/>
		
		<many-to-one name="cus" class="com.kiwi.domain.Customer" column="cus_id"/>
		
	</class>

</hibernate-mapping> 

Test.java

			Customer c = new Customer();
			c.setUsername("BBB");
			
			Order o1 = new Order();
			o1.setName("order3");
			Order o2 = new Order();
			o2.setName("order4");
			
			//设置关联关系
			o1.setCus(c);
			o2.setCus(c);
			
			c.getOrders().add(o1);
			c.getOrders().add(o2);
			
			//3条insert语句,2条update语句
			//因为两端都维护关联关系，所以会多update语句
			session.save(c);
			session.save(o1);
			session.save(o2);

结果:

      发现执行了3条insert语句后，又执行了2条update语句。原因是由于两端都维护了关联而导致的，所以我们设置一端维护关联关系即可，使用inverse属性。   

1.元素的inverse属性

     (1)在hibernate中通过对 inverse 属性的来决定是由双向关联的哪一方来维护表和表之间的关系。

     (2)inverse = false 的为主动方，inverse = true 的为被动方，由主动方负责维护关联关系。

     (3)在没有设置 inverse=true 的情况下，父子两边都维护父子关系。

     (4)在1-n关系中，将n方设为主控方将有助于性能改善。

     (5)在1-n 关系中，若将1方设为主控方，会额外多出update语句。

     建议设定set的inverse=true，先插入1的一端，再插入多的一端不会多出update语句。

Customer.hbm.xml

<hibernate-mapping>

	<class name="com.kiwi.domain.Customer" table="t_cus">

		<id name="uid">
			<generator class="native" />
		</id>

		<property name="username" />

		<!-- 1对多的映射 -->
		<set name="orders" table="t_order" inverse="true">
			<key column="cus_id" />
			<one-to-many class="com.kiwi.domain.Order" />
		</set>

	</class>

</hibernate-mapping> 

     (6)当Session从数据库中加载Java集合时, 创建的是Hibernate内置集合类的实例, 因此在持久化类中定义集合属性时必须把属性声明为Java接口类型。
     (7)Hibernate的内置集合类具有集合代理功能, 支持延迟检索策略。
    (8)事实上, Hibernate 的内置集合类封装了JDK中的集合类, 这使得Hibernate能够对缓存中的集合对象进行脏检查, 按照集合对象的状态来同步更新数据库。
    (9)在定义集合属性时, 通常把它初始化为集合实现类的一个实例. 这样可以提高程序的健壮性, 避免应用程序访问取值为null 的集合的方法抛出NullPointerException。

测试:

结果:

     class org.hibernate.collection.PersistentSet

2.cascade属性

     在对象-关系映射文件中，用于映射持久化类之间关联关系的元素，<set>，<many-to-one>和<one-to-one>都有一个 cascade 属性，它用于指定如何操纵与当前对象关联的其他对象。

    

Customer.xml

    

测试代码:

           

结果:

      Hibernate: insert into t_customer (cname) values (?)
      Hibernate: insert into t_order (price, customer_id) values (?, ?)
      Hibernate: insert into t_order (price, customer_id) values (?, ?)

三、1-1关联关系

    

1.基于外键映射1-1

     对于基于外键的1-1关联，存在外键的一方可认为是1-n的特殊情况，增加many-to-one元素，并且增加"unique=true"属性来表示1-1关联。

     另一端使用one-to-one元素，该元素使用property-ref属性指定对方映射中外键列对应的属性名。

Person.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

	<class name="com.kiwi.domain.Person" table="t_person">
	
		<id name="uid">
			<generator class="native"/>
		</id>
		
		<property name="name" type="string"/>
		<property name="age" type="integer"/>
		
		<!-- 
		 	idCard属性 	IdCard类型
		 	本类与IdCard的1对1关系。本方无外键方
		 	property-ref:对方映射中外键列对应的属性名
		 -->
		 <one-to-one name="idCard" class="com.kiwi.domain.IdCard" property-ref="person" />
		
	</class>

</hibernate-mapping> 

IdCard.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

	<class name="com.kiwi.domain.IdCard" table="t_idcard">
		
		<id name="uid">
			<generator class="native"/>
		</id>
		
		<property name="no"/>
		
		<!-- 
		 	person属性 	Person类型
		 	本类与person的1对1关系。本方有外键方
		 -->
		 <many-to-one name="person" class="com.kiwi.domain.Person" column="personId" unique="true" />
		 	
	</class>

</hibernate-mapping> 

Test.java

public class TestDemo{

	//测试保存对象
	@Test
	public void testSava(){

		Session session = HibernateUtils.getSession();
		Transaction tx = null;

		try{
			tx = session.beginTransaction();

			Person p = new Person();
			p.setAge(18);
			p.setName("李四");
			
			IdCard i = new IdCard();
			i.setNo("4128231992000002");
			
			p.setIdCard(i);
			i.setPerson(p);
			
			session.save(p);
			session.save(i);
			
			tx.commit();
		}catch(RuntimeException e){
			tx.rollback();
			throw e;
		}finally{
			session.close();
		}

	}
	
	//解除关联关系: 在1-1中，只能有外键方可以维护关联关系
	@Test
	public void testRelation(){
		
		Session session = HibernateUtils.getSession();
		Transaction tx = null;
		
		try{
			tx = session.beginTransaction();
			
			//从无外键方解除关系: 不可以
			Person p = (Person)session.get(Person.class,1);
			p.setIdCard(null);
			
			//从有外键方解除关系: 可以
			IdCard i = (IdCard)session.get(IdCard.class,1);
			i.setPerson(null);
			
			tx.commit();
		}catch(RuntimeException e){
			tx.rollback();
			throw e;
		}finally{
			session.close();
		}
		
	}
	
	//删除对象 对关联关系的影响
	@Test
	public void testDelete(){
		
		Session session = HibernateUtils.getSession();
		Transaction tx = null;
		
		try{
			tx = session.beginTransaction();
			
			//a.如果没有关联对方，能删除
			//b.如果有关联的对方，但是不能维护关联关系，所以会先删自己，有异常
			//c.如果有关联的对方，而且可以维护关联关系，它会先删除关联关系再删除自己
			
			Person p = (Person)session.get(Person.class,1);
			IdCard i = (IdCard)session.get(IdCard.class,1);
			//会抛异常
			session.delete(p);
			//先解除关联关系，然后删掉自己
			session.delete(i);
			
			tx.commit();
		}catch(RuntimeException e){
			tx.rollback();
			throw e;
		}finally{
			session.close();
		}
	}

}

注意:

(1)在1-1关联关系中，只有外键方能维护关联关系，从无外键方解除关联关系不可以，从有外键方解除关联关系可以。

(2)在1-1关联关系中，执行删除操作。如果没有关联关系，能直接删除;如果有关联关系，但是不能维护关联关系，会出异常。如果有关联关系，而且能维护关联关系，能直接删除自己。

2.基于主键映射1-1

基于主键的映射策略:指一端的主键生成器使用 foreign 策略,表明根据"对方"的主键来生成自己的主键，自己并不能独立生成主键. <param> 子元素指定使用当前持久化类的哪个属性作为"对方"。

采用foreign主键生成器策略的一端增加one-to-one元素映射关联属性，其one-to-one属性还应增加constrained="true" 属性；另一端增加one-to-one元素映射关联属性。

constrained(约束):指定为当前持久化类对应的数据库表的主键添加一个外键约束，引用被关联的对象("对方")所对应的数据库表主键。

Person.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

	<class name="com.kiwi.domain.Person" table="t_person">
	
		<id name="uid">
			<generator class="native"/>
		</id>
		
		<property name="name" type="string"/>
		<property name="age" type="integer"/>
		
		<!-- 
		 	idCard属性 	IdCard类型
		 	本类与IdCard的1对1关系。本方无外键方
		 -->
		 <one-to-one name="idCard" class="com.kiwi.domain.IdCard"/>
		
	</class>

</hibernate-mapping> 

IdCard.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

	<class name="com.kiwi.domain.IdCard" table="t_idcard">
		
		<id name="uid">
			<!--当使用基于主键1-1映射时 
				有外键方的主键生成策略一定要是foreign
				property:生成主键值所根据的对象
			 -->
			<generator class="foreign">
				<param name="property">person</param>
			</generator>
		</id>
		
		<property name="no"/>
		
		<!-- 
		 	person属性 	Person类型
		 	本类与person的1对1关系。本方有外键方
		 -->
		 <one-to-one name="person" class="com.kiwi.domain.Person" constrained="true"/>
		 	
	</class>

</hibernate-mapping> 

四、双向n-n

(1)双向n-n需要两端都使用集合属性。

(2)双向n-n必须使用中间表。

(3)双向n-n默认都维护关联关系的，所以必须把其中一端的inverse设置为true，否则会造成主键冲突。

    

Student.java

public class Student{

	private Long uid;
	private String name;
	
	private Set<Teacher> teachers = new HashSet<Teacher>();
	
	//省略get、set方法...
}

Teacher.java

public class Teacher{

	private Long uid;
	private String name;

	private Set<Student> students = new HashSet<Student>();
	
	//省略get、set方法...
}

Student.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

	<class name="com.kiwi.domain.Student" table="t_stu">
	
			<id name="uid">
				<generator class="native"/>
			</id>
			
			<property name="name"/>
			
			<!-- 
				teachers属性 set集合
				本类与Teacher的n-n关联关系
				table:中间表(集合表)
				key: 集合外键(引用当前表主键的那个外键)
			 -->
			 
			 <set name="teachers" table="teach_stu" inverse="true">
			 	<key column="stu_id"/>
			 	<many-to-many class="com.kiwi.domain.Teacher" column="teacher_id"/>
			 </set>
		
	</class>

</hibernate-mapping> 

Teacher.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

	<class name="com.kiwi.domain.Teacher" table="t_teacher">
	
		<id name="uid">
			<generator class="native"/>
		</id>
		
		<property name="name"/>
		
		<!-- 
			students属性 set集合
			本类与Student的n-n关联关系
		-->
		<set name="students" table="teach_stu">
			<key column="teacher_id"/>
			<many-to-many class="com.kiwi.domain.Student" column="stu_id"/>
		</set>
	
	</class>

</hibernate-mapping> 

Test.java

			Student s1 = new Student();
			s1.setName("学生1");
			Student s2 = new Student();
			s2.setName("学生2");
			
			Teacher t1 = new Teacher();
			t1.setName("老师1");
			Teacher t2 = new Teacher();
			t2.setName("老师2");
			
			s1.getTeachers().add(t1);
			s1.getTeachers().add(t2);
			s2.getTeachers().add(t1);
			s2.getTeachers().add(t2);
			t1.getStudents().add(s1);
			t1.getStudents().add(s2);
			t2.getStudents().add(s1);
			t2.getStudents().add(s2);
			
			session.save(s1);
			session.save(s2);
			session.save(t1);
			session.save(t2);

结果:

五、映射继承关系

    Hibernate的继承映射可以理解持久化类之间的基础关系。例如: 人和学生之间的关系，学生继承了人，可以认为学生是一种特殊的人，如果对人进行查询，学生的实例也将被得到。

     Hibernate支持三种继承关系:

     使用subclass进行映射

     使用joined-subclass进行映射

     使用union-subclass进行映射

1.使用subclass进行映射

(1)可以实现对继承关系中的父类和子类使用同一张表。

(2)因为父类和子类的实例全部保存在同一张表，因此需要在该表内增加一列，使用该列来区分每行记录属于哪个类的实例，这个列被称为辨别者列(discriminator)。

(3)在这种映射策略下，使用subclass来映射子类，使用class和subclass的discriminator-value属性来指定辨别者列的值。

(4)所有的子类定义的字段都不能有非空约束。如果为那些字段添加非空约束，那么父类的实例在那些列其实并没有值，这将引起数据库完整性冲突，导致父类的实例无法保存到数据库中。

Person.java

public class Person{

	private Long uid;
	private String name;
	private int age;

	//省略get、set方法...
}

Student.java

public class Student extends Person{

	private String school;
	
	//省略get、set方法...
}

Person.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

	<class name="com.kiwi.domain.Person" table="t_person" discriminator-value="person">

		<id name="uid">
			<generator class="native" />
		</id>

		<!-- 添加辨别者列 -->
		<discriminator column="type" type="string" />

		<property name="name" />
		<property name="age" />

		<!-- 使用 subclass 来映射子类 -->
		<subclass name="com.kiwi.domain.Student" discriminator-value="stu">
			<property name="school" type="string" />
		</subclass>

	</class>

</hibernate-mapping> 

Test.java

			Person p = new Person();
			p.setAge(11);
			p.setName("person1");
			
			Student s = new Student();
			s.setAge(22);
			s.setName("studnet1");
			s.setSchool("QingHua");
			
			session.save(p);
			session.save(s);

结果:

    

2.使用joined-subclass进行映射

(1)采用 joined-subclass 元素的继承映射可以实现每个子类一张表。

(2)采用这种映射策略时，父类实例保存在父类表中，子类实例由父类表和子类表共同存储。因为子类实例也是一个特殊的父类实例，因此必然也包含了父类实例的属性。于是将子类和父类共有的属性保存在父类表中，子类增加的属性，则保存在子类表中。

(3)在这种映射策略下，无须使用辨别者列，但需要为每个子类使用 key 元素映射共有主键。

(4)子类增加的属性可以添加非空约束。因为子类的属性和父类的属性没有保存在同一个表中。

Person.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

	<class name="com.kiwi.domain.Person" table="t_person" >

		<id name="uid">
			<generator class="native" />
		</id>


		<property name="name" />
		<property name="age" />

		<!-- 使用 joined-subclass 来映射子类 -->
		<joined-subclass name="com.kiwi.domain.Student" table="t_stu">
			<key column="stu_id"/>
			<property name="school" type="string" />
		</joined-subclass>
		
	</class>

</hibernate-mapping> 

Test.java

			Person p = new Person();
			p.setAge(11);
			p.setName("person1");
			
			Student s = new Student();
			s.setAge(22);
			s.setName("studnet1");
			s.setSchool("QingHua");
			
			session.save(p);
			session.save(s);

结果:

    

3.使用union-subclass进行映射

(1)采用union-subclass元素可以实现将每一个实体对象映射到一个独立的表中。

(2)子类增加的属性可以有非空约束 --- 即父类实例的数据保存在父表中，而子类实例的数据保存在子类表中。

(3)子类实例的数据仅保存在子类表中, 而在父类表中没有任何记录。

(4)在这种映射策略下，子类表的字段会比父类表的映射字段要多,因为子类表的字段等于父类表的字段、加子类增加属性的总和

(5)在这种映射策略下，既不需要使用鉴别者列，也无须使用key元素来映射共有主键。

(6)使用union-subclass映射策略是不可使用identity的主键生成策略。

Person.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

	<class name="com.kiwi.domain.Person" table="t_person" >

		<id name="uid">
			<!-- 使用union-subclass映射策略是不可使用identity的主键生成策略 -->
			<generator class="hilo">
				<param name="table">hilo_table</param>
				<param name="column">next_value</param>
				<param name="max_lo">10</param>
			</generator>
		</id>


		<property name="name" />
		<property name="age" />

		<!-- 使用 union-subclass 来映射子类 -->
		
		
		<union-subclass name="com.kiwi.domain.Student" table="t_stu">
			<property name="school" type="string" />
		</union-subclass>
		
	</class>

</hibernate-mapping> 

Test.java

			Person p = new Person();
			p.setAge(11);
			p.setName("person1");
			
			Student s = new Student();
			s.setAge(22);
			s.setName("studnet1");
			s.setSchool("QingHua");
			
			session.save(p);
			session.save(s);

结果: