`
penghao122
  • 浏览: 363038 次
  • 性别: Icon_minigender_1
  • 来自: 广东珠海
社区版块
存档分类
最新评论

hibernate 全面学习【hibernate 粗粒度分析 】

Hibernatejunit.net 
阅读更多
Hibernate继承映射的第一种策略：每棵类继承树对应一张表

1、理解如何映射
因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。
这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：
父类用普通的<class>标签定义
在父类中定义一个discriminator，即指定这个区分的字段的名称和类型
如：<discriminator column=”XXX” type=”string”/>
子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：
Subclass标签的name属性是子类的全路径名
在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）的值
Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。
当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值是父类的全路径名称。
子类的其它属性，像普通类一样，定义在subclass标签的内部。

2、理解如何存储
在存储数据的时候，hibernate会自动将鉴别字段的值插入到数据库中，在加载数据的时候，
hibernate便能根据这个鉴别字段正确的加载对象

3、理解何为多态查询，即hibernate能够加载数据的时候自动鉴别其真正的类型

多态get()，支持
多态load(),设置Lazy＝“false”时，支持
多态查询，支持



Hibernate继承映射的第一种策略:每个类对应一张表

1、如何映射
这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。
在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，
这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。实现这种策略的时候，有如下步骤：
父类用普通的<class>标签定义即可
父类不再需要定义discriminator字段
子类用<joined-subclass>标签定义，在定义joined-subclass的时候，需要注意如下几点：
Joined-subclass标签的name属性是子类的全路径名
Joined-subclass标签需要包含一个key标签，这个标签指定了子类和父类之间是通过哪个字段来关联的。
如：<key column=”PARENT_KEY_ID”/>，这里的column，实际上就是父类的主键对应的映射字段名称。
Joined-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），
也可以与class标签平行。 当Joined-subclass标签的定义与class标签平行的时候，需要在Joined-subclass标签中，添加extends属性，里面的值是父类的全路径名称。
子类的其它属性，像普通类一样，定义在joined-subclass标签的内部。

2、存储和多态查询参见策略一：每棵类继承树对应一张表





Hibernate继承映射的第一种策略：每个具体类一张表

1、如何映射
这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，
即包含了所有从父类继承下来的属性映射的字段（这就是它跟joined-subclass的不同之处，joined-subclass定义的子类的表，
只包含子类特有属性映射的字段）。实现这种策略的时候，有如下步骤：
父类用普通<class>标签定义即可
子类用<union-subclass>标签定义，在定义union-subclass的时候，需要注意如下几点：
Union-subclass标签不再需要包含key标签（与joined-subclass不同）
Union-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），
也可以与class标签平行。 当Union-subclass标签的定义与class标签平行的时候，需要在Union-subclass标签中，添加extends属性，里面的值是父类的全路径名称。
子类的其它属性，像普通类一样，定义在Union-subclass标签的内部。这个时候，虽然在union-subclass里面定义的只有子类的属性，但是因为它继承了父类，所以，
不需要定义其它的属性，在映射到数据库表的时候，依然包含了父类的所有属性的映射字段。

！！！特别注意：在保存对象的时候，id不能重复（所以不能用自增方法生成主键）

2、存储和多态查询参见策略一：每棵类继承树对应一张表



subclass 配置 及测试 

<?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="com.bjsxt.hibernate.Animal" table="t_animal">
		<id name="id">
			<generator class="native"/>
		</id>
		<discriminator column="type" type="string"/>
		<property name="name"/>
		<property name="sex"/>
		<subclass name="com.bjsxt.hibernate.Pig" discriminator-value="P">
			<property name="weight"/>
		</subclass>			
		<subclass name="com.bjsxt.hibernate.Bird" discriminator-value="B">
			<property name="height"/>
		</subclass>
	</class>
</hibernate-mapping>


joined_subclass 

<?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="com.bjsxt.hibernate.Animal" table="t_animal">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<property name="sex"/>
		<joined-subclass name="com.bjsxt.hibernate.Pig" table="t_pig">
			<key column="id"/>
			<property name="weight"/>
		</joined-subclass>
		<joined-subclass name="com.bjsxt.hibernate.Bird" table="t_bird">
			<key column="id"/>
			<property name="height"/>
		</joined-subclass>
	</class>
</hibernate-mapping>


union_subclass 

<?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="com.bjsxt.hibernate.Animal" abstract="true">
		<id name="id">
			<generator class="assigned"/>
		</id>
		<property name="name"/>
		<property name="sex"/>
		<union-subclass name="com.bjsxt.hibernate.Pig" table="t_pig">
			<property name="weight"/>
		</union-subclass>
		<union-subclass name="com.bjsxt.hibernate.Bird" table="t_bird">
			<property name="height"/>
		</union-subclass>
	</class>
</hibernate-mapping>


测试 subclass 

package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

public class ExtTest extends TestCase {
	
	/**
	 * 保存数据
	 *
	 */
	public void testSaveAnimal() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			Pig p = new Pig();
			p.setName("猪1");
			p.setSex(true);
			p.setWeight(400);
			
			Bird b = new Bird();
			b.setName("孔雀");
			b.setSex(true);
			b.setHeight(100);
			
			session.save(p);
			session.save(b);
			
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	/**
	 * 通过Pig类来装载
	 *
	 */
	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Pig p = (Pig)session.load(Pig.class, 1);
			System.out.println("name=" + p.getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	/**
	 * 通过Animal类来装载
	 *
	 */
	public void testLoad2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.load(Animal.class, 1);
			System.out.println("name=" + a.getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}

	public void testLoad3() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.load(Animal.class, 1);
			
			//因为我们load默认是Lazy，因为Lazy所以我们看到的是Animal的代理类
			//所以通过instance是具体反映不出真正的对象类型的
			if (a instanceof Pig) {
				System.out.println("name=" + a.getName());				
			}else {
				System.out.println("不是猪!");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testLoad4() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.get(Animal.class, 1);
			
			//可以正确判断，因为Animal不是代理类
			if (a instanceof Pig) {
				System.out.println("name=" + a.getName());				
			}else {
				System.out.println("不是猪!");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	/**
	 * 将Animal的lazy设置为false
	 *
	 */
	public void testLoad5() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.load(Animal.class, 1);
			if (a instanceof Pig) {
				System.out.println("name=" + a.getName());				
			}else {
				System.out.println("不是猪!");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testLoad6() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			/**
			 * 多态查询
			 */
			List animalList = session.createQuery("from com.bjsxt.hibernate.Animal").list();
			
			for (Iterator iter = animalList.iterator(); iter.hasNext(); ) {
				Animal a = (Animal)iter.next();
				System.out.println("name=" + a.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
}


测试joined_subclass 

package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

public class ExtTest extends TestCase {
	
	/**
	 * 保存数据
	 *
	 */
	public void testSaveAnimal() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			Pig p = new Pig();
			p.setName("猪1");
			p.setSex(true);
			p.setWeight(400);
			
			Bird b = new Bird();
			b.setName("孔雀");
			b.setSex(true);
			b.setHeight(100);
			
			session.save(p);
			session.save(b);
			
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	/**
	 * 通过Pig类来装载
	 *
	 */
	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Pig p = (Pig)session.load(Pig.class, 1);
			System.out.println("name=" + p.getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	/**
	 * 通过Animal类来装载
	 *
	 */
	public void testLoad2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.load(Animal.class, 1);
			System.out.println("name=" + a.getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}

	public void testLoad3() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.load(Animal.class, 1);
			
			//因为我们load默认是Lazy，因为Lazy所以我们看到的是Animal的代理类
			//所以通过instance是具体反映不出真正的对象类型的
			if (a instanceof Pig) {
				System.out.println("name=" + a.getName());				
			}else {
				System.out.println("不是猪!");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testLoad4() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.get(Animal.class, 1);
			
			//可以正确判断，因为Animal不是代理类
			if (a instanceof Pig) {
				System.out.println("name=" + a.getName());				
			}else {
				System.out.println("不是猪!");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	/**
	 * 将Animal的lazy设置为false
	 *
	 */
	public void testLoad5() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.load(Animal.class, 1);
			if (a instanceof Pig) {
				System.out.println("name=" + a.getName());				
			}else {
				System.out.println("不是猪!");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testLoad6() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			/**
			 * 多态查询
			 */
			List animalList = session.createQuery("from com.bjsxt.hibernate.Animal").list();
			
			for (Iterator iter = animalList.iterator(); iter.hasNext(); ) {
				Animal a = (Animal)iter.next();
				System.out.println("name=" + a.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
}


测试 union_subclass 

package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

public class ExtTest extends TestCase {
	
	/**
	 * 保存数据
	 *
	 */
	public void testSaveAnimal() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			Pig p = new Pig();
			p.setId(1);
			p.setName("猪1");
			p.setSex(true);
			p.setWeight(400);
			
			Bird b = new Bird();
			b.setId(2);
			b.setName("孔雀");
			b.setSex(true);
			b.setHeight(100);
			
			session.save(p);
			session.save(b);
			
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	/**
	 * 通过Pig类来装载
	 *
	 */
	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Pig p = (Pig)session.load(Pig.class, 1);
			System.out.println("name=" + p.getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	/**
	 * 通过Animal类来装载
	 *
	 */
	public void testLoad2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.load(Animal.class, 1);
			System.out.println("name=" + a.getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}

	public void testLoad3() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.load(Animal.class, 1);
			
			//因为我们load默认是Lazy，因为Lazy所以我们看到的是Animal的代理类
			//所以通过instance是具体反映不出真正的对象类型的
			if (a instanceof Pig) {
				System.out.println("name=" + a.getName());				
			}else {
				System.out.println("不是猪!");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testLoad4() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.get(Animal.class, 1);
			
			//可以正确判断，因为Animal不是代理类
			if (a instanceof Pig) {
				System.out.println("name=" + a.getName());				
			}else {
				System.out.println("不是猪!");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	/**
	 * 将Animal的lazy设置为false
	 *
	 */
	public void testLoad5() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Animal a = (Animal)session.load(Animal.class, 1);
			if (a instanceof Pig) {
				System.out.println("name=" + a.getName());				
			}else {
				System.out.println("不是猪!");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testLoad6() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			/**
			 * 多态查询
			 */
			List animalList = session.createQuery("from com.bjsxt.hibernate.Animal").list();
			
			for (Iterator iter = animalList.iterator(); iter.hasNext(); ) {
				Animal a = (Animal)iter.next();
				System.out.println("name=" + a.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
}
分享到：
| hibernate 全面学习【hibernate 集合映射】
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate常见面试题

    - 精粒度模型与粗粒度模型的不同需求也导致了不匹配。 ### 映射继承关系的三种方式 1. **每个具体类对应一张表**：表中包括父类和子类的所有属性字段。 2. **根类对应一张表**：表中包括根类及其所有子类的属性...

    精通 Hibernate：Java 对象持久化技术详解(第2版).part2

    　10.2 建立粗粒度关系数据模型 　10.3 映射组成关系 　10.3.1 区分值（Value）类型和实体（Entity）类型 　10.3.2 在应用程序中访问具有组成关系的持久化类 　10.4 映射复合组成关系 　10.5 小结 　10.6 思考题 第...

    Hibernate 映射组成关系

    本人在厦门邦初培训时的快速入门精简文档 建立具有组成关系的域模型 建立粗粒度的关系模型 映射组成关系 区分值类型和实体类型

    Hibernate In Action

    - **粒度差异**: 对象通常是细粒度的，而数据库表则倾向于粗粒度表示。 - **子类型问题**: 对象模型中的继承结构难以在关系模型中表示。 - **标识问题**: 对象的标识与数据库记录之间的映射。 - **关联问题**: ...

    hibernate二级缓存

    3. **缓存粒度**：合理设计缓存的粒度，过细可能导致大量小缓存，过粗可能导致无效的缓存命中。 4. **缓存失效**：对于有实时性要求的数据，需考虑如何及时更新缓存，避免返回旧数据。 总之，Hibernate的二级缓存...

    J2EE Persistence Options - JDO, Hibernate and EJB 3.0.pdf

    - **正交语言透明的方法**：既适用于粗粒度也适用于细粒度的持久化对象。在这种方法下，持久化对象与其他对象一样被对待，应用程序设计与底层持久化基础设施解耦。JDO持久化框架和Hibernate就是这类方法的典型代表。...

    精通 Hibernate：Java 对象持久化技术详解(第2版).part4

    　10.2 建立粗粒度关系数据模型 　10.3 映射组成关系 　10.3.1 区分值（Value）类型和实体（Entity）类型 　10.3.2 在应用程序中访问具有组成关系的持久化类 　10.4 映射复合组成关系 　10.5 小结 　10.6 思考题 第...

    精通 Hibernate：Java 对象持久化技术详解(第2版).part3

    　10.2 建立粗粒度关系数据模型 　10.3 映射组成关系 　10.3.1 区分值（Value）类型和实体（Entity）类型 　10.3.2 在应用程序中访问具有组成关系的持久化类 　10.4 映射复合组成关系 　10.5 小结 　10.6 思考题 第...

    精通 Hibernate：Java 对象持久化技术详解(第2版).part1.rar

    　10.2 建立粗粒度关系数据模型 　10.3 映射组成关系 　10.3.1 区分值（Value）类型和实体（Entity）类型 　10.3.2 在应用程序中访问具有组成关系的持久化类 　10.4 映射复合组成关系 　10.5 小结 　10.6 思考题 第...

    Hibernate in action

    - **颗粒度问题**：对象模型中的细粒度与关系模型中的粗粒度之间的冲突。 - **子类型问题**：继承关系在关系数据库中难以实现。 - **身份问题**：对象标识符与数据库主键之间的不一致。 - **关联问题**：一对多...

    SSH（Spring Struts Hibernate）的优缺点

    9. **事件支持不足**：每个表单通常对应一个Action，导致事件处理粒度较粗。 **Hibernate** Hibernate是一个强大的ORM框架，其优点包括： 1. **透明性**：通过Java反射机制实现对象和数据库间的透明映射。 2. **高...

    hibernat非常有用的学习文档

    Component 通常用来将数据库中的粗粒度表结构映射到对象模型的细粒度部分，以提高代码的复用性和可维护性。例如，在 `User` 实体中，`contact` 是一个联系方式的组件，包含 `address`、`contactTel`、`email` 和 `...

    JavaEE8500offer模板包含详细说明和定义

    - **Filter**：在Servlet容器中，用于全局处理请求和响应，实现粗粒度的权限控制。 - **HTTPClient**：用于与外部接口通信，如发送短信。 - **Hibernate原生API**：直接使用Hibernate的核心API，而不是Spring的...

    JavaEE---饶忠堂8500.doc

    Filter则用于粗粒度的权限管理和URL过滤。JavaScript、JSP和XML则分别用于前端交互、视图呈现和配置文件。 在饶忠堂先生的项目经验中，我们可以看到JavaEE技术栈的广泛应用，从需求调研、系统设计到开发、测试和...

    java开发程序员简历

    * 粗粒度权限管理使用 Filter 实现 * 使用 Java、JavaScript、JSP 及 XML 等技术解决系统前台页面响应速度、前台页面异步刷新等问题 项目管理知识 * 项目开发过程中，运用 Java、JavaScript、JSP 及 XML 等技术 * ...

    Java工程师个人简历模板1.doc

    - 使用Filter实现粗粒度权限管理 - **模块列表**： - 知识管理、人力资源、客户关系、个人事务等众多功能模块 - **职责描述**： - 参与功能分析和设计讨论 #### 六、总结 从上述简历模板中可以看出，这位候选...

    superscangood

    和使用容器声明式事务管理。持久化层使用hibernate来实现，使用泛型DAO把添/删/改/查/分页/统计这些操作进行了封装，子类只要继承该DAO就具备这些行为。在实现细粒度权限管理时使用了Struts2中提供的拦截器...粗粒度

    JavaEE程序员简历最新版

    - **JC6协同管理平台 6.0**：开发者在项目中担任开发工程师，利用Struts、Spring和Hibernate进行开发，实现了细粒度和粗粒度权限管理，并且强调了不依赖Spring的DAO实现，以减少耦合。 5. **技能与技术**： - **...

Magicbox
Global site tag (gtag.js) - Google Analytics