- 浏览: 203593 次
- 性别:
- 来自: 芜湖
文章分类
- 全部博客 (139)
- 软件 (0)
- Pattern (6)
- CSDN导入 (19)
- Struts (3)
- [网站分类]1.网站首页原创 (27)
- [网站分类]6.转载区 (4)
- Hibernate (10)
- Error (8)
- [网站分类]2.Java新手区 (20)
- Java (8)
- [网站分类]4.其他技术区 (10)
- Web (1)
- C++ (2)
- Algorithm (4)
- Linux (2)
- Skill (1)
- Tech (2)
- Note (2)
- [网站分类]3.非技术区 (1)
- Database (1)
- Winty (7)
- [网站分类]1.网站首页原创Java技术区(对首页文章的要求: 原创、高质量、经过认真思考并精心写作。BlogJava管理团队会对首页的文章进行管理。) (0)
最新评论
-
haohao-xuexi02:
很不错哦。
O'Reilly cos上传组件的使用(1/3) - 上传文件 -
yoin528:
useUnicode=true&charact ...
[原]向MySQL数据库插入Blob数据的问题 -
xiaoqing20:
下载来看看!呵呵
[原]Struts2类型转换 -
xiaoqing20:
[原]Struts2类型转换
[标题]:[原]Hibernate继承映射-整个类层次映射为单个数据库表
[时间]:2009-6-21
[摘要]:将整个类层次映射为单个数据库表。这对于子类属性不多的情况非常有效。每个子类由识别列(discriminator column)区分。优点:实现简单,并支持多态。同时数据访问也比较简单,因为数据库表中包含了所有需要的信息。缺点:增加类层次中的耦合,类层次中任何类的属性的增加都有会导致表的变更。另外,对子类属性的修改错误将会影响到整个类的层次结构。当然也浪费了大量的数据库空间。表中引入区分子类的字段,子类的字段不能创建为空。
[关键字]:Hibernate,ORM,关联,继承,持久化,映射,Abstract
[环境]:MyEclipse7,Hibernate3.2,MySQL5.1
[作者]:Winty (wintys@gmail.com) http://www.blogjava.net/wintys
[正文]:
将整个类层次映射为单个数据库表。这对于子类属性不多的情况非常有效。每个子类由识别列(discriminator column)区分。
优点:
实现简单,并支持多态。同时数据访问也比较简单,因为数据库表中包含了所有需要的信息。
缺点:
增加类层次中的耦合,类层次中任何类的属性的增加都有会导致表的变更。另外,对子类属性的修改错误将会影响到整个类的层次结构。当然也浪费了大量的数据库空间。表中引入区分子类的字段,子类的字段不能创建为空。
例:学校管理系统中的实体关系:
【图:department.jpg】
1、概述
a.实体类
public class Department {
......
private Set<Person> persons;
......
}
public abstract class Person {
......
private Department department;
......
}
public class Student extends Person {
......
}
public class Teacher extends Person {
......
}
b.数据库表
将整个类层次的所有属性全部放入一张表中,不过新增一个字段(discriminator column),用于区分子类。
c.配置文件
Person.hbm.xml:
......
<discriminator column="personType" type="string" />
......
2、实体类:
Department.java:
import java.util.Set;
//Person类相同,直接引用
import wintys.hibernate.inheritance.allinone.Person;
/**
*
* @version 2009-06-20
* @author Winty (wintys@gmail.com)
*
*/
public class Department {
private Integer id;
private String name;
private String desc;
//Department 与 Person一对多
private Set<Person> persons;
public Department(){
}
public Department(String name , String desc){
this.name = name;
this.desc = desc;
}
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 String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public Set<Person> getPersons() {
return persons;
}
public void setPersons(Set<Person> persons) {
this.persons = persons;
}
}
Person.java、Student.java、Teacher.java与wintys.hibernate.inheritance.concrete包中相同,直接复制过来即可。因为Person.java引用的Department与concrete包中的Department不一样,所以要把Person.java等复制过来,而不是直接import。
3、数据库表:
【图:allinone_db.jpg】
db.sql:
-- Date:2009-06-20
-- http://www.blogjava.net/wintys
USE db;
-- Department
CREATE TABLE mydepartment(
id INT(4) NOT NULL,
name VARCHAR(100),
descs VARCHAR(100),
PRIMARY KEY(id)
);
-- Person 、Student、Teacher在一张表中定义
CREATE TABLE myperson(
id INT(4) NOT NULL,
name VARCHAR(100),
dept INT(4), -- 与Department关联
personType VARCHAR(20) NOT NULL,-- 区分Student和Teacher
studentMajor VARCHAR(100),
teacherSalary FLOAT(7,2),
PRIMARY KEY(id),
CONSTRAINT FK_dept_p FOREIGN KEY(dept) REFERENCES mydepartment(id)
);
4、映射文件:
【图:allinone_mapping.jpg】
Department.hbm.xml:
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="wintys.hibernate.inheritance.allinone.Department" table="mydepartment" catalog="db">
<id name="id" type="int">
<column name="id" not-null="true"/>
<generator class="increment" />
</id>
<property name="name" />
<property name="desc" type="string" column="descs"/>
<!-- 实现一对多映射 -->
<set name="persons" inverse="true">
<key column="dept" />
<one-to-many class="wintys.hibernate.inheritance.allinone.Person"/>
</set>
</class>
</hibernate-mapping>
Person.hbm.xml:
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="wintys.hibernate.inheritance.allinone.Person" table="myperson" catalog="db">
<id name="id" type="int">
<column name="id" not-null="true"/>
<generator class="increment" />
</id>
<discriminator column="personType" type="string" />
<property name="name" />
<many-to-one name="department"
unique="true"
column="dept"
class="wintys.hibernate.inheritance.allinone.Department"/>
<subclass name="wintys.hibernate.inheritance.allinone.Student" discriminator-value="Student">
<property name="studentMajor" />
</subclass>
<subclass name="wintys.hibernate.inheritance.allinone.Teacher" discriminator-value="Teacher">
<property name="teacherSalary" column="teacherSalary" type="float"/>
</subclass>
</class>
</hibernate-mapping>
hibernate.cfg.xml:
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<!-- Generated by MyEclipse Hibernate Tools. -->
<hibernate-configuration>
<session-factory>
<property name="connection.username">root</property>
<property name="connection.url">
jdbc:mysql://localhost:3306/db?useUnicode=true&characterEncoding=utf-8
</property>
<property name="dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name="myeclipse.connection.profile">MySQLDriver</property>
<property name="connection.password">root</property>
<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="show_sql">true</property>
<mapping
resource="wintys/hibernate/inheritance/allinone/Department.hbm.xml" />
<mapping
resource="wintys/hibernate/inheritance/allinone/Person.hbm.xml" />
</session-factory>
</hibernate-configuration>
4、使用测试:
DAOBean.java:
import wintys.hibernate.inheritance.concrete.DAO;
import wintys.hibernate.inheritance.concrete.HibernateUtil;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
/**
*
* @version 2009-06-20
* @author Winty (wintys@gmail.com)
*
*/
public class DAOBean implements DAO {
@Override
public void insert() {
Transaction tc = null;
try{
Department dept = new Department("college of math" , "the top 3 college");
Person p1,p2;
p1 = new Student("Sam" , "Math");
p1.setDepartment(dept);
p2 = new Teacher("Martin" , new Float(15000f));
p2.setDepartment(dept);
Session session = HibernateUtil.getSession();
tc = session.beginTransaction();
session.save(dept);
//多态保存
session.save(p1);
session.save(p2);
tc.commit();
}catch(HibernateException e){
try{
if(tc != null)
tc.rollback();
}catch(Exception ex){
System.err.println(ex.getMessage());
}
System.err.println(e.getMessage());
}finally{
HibernateUtil.closeSession();
}
}
@SuppressWarnings("unchecked")
@Override
public <T> List<T> select(String hql) {
List<T> items = null;
Transaction tc = null;
try{
Session session = HibernateUtil.getSession();
tc = session.beginTransaction();
Query query = session.createQuery(hql);
items = query.list();
tc.commit();
}catch(HibernateException e){
try{
if(tc != null){
tc.rollback();
items = null;
}
}catch(Exception ex){
System.err.println(ex.getMessage());
}
System.err.println(e.getMessage());
}finally{
//HibernateUtil.closeSession();
}
return items;
}
}
Test.java:
import java.util.Iterator;
import java.util.List;
import wintys.hibernate.inheritance.concrete.DAO;
import wintys.hibernate.inheritance.concrete.HibernateUtil;
public class Test {
public static void main(String[] args) {
String config = "wintys/hibernate/inheritance/allinone/hibernate.cfg.xml";
HibernateUtil.setConfigFile(config);
DAO dao = new DAOBean();
//dao.insert();
//不支持多态查询
//Error:Person is not mapped
//List<Person> ps = dao.select("from Person");
//System.out.println(printStudentOrTeacher(ps));
/*List<Student> students = dao.select("from Student");
System.out.println(printStudentOrTeacher(students));*/
List<Student> teachers = dao.select("from Teacher");
System.out.println(printStudentOrTeacher(teachers));
}
public static String printStudentOrTeacher(List<? extends Person> students){
String str = "";
Iterator<? extends Person> it = students.iterator();
while(it.hasNext()){
Person person = it.next();
int id = person.getId();
String name = person.getName();
Department dept = person.getDepartment();
int deptId = dept.getId();
String deptName = dept.getName();
String deptDesc = dept.getDesc();
str += "id:" +id + ""n";
str += "name:" + name + ""n";
if(person instanceof Student)
str += "major:" + ((Student) person).getStudentMajor() + ""n";
if(person instanceof Teacher)
str += "salary:" + ((Teacher) person).getTeacherSalary().toString() + ""n";
str += "dept:" + ""n";
str += " deptId:" + deptId + ""n";
str += " deptName:" + deptName + ""n";
str += " deptDesc:" + deptDesc + ""n";
str += ""n";
}
return str;
}
}
5、运行结果
【图:allinone_tables.jpg】
控制台显示:
Hibernate: select max(id) from mydepartment
Hibernate: select max(id) from myperson
Hibernate: insert into db.mydepartment (name, descs, id) values (?, ?, ?)
Hibernate: insert into db.myperson (name, dept, studentMajor, personType, id) values (?, ?, ?, 'Student', ?)
Hibernate: insert into db.myperson (name, dept, teacherSalary, personType, id) values (?, ?, ?, 'Teacher', ?)
Hibernate: select person0_.id as id1_, person0_.name as name1_, person0_.dept as dept1_, person0_.studentMajor as studentM5_1_, person0_.teacherSalary as teacherS6_1_, person0_.personType as personType1_ from db.myperson person0_
Hibernate: select department0_.id as id0_0_, department0_.name as name0_0_, department0_.descs as descs0_0_ from db.mydepartment department0_ where department0_.id=?
id:1
name:Sam
major:Math
dept:
deptId:1
deptName:college of math
deptDesc:the top 3 college
id:2
name:Martin
salary:15000.0
dept:
deptId:1
deptName:college of math
deptDesc:the top 3 college
[参考资料]:
《J2EE项目实训--Hibernate框架技术》-杨少波 : 清华大学出版社
作者:Winty (wintys@gmail.com)
博客:http://www.blogjava.net/wintys
发表评论
-
Hibernate一对多(单向)
2009-07-14 23:01 1398[原]Hibernate一对多(单向) ... -
Hibernate继承映射-继承关系中每个类均映射为一个数据库表
2009-07-14 22:49 1745[标题]:[原]Hibernate继承映射-继承关系中每个类均 ... -
[原]Hibernate一对多(双向)
2009-06-17 22:04 1931[标题]:Hibernate一对多(双向) [时间]:2009 ... -
[原]在MyEclipse中开发Hibernate入门
2009-06-17 22:21 926[标题]:在MyEclipse中开发Hibernate入门 ... -
[原]Hibernate多对多(单向)
2009-06-19 22:43 888[标题]:[原]Hibernate多对多(单向) [时间]:2 ... -
[原]Hibernate多对多(双向)
2009-06-19 22:50 1107[标题]:[原]Hibernate多对多(双向) [时间]: ... -
[原]Hibernate继承映射-具体类映射为数据库表
2009-06-21 13:05 1078[标题]:[原]Hibernate继承映射-具体类映射为数据库 ... -
Hibernate继承映射-概述
2009-06-21 14:24 1073Hibernate中对继承关系的 ... -
[原]Hibernate集合映射
2009-07-03 23:50 1469[标题]:[原]Hibernate集合映射 [时间]:200 ...
相关推荐
本教程以“Hibernate-lab2”为例,将深入探讨Hibernate中的继承映射,为初学者提供一个清晰的学习路径。 一、Hibernate继承映射概述 Hibernate继承映射是将Java中的继承关系映射到数据库的关系模型中。在Java中,...
本文档主要聚焦于Hibernate框架下继承关系的映射,通过三种不同的策略——隐式继承映射、单表映射和关联表映射,来实现类的继承结构在数据库中的映射。 ### 隐式继承映射 #### 定义与配置 隐式继承映射也称为“表...
实体类代表数据库中的表,通过注解或XML映射文件(hibernate-mapping.xml)定义与数据库表的对应关系。例如,@Entity表示实体类,@Table指定表名,@Id标识主键,@GeneratedValue指定主键生成策略。 五、持久化操作 ...
其中,集合映射是Hibernate中非常关键的概念,它允许我们将数据库中的表行映射到Java对象的集合。本文将深入探讨Hibernate集合映射的各个方面,帮助读者理解并熟练运用这一功能。 首先,我们需要了解什么是集合。在...
在IT领域,Hibernate是一个非常重要的Java持久化框架,它简化了数据库操作,使得开发者能够更加专注于业务逻辑而不是数据库层面的细节。本篇文章将全面探讨Hibernate的关联映射学习,包括一对一(One-to-One)、一对...
- **实体类注解**:使用@Entity、@Table等注解,定义Java类与数据库表的映射关系;@Id、@GeneratedValue指定主键生成策略。 - **SessionFactory与Session**:SessionFactory是线程安全的,用于创建单个Session,而...
1. **对象关系映射(ORM)**:ORM是Hibernate的核心功能,它通过将Java类与数据库表进行映射,实现了程序与数据库之间的松耦合。开发者可以操作对象,而无需直接编写SQL语句。 2. **配置文件(hibernate.cfg.xml)*...
总的来说,"Hibernate自动生成持久化类和映射文件"是myEclipse提供的一种便捷工具,它帮助开发者快速地将数据库表结构转化为Java对象,简化了开发流程,使开发者能够更加专注于业务逻辑的实现,而不是底层的数据库...
通过精心设计的继承映射策略,可以将继承关系树中的每个类对应到数据库的一个表,从而有效管理不同级别的实体属性。 #### 支持多态:实现灵活的数据处理 继承映射的一个显著优势在于其对多态的支持。多态是指同一...
在Java世界中,Hibernate是一个非常流行的对象关系映射(ORM)框架,它允许开发者将数据库操作转换为对Java对象的操作,极大地简化了数据库编程。在本实例中,我们将深入探讨如何使用XML配置文件来实现Hibernate的表...
"Hibernate初之单表映射学习例子" 这个标题表明我们将探讨的是Hibernate框架在处理单个数据库表映射的基础教程。Hibernate是Java开发中一个流行的对象关系映射(ORM)工具,它允许开发者用面向对象的方式来操作...
在Hibernate中,每个Java类都可以代表一个数据库表,类的属性对应表的列。通过XML映射文件(.hbm.xml)或注解(@Entity、@Table等)定义实体类与数据库表的关系。 五、持久化操作 1. 插入:通过Session的save()或...
在IT行业中,关系型数据库管理和持久化框架是关键部分,特别是在Java领域,Hibernate作为一个流行的ORM(对象关系映射)框架,极大地简化了数据库操作。本文将深入探讨如何在Oracle数据库中利用Hibernate实现User与...
Hibernate 是一个开源的对象关系映射(ORM)框架,它允许开发者使用面向对象的方式来操作数据库,极大地简化了Java应用与数据库之间的交互。在Hibernate中,组件映射是将一个类的实例作为另一个类的一个属性进行持久...
首先,树形结构在数据库中通常表示为层级数据,例如组织结构、目录树或类别层次。在Hibernate中,映射这种结构的关键在于理解实体之间的关联和嵌套关系。标题“Hibernate映射树形结构”指的是如何用Hibernate来存储...
8. **实体继承与多态**:Hibernate支持单表继承、联合继承和表 per 类继承等多种方式。4.1.0.Final版本对这些继承策略做了优化,更好地适应复杂的数据模型。 9. **性能优化**:该版本提升了查询效率,通过批处理和...
在 Hibernate 中,映射关系是将数据库表与 Java 类之间的关联方式,使得对象模型可以与关系模型无缝对接。本篇文章将详细探讨 Hibernate 中的多种映射关系。 1. **一对一映射 (One-to-One)** 一对一映射表示两个...
-- 在hibernate.cfg.xml或对应的hibernate映射文件中 --> from Student where name = ? ``` 在Java代码中: ```java public class NamedQueryTest { public void namedQuery(Session session) { Query...
- HQL是Hibernate提供的面向对象的查询语言,与SQL类似,但更加面向对象,将数据库表映射为Java类,表中的行映射为类的对象。 - HQL与JPA的JPQL相似,都是为了提高代码的可读性和可维护性,避免硬编码SQL。 2. **...