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

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

阅读更多
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常见面试题

    - 精粒度模型与粗粒度模型的不同需求也导致了不匹配。 ### 映射继承关系的三种方式 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. **技能与技术**: - **...

Global site tag (gtag.js) - Google Analytics