JAVAWEB开发之Hibernate详解（四）——持久化类的继承映射关系

最新推荐文章于 2023-04-03 00:00:45 发布
最新推荐文章于 2023-04-03 00:00:45 发布
阅读量233 收藏
点赞数
文章标签： java 数据库
本文探讨了在ORM框架中如何处理类的继承关系，详细介绍了三种不同的映射策略及其适用场景，包括每个具体类对应一个表、根类对应一个表以及每个类对应一个表的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

简介说明：

在域模型中，类与类之间除了关联关系和聚集关系，还可以存在继承关系，在如图所示的域模型中，Company类和Employee类之间为一对多的双向关联关系(假定不允许雇员同时在多个公司兼职），Employee类为抽象类，因此它不能被实例化，它有两个具体的子类：HourlyEmployee类和SalaiedEmployee类。由于Java只允许一个类最多有一个直接的父类，因此Employee类、HourlyEmployee类和SalariedEmployee类构成了一棵继承关系树。
在面向对象的范畴中，还存在多态的概念，多态建立在继承关系的基础上。简单地理解，多态是指当一个Java应用变量被声明为Employee类时，这个变量实际上既可以引用HourlyEmployee类的实例，也可以引用SalariedEmployee类的实例。以下这段程序代码就体现了多态：
List employees=businessService.findAllEmployees();
Iterator it=employees.iterator();
while(it.hasNext()){
Employee e=(Employee)it.next();
if(e instanceof HourlyEmployee){
System.out.println(e.getName()+" "+((HourlyEmployee)e).getRate());
}else{
System.out.println(e.getName()+" "+((SalariedEmployee)e).getRate());
}
}
BusinessService类的findAllEmployees（）方法通过Hibernate API从数据库中检索出所有Employee对象。findAllEmployees()方法返回的集合既包含HourlyEmployee类的实例，也包含SalariedEmployee类的实例，这种查询被称为多态查询。以上程序中变量e被声明为Employee类型，它实际上既可能引用HourlyEmployee类的实例，也可
能引用SalariedEmployee类的实例。
此外，从Company类到Employee类为多态关联，因为Company类的employees集合中可以包含HourlyEmployee类和SalariedEmployee类的实例。从Employee类到Company类不是多态关联，因为Employee类的company属性只会引用Company类本身的实例。
数据库表之间不存在继承关系，那么如何把域模型的继承关系映射到关系数据模型中，有以下三种方式：
  • 继承关系树的每个具体类对应一个表: 关系数据模型完全不支持域模型中的继承关系和多态。
  • 继承关系树的根类对应一个表：对关系数据模型进行非常规设计，在数据库表中加入额外的区分子类型的字段。通过这种方式，可以使关系数据模型支持继承关系和多态。
  • 继承关系树的每个类对应一个表：在关系数据模型中用外键参照关系来表示继承关系。
具体类是指非抽象的类，具体类可以被实例化。HourlyEmpolyee和SalariedEmployee类就是具体类。
以上三种方式都有利也有弊。

继承关系树的每个具体类对应一个表

把每个具体类映射到一张表是最简单的映射方式。如图12-2所示，在关系数据模型中只需定义COMPANIES、HOURLY_EMPLOYEES和SALARIED_EMPLOYEES表。为了叙述的方便，下文把HOURLY_EMPLOYEES表简称为HE表，把SALARIED_EMPLOYEES表简称为SE表。HourlyEmployee类和HHE表对应HourlyEmployee类本身的rate属性，以及从Employee类中继承的id属性和name属性，在HE表中都有对应的字段。此外，HourlyEmployee类继承了Employee类与Company类的关联关系，与此对应，在HE表中定义了参照COMPANIES表的COMPANY_ID外键。
SalariedEmployee类和SE表对应，SalariedEmployee类本身的salary属性，以及从Employee类中继承的id属性和name属性，在SE表中都有对应的字段。此外SalariedEmployee类继承了Employee类与Company类的关联关系，与此对应，在SE表中定义了参照COMPANIES表的COMPANY_ID外键。
Company类、HourlyEmployee类和SalariedEmployee类都有相应的映射文件，而Employee类没有相应的映射文件。如下图显示了持久化类、映射文件和数据库表之间的对应关系。

图12-2 每个具体类对应一个表

图12-3 持久化类、映射文件和数据表之间的对应关系
如果Empolyee类不是抽象类，即Employee类本身也能被实例化，那么还需要为Empolyee类创建对应的EMPLOYEES表，此时HE表和SE表的结构仍然和图12-2中所示的一样。这意味着在EMPLOYEES表、HE表和SE表中都定义了相同的NAME字段及参照COMPANYS表的外键COMPANY_ID。另外，还需为EMPLOYEE类创建单独的Employee.hbm.xml文件。

创建映射文件

从Company类到Employee类是多态关联，但是由于关系数据模型没有描述Employee类和它的两个子类的继承关系，因此无法映射Company类的employees集合。例程12-1是Company.hbm.xml文件的代码，该文件仅映射了Company类的id和name属性。
例程12-1 Company.hbm.xml
<hibernate-mapping>
	<class name="mypack.Company" table="COMPANIES">
		<id name="id" type="long" column="ID">
			<generator class="increment" />
		</id>
		<property name="name" type="string" column="NAME"/>
	</class>
</hibernate-mapping>
HourlyEmployee.hbm.xml文件用于把HourlyEmployee类映射到HE表，在这个映射文件中，除了需要映射HourlyEmployee类本身的rate属性，还需要映射从Employee类中继承的name属性，此外还要映射从Employee类中继承的与Company类的关联关系。例程12-2是HourlyEmployee.hbm.xml文件的代码。
例程 12-2 HourlyEmployee.hbm.xml
<hibernate-mapping>
	<class name="mypack.HourlyEmployee" table="HOURLY_EMPLOYEES">
		<id name="id" type="long" column="ID">
			<generator class="increment" />
		</id>
		<property name="name" type="string" column="NAME"/>
		<property name="rate" type="double" column="RATE"/>
		<many-to-one name="company" column="COMPANY_ID" class="mypack.Company"/>
	</class>
</hibernate-mapping>
SalariedEmployee.hbm.xml文件用于把SalariedEmployee类映射到SE表，在这个映射文件中，除了需要映射SalariedEmployee类本身的salary属性，还需要映射从Employee类中继承的name属性，此外还要映射从Employee类中继承的与Company类的关联关系。例程12-3是SalariedEmployee.hbm.xml文件的代码。
例程12-3 SalariedEmployee.hbm.xml
<hibernate-mapping>
	<class name="mypack.SalariedEmployee" table="SALARIED_EMPLOYEES">
		<id name="id" type="long" column="ID">
			<generator class="increment" />
		</id>
		<property name="name" type="string" column="NAME"/>
		<property name="salary" type="double" column="SALARY"/>
		<many-to-one name="company" column="COMPANY_ID" class="mypack.Company"/>
	</class>
</hibernate-mapping>

操作持久化对象

这种映射方式不支持多态查询。对于以下查询语句。
List employees=session.createQuery("from Employee").list();
如果Employee类是抽象类，那么Hibernate会抛出异常。如果Employee类是具体类，那么Hibernate仅查询EMPLOYEES表，检索出Employee类本身的实例，但不会检索出它的两个子类的实例。
  • findAlIEmployees()：检索数据库中所有的Employee对象。
  • loadCompany()：加载一个Company对象。
  • saveEmployee()：保存一个Employee对象。
(1）运行findAllEmployees0方法，它的代码如下
List results=new ArrayList();
tx=session.beginTransaction();
List hourlyEmployees=session.createQuery(" from HourlyEmployee").list();
results.addAll(hourlyEmployees);
List salariedEmployees=session.createQuery(" from SalariedEmployee").list();
results.addAll(salariedEmployees);
tx.commit();
return results;
为了检索所有的Employee对象，必须分别检索所有的HourlyEmployee实例和SalariedEmployee实例，然局把它们合并到同一个集合中。在运行第一个Query的list()方法时，Hibernate执行以下select语句：
select * from HOURLY_EMPLOYEES;
在运行第二个Query的list()方法时 Hibernate会执行以下的select语句
select * from SALARIED_EMPLOYEES;

(2) 运行loadCompany() 方法，它的代码如下：
tx=session.beginTransaction();
Company company=(Company)session.get(Company.class,new Long(id));
List hourlyEmployees=session.createQuery(" from HourlyEmployee h where h.company.id="+id).list();
company.getEmployees().addAll(hourlyEmployees);
List salariedEmployees=session.createQuery(" from SalariedEmployee s where s.company.id="+id).list();
company.getEmployees().addAll(salariedEmployees);
tx.commit();
return company;

(3) 运行saveEmployee(Employee employee)方法，它的代码如下：
tx=session.beginTransaction();
session.save(employee);
tx.commit();
在test()方法中，创建了一个HourlyEmployee实例，然后调用saveEmployee()方法保存这个实例：
Employee employee=newHourlyEmployee("Mary",300,company);
saveEmployee(employee);
Session的save()方法能判断employee变量实际引用的实例的类型，如果employee变量引用HourlyEmployee实例,就向HE表中插入一条记录，执行如下insert语句：
insert into HOURLY_EMPLOYEES(ID,NAME,RATE,CUSTOMER_ID) values(3, 'Mary', 300,1);
如果employee变量引用SalariedEmployee实例，就向SE表插入一条记录。

继承关系树的根类对应一个表

这种映射方式只需为继承关系树的Employee根类创建一张表EMPLOYEES如图12-4所示，在EMPLOYEES表中不仅提供和Employee类的属性对应的字段，还要提供和它的两个子类的所有属型对应的字段，此外，EMPLOYEES表中需要额外加入一个字符串类型的EMPLOYEE_TYPE字段，用于区分Employee的具体类型。

Company类和Employee类有相应的映射文件，而HourlyEmployee类和SalariedEmployee类没有相应的映射文件。图12-5显示了持久化类、映射文件和数据库表之间的对应关系。

创建映射文件

从Company类到Employee类是多态关联，由于关系数据模型可以反映出Employee类和它的两个子类的继承关系，因此可以映射Company类的employees集合。例程12-5是Company.hbm.xml文件的代码，该文件不仅映射了Company类的id和name属性，还映射了它的employees集合。
例程12-5 Company.hbm.xml
<hibernate-mapping>
	<class name="mypack.Company" table="COMPANIES">
		<id name="id" type="long" column="ID">
			<generator class="increment" />
		</id>
		<property name="name" type="string" column="NAME" />
		<set name="employees" inverse="true">
			<key column="COMPANY_ID" />
			<one-to-many class="mypack.Employee" />
		</set>
	</class>
</hibernate-mapping>
Employee.hbm.xml文件用于把Employee类映射到EMPLOYEES表，在这个映射文件中，除了需要映射Employee类本身的属性，还需要在<subclass>元素中映射两个子类的属性。例程12-6是Employee.hbm.xml文件的代码：
例程 12-6 Employee.hbm.xml
<hibernate-mapping>
	<class name="mypack.Employee" table="EMPLOYEES">
		<id name="id" type="long" column="ID">
			<generator class="increment" />
		</id>
		<discriminator column="EMPLOYEE_TYPE" type="string" />
		<property name="name" type="string" column="NAME" />
		<many-to-one name="company" column="COMPANY_ID" class="mypack.Company" />

		<subclass name="mypack.HourlyEmployee" discriminator-value="HE">
			<property name="rate" type="double" column="RATE" />
		</subclass>

		<subclass name="mypack.SalariedEmployee" discriminator-value="SE">
			<property name="salary" type="double" column="SALARY" />
		</subclass>
	</class>
</hibernate-mapping>

在Employee.hbm.xml文件中，<discriminator>元素指定EMPLOYEES表中用于区分Employee类型的字段为EMPLOYEE_TYPE，两个<subclass>元素用于映射HourlyEmployee类和SalariedEmployee类，<subclass>元素的discriminator-value属性指定EMPLOYEE TYPE字段的取值。EMPLOYEES表中有以下记录:

其中ID为1和2的记录的EMPLOYEE_TYPE字段的取值为“HE”，因此它们对应HourlyEmployee类的实例，其中ID为3和4的记录的EMPLOYEE_TYPE字段的取值为“SE”，因此它们对应SalariedEmployee类的实例这种映射方式要求EMPLOYEES表中和子类属性对应的字段允许为null，如ID为1和2的记录的SALARY字段为null，而ID为3和4的记录的RATE字段为null 如果业务需求规定SalariedEmployee对象的rate属性不允许为null，显然无法在EMPLOYEES表中为SALARY字段定义not null约束，可见这种映射方式无法保证关系数据模型的数据完整性。
如果Employee类不是抽象类，即它本身也能被实例化，那么可以在<class>元素中定义它的discriminator值，形式如下：
<class name="mypack.Employee" table="EMPLOYEES" discriminator-value="EE">
以上代码表明，如果EMPLOYEES表中一条记录的EMPLOYEE_TYPE字段的取值为"EE"，那么它对应Employee类本身的实例。

操作持久化对象

这种映射方式支持多态查询，对于以下查询语句：
List employees=session.createQuery("from Employee").list();
Hibemate会检索出所有的HourlyEmployee对象和SalariedEmployee对象。此外也可以单独查询Employee类的两个子类的实例，例如：
List hourlyEmployees=session.createQuery("from HourlyEmployee").list();
业务代码类中有以下方法：
  • findAllHourlyEmployees()：检查数据库中所有的HourlyEmployee对象。
  • findAlIEmployees()：检索数据库中所有的Employee对象。
  • loadCompany()：加载一个Company对象。
  • saveEmployee()：保存一个Employee对象。
(1) 运行findAllHourlyEmployees() 方法，它的代码如下：
tx=session.beginTransaction();
List results=session.createQuery("from HourlyEmployee").list();
tx.commit();
return results;
在运行Query的list()方法时，Hibernate执行以下的select语句：
select * from EMPLOYEES where EMPLOYEE_TYPE='HE';

(2) 运行findAllEmployees()方法，它的代码如下：
tx=session.beginTransaction();
List results=session.createQuery("from Employee").list();
tx.commit();
return results;
在运行Query的list()方法时，Hibernate执行以下的select语句：
select * from EMPLOYEES ;
在这种映射方式下，Hibernate支持多态查询，对于从EMPLOYEES表获得的查询结果，如果EMPLOYEE_TYPE字段取值为“HE”，就创建HoulyEmployee实例，如果EMPLOYEE_TYPE字段取值为“SE”，就创建SalariedEmployee实例。

（3）运行loadCompany()方法，它的代码如下：
tx=session.beginTransaction();
Company company=(Company)session.get(Company.class,new Long(id));
Hibernate.initialize(company.getEmployees());
tx.commit();
这种映射方式支持多态关联。如果在Company.hbm.xml文件中对employees集合设置了立即检索策略，那么Session的get()方法加载的Company对象的employees集合中包含所有关联的Employee对象。由于提供的Company.hbm.xml文件对employees集合采用默认的延迟检索策略，因此以上程序代码通过Hibemate类的静态
initialize()方法来显式初始化employees集合。

(4)运行saveEmployee(Employee employee)方法，它的代码如下：
tx=session.beginTransaction();
session.save(employee);
tx.commit();
在test方法中，创建了一个HourlyEmployee实例，然后调用saveEmployee()方法保存这个实例：
Employee employee=new HourlyEmployee("Mary",300,company);
saveEmployee(employee);
Session的save()方法能判断employee变量实际引用的实例的类型，如果employee变量引用HourlyEmployee实例，就执行如下insert语句：
insert into EMPLOYEES(ID,NAME,RATE, EMPLOYEE_TYPE, CUSTOMER_ID) values(5, 'Mary', 300, 'HE',1);
以上insert语句没有为SalariedEmployee类的salary属性对应的SALARY字段赋值，因此这条记录的SALARY字段为null.

继承关系树的每个类对应一个表

在这种映射方式下，继承关系树的每个类及接口都对应一个表。在本例中需要创建EMPLOYEES、HE和SE表。如图12-6所示，EMPLOYEES表仅包含和Employee类的属性对应的字段，HE表仅包含和HourlyEmployee类的属性对应的
字段，SE表仅包含和SalariedEmployee类的属性对应的字段。此外，HE表和SE表都以EMPLOYEE_ID字段作为主键，该字段还同时作为外键参照EMPLOYEES表。

Company类和Employee类有相应的映射文件，而HourlyEmployee类和SalariedEmployee类没有相应的映射文件。图12-7显示了持久化类、映射文件和数据库表之间的对应关系。

创建映射文件

从Company类到Employee类是多态关联，由于关系数据模型反映出了Employee类和它的两个子类的继承关系，因此可以映射Company类的employees集合。例程12-7是Company.hbm.xml文件的代码，该文件不仅映射了Company类的id和name属性，还映射了它的employees集合。
<hibernate-mapping>
	<class name="mypack.Company" table="COMPANIES">
		<id name="id" type="long" column="ID">
			<generator class="increment" />
		</id>
		<property name="name" type="string" column="NAME" />
		<set name="employees" inverse="true">
			<key column="COMPANY_ID" />
			<one-to-many class="mypack.Employee" />
		</set>
	</class>
</hibernate-mapping>
Employee.hbm.xml文件用于把Employee类映射到EMPLOYEES表，在这个映射文件中，除了需要映射Employee类本身的属性，还需要在<joined-subclass>元素中映射两个子类的属性。例程12-8是Employee.hbm.xml文件的代码。
例程 12-8 Employee.hbm.xml
<hibernate-mapping>
	<class name="mypack.Employee" table="EMPLOYEES">
		<id name="id" type="long" column="ID">
			<generator class="increment" />
		</id>
		<property name="name" type="string" column="NAME" />

		<many-to-one name="company" column="COMPANY_ID" class="mypack.Company" />

		<joined-subclass name="mypack.HourlyEmployee" table="HOURLY_EMPLOYEES">
			<key column="EMPLOYEES_ID" />
			<property name="rate" type="double" column="RATE" />
		</joined-subclass>

		<joined-subclass name="mypack.SalariedEmployee" table="SALARIED_EMPLOYEES">
			<key column="EMPLOYEES_ID" />
			<property name="salary" type="double" column="SALARY" />
		</joined-subclass>

	</class>
</hibernate-mapping>

在Employee.hbm.xml文件中，两个<joined-subclass>元素用于映射HourlyEmployee类和SalariedEmployee类，<joined-subclass>元素的<key>子元素指定HE表和SE表中即作为主键，又作为外键的EMPLOYEE_ID字段。图12-8显示了EMPLOYEES表、HE表和SE表中记录的参照关系。


也可以在单独的映射文件中配置<subclass>或<joined-subclass>元素，但此时必须显式设定它们的extends属性。例如，可以在单独的HourlyEmployee.hbm.xml文件中映射HourlyEmployee类:

<hibernate-mapping>

<joined-subclass name="mypack.HourlyEmployee" table="HOURLY_EMPLOYEES" extends="mypack.Employee">

......

</joined-subclass>

</hibernate-mapping>

使用注意事项：

值得注意的是，在<subclass>元素中只能嵌入<subclass>子元素，但不能嵌入<joined-subclass>子元素，而在<joined-subclass>元素中只能嵌入<joined-subclass>子元素，但不能嵌入<subclass>子元素。

操纵持久化对象

这种映射方式支持多态查询，对于以下查询语句：
List employees=session.createQuery("from Employee").list();
Hibernate会检索出所有的HourlyEmployee对象和SalariedEmployee对象。此外，也可以单独查询Employee类的两个子类 的实例，例如：
List hourlyEmployees=session.createQuery("from HourlyEmployee").list();
业务代码类中有以下方法：
  • findAllHourlyEmployees()：检查数据库中所有的HourlyEmployee对象。
  • findAlIEmployees()：检索数据库中所有的Employee对象。
  • loadCompany()：加载一个Company对象。
  • saveEmployee()：保存一个Employee对象。
(1) 运行findAllHourlyEmployees()非，它的代码如下：
tx = session.beginTransaction();
List results=session.createQuery("from HourlyEmployee").list();
tx.commit();
return results;
在运行Query的list()方法时，Hibernate执行以下的Select语句：
select * from HOURLY_EMPLOYEES he inner join EMPLOYEES e on he.EMPLOYEE_ID=e.ID;
Hibernate通过HE表与EMPLOYEES表的内连接获得HourlyEmployee对象的所有属性值。

(2) 运行findAllEmployees() 方法，它的代码如下：
tx=session.beginTransaction();
List results=session.createQuery("from Employee").list();
tx.commit();
return results;
在运行Query的list()方法时，Hibernate执行以下Select语句：
select * from EMPLOYEES e
left outer join HOURLY_EMPLOYEES he on e.ID = he.EMPLOYEE_ID
left outer join SALARIED_EMPLOYEES se on e.ID = se.EMPLOYEE_ID;
Hibernate把EMPLOYEES表与HE表及SE表进行左外连接，从而获得HourlyEmployee对象和SalariedEmployee对象的所有属性。在这种映射方式下，Hibernate支持多态查询，对于以上查询语句获得的查询结果，如果HE表的EMPLOYEE_ID字典不为null，就创建HourlyEmployee实例；如果SE表的EMPLOYEE_ID不为null，就创建SalariedEmployee实例。

(3) 运行loadCompany()方法，它的代码如下：
tx=session.beginTransaction();
Company company=(company)session.get(Company.class, new Long(id));
Hibernate.initialize(company.getEmployees());
tx.commit();
这种映射方式支持多态查询。如果在Company.hbm.xml文件中对employees集合设置了立即检索策略，那么Session的 get()方法加载的Company对象的employees集合中包含了所有关联的Employees对象。由于以上Company.hbm.xml文件对employees集合使用了默认的延迟检索的策略，因此以上程序代码还通过Hibernate累的静态initialize()方法来显式初始化employees集合，初始化时执行以下的select语句：
select e.COMPANY_ID, e.ID, e.NAME, he.RATE, se.SALARY, case when he.EMPLOYEE_ID is not null then 1 when se.EMPLOYEE_ID is not null then 2 when e.ID is not null then 0 as clazz from EMPLOYEES e left outer join HOURLY_EMPLOYEES he on e.ID =he.EMPLOYEE_ID left outer join SALARIED_EMPLOYEES se on e.ID=se.EMPLOYEE_ID where e.COMPANY_ID=1;

(4)运行saveEmployee(Employee employee)方法，它的代码如下：
tx=session.beginTransaction();
session.save(employee);
tx.commit();
在Test方法中，创建了一个HourlyEmployee实例，然后调用saveEmployee()方法保存这个实例：
Employee employee=new HourlyEmployee("Mary", 300, company);
saveEmployee(employee);
Session的save()方法能判断employee变量实际引用的实例的类型，如果employee变量引用HourlyEmployee实例，就执行如下的insert语句：
insert into EMPLOYEES (ID, NAME, COMPANY_ID) values (5, 'Mary', 1);
insert into HOURLY_EMPLOYEES (EMPLOYEE_ID, RATE) values (5, 300);
可见，每保存一个HourlyEmployee对象，需要分别向EMPLOYEES表和HE表插入一条记录，EMPLOYEES表的记录和HE表的记录共享一个主键。

选择继承的映射方式

比较三种映射方式

如果不需要支持多态查询和多态关联，可以采用每个具体类对应一个表的映射方式；如果需要支持多态查询和多态关联，并且子类包含的属性不多，可以采用根类对应一个表的映射方式；如果需要支持多态查询和多态关联，并且子类包含的属性很多，可以采用每个类对应一个表的映射方式。如果继承关系树中包含接口，可以将它当做抽象类来处理。
图12-9显示了一棵复杂的继承关系树，其中DOClass为抽象类，其它均为具体类。

可以将图12-9的继承关系树分解成3棵子树：
  • DOClass类、ClassA类和ClassB类为一棵子树：DOClass类为抽象类，位于整个继承关系树的顶层，通常不会对它进行多态查询，因此可以采用每个具体类对应一个表的映射方式，ClassA类对应TABLE_A表，ClassB类对应TABLEB表。
  • ClassA类、ClassC类、ClassD类、ClassG类和ClassH类为一棵子树：ClassA类的所有子类都只包含少量属性，因此可以采用根类对应一个表的映射方式，ClassA类对应TABLEA表
  • ClassB类、ClassE类和ClassF为一棵子树：ClassB类的两个子类都包含很多属性，因此采用每个类对应一个表的映射方式，ClassB类对应TABLE_B表，ClassE类对应TABLE_E表，ClassF类对应TABLE_F表。
如图12-10所示，在关系数据模型中，只需创建TABLE_A、TABLE_B、TABLE_E和TABLE_F表，其中TABLE_A中包含了与DOClass、ClassA、ClassC、ClassD、ClassG和ClassH的属性对应的字段。TABLE_B中包含了与DOClass和ClassB的属性对应的字段，TABLE_E和TABLE_F的BID字段既是主键，又是参照TABLE_B表的外键.

示例如下：

只需要创建两个映射文件，ClassA.hbm.xml和ClassB.hbm.xml如下所示：
例程12-9 ClassA.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="cn.test.hibernate3.demo1.ClassA" table="TABLE_A"
		discriminator-value="A">
		<id name="id" type="long" column="ID">
			<generator class="increment" />
		</id>
		<discriminator column="A_TYPE" type="string" />
		<property name="a1" type="string" column="A1" />

		<subclass name="cn.test.hibernate3.demo1.ClassC"
			discriminator-value="C">
			<property name="c1" column="C1" type="string" />
		</subclass>

		<subclass name="cn.test.hibernate3.demo1.ClassD"
			discriminator-value="D">
			<property name="d1" column="D1" type="string" />

			<subclass name="cn.test.hibernate3.demo1.ClassG"
				discriminator-value="G">
				<property name="g1" column="G1" type="string" />
			</subclass>

			<subclass name="cn.test.hibernate3.demo1.ClassH"
				discriminator-value="H">
				<property name="h1" column="H1" type="string" />
			</subclass>
		</subclass>
	</class>

</hibernate-mapping>
例程 12-10 ClassB.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="cn.test.hibernate3.demo1.ClassB" table="TABLE_B">
		<id name="id" type="long" column="ID">
			<generator class="increment" />
		</id>
		<property name="b1" type="string" column="B1" />

		<joined-subclass name="cn.test.hibernate3.demo1.ClassE" table="TABLE_E">
			<key column="B_ID" />
			<property name="e1" column="E1" type="string" />
			<property name="e2" column="E2" type="string" />
			<property name="e3" column="E3" type="string" />
			<property name="e4" column="E4" type="string" />
			<property name="e5" column="E5" type="string" />
			<property name="e6" column="E6" type="string" />
		</joined-subclass>

		<joined-subclass name="cn.test.hibernate3.demo1.ClassF" table="TABLE_F">
			<key column="B_ID" />
			<property name="f1" column="F1" type="string" />
			<property name="f2" column="F2" type="string" />
			<property name="f3" column="F3" type="string" />
			<property name="f4" column="F4" type="string" />
			<property name="f5" column="F5" type="string" />
			<property name="f6" column="F6" type="string" />
			<property name="f7" column="F7" type="string" />
		</joined-subclass>

	</class>

</hibernate-mapping>


在 ClassA.hbm.xml文件中，在用于映射ClassD 的<subclass>元素中还嵌入了两个<subclass>元素，它们分别映射ClassG和ClassHH类。在<class>及所有的<subclass>元系中都设置了discriminator-value属性，Hibernate根据discriminator-value属性来判断TABLE_A表中的记录对应哪个类的实例，如果TABLE_A表的一条记录的A_TYPE
子段取值为“A”，表明它是ClassA类的实例；如果A_TYPE字段取值为“G”，表明它是ClassG类的实例，依次类推。
测试类如下：
TestHbmExtend
package cn.test.hibernate3.demo1;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.test.hibernate3.utils.HibernateUtils;

public class TestHbmExtend {

	@Test
	// 测试保存操作
	public void demo1() {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		ClassA g = new ClassG("a1", "d1", "g1");
		ClassB f = new ClassF("b1", "f1", "f2", "f3", "f4", "f5", "f6", "f7");
        session.save(g);
        session.save(f);
		tx.commit();
		session.close();
	}
}
生成表的结构如下：


插入的数据如下所示：




iteye_18817
关注
【Hibernate】——由持久化和映射文件创建表
王萌萌
01-09 955
对应关系     首先，要使用持久化类和映射文件创建表，要先认识到持久化类与映射文件是如何一一对应的，如下：     配置文件     存放连接的数据库信息等，具体信息看以下hibernate.cfg.xml中代码注释解释： <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate C
JAVAWEB开发之Hibernate详解（二）——Hibernate的持久化类状态与转换、以及一级缓存详解、关联关系的映射（一对多、多对多、级联）
04-03 2784
持久化对象的状态  Hibernate持久化对象存在三种状态： 瞬时态 transient:(临时态)  不存在持久化标识OID，尚未与Hibernate  Session关联对象，被认为是瞬时状态，失去引用将被JVM回收。特点：无持久化标识OID，未与Session关联。 持久态 persistent:存在持久化标识OID，与当前Session有关联，并且相关联的Session没有关闭，并
Hibernate自动生成持久化类和映射文件
09-03
Hibernate中根据数据库中各表,使用myEclipse的返向工程,自动生成hibernate.cfg.xml 配置文件 与person.hbm.xml映射文件和持久化类 (图文介绍)
JAVAWEB开发之Hibernate详解（二）——Hibernate的持久化类状态与转换、以及一级缓存详解、关联关系的映射（一对多、多对多、级联）...
iteye_18817的博客
04-03 1356
持久化对象的状态 Hibernate持久化对象存在三种状态： 瞬时态 transient:(临时态) 不存在持久化标识OID，尚未与Hibernate Session关联对象，被认为是瞬时状态，失去引用将被JVM回收。特点：无持久化标识OID，未与Session关联。 持久态 persistent:存在持久化标识OID，与当前Session有关联，并且相关联的Session没有关闭，并且事务未提交...
hibernate持久化类映射文件*.hbm.xml
zcyhappy1314的专栏
03-19 4321
通过 POJO 类的数据库映射文件，Hibernate可以理解持久化类和数据表之间的对应关系，也可以理解持久化类属性与数据库表列之间的对应关系。 在运行时 Hibernate 将根据这个映射文件来生成各种 SQL 语句。 hibernate-mapping 是 hibernate 映射文件的根元素，其属性如下： schema: 指定所映射的数据库schema的名称。若指定该属性, 则表明会自
hibernate由表生成持久化类和映射文件
weixin_34014555的博客
06-30 160
Eclipse由表生成持久化类和映射文件 转载于:https://blog.51cto.com/pengya123/1794494
JAVAWEB开发之Hibernate详解（一）——Hibernate的框架概述、开发流程、CURD操作和核心配置与API以及Hibernate日志的使用
03-26 8862
Hibernate框架概述 什么是Hibernate 为何要学习Hibernate Hibernate版本 Hibernate日志记录 Log4J技术 Hibernate快速入门 第一步下载Hibernate3x的开发包3610 第二步Hibernate框架目录结构 第三步创建一个工程Java工程 第四步搭建环境创建一个customer表与对应的持久化类 第五步在Customerclass所在的目录创建映射文件 第六步配置JDBC连接数据库基本属性 第七步编程操作hibernate框架 Hibernate的
轻松学JavaWeb开发之Hibernate配置和会话PPT学习教案.pptx
10-03
【JavaWeb开发】 Hibernate是Java领域中常用的ORM（对象关系映射）框架，它简化了数据库操作，使得开发者可以通过操作Java对象而不是SQL语句来进行数据交互。本教程主要讲解了Hibernate的传统配置方法和会话管理。 ...
学JavaWeb开发之Hibernate配置与会话学习教案PPT详解
"轻松学JavaWeb开发之Hibernate配置和会话PPT学习教案.pptx" 是一份教学材料，旨在帮助学习者掌握Hibernate的配置和会话管理。本教案介绍了Hibernate的传统配置方法和使用Annotations进行配置的方法。在学习...
Hibernate入门详解：配置、持久化与对象映射
总结来说，本章内容涵盖了Hibernate从基础配置到实际应用的全过程，包括配置文件的创建、持久化类的设计、对象关系映射的编写，以及如何利用Hibernate API与数据库交互。通过helloapp应用的实例，读者可以掌握...
继承映射的详细解说
11-14
继承映射详细，非常实用的学习资料继承映射详细，非常实用的学习资料
java实验源码（化工大学java课）
12-17
自己写的 java实验的源码（化工大学java课）java实验的源码（化工大学java课）
Hibernate根据数据库表生成持久化类和映射文件
09-03
Hibernate中根据数据库中各表,使用myEclipse的返向工程,自动生成hibernate.cfg.xml 配置文件 与person.hbm.xml映射文件和持久化类 (图文介绍)
Hibernate学习笔记三 ---持久化类和关系数据库的映射
04-08 310
 Middlegen: 从数据库中已有 的表结构中生成Hibernate映射文 件。当前版本是2.1可以去http://boss.bekk.no/boss/middlegen下载。    XDoclet：它通过在Java源代码中加入特定的JavaDoc tag，从而为其添加特定的附加语义，之后通过XDoclet工具对代码中JavaDoc Tag进行分析，自动生成与代码对应的
hibernate中持久化类映射到数据表的注意事项。
diangeng1155的博客
11-08 287
在web项目中，我们用到hibernate的话要先在用java语言创建一个持久化的bean类，然后在映射到数据库中的表！ 在这里我要说的是这个数据表的创建 应该使用SQL的DDL语言来完成，不要用management studio，我在做项目的时候用management studio建表导致id主键和java持久化类当中的id不匹配。报了很多错误，所以写此随笔作为警示。 我的栗子！ ...
ssh框架hibernate 2持久化对象和关系关联映射
蹲茅坑逗蛆蛆
09-12 633
什么是持久化类1. 持久化类:就是一个Java类（编写的JavaBean），这个Java类与表建立了映射关系就可以成为是持久化类。 * 持久化类 = JavaBean + xxx.hbm.xml 持久化类的编写规则1. 提供一个无参数 public访问控制符的构造器 -- 底层需要进行反射. 2. 提供一个标识属性，映射数据表主键字段
继承关系如何持久化到数据库
让兔子飞得更高
10-15 1098
关系型数据库中的关系的详细描述可以参见下面的博文： 数据库（二）—— 关系数据库以及关系代数和关系运算 数据库设计中的数据库表和表之间的关系有：一对一、一对多和多对多这三种关系。 可见，数据库表之间的关系是组合关系。 那么在面向对象程序设计当中有哪些关系呢？ 答案是有两种关系：继承和组合。 在设计模式中有一句话叫做：组合优于继承，说的是组合相对于继承更加灵活。参见如下博文： 组合优于继承—设计模式...
实现类的多继承
算法与编程之美
04-03 254
1 问题在类的继承中，我们知道了只能继承一个父类，在使用中就会降低我们编写代码的效率，如果要实现多继承就只能多创造类。2 方法在同时可用内部类和接口时，优先使用接口，因内部类需要应用于继承关系，而接口可用于继承也可用于其它，比较灵活。定义类实现接口，需要实现其所有父接口的方法.//接口实现多继承interface IA{//父接口A void funA();}interface IB {//...
[javase学习笔记]-9.2 单继承与多重继承
aodiyi6351的博客
07-18 168
这一节我们来看java中的单继承和多重继承。 在java语言中，支持的是单继承，不直接支持多继承，可是对C++中的多继承进行了改良。 那么什么是单继承和多继承呢？ 单继承：一个子类仅仅能有一个直接父类。 多继承：一个子类能够有多个直接父类。这个在java中是不同意的。 为什么不同意呢？我们看一个样例： class A { void method(...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值