hibernate中继承映射

最新推荐文章于 2016-10-01 16:32:00 发布
最新推荐文章于 2016-10-01 16:32:00 发布
阅读量755 收藏
点赞数
分类专栏： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_niu_1/article/details/8976466
版权

继承映射：

1）每个类一张表。

package model;

public class Person {
	private String id;
	
	private String name;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	
}



package model;

public class Student extends Person{
	
	private String idCard;

	public String getIdCard() {
		return idCard;
	}

	public void setIdCard(String idCard) {
		this.idCard = idCard;
	}
	
	
}


package model;

public class Teacher  extends Person{
	private int salary;
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
}

<?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">
<hibernate-mapping>
	<class name = "model.Student" table = "student" lazy="true">
		<id name="id" column="id" type="string">
			<generator class="uuid"></generator>
		</id>
		<property name="name" column = "name" type = "string"></property>
		<property name="idCard" column = "idCard" type = "string"></property>
	</class>
</hibernate-mapping>


<?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">
<hibernate-mapping>
	<class name = "model.Teacher" table = "teacher" lazy="true">
		<id name="id" column="id" type="string">
			<generator class="uuid"></generator>
		</id>
		<property name="name" column = "name" type = "string"></property>
		<!-- 
		虽然Person中的id属性和name属性是private，当是它们的存储方法被Teacher类继承下来了，hibernate只要根据get和set方法来存取即可。
		-->
		<property name="salary" column = "salary" type = "integer"></property>
	</class>
</hibernate-mapping>

package model;

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
/*
 * 
 * create table student (id varchar(255) not null, name varchar(255), idCard varchar(255), primary key (id))
create table teacher (id varchar(255) not null, name varchar(255), salary integer, primary key (id))
 */
public class Create {
	public static void main(String[] args) {
		SchemaExport export = new SchemaExport(new Configuration().configure());
		export.create(true, true);
	}
}


package model;

import java.util.Iterator;

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

public class Test {
	public static void main(String[] args) {
		//save();
		fetch();
	}
	
	/**
	 * 
Hibernate: insert into student (name, idCard, id) values (?, ?, ?)
Hibernate: insert into teacher (name, salary, id) values (?, ?, ?)
	 */
	static void save () {
		Session session = HibernateUtil.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
				
			Student student = new Student ();
			student.setIdCard("12334");
			student.setName("zhanglei");
			
			Teacher teacher = new Teacher ();
			teacher.setSalary(100);
			
			teacher.setName("lisi");
			
			session.save(student);
			
			session.save(teacher);
			
			
			tx.commit();
		}catch (Exception ex) {
			ex.printStackTrace();
			if (null != tx) {
				tx.rollback();
			}
		}finally {
			HibernateUtil.close(session);
		}
	}
	
	static void fetch () {
		Session session = HibernateUtil.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			Query query = session.createQuery("from model.Person");//多态查询
			Iterator it = query.list().iterator() ;
			while (it.hasNext()) {
				Person person = (Person)it.next();
				System.out.println(person.getName());
			}
			tx.commit();
		}catch (Exception ex) {
			ex.printStackTrace();
			if (null != tx) {
				tx.rollback();
			}
		}finally {
			HibernateUtil.close(session);
		}
	}
}


Hibernate: select teacher0_.id as id1_, teacher0_.name as name1_, teacher0_.salary as salary1_ from teacher teacher0_
Hibernate: select student0_.id as id0_, student0_.name as name0_, student0_.idCard as idCard0_ from student student0_
lisi
zhanglei



2）一张表存储继承体系中所有类的信息（数据库表实际上是继承体系中所有类的属性并集所构成的字段）

需要在HBM文件中增加如下一行。

<discriminator column = "personType" type = "string" length="10"></discriminator>

Student类，Person类，Teacher类同上：


<?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">
<hibernate-mapping>
	<class name = "model.Person" table = "Person" lazy="true">
		<id name="id" column="id" type="string" length="50">
			<generator class="uuid"></generator>
		</id>
		<discriminator column = "personType" type = "string" length="10"></discriminator>
		<property name="name" column = "name" type = "string"></property>
		<subclass name = "model.Student" discriminator-value="student">
			<property name="idCard" type = "string"></property>
		</subclass>
		<subclass name="model.Teacher" discriminator-value="teacher">
			<property name="salary" type = "int"></property>
		</subclass>
	</class>
