`
zhaosoft
  • 浏览: 186202 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

hibernate:继承关系_整个继承树映射到一张表

阅读更多
hibernate继承映射:

domain类:
Employee.java

package com.zhaosoft.domain;

public class Employee {

 private int id;
 private String name;
 private Department depart;

 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 getDepart() {
  return depart;
 }

 public void setDepart(Department depart) {
  this.depart = depart;
 }

}

两个子类:
sales.java

package com.zhaosoft.domain;

public class Sales extends Employee{

 private int sell;//销售额

 public int getSell() {
  return sell;
 }

 public void setSell(int sell) {
  this.sell = sell;
 }
}
Skiller.java

package com.zhaosoft.domain;

public class Skiller extends Employee{
 private String skill;

 public String getSkill() {
  return skill;
 }

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

}

映射文件:
<?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="com.zhaosoft.domain">
     <!-- 当discriminator-value值为0时,为普通员工 -->
 <class name="Employee" discriminator-value="0">  
  <id name="id">
      <!-- 表示主键为自动增长 -->
   <generator class="native"/>
  </id>
  <!-- 鉴别器,区分是那一种子类 -->
 <discriminator column="type" type="int"/>
 <property name="name" type="string"/>
 <many-to-one name="depart" class="Department" column="depart_id"></many-to-one>
 <!-- 当为1时,为技术人员 -->
 <subclass name="Skiller" discriminator-value="1">
    <property name="skill"></property>
 </subclass>
 <!-- 当为2时为销售人员 -->
 <subclass name="Sales" discriminator-value="2">
   <property name="sell"></property>
 </subclass>
 </class>
</hibernate-mapping>
测试:

package com.zhaosoft.test;

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

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

import com.zhaosoft.domain.Department;
import com.zhaosoft.domain.Employee;
import com.zhaosoft.domain.Sales;
import com.zhaosoft.domain.Skiller;
import com.zhaosoft.hibernate.HibernateUtil;

public class Many2One {
 public static void main(String[] args) {
  add();
  //queryDepartment(1);
  //queryEmployee(1);
 }

 public static void queryDepartment(int id) {
  Session s = HibernateUtil.getSession();
  try {
   Transaction t = s.beginTransaction();
   t.begin();
   Department de = (Department) s.get(Department.class, 1);
   
   t.commit();
   Hibernate.initialize(de.getEmps());
   System.out.println(de.getName());
   Set<Employee> set=de.getEmps();   //加载数据
   Iterator<Employee> it=set.iterator();
   while(it.hasNext()){
   Employee employee= it.next();
   System.out.println(employee.getName());
   }
   
  } catch (Exception e) {

  } finally {
   if (s != null) {
    s.close();
   }
  }

 }

 public static Employee queryEmployee(int id) {

  Session s = null;
  Transaction tx=null;
  try {

   s=HibernateUtil.getSession();
   tx=s.beginTransaction();
   Employee emp=(Employee)s.get(Employee.class,id);
   //Hibernate.initialize(emp.getDepart());
   tx.commit();
   return emp;
  } finally {
   if (s != null) {
    s.close();
   }
  }

 }

 public static void add() {
  Session s = null;
  Transaction t=null;
  try {
   s=HibernateUtil.getSession();
   t = s.beginTransaction();
   t.begin();
   Department d = new Department();
   d.setName("销售部");

   Employee employee1 = new Employee();
   employee1.setName("小三");
   employee1.setDepart(d);

   Skiller employee2 = new Skiller();
   employee2.setName("李斯");
   employee2.setSkill("skill");
   employee2.setDepart(d);
   
   Sales employee3 = new Sales();
   employee3.setName("王五");
   employee3.setSell(100);
   employee3.setDepart(d);

   Set<Employee> set=new HashSet<Employee>();
   set.add(employee1);
   set.add(employee2);
   set.add(employee3);
   d.setEmps(set);
   s.save(d);
   s.save(employee1);
   s.save(employee2);
   s.save(employee3);
   
   t.commit();
  } catch (Exception e) {

  } finally {
   if (s != null) {
    s.close();
   }
  }
 }
}

1
0
分享到:
评论

相关推荐

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

    标题“14 继承(一)(整个继承树映射到一张表)”揭示了我们今天将探讨的主题——如何在数据库中通过ORM(对象关系映射)工具如Hibernate处理类的继承关系。 在Hibernate中,当一个类继承体系映射到数据库时,有几种...

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

    本篇将详细介绍Hibernate继承映射的第一种策略——每棵类继承树对应一张表,即单一表继承策略。 ### 单一表继承策略 在单一表继承策略中,所有类层次结构中的实例都存储在同一张数据库表中。这种策略通过在表中...

    用Hibernate映射继承关系

    在Hibernate中映射继承关系时,一种常见的策略是将继承关系树的每个具体类映射到单独的数据库表中。这种方法称为**表/类映射**(Table/Class Mapping),是最直观且简单的映射方式。它不考虑抽象类或继承关系,而是...

    hibernate映射继承关系(每个类都对应一张表)

    总结起来,"每个类都对应一张表"的继承映射策略在Hibernate中是一种直接且易于理解的方法,适合那些每个类都有独特属性的情况。然而,它可能不适合所有场景,特别是当子类众多或者需要减少数据冗余时。在实际应用中...

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

    JOINED策略是Hibernate实现继承映射的一种方式,它将每个继承层次的类映射到单独的表中。 1. **继承映射的基础**: - Hibernate提供了四种继承映射策略:`SINGLE_TABLE`、`JOINED`、`TABLE_PER_CLASS` 和 `MAPPED_...

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

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

    Hibernate继承映射代码

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

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

    总结来说,“每个子类一张表”的继承映射策略是Hibernate提供的一种处理继承关系的方法,它将类的继承结构映射到数据库的多个表中。这种策略适合于子类具有大量特有属性的情况,但需要权衡可能带来的数据库设计复杂...

    Hibernate继承关系映射.pdf

    单表映射策略将继承树中的所有类映射到同一张表中,通过一个额外的“识别字段”(通常称为`discriminator`)来区分不同类型的子类记录。 #### 示例代码 ```xml &lt;hibernate-mapping package="guides.hibernate....

    Hibernate教程17_继承映射

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

    hibernate的继承映射关系

    在ORM(Object-Relational Mapping)框架如Hibernate中,如何优雅地将这些继承关系映射到关系型数据库中,成为了一个重要的议题。本文将深入探讨Hibernate如何处理继承多态映射关系,主要通过三种不同的策略来实现这一...

    Hibernate继承映射一:每个类分层结构一张表

    本篇文章主要探讨的是Hibernate的继承映射策略,特别是“每个类分层结构一张表”(Table per Concrete Class)的方式。这种映射策略是Hibernate提供的多种继承映射方案之一,适用于处理复杂的对象模型。 首先,我们...

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

    本篇文章将详细探讨Hibernate继承映射的策略,特别是“每个具体类一张表”(Table Per Concrete Class)的映射方式。 在面向对象编程中,继承是常见的代码复用手段,但在关系型数据库中,这种概念并不直接对应。...

    Hibernate映射继承关系的三种方案.docx

    总结来说,Hibernate的继承映射策略提供了灵活的方法来处理对象模型与数据库模型之间的关系,开发者可以根据项目的特性和需求选择最适合的映射方式。在实现时,需要确保配置文件(如hibernate.cfg.xml)的正确设置,...

Global site tag (gtag.js) - Google Analytics