继承映射有3种情况:
1.单表继承:每颗继承树使用一个表 table per class hierarchy
2.具体表继承:每个子类一个表 table per subclass
3.类表继承:每个具体类一个表 table per concrete class 有部分限制,
以下,单表继承
Animal类:
package com.cnblogs.hibernate_first; public class Animal { private int id; private String name; private boolean sex; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public boolean isSex() { return sex; } public void setSex(boolean sex) { this.sex = sex; } }
Pig类:
package com.cnblogs.hibernate_first; public class Pig extends Animal { private int weight; public int getWeight() { return weight; } public void setWeight(int weight) { this.weight = weight; } }
Bird类:
package com.cnblogs.hibernate_first; public class Bird extends Animal { private int height; public int getHeight() { return height; } public void setHeight(int height) { this.height = height; } }
extends.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 package="com.cnblogs.hibernate_first"> <!-- class的lazy属性,设为ture为支持延时加载,如果更改为false则不支持延时加载 --> <class name="Animal" table="t_animal" lazy="false"> <id name="id"> <generator class="native"></generator> </id> <!-- 鉴别字段,必须在id下面,还要设置鉴别字段的类型,如本鉴别字段是string 注意是小写,或者包装类java.lang.String --> <discriminator column="type" type="string"> </discriminator> <property name="name"></property> <property name="sex"></property> <!-- 鉴别字段在前面设置了,鉴别字段在类中定义,如下Pig鉴别值是P --> <subclass name="Pig" discriminator-value="P"> <property name="weight"></property> </subclass> <!-- 鉴别字段在前面设置了,鉴别字段在类中定义,如下Bird鉴别值是B --> <subclass name="Bird" discriminator-value="B"> <property name="height"></property> <!-- 可以加manytoone 或者manytomany --> </subclass> </class> <!-- 可以 将之类映射到</class>标签下,但是一般映射到</class>标签上。如果在下面应该是以下映射: <subclass name="路径.类名" extends ="父类路径.类名"> </subclass> --> </hibernate-mapping>
hibernate.hbm.xml:
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <!-- CREATE DATABASE hibernate_extends_1 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci --> <session-factory> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <property name="connection.url">jdbc:mysql://localhost:3306/hibernate_extends_1?useUnicode=true&characterEncoding=UTF8</property> <property name="connection.username">root</property> <property name="connection.password"></property> <!-- 每次从数据库中取出并放到JDBC的Statement中的记录条数。Fetch Size设的越大,读数据库的次数越少,速度越快,Fetch Size越小,读数据库的次数越多,速度越慢 --> <property name="jdbc.fetch_size">50 </property> <!--批量插入,删除和更新时每次操作的记录数。Batch Size越大,批量操作的向数据库发送Sql的次数越少,速度就越快,同样耗用内存就越大 --> <property name="jdbc.batch_size">23 </property> <!-- SQL 方言 --> <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property> <!-- Enable Hibernate's automatic session context management --> <property name="current_session_context_class">thread</property> <!-- 在控制台输出sql语句 --> <property name="show_sql">true</property> <!-- 在启动时根据配置更新数据库 --> <property name="hbm2ddl.auto">update</property> <mapping resource="com/cnblogs/hibernate_first/Extends.hbm.xml" /><!-- 注册我们的实体映射类 --> </session-factory> </hibernate-configuration>
test类:
package com.cnblogs.hibernate_first; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set; import javax.persistence.EntityTransaction; import org.hibernate.Session; import org.hibernate.cfg.Configuration; import junit.framework.TestCase; public class extensTest extends TestCase { public void testSave1() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); Pig pig1 = new Pig(); pig1.setName("小猪猪"); pig1.setSex(true); pig1.setWeight(200); session.save(pig1); Bird bird1 = new Bird(); bird1.setName("小鸟鸟"); bird1.setSex(false); bird1.setHeight(100); session.save(bird1); session.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); session.getTransaction().rollback(); } finally { HibernateUtils.closeSession(session); } } //加载查询 /* * 采用load查询,通过pig查询 */ public void testLoad1() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); Pig pig = (Pig)session.load(Pig.class, 1); System.out.println(pig.getName()); session.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); session.getTransaction().rollback(); } finally { HibernateUtils.closeSession(session); } } /* * 采用load查询,通过Animal查询 */ public void testLoad2() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); Animal a = (Animal)session.load(Animal.class, 1); System.out.println(a.getName()); session.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); session.getTransaction().rollback(); } finally { HibernateUtils.closeSession(session); } } /* * 使用load查询,不能鉴别真正类型,以下示例输出的原因是:load是延时加载,返回的是animal的一个代理对象,与pig bird同级, * 所以instance为否。load在这种情况下不支持多态查询。 * 多态查询:在hibernate加载数据的时候,能够采用instanceof鉴别出其真正的类型。 */ public void testLoad3() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); Animal a = (Animal)session.load(Animal.class, 1); if(a instanceof Pig){ System.out.println(a.getName()); }else{ System.out.println("不是猪"); } session.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); session.getTransaction().rollback(); } finally { HibernateUtils.closeSession(session); } } /* * 采用load查询,通过animal查询, * 将<class>标签中的lazy设置成为false,返回的不是代理类,二十真正的类型,所以用instanceof 可以正确判断出其真正的类型, */ public void testLoad4() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); Animal a = (Animal)session.load(Animal.class, 1); if(a instanceof Pig){ System.out.println(a.getName()); }else{ System.out.println("不是猪"); } session.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); session.getTransaction().rollback(); } finally { HibernateUtils.closeSession(session); } } /* * 采用get查询,通过animal查询,因为get返回的就是具体类,所以get是支持多台查询的 */ public void testLoad5() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); Animal a = (Animal)session.get(Animal.class, 1); if(a instanceof Pig){ System.out.println(a.getName()); }else{ System.out.println("不是猪"); } session.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); session.getTransaction().rollback(); } finally { HibernateUtils.closeSession(session); } } /* * 采用hql查询,通过animal查询.返回的是真正类型,所以hql是支持多态查询的 */ @SuppressWarnings("unchecked") public void testLoad6() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); List animalList = session.createQuery("from Animal").list(); for(Iterator iter = animalList.iterator();iter.hasNext();){ Animal a = (Animal)iter.next(); if(a instanceof Pig){ System.out.println(a.getName()); }else if(a instanceof Bird){ System.out.println(a.getName()); } } session.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); session.getTransaction().rollback(); } finally { HibernateUtils.closeSession(session); } } /* * 采用hql查询,通过animal查询.session.createQuery("from java.lang.Object")相当于show tables * 因为所有类都是object */ @SuppressWarnings("unchecked") public void testLoad7() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); List animalList = session.createQuery("from java.lang.Object").list(); for(Iterator iter = animalList.iterator();iter.hasNext();){ Object obj = iter.next(); if(obj instanceof Pig){ System.out.println(obj); }else if(obj instanceof Bird){ System.out.println(obj); } } session.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); session.getTransaction().rollback(); } finally { HibernateUtils.closeSession(session); } } }