</hibernate-mapping>

package model;

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
/*
 * 
 * create table Person (id varchar(255) not null, personType varchar(255) not null, name varchar(255), idCard varchar(255), salary integer, primary key (id))
 */
public class Create {
	public static void main(String[] args) {
		SchemaExport export = new SchemaExport(new Configuration().configure());
		export.create(true, true);
	}
}

package model;

import java.util.Iterator;

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

public class Test {
	public static void main(String[] args) {
		//save();
		//fetch();
		fetch3();
	}
	
	/**
	 * 
Hibernate: insert into Person (name, idCard, personType, id) values (?, ?, 'student', ?)
Hibernate: insert into Person (name, salary, personType, id) values (?, ?, 'teacher', ?)
	 */
	static void save () {
		Session session = HibernateUtil.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
				
			Student student = new Student ();
			student.setIdCard("12334");
			student.setName("zhanglei");
			
			Teacher teacher = new Teacher ();
			teacher.setSalary(100);
			
			teacher.setName("lisi");
			
			session.save(student);
			
			session.save(teacher);
			
			
			tx.commit();
		}catch (Exception ex) {
			ex.printStackTrace();
			if (null != tx) {
				tx.rollback();
			}
		}finally {
			HibernateUtil.close(session);
		}
	}
	/*
	 * 
	 * Hibernate: select person0_.id as col_0_0_ from Person person0_
Hibernate: select person0_.id as id0_0_, person0_.name as name0_0_, person0_.idCard as idCard0_0_, person0_.salary as salary0_0_, person0_.personType as personType0_0_ from Person person0_ where person0_.id=?
zhanglei
Hibernate: select person0_.id as id0_0_, person0_.name as name0_0_, person0_.idCard as idCard0_0_, person0_.salary as salary0_0_, person0_.personType as personType0_0_ from Person person0_ where person0_.id=?
lisi
	 */
	static void fetch () {
		Session session = HibernateUtil.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			Query query = session.createQuery("from model.Person");//多态查询
			Iterator it = query.iterate() ;
			while (it.hasNext()) {
				Person person = (Person)it.next();
				System.out.println(person.getName());
			}
			tx.commit();
		}catch (Exception ex) {
			ex.printStackTrace();
			if (null != tx) {
				tx.rollback();
			}
		}finally {
			HibernateUtil.close(session);
		}
	}
	/**
	 * Hibernate: select person0_.id as col_0_0_ from Person person0_
model.Person_$$_javassist_0
model.Person_$$_javassist_0
	 */
	static void fetch2 () {
		Session session = HibernateUtil.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			Query query = session.createQuery("from Person");//多态查询
			Iterator it = query.iterate() ;
			while (it.hasNext()) {
				Object object = (Person)it.next();
				System.out.println(object.getClass().getName());
				/*
				 原因在于System.out.println(object.getClass().getName());model.Person_$$_javassist_0
				if (object instanceof Student) {
					System.out.println(((Student)object).getIdCard());
				}
				if (object.getClass()==  Student.class) {
					System.out.println(((Student)object).getIdCard());
				}*/
				
			}
			tx.commit();
		}catch (Exception ex) {
			ex.printStackTrace();
			if (null != tx) {
				tx.rollback();
			}
		}finally {
			HibernateUtil.close(session);
		}
	}
	/*
	 * Hibernate: select person0_.id as id0_, person0_.name as name0_, person0_.idCard as idCard0_, person0_.salary as salary0_, person0_.personType as personType0_ from Person person0_
	   12334
	 */
	static void fetch3 () {
		Session session = HibernateUtil.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			Query query = session.createQuery("from Person");//多态查询
			Iterator it = query.list().iterator();
			while (it.hasNext()) {
				Object object = (Person)it.next();
				if (object instanceof Student) {
					Student student = (Student)object;
					System.out.println(student.getIdCard());
				}
			}
			tx.commit();
		}catch (Exception ex) {
			ex.printStackTrace();
			if (null != tx) {
				tx.rollback();
			}
		}finally {
			HibernateUtil.close(session);
		}
	}
}
3：公共信息放在父类表中，独有信息放在子类表中，每个子类对应一张表。 



