`

十六 继承映射

 
阅读更多
第一种
一个员工类它有两个子类,利用hibernate我们把这员工类及子类都映射到一张表里,员工表是普通员工,子类的
话是技术员工的类和销售员工 那么这三个类怎么映射到一张表里,我们又如何区分这员工的到底是哪一类员工呢 
这时,我们一般在表中加入了一个识别的字段,比如说type 这个字段有三个值,默认值为0 表示的普通员工,1是
技术员工 2是销售员工 
好,现在开始
设计主体员工实体类
package vo.util.bean;
/**
 * 员工类
 * @author Administrator
 *
 */
public class Employee {
    private int id;
    private String name;
    private Department derpartment;
	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 Department getDerpartment() {
		return derpartment;
	}
	public void setDerpartment(Department derpartment) {
		this.derpartment = derpartment;
	}
}

技术员工类 继承主体员工类
package vo.util.bean;

public class Skiller extends Employee {
   private String skill;

public String getSkill() {
	return skill;
}
public void setSkill(String skill) {
	this.skill = skill;
}
}

销售员工类 继承主体员工类
package vo.util.bean;

public class Sales extends Employee {
    private int sale;

	public int getSale() {
		return sale;
	}

	public void setSale(int sale) {
		this.sale = sale;
	}
}


主体实体映射文件
<?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 
	package="vo.util.bean">

	<class name="Employee" discriminator-value="0">
		<id name="id">
			<generator class="native"/>
		</id>
		<discriminator column="type"/>
		<property name="name"/>
		<many-to-one name="derpartment" column="depaer_id" not-null="true"/>
		<subclass name="Sales" discriminator-value="1">
		<property name="sale"/>
		</subclass>
		<subclass name="Skiller" discriminator-value="2">
		<property name="skill"/>
		</subclass>
	</class>
</hibernate-mapping>

分析 subclass 就是子类的意思 在这里的节点就是配置就是主实体的子类的配置
name 子实体名称 property 子实体的属性 discriminator-value识别字段值 
discriminator节点 加入主表的识别字段 column="type"就是识别字段的列名是type
这个列默认的字段默认类型是string 可以加入 type="string" 就可以设计这个列的值的
类型

测试类
package vo.util.test;

import java.util.HashSet;
import java.util.Set;

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

import vo.util.HibernateUtil;
import vo.util.bean.Department;
import vo.util.bean.Employee;
import vo.util.bean.Sales;
import vo.util.bean.Skiller;

public class OneToMany {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
	
         add();
        query(1);
	}
    static Department add(){
    	Session session = null;
    	Transaction tx = null;
    	try{
    		session =HibernateUtil.getSession();
    		tx = session.beginTransaction();
    		//…你的代码save,delete,update,get…
    		Department dpart=new Department();
    		dpart.setName("政企事业部");
    		
    		Employee em1=new Employee();
    		em1.setName("员工李小仙");
    		em1.setDerpartment(dpart);
    		
    		Employee em2=new Employee();
    		em2.setName("员工张小三");
    		em2.setDerpartment(dpart);
    		
    		Skiller s=new Skiller();
    		s.setDerpartment(dpart);
    		s.setName("员工高明明");
    		s.setSkill("skill");
    		
    		Sales sl=new Sales();
    		sl.setDerpartment(dpart);
    		sl.setName("小凤仙");
    		sl.setSale(2);
    		/**
    		Set<Employee> em=new HashSet<Employee>();
    	    em.add(em1);
    	    em.add(em2);
    	    em.add(sl);
    	    em.add(s);
    	    dpart.setEms(em);
    	    */
    		session.save(dpart);
    		session.save(em1);
    		session.save(em2);
    		session.save(s);
    		session.save(sl);
    		
    		tx.commit();
    		return dpart;
    	}finally{
    		if(session != null)session.close();
    	} 

    }
    
    static Department query(int id){
    	Session session=null;
    	
    	try{
    	   session=HibernateUtil.getSession();
    	   Department d=(Department)session.get(Department.class, id);
    	   
    	   System.out.println(d.getName()+"--------->"+d.getEms().getClass().getName());
    	  
    		return d;
    	}finally{
    		if(session != null)session.close();
    	} 

    }
}



映射的表的值 
1,"0","员工李小仙",1,NULL,NULL
2,"0","员工张小三",1,NULL,NULL
3,"2","员工高明明",1,NULL,"skill"
4,"1","小凤仙",    1,  2, NULL

发现表中的值有很多值为空值 
现在我们来看表结构
CREATE TABLE `employee` (
  `id` int(11) NOT NULL auto_increment,
  `type` varchar(255) NOT NULL,
  `name` varchar(255) default NULL,
  `depaer_id` int(11) NOT NULL,
  `sale` int(11) default NULL,
  `skill` varchar(255) default NULL,
  PRIMARY KEY  (`id`),
  KEY `FK4AFD4ACE59BDCD94` (`depaer_id`),
  CONSTRAINT `FK4AFD4ACE59BDCD94` FOREIGN KEY (`depaer_id`) REFERENCES `department` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;


但是这样是不是不合理呢?怎么修正它呢 ?

第二种方式
可以这样来,我们可以根据子类实体也新建一张表,比如技术员工,就新建一张技术员工表 
同时新建的表如何跟主表employee连接呢?我们可以这样类设计,子表的id就是employee的id
这个字表的id不但是主键同时也是一个外键,引用的是主表的id

那现在我们来设计吧 joined-subclass节点的作用就出来了

主实体和子实体都不变
只需要修改员工的employee的映射文件便可

<?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 
	package="vo.util.bean">

	<class name="Employee">
		<id name="id">
			<generator class="native"/>
		</id>
		<!--  <discriminator column="type"/>-->
		<property name="name"/>
		<many-to-one name="derpartment" column="depaer_id" not-null="true"/>
		<!--  
		<subclass name="Sales" discriminator-value="1">
		<property name="sale"/>
		</subclass>
		<subclass name="Skiller" discriminator-value="2">
		<property name="skill"/>
		</subclass>
		-->
		<joined-subclass name="Sales">
		<key column="emp_id"/>
		<property name="sale"/>
		</joined-subclass>
		
		<joined-subclass name="Skiller">
		<key column="emp_id"/>
		<property name="skill"/>
		</joined-subclass>
	</class>
</hibernate-mapping>


分析:joined-subclass 节点就是引入子实体类  key节点就是外键主键名称 

property 就是子实体的属性

测试类不变

测试后输出的sql

log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
打开连接成功!Hibernate: insert into Department (name) values (?)
Hibernate: insert into Employee (name, depaer_id) values (?, ?)
Hibernate: insert into Employee (name, depaer_id) values (?, ?)
Hibernate: insert into Employee (name, depaer_id) values (?, ?)
Hibernate: insert into Skiller (skill, emp_id) values (?, ?)
Hibernate: insert into Employee (name, depaer_id) values (?, ?)
Hibernate: insert into Sales (sale, emp_id) values (?, ?)
Hibernate: select department0_.id as id0_0_, department0_.name as name0_0_ from Department department0_ where department0_.id=?
Hibernate: select ems0_.depaer_id as depaer3_1_, ems0_.id as id1_, ems0_.id as id1_0_, ems0_.name as name1_0_, ems0_.depaer_id as depaer3_1_0_, ems0_1_.sale as sale2_0_, ems0_2_.skill as skill3_0_, case when ems0_1_.emp_id is not null then 1 when ems0_2_.emp_id is not null then 2 when ems0_.id is not null then 0 end as clazz_0_ from Employee ems0_ left outer join Sales ems0_1_ on ems0_.id=ems0_1_.emp_id left outer join Skiller ems0_2_ on ems0_.id=ems0_2_.emp_id where ems0_.depaer_id=?
政企事业部--------->[vo.util.bean.Employee@fcfa52, vo.util.bean.Sales@1fc6e42, vo.util.bean.Skiller@18b81e3, vo.util.bean.Employee@961dff]


现在来看表结构
CREATE TABLE `employee` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(255) default NULL,
  `depaer_id` int(11) NOT NULL,
  PRIMARY KEY  (`id`),
  KEY `FK4AFD4ACE59BDCD94` (`depaer_id`),
  CONSTRAINT `FK4AFD4ACE59BDCD94` FOREIGN KEY (`depaer_id`) REFERENCES `department` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

子表
CREATE TABLE `sales` (
  `emp_id` int(11) NOT NULL,
  `sale` int(11) default NULL,
  PRIMARY KEY  (`emp_id`),
  KEY `FK4BF58ECF47ACFA7` (`emp_id`),
  CONSTRAINT `FK4BF58ECF47ACFA7` FOREIGN KEY (`emp_id`) REFERENCES `employee` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;


CREATE TABLE `skiller` (
  `emp_id` int(11) NOT NULL,
  `skill` varchar(255) default NULL,
  PRIMARY KEY  (`emp_id`),
  KEY `FKE3361E9EF47ACFA7` (`emp_id`),
  CONSTRAINT `FKE3361E9EF47ACFA7` FOREIGN KEY (`emp_id`) REFERENCES `employee` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

第三种方式

为了效率的提高 我们可以结合这两种的映射配置映射文件,可以去试下吧

第四种方式 员工是一张完整的表 技术员工 销售员工都是一张完整的信息表 
主实体及子实体都不变  
修改Employee的映射文件
<?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 
	package="vo.util.bean">

	<class name="Employee" discriminator-value="0">
		<id name="id">
			<generator class="native"/>
		</id>
		<!-- 
		<discriminator column="type"/>
		-->
		<property name="name"/>
		<many-to-one name="derpartment" column="depaer_id" not-null="true"/>
		<!-- 
		<subclass name="Sales" discriminator-value="1">
		<property name="sale"/>
		</subclass>
		<subclass name="Skiller" discriminator-value="2">
		<property name="skill"/>
		</subclass>
		 -->
		 
		<union-subclass name="Sales" table="tables">
		<property name="sale"/>
		</union-subclass> 
		
		<union-subclass name="Skiller" table="skill">
		<property name="skill"/>
		</union-subclass>
	</class>
</hibernate-mapping>

union-subclass节点配置  name="Sales" 就是对应的实体类 table 给子实体指定的表
property 节点是属性名 就是对应子实体的属性

测试类不变 
运行测试
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Exception in thread "main" java.lang.ExceptionInInitializerError
	at vo.util.test.OneToMany.add(OneToMany.java:29)
	at vo.util.test.OneToMany.main(OneToMany.java:22)
Caused by: org.hibernate.MappingException: Cannot use identity column key generation with <union-subclass> mapping for: vo.util.bean.Employee
	at org.hibernate.persister.entity.UnionSubclassEntityPersister.<init>(UnionSubclassEntityPersister.java:67)
	at org.hibernate.persister.PersisterFactory.createClassPersister(PersisterFactory.java:61)
	at org.hibernate.impl.SessionFactoryImpl.<init>(SessionFactoryImpl.java:226)
	at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1294)
	at vo.util.HibernateUtil.<clinit>(HibernateUtil.java:23)
	... 2 more


发现报实体异常,意思说说主键的生成器 identity 问题 这是什么原因造成的呢?
主键生成错误 看配置文件 <generator class="native"/>  这种主键生成是自增长得,那么这个三张表会产生
主键值是一样的 主键值代表的是一条记录 
所以可以改成hilo


end 完毕!

 

分享到:
评论

相关推荐

    继承映射的

    ### 继承映射在IT行业的深入解析 #### 核心概念:继承映射与多态支持 在软件开发领域,尤其是使用ORM(对象关系映射)技术进行数据库操作时,“继承映射”是一个关键的概念。它允许在数据库中表示面向对象编程中的...

    继承映射的详细解说

    继承映射详细,非常实用的学习资料继承映射详细,非常实用的学习资料

    Hibernate继承映射代码

    本主题将深入探讨"Hibernate继承映射+C3P0代码"的相关知识点。 首先,让我们理解Hibernate的继承映射。在Java中,我们可以创建一个基类,然后派生出多个子类,这种设计模式在数据库中也可以被映射出来。Hibernate...

    Hibernate教程17_继承映射

    本教程主要探讨的是Hibernate中的“继承映射”特性,这是一项关键功能,它允许我们将复杂的类继承结构映射到数据库表中。通过继承映射,我们可以有效地管理和组织数据,提高代码的复用性和可维护性。 在Hibernate中...

    使用jpa映射关联和继承

    继承映射则适用于具有共同属性但又有所区别的实体,如不同类型的用户、不同状态的订单等,通过继承关系可以避免代码重复,提高代码复用性。 总结,JPA提供了强大的关联和继承映射机制,让开发者能更便捷地处理...

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

    Hibernate继承映射是将Java类的继承关系映射到数据库表的一种策略,使得对象模型的复杂性能够平滑地转化为关系数据库模型。本篇将详细介绍Hibernate继承映射的第一种策略——每棵类继承树对应一张表,即单一表继承...

    用Hibernate映射继承关系

    ### 用Hibernate映射继承关系 #### 14.1 继承关系树的每个具体类对应一个表 在Hibernate中映射继承关系时,一种常见的策略是将继承关系树的每个具体类映射到单独的数据库表中。这种方法称为**表/类映射**(Table/...

    hibernate继承映射.rar

    《Hibernate继承映射详解》 Hibernate,作为Java领域中的一款著名对象关系映射(ORM)框架,极大地简化了数据库操作。在实际项目中,我们常常会遇到类的继承关系,而Hibernate提供了强大的支持来处理这种继承关系的...

    Hibernate继承映射-概述

    《Hibernate继承映射详解》 在Java开发中,对象关系映射(ORM)框架如Hibernate大大简化了数据库操作。Hibernate不仅提供了对基本数据类型的映射,还支持复杂的数据结构,如继承关系的映射。本篇文章将深入探讨...

    Hibernate继承映射(annotation)

    【标题】:“Hibernate继承映射(annotation)” 在Java对象关系映射(ORM)框架中,Hibernate是一个非常重要的工具,它允许开发人员将Java类映射到数据库表,从而简化了数据库操作。本主题主要探讨的是Hibernate中的...

    14 继承(一)(整个继承树映射到一张表)

    4. **继承映射的配置**:在Hibernate的XML映射文件或注解中,需要显式声明继承关系。例如,使用`@Inheritance(strategy=InheritanceType.SINGLE_TABLE)`注解在父类上,然后在子类上使用`@DiscriminatorValue`指定...

    hibernate继承映射教学

    针对hibernate的继承映射部分做了几个测试的例子,更加直观的阐述了继承映射的几种方式以及对应的表结构方式,文件被分割成3部分 http://download.csdn.net/source/259075 http://download.csdn.net/source/259072 ...

    Hibernate教程17_继承映射_补充2

    在本教程中,我们将深入探讨Hibernate中的继承映射,特别是在"Hibernate教程17_继承映射_补充2"中所涉及的主题。Hibernate是Java中一个非常流行的对象关系映射(ORM)框架,它允许开发者用面向对象的方式处理数据库...

    Hibernate教程17_继承映射_补充1

    在本教程中,我们将深入探讨Hibernate中的继承映射策略,特别是"Table Per Class"策略,这是Java对象模型到关系数据库映射的一种方法。在Hibernate框架中,继承是通过ORM(对象关系映射)来实现的,它允许我们将复杂...

    hibernate的继承映射教学

    针对hibernate的继承映射部分做了几个测试的例子,更加直观的阐述了继承映射的几种方式以及对应的表结构方式,文件被分割成3部分 http://download.csdn.net/source/259075 http://download.csdn.net/source/259072 ...

    Hibernate继承映射二:每个子类一张表

    本篇主要探讨的是Hibernate中的继承映射策略,特别是“每个子类一张表”(Table per subclass)的方式。这种方式也被称为单表继承或多表继承,是Hibernate支持的四种继承映射策略之一。了解并熟练掌握这种映射模式...

Global site tag (gtag.js) - Google Analytics