hibernate继承映射2

           关于以前写的hibernate继承关系映射，当30多张表的时候，系统开销太大，导致了内存溢出的严重问题，没有办法，只能换一种继承策略了。

            就是30多张表的共用字段都提取出来，在数据库里建一张表，其他表里只有自身的字段。然后在配置文件里面去继承共用的那张表就OK了。其间，只是一些配置文件的细节发生了变化。程序代码一点都不用改变！hibernate真强大啊！说多了没用，上代码！哦。。。先说说例子的大概情况：有一张职员表（这张表就是共用字段），一张小时工表（继承职员表），一张薪水工表（也继承职员表）。

（1）职员表

    

package mypack;

import java.io.Serializable;

public abstract  class Employee implements Serializable ...{

    private Long id;
    private String name;

        private String type;
   
    生成get、set方法
}

 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping >
   <class name="mypack.Employee" table="EMPLOYEES" polymorphism="implicit"> 
      <id name="id" type="long" column="ID">
        <generator class="native"/>
      </id>  
      <property name="name" type="string" column="NAME" />

         <property name="type" type="string" column="type" length="50"/>
    </class>
</hibernate-mapping>

 

(2)小时工表

       

package mypack;

import java.io.Serializable;

public class HourlyEmployee extends Employee...{

    private double rate;

   /** *//** default constructor */
    public HourlyEmployee() ...{
    }

    public double getRate() ...{
        return this.rate;
    }

    public void setRate(double rate) ...{
        this.rate = rate;
    }

}

       

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping >
      <joined-subclass name="mypack.HourlyEmployee" table="HOURLY_EMPLOYEES"  extends="mypack.Employee" >
         <key column="EMPLOYEE_ID" />
         <property name="rate" column="RATE" type="double" />
      </joined-subclass>
</hibernate-mapping>

 

(3)薪水工表

 

package mypack;

import java.io.Serializable;

public class SalariedEmployee extends Employee ...{

    private double salary;

    /** *//** default constructor */
    public SalariedEmployee() ...{
    }

   public double getSalary() ...{
        return this.salary;
    }

    public void setSalary(double salary) ...{
        this.salary = salary;
    }

}

         

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping >
      <joined-subclass name="mypack.SalariedEmployee"  table="SALARIED_EMPLOYEES" extends="mypack.Employee" >
         <key column="EMPLOYEE_ID" />
         <property name="salary" column="SALARY" type="double" />
      </joined-subclass>
</hibernate-mapping>

 

最后一步：注意了！把职员表重新命名再映射一遍,这回不是抽象的了。

package mypack;

import java.io.Serializable;

public class jEmployee implements Serializable ...{

    private Long id;
    private String name;
    private String type;
 
    /** *//** default constructor */
    public jEmployee() ...{
    }
   
    //生成get，set方法
}

 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping >
   <class name="mypack.jEmployee" table="EMPLOYEES" >
      <id name="id" type="long" column="ID">
        <generator class="native"/>
      </id>  
      <property name="name" type="string" column="NAME" />
      <property name="type" type="string" column="type"  length="50"/>
    </class>
</hibernate-mapping>

一会说，接着说。

     职位表中的type字段记录着每个子表的表名。

    上面2，3的配置文件采用joined-subclass，hiberntae中的继承有3中，还有两种，一个是union-subclass和subclass。用union-subclass生成的sql语句都是以union形式的，用join-subclass生成的sql语句都是什么什么join。subclass这个方式太简单了，不说了。

   为什么把职位表映射两遍呢？而且最后一遍的映射是没有继承关系的单一文件，而且也不是抽象的。因为hibernate继承映射的话，它会查出它子类的所有的东西，hibernate3.0是这样的。假如说我程序里面想把所有共性的字段以列表的形式查出来，那么hibernate就会把它的子类都查出来，这样开销太大了。所以把员工表单独映射一个纯净的类来解决这个开销问题。

  关于（1）中的配置文件中的polymorphism="implicit"属性，有两个值，即：implicit (隐式)和explicit（显式）两种。默认是implicit。很多人说，把这个属性值设一下，这样按着父类查询是就不会把子类查出来，这是不对的，这种说法并没有理解隐式和显式的真正含义。他们的区别如下：

    implicit（隐式）形式不使用join关键字。关联使用"点号"来进行“引用”。implicit join可以在任何HQL子句中出现.implicit join在最终的SQL语句中以inner join的方式出现。

from Cat as cat where cat.mate.name like '%s%'

Implicit (隐式)的多态是指，如果查询中给出的是任何超类、该类实现的接口或者该类的名字，都会返回这个类的实例；如果查询中给出的是子类的名字，则会返回子类的实例。 Explicit （显式）的多态是指，只有在查询中给出的明确是该类的名字时才会返回这个类的实例；同时只有当在这个<class>的定义中作为<subclass>或者<joined-subclass>出现的子类，才会可能返回。 大多数情况下，默认的polymorphism="implicit"都是合适的。 显式的多态在有两个不同的类映射到同一个表的时候很有用。（允许一个“轻型”的类，只包含部分表字段）。