<?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">
<hibernate-mapping>
	<class name = "model.Person" table = "person" lazy="true">
		<id name="id" column="id" type="string">
			<generator class="uuid"></generator>
		</id>
		<property name="name" type = "string"></property>
		<joined-subclass name="model.Student" table="student">
			<key column = "id"></key>
			<property name="idCard" type = "string"></property>
		</joined-subclass>
		
		<joined-subclass name="model.Teacher" table="teacher">
			<key column = "id"></key>
			<property name="salary" type = "int"></property>
		</joined-subclass>
	</class>
</hibernate-mapping>


package model;

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
/*
create table person (id varchar(255) not null, name varchar(255), primary key (id))
create table student (id varchar(255) not null, idCard varchar(255), primary key (id))
create table teacher (id varchar(255) not null, salary integer, primary key (id))
alter table student add index FK8FFE823BA4230EF5 (id), add constraint FK8FFE823BA4230EF5 foreign key (id) references person (id)
alter table teacher add index FKAA31CBE2A4230EF5 (id), add constraint FKAA31CBE2A4230EF5 foreign key (id) references person (id)

 */
public class Create {
	public static void main(String[] args) {
		SchemaExport export = new SchemaExport(new Configuration().configure());
		export.create(true, true);
	}
}

package model;

import java.util.Iterator;

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

public class Test {
	public static void main(String[] args) {
		//save();
		fetch();
	}
	/*	 
Hibernate: insert into person (name, id) values (?, ?)
Hibernate: insert into student (idCard, id) values (?, ?)
Hibernate: insert into person (name, id) values (?, ?)
Hibernate: insert into teacher (salary, id) values (?, ?)
	 */
	static void save () {
		Session session = HibernateUtil.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
		
			
			Student student = new Student ();
			student.setIdCard("12334");
			student.setName("zhanglei");
			
			Teacher teacher = new Teacher ();
			teacher.setSalary(100);
			
			teacher.setName("lisi");
			
			session.save(student);
			
			session.save(teacher);
			
			tx.commit();
		}catch (Exception ex) {
			ex.printStackTrace();
			if (null != tx) {
				tx.rollback();
			}
		}finally {
			HibernateUtil.close(session);
		}
	}
	/**
Hibernate: select person0_.id as col_0_0_ from person person0_
Hibernate: select person0_.id as id0_0_, person0_.name as name0_0_, person0_1_.idCard as idCard1_0_, person0_2_.salary as salary2_0_, case when person0_1_.id is not null then 1 when person0_2_.id is not null then 2 when person0_.id is not null then 0 end as clazz_0_ from person person0_ left outer join student person0_1_ on person0_.id=person0_1_.id left outer join teacher person0_2_ on person0_.id=person0_2_.id where person0_.id=?
zhanglei
Hibernate: select person0_.id as id0_0_, person0_.name as name0_0_, person0_1_.idCard as idCard1_0_, person0_2_.salary as salary2_0_, case when person0_1_.id is not null then 1 when person0_2_.id is not null then 2 when person0_.id is not null then 0 end as clazz_0_ from person person0_ left outer join student person0_1_ on person0_.id=person0_1_.id left outer join teacher person0_2_ on person0_.id=person0_2_.id where person0_.id=?
lisi
Hibernate: select person0_.id as id0_0_, person0_.name as name0_0_, person0_1_.idCard as idCard1_0_, person0_2_.salary as salary2_0_, case when person0_1_.id is not null then 1 when person0_2_.id is not null then 2 when person0_.id is not null then 0 end as clazz_0_ from person person0_ left outer join student person0_1_ on person0_.id=person0_1_.id left outer join teacher person0_2_ on person0_.id=person0_2_.id where person0_.id=?
zhanglei
Hibernate: select person0_.id as id0_0_, person0_.name as name0_0_, person0_1_.idCard as idCard1_0_, person0_2_.salary as salary2_0_, case when person0_1_.id is not null then 1 when person0_2_.id is not null then 2 when person0_.id is not null then 0 end as clazz_0_ from person person0_ left outer join student person0_1_ on person0_.id=person0_1_.id left outer join teacher person0_2_ on person0_.id=person0_2_.id where person0_.id=?
lisi
Hibernate: select person0_.id as id0_0_, person0_.name as name0_0_, person0_1_.idCard as idCard1_0_, person0_2_.salary as salary2_0_, case when person0_1_.id is not null then 1 when person0_2_.id is not null then 2 when person0_.id is not null then 0 end as clazz_0_ from person person0_ left outer join student person0_1_ on person0_.id=person0_1_.id left outer join teacher person0_2_ on person0_.id=person0_2_.id where person0_.id=?
baother
Hibernate: select person0_.id as id0_0_, person0_.name as name0_0_, person0_1_.idCard as idCard1_0_, person0_2_.salary as salary2_0_, case when person0_1_.id is not null then 1 when person0_2_.id is not null then 2 when person0_.id is not null then 0 end as clazz_0_ from person person0_ left outer join student person0_1_ on person0_.id=person0_1_.id left outer join teacher person0_2_ on person0_.id=person0_2_.id where person0_.id=?
wokao
	 * 
	 */
	static void fetch () {
		Session session = HibernateUtil.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			Query query = session.createQuery("from model.Person");//多态查询
			Iterator it = query.iterate();
			while (it.hasNext()) {
				Person person = (Person)it.next();
				System.out.println(person.getName());
			}
			tx.commit();
		}catch (Exception ex) {
			ex.printStackTrace();
			if (null != tx) {
				tx.rollback();
			}
		}finally {
			HibernateUtil.close(session);
		}
	}
}




baother0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate使用注解，继承映射写法
focusぃclouds
08-19 5418
继承映射在 Annotation 中使用 @Inheritance 注解，并且需要使用 strategy 属性指定继承策略，继承策略有 SINGLE_TABLE、TABLE_PER_CLASS 和 JOINED 三种。 一、SINGLE_TABLE SINGLE_TABLE 是将父类和其所有的子类集合在一块，存在一张表中，并创建一个新的字段来判断对象的类型。 Person.j
Hibernate第九篇【组件映射、继承映射】
zhong_fucheng
05-08 1363
前言到目前位置，我们已经学习了一对一、一对多、多对一、多对多映射了…既然Hibernate是ORM实现的框架，它还提供了组件映射和继承映射..本博文主要讲解组件映射和继承映射Java主要的类主要有两种方式 组合关系，组合关系对应的就是组件映射 继承关系，继承关系对应的就是继承映射 组件映射组件映射实际上就是将组合关系的数据映射成一张表，组件类和被包含的组件类映射成一张表有的时候，两个类的关系明显不是
Hibernate综合问题
weixin_33951761的博客
10-04 474
n + 1问题 query.iterate()信息返回迭代查询将开始发表声明：录ID语句      Hibernate: select student0_.id ascol_0_0_from t_student student0_ 然后有多少条记录，会发出多少条查询语句。 n + 1问题：n:有n条记录。发出n条查询语句。1 ：发出一条查询全部记录ID语句。 出现n+1的原因...
Hibernate继承映射
kilowen3的博客
02-15 76
在面向对象的程序领域中，类与类之间是有继承关系的，例如Java世界中只需要extends关键字就可以确定这两个类的父子关系，但是在关系数据库的世界中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据中，Hibernate为我们提供了3中方案： 第一种方案：一个子类对应一张表。 第二种方案：使用一张表表示所有继...
关于Hibernate中的继承映射
a253664942的专栏
04-24 530
在面向对象中，类与类之间是有继承关系的，但是在关系数据库中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据 中，Hibernate为我们提供了3中方案：第一种方案：一个子类对应一张表。第二种方案：使用一张表表示所有继承体系下的类的属性的并集。第三种方案：每个子类使用一张表只存储它特有的属性，然后与父类所对应的表以一对一主
Hibernate: select user0_.uid as uid4_, user0_.username as username4_, user0_.password as password4_,
tfy1332的专栏
08-22 4727
Hibernate: select user0_.uid as uid4_, user0_.username as username4_, user0_.password as password4_, user0_.email as email4_, user0_.phone as phone4_, user0_.sex as sex4_, user0_.did as did4_ from use
【Hibernate】继承映射
Dream it Possible
10-01 1353
【前言】     不知道大家是否还记得UML中的四种关系？自己回想了一下，还是没有忘记的，分别是继承、实现、依赖和关联。     怎么突然会想到这样一个问题？是因为在学习完Hibernate关联映射之后，紧接着又来了一个继承映射。关联和继承，都属于四种关系之一，所以，本篇博客就先提了个问题，下面就开始继承映射的学习。 【概述】     继承是面向对象语言的三大重要特性之一，它实
hibernate中继承映射配置详细解析（三）
mischen520的博客
08-11 348
本例模仿的是每个类映射一张表的信息，例如动物，猴子，猫，所以一共有三张表，下面是修改映射配置文件信息，其他文件如需参考，请参考我的上篇文章《hibernate中继承映射配置详细解析（二）》 Animal.hbm.xml <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "htt
Java的Hibernate框架中的继承映射学习教程
09-02
在Java的Hibernate框架中，继承映射是一个重要的概念，它允许我们将面向对象编程中的类继承关系映射到关系数据库的表结构中。通过这种方式，我们可以充分利用OOP的抽象、封装和继承特性，同时保持数据库模型的高效和...
Hibernate继承映射代码
05-08
在"javaII-8"这个压缩包文件中，很可能包含了实现Hibernate继承映射和C3P0连接池配置的源代码示例。这些代码可能包括实体类定义、映射文件（如.hbm.xml或使用注解的类）、Hibernate配置文件（hibernate.cfg.xml）...
hibernate继承映射.rar
01-14
Hibernate继承映射是将Java中的继承关系映射到数据库的关系模型中。在Java中，一个基类可以有多个子类，而在数据库中，这些子类可以共享一张表或者各自拥有独立的表，这取决于我们选择的继承策略。Hibernate提供了四...
hibernate中一对多映射（set集合中存放的原生数据类型，而不是实体）
low_coder
05-24 1642
1：map与set标签中的element子标签映射的是 原子类型（string,date,int,long.....）,即可以直接映射到数据库表字段上的类型，而one-to-many 映射的则是实体类型，指的是无法映射到表的某个字段，而是映射到整张表的类型。 package model; import java.util.HashMap; import java.util.HashSe
<id>元素的映射OID
low_coder
05-11 1234
元素映射值类型属性 -name属性：指定持久化类的属性名字。 -type属性：指定hibernate或java映射类型。 hibernate映射类型是java类型是java类型与sql类型的桥梁。 column属性：指定与类的属性映射的表的字段名。 Java类型，hibernate映射类型以及sql类型之间的对应关系 Hibernate配置文件的属性 通过Hi
映射Category一对多双向自身关联关系
low_coder
05-11 1169
create table categories ( id bigint not null, name varchar(15), category_id bigint, primary key (id) ); <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http
域对象在持久化层的三种状态
low_coder
05-11 1130
！import -session的缓存的作用 -session清理缓存的时间点 -对象的临时状态，持久化状态和游离状态 -用session的update方法使游离对象转化为持久化对象 session级别的缓存又叫一级缓存；SessionFactory级别的缓存叫做二级缓存。 在hibernate应用中java对象的状态 -临时状态（transient）：刚刚用new语句创建，
hibernate中查询排序
low_coder
05-26 1034
查询排序：（内存排序与数据库排序） 推荐使用数据库排序 package model; public class Student { private String id; private String card_id; private String name; private int age; private Team team; public Team g
Hibernate中 Bag
low_coder
05-26 995
Bag（结合了List与Set），可以重复且没有顺序的一种集合，是hibernate提供的。 hibernate用List来模拟bag。 package model; public class Student { private String id; private String card_id; private String name; private int ag
hibernate中的propery-ref 用法
low_coder
06-02 899
1.如表Class(ClassID,Class_No,ClassName)与Student(StudentID,studentName,Class_No), 其中ClassID,studentID为主键 两个表是一对多的关系,而要求两个通过ClassNo来关联. 而一般的情况下是通过ClassID,放在student表中作为外键. 2.具体的Hibernate的配置文件如下: Clas
Hibernate继承映射策略解析
"这篇文档介绍了Hibernate框架中关于继承映射的三种策略，即每个继承层次一张表、每个具体类一张表以及每个类一张表。这些策略用于将面向对象的继承关系映射到关系数据库中，以适应不同场景的需求。文档详细讲解了每...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值