Hibernate 3.2 学习笔记 映射继承关系

最新推荐文章于 2024-06-04 09:07:32 发布
最新推荐文章于 2024-06-04 09:07:32 发布
阅读量2.2k 收藏 2
点赞数
分类专栏： Hibernate 文章标签： hibernate payment generator class table inheritance
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RainyTooo/article/details/1121300
版权

由于 之前的书上讲的方法 有的很不安全 Bug不断 结构也不够清晰 在做例子程序是反复调试还是出错

在加上书上所用的 ant  和 hibernate  还有 hibernate tools 版本太旧

固自己研究reference 做总结

 一     Table per class hierarchy (每个类分层结构一张表)

例子

Company 和 Employee 一对多 Employee 有两个子类 HourlyEmployee 和 SalaruedEmployee
Company.hbm.xml

<? 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 ="ergal.Company"  table ="COMPANIES"  lazy ="true" >
         < id  name ="id"  type ="long"  column ="ID" >
             < generator  class ="native" />
         </ id >
        
         < property  name ="name"  column ="NAME"  type ="string" />
        
         < set  name ="employees"
            inverse ="true"
            lazy ="true" >
             < key  column ="COMPANY_ID" />
             < one-to-many  class ="ergal.Employee" />
         </ set >
        
     </ class >
    
 </ hibernate-mapping >     


Employee.hbm.xml

<? 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 ="ergal.Employee"  table ="EMPLOYEES"  lazy ="true" >
         < id  name ="id"  type ="long"  column ="ID" >
             < generator  class ="native" />
         </ id >
         < discriminator  column ="EMPLOYEE_TYPE"  type ="string" />
        
         < property  name ="name"  column ="NAME"  type ="string" />
        
         < many-to-one  name ="company"
            column ="COMPANY_ID"
            class ="ergal.Company" />
        
         < subclass  name ="ergal.HourlyEmployee"  discriminator-value ="HE" >
             < property  name ="rate"  column ="RATE"  type ="double" />         
         </ subclass >
                    
         < subclass  name ="ergal.SalariedEmployee"  discriminator-value ="SE" >
             < property  name ="salary"  column ="SALARY"  type ="double" />
         </ subclass >
     </ class >
    
 </ hibernate-mapping >     


hbm2java
工具会自动产生
Employee.java
HourlyEmplyee.java
SalariedEmployee.java
并自动完整他们得继承关系 

hbm2ddl

工具会自动产生

2个表

COMPANYS和EMPLOYEES

EMPLOYEES中多了个EMPLOYEE_TYPE字段

EMPLOYEES

6 个字段

1 - ID

2 - EMPLOYEE_TYPE

3- NAME

4 - COMPANY_ID

5 - RATE

6 - SALARY

优点：方便查询  只需建立一张表 支持多态查询和多态关联 不需要查询时连接 可维护性较强

缺点：有额外的字段

Inheritance strategyPolymorphic many-to-onePolymorphic one-to-onePolymorphic one-to-manyPolymorphic many-to-manyPolymorphic load()/get()Polymorphic queriesPolymorphic joinsOuter join fetching
table per class-hierarchy<many-to-one><one-to-one><one-to-many><many-to-many>s.get(Payment.class, id)from Payment pfrom Order o join o.payment psupported

 

 二    Table per subclass (每个子类一张表)

例子同上

Company 和 Employee 一对多 Employee 有两个子类 HourlyEmployee 和 SalaruedEmployee

Company.hbm.xml

没有变化

Employee.hbm.xml

<? 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 ="ergal.Employee"  table ="EMPLOYEES"  lazy ="true" >
         < id  name ="id"  type ="long"  column ="ID" >
             < generator  class ="native" />
         </ id >
        
         < property  name ="name"  column ="NAME"  type ="string" />
        
         < many-to-one  name ="company"
            column ="COMPANY_ID"
            class ="ergal.Company" />
        
         < joined-subclass  name ="ergal.HourlyEmployee"  table ="HOURLY_EMPLOYEE" >
             < key  column ="EMPLOYEE_ID" />
             < property  name ="rate"  column ="RATE"  type ="double" />
         </ joined-subclass >
        
         < joined-subclass  name ="ergal.SalariedEmployee"  table ="SALARUED_EMPLOYEE" >
             < key  column ="EMPLOYEE_ID" />
             < property  name ="salary"  column ="SALARY"  type ="double" />
         </ joined-subclass >

     </ class >
    
 </ hibernate-mapping >     

 

运行hbm2ddl工具会在数据库中产生4个表

COMPSNYS EMPLOYEES    HOURLYE_MPLOYEE 和SALARIED_EMPLOYEE

EMPLOYEES    3个字段

1 - ID

2 - NAME

3 - COMPANY_ID

HOURLYE_MPLOYEE  2个字段

1 - EMPLOYEE_ID

2 - RATE

SALARIED_EMPLOYEE  2个字段

1 - EMPLOYEE_ID

2 - SALARY

运行hbn2java工具

会自动产生
Employee.java
HourlyEmplyee.java
SalariedEmployee.java
并使他们具备完整的继承关系 

优点：支持多态查询和多态关联 某个类要修改可以修改相应的这个类对应的表

缺点：表的数目多 表之间有外键参照关系  查询时需要连接

Inheritance strategyPolymorphic many-to-onePolymorphic one-to-onePolymorphic one-to-manyPolymorphic many-to-manyPolymorphic load()/get()Polymorphic queriesPolymorphic joinsOuter join fetching
table per class-hierarchy<many-to-one><one-to-one><one-to-many><many-to-many>s.get(Payment.class, id)from Payment pfrom Order o join o.payment psupported
table per subclass<many-to-one><one-to-one><one-to-many><many-to-many>s.get(Payment.class, id)from Payment pfrom Order o join o.payment psupported

 

三 Table per subclass, using a discriminator   (使用标识符的 每个子类一张表)

例子同上

Company 和 Employee 一对多 Employee 有两个子类 HourlyEmployee 和 SalaruedEmployee

Company.hbm.xml

没有变化

Employee.hbm.xml

 

<? 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 ="ergal.Employee"  table ="EMPLOYEES"  lazy ="true" >
         < id  name ="id"  type ="long"  column ="ID" >
             < generator  class ="native" />
         </ id >         
         < discriminator  column ="EMPLOYEE_TYPE"  type ="string" />
        
         < property  name ="name"  column ="NAME"  type ="string" />
        
         < many-to-one  name ="company"
            column ="COMPANY_ID"
            class ="ergal.Company" />
        
         < subclass  name ="ergal.HourlyEmployee"  discriminator-value ="HE" >
             < join  table ="HOURLY_EMPLOYEE" >
                 < key  column ="EMPLOYEE_ID" />
                 < property  name ="rate"  column ="RATE"  type ="double" />
             </ join >
         </ subclass >
        
         < subclass  name ="ergal.SalariedEmployee"  discriminator-value ="SE" >
             < join  table ="SALARUED_EMPLOYEE" >
                 < key  column ="EMPLOYEE_ID" />
                 < property  name ="rate"  column ="RATE"  type ="double" />
             </ join >
         </ subclass >


     </ class >
    
 </ hibernate-mapping >     

 

运行hbm2ddl工具会在数据库中产生4个表

COMPANIES EMPLOYEES     HOURLYEMPLOYEE 和SALARIEDEMPLOYEE

其中在EMPLOYEE  中多了用来标识的EMPLOYEE_TYPE 取值为 HE和SE

EMPLOYEES 4个字段

1 - ID

2 - NAME

3 - EMPLOYEE_TYPE

4 - COMPANY_ID

HOURLY_EMPLOYEE  2个字段

1 - EMPLOYEE_TPYE

2 - RATE

SALARIED_EMPLOYEE 2个字段

1 - EMPLOYEE_TPYE

2 - SALARY

运行hbn2java工具

会自动产生
Employee.java
HourlyEmplyee.java
SalariedEmployee.java
并使他们具备完整的继承关系 

只是介绍这种映射方式---结合标识器 并没有什么突出的特征和用途

四 Mixing table per class hierarchy with table per subclass  (混合模式)

不做更多解释 本身这种映射的意义就不大

reference上的例子

 

< class  name ="Payment"  table ="PAYMENT" >
     < id  name ="id"  type ="long"  column ="PAYMENT_ID" >
         < generator  class ="native" />
     </ id >
     < discriminator  column ="PAYMENT_TYPE"  type ="string" />
     < property  name ="amount"  column ="AMOUNT" />
    ...
     < subclass  name ="CreditCardPayment"  discriminator-value ="CREDIT" >
         < join  table ="CREDIT_PAYMENT" >
             < property  name ="creditCardType"  column ="CCTYPE" />
            ...
         </ join >
     </ subclass >
     < subclass  name ="CashPayment"  discriminator-value ="CASH" >
        ...
     </ subclass >
     < subclass  name ="ChequePayment"  discriminator-value ="CHEQUE" >
        ...
     </ subclass >
</ class >

 

 疑问

reference上的这句

对上述任何一种映射策略而言，指向根类Payment的 关联是使用<many-to-one>进行映射的。
<many-to-one name="payment" column="PAYMENT_ID" class="Payment"/>

我之前没有做这项工作

并没有报错 而且这么做的话 我原来的多对一 Employee对Company该怎么映射

 

 

五 Table per concrete class (每个具体的类一张表)    这里把它叫做 每个具体类一张表(union-subclass) 好一点

它有两种方式来实现

一种是显式多态

一种是隐式多态

显式多态采用的为 @hibernate.union-subclass 的方式，reference上也把这种映射方式叫做每个具体的类(union-subclass)

隐式多态则采用每个具体类的 PO 独立建表的策略，在它的映射文件中将看不出任何的和接口、抽象类的关系，同时对于抽象类，需要指明其 abstract=”true” 。

这里采用的是显式多态

例子同上

Company 和 Employee 一对多 Employee 有两个子类 HourlyEmployee 和 SalaruedEmployee

Company.hbm.xml

没有变化

Employee.hbm.xml

 

<? 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 ="ergal.Employee"  table ="EMPLOYEES"  lazy ="true" >
         < id  name ="id"  type ="long"  column ="ID" >
             < generator  class ="native" />
         </ id >         
        
         < property  name ="name"  column ="NAME"  type ="string" />
        
         < many-to-one  name ="company"
            column ="COMPANY_ID"
            class ="ergal.Company" />
        
         < union-subclass  name ="ergal.HourlyEmployee"  table ="HOURLY_EMPLOYEES" >
             < property  name ="rate"  column ="RATE"  type ="double" />
         </ union-subclass >
        
         < union-subclass  name ="ergal.SalariedEmployee"  table ="SALARIED_EMPLOYEES" >
             < property  name ="salary"  column ="SALARY"  type ="double" />
         </ union-subclass >



     </ class >
    
 </ hibernate-mapping >     

 

同样会产生4个表 但是这个映射是有限制的

官方的reference这么写到

The limitation of this approach is that if a property is mapped on the superclass, the column name must be the same on all subclass tables. (We might relax this in a future release of Hibernate.) The identity generator strategy is not allowed in union subclass inheritance, indeed the primary key seed has to be shared accross all unioned subclasses of a hierarchy.

主要限制在不允许在联合子类(union subclass)的继承层次中使用标识生成器策略(identity generator strategy)

再加上 这种方法下 生成的表多 而且字段有重复 

查询时如果查询父类必须查询子类的表 修改父类的表 子类的表也要修改

既不支持多态查询也不支持多态关联

所以不推荐使用

但是还是要说一说

毕竟要让它跑起来嘛 再说 既然有这个方法 也是有它存在的理由

在调试中 ID的属性没有设置正确

这正是

不允许在联合子类(union subclass)的继承层次中使用标识生成器策略(identity generator strategy)

而且子类不该设置ID

看了很多资料

主要参考了一个和我遇到同样问题的帖子

地址

http://forum.hibernate.org/viewtopic.php?t=963635

最后让它可以运行了

Empolyee.hbm.xnl

修改成如下：

 

<? 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 ="ergal.Employee"  table ="EMPLOYEES"  lazy ="true" >
         < id  name ="id"  type ="long"  column ="ID" >
                 < generator  class ="hilo" >
                         < param  name ="table" > hi_value </ param >
                         < param  name ="column" > next_value </ param >
                         < param  name ="max_lo" > 100 </ param >
                 </ generator >
         </ id >         
        
         < property  name ="name"  column ="NAME"  type ="string" />
        
         < many-to-one  name ="company"
            column ="COMPANY_ID"
            class ="ergal.Company" />
        
         < union-subclass  name ="ergal.HourlyEmployee"  table ="HOURLY_EMPLOYEES" >
             < property  name ="rate"  column ="RATE"  type ="double" />
         </ union-subclass >
        
         < union-subclass  name ="ergal.SalariedEmployee"  table ="SALARIED_EMPLOYEES" >
             < property  name ="salary"  column ="SALARY"  type ="double" />
         </ union-subclass >



     </ class >
    
 </ hibernate-mapping >     

把generator 换成了 hilo

这样在hbm2ddl的时候又5个表

COMPANIES EMPLOYEES     HOURLY_EMPLOYEE 和SALARIED_EMPLOYEE 多了个 Hi_Value

EMPLOYEES

1 - ID

2 - NAME

3 - COMPANY_ID

HOURLY_EMPLOYEE

1 - ID

2 - NAME

3 - COMPANY_ID

4 - RATE

SALARIED_EMPLOYEE

1 - ID

2 - NAME

3 - COMPANY_ID

4 - SALARY

Hi_Value

1 - next_value

测试代码

BusinessService.java

package  ergal;

 import  java.util. * ;
 import  org.hibernate. * ;
 import  org.hibernate.cfg. * ;

 public   class  BusinessService
 {
    public static SessionFactory sessionFactory;
    static
    {
        try
        {
            Configuration config=new Configuration();
            sessionFactory=config.configure().buildSessionFactory();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
    public void saveEmployee(Employee employee)throws Exception
    {
        Session session=sessionFactory.openSession();
        Transaction tx=null;
        try
        {
            tx=session.beginTransaction();            
            session.save(employee);
            tx.commit();
        }
        catch(Exception e)
        {
            if(tx!=null)
            {
                tx.rollback();
            }
            throw e;
        }
        finally
        {
            session.close();
        }
    }
    
    public Company loadCompany(Long id)throws Exception
    {
        Session session=sessionFactory.openSession();
        Transaction tx=null;
        try
        {
            tx=session.beginTransaction();
                        
            Company company=(Company)session.load(Company.class, id);
            
            tx.commit();
            return company;
        }
        catch(Exception e)
        {
            if(tx!=null)
            {
                tx.rollback();
            }
            throw e;
        }
        finally
        {
            session.close();
        }
    }
    
    public void test()throws Exception
    {
        Company company=loadCompany(new Long(1));
        double d1=150;
        double d2=5000;
        Employee he=new HourlyEmployee("Tom", company, d1);
        Employee se=new SalariedEmployee("Mary", company, d2);
        saveEmployee(he);
        saveEmployee(se);
    }
    
    public void find()throws Exception
    {
        Session session=sessionFactory.openSession();
        Transaction tx=null;
        try
        {
            tx=session.beginTransaction();
                        
            List result=session.createQuery("from Employee").list();
            
            for(Iterator it=result.iterator(); it.hasNext();)
                        {
                                Employee c =(Employee)it.next();
                                System.out.println("Employee's ID :" + c.getId());
                                System.out.println("Employee's name :" + c.getName());
                        }
            tx.commit();
            
        }
        catch(Exception e)
        {
            if(tx!=null)
            {
                tx.rollback();
            }
            throw e;
        }
        finally
        {
            session.close();
        }
    }
    
    public static void main(String[] args)throws Exception
    {
        new BusinessService().find();
        sessionFactory.close();
    }
}

 

运行后我有疑问没有解决

查询和插入都没有问题

可以正常显示结果

但是

EMPLOYEE表始终是个空表

不像前面的映射 不管多少个表 怎么映射EMPLOYEE表都是存在的而且里面的值会自动和 子类的表同步

 

六 Table per concrete class, using implicit polymorphism每个具体类一个表 隐式多态

这就是实现 每个具体的类一张表的 另一种方法 隐式多态

 

 

代码如下

Employee.hbm.xml

 

<? 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 ="ergal.Employee"  table ="EMPLOYEES" >
         < id  name ="id"  type ="long"  column ="EMPLOYEE_ID" >
             < generator  class ="native" />
         </ id >
        
         < property  name ="name"  column ="NAME"  type ="string" />
        
         < any  name ="employee"  meta-type ="string"  id-type ="long" >
             < meta-value  value ="HE"  class ="ergal.HourlyEmployee" />
             < meta-value  value ="SE"  class ="ergal.SalariedEmployee" />
             < column  name ="EMPLOYEE_TYPE" />
             < column  name ="SUB_EMPLOYEE_ID" />
        
         </ any >         
                
     </ class >
    
 </ hibernate-mapping >     

 

 HourlyEmployee.hbm.xml

 

<? 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 ="ergal.HourlyEmployee"  table ="HOURLY_EMPLOYEES"  polymorphism ="implicit" >
         < id  name ="id"  type ="long"  column ="HOURLY_EMPLOYEE_ID" >
             < generator  class ="native" />
         </ id >
         < property  name ="name"  column ="NAME"  type ="string" />
         < property  name ="rate"  column ="RATE"  type ="double" />
        
        
         < many-to-one
             name ="company"
            column ="COMPANY_ID"
            class ="ergal.Company"
             />
                
     </ class >
    
 </ hibernate-mapping >     

 

SalariedEmployee.hbm.xml

 

<? 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 ="ergal.SalariedEmployee"  table ="SALARUED_EMPLOYEES"  polymorphism ="implicit" >
         < id  name ="id"  type ="long"  column ="SALARUED_EMPLOYEE_ID" >
             < generator  class ="native" />
         </ id >
         < property  name ="name"  column ="NAME"  type ="string" />
         < property  name ="salary"  column ="SALARY"  type ="double" />
        
        
        
         < many-to-one
             name ="company"
            column ="COMPANY_ID"
            class ="ergal.Company"
             />
        
        
        
     </ class >
    


    
 </ hibernate-mapping >     

 

运行hbm2ddl

产生表如下 4个

COMPANIES EMPLOYEES     HOURLYEMPLOYEE 和SALARIEDEMPLOYEE

EMPLOYEES  

1 - EMPLOYEE_ID

2 - NAME

3 - EMPLOYEE_TYPE

4 - SUB_EMPLOYEE_ID

5 - COMPANY_ID

 HOURLYEMPLOYEE

1 - HOURLYEMPLOUYEE_ID

2 - NAME

3 - RATE

4 - COMPANY_ID

SALARIEDEMPLOYEE

1 - SALARIEDEMPLOYEE_ID

2 - NAME

3 - SALAR

4 - COMPANY_ID

测试代码有所变化

BusinessService.java

 

        Company company = loadCompany( new  Long( 1 ));
         double  d1 = 150 ;

        HourlyEmployee he = new  HourlyEmployee( " Tom " , d1, company);
        saveEmployee(he);

        Employee employee = new  Employee();
        employee.setEmployee(he);

        saveEmployee(employee);

 

这样在储存时必须先持久化 一个子类 再用set方法加到父类中 再持久化父类

否则会抛出

[java] org.hibernate.TransientObjectException: object references an unsaved
 transient instance - save the transient instance before flushing: ergal.HourlyE
mployee

这样的好处是什么?

还有这里使用了any

我要思考一下

最后一种

另外这里使用了any

简单记一下

<any> 是隐式的 我是这么理解的

从字面上看 就是这个属性可以关联到多个其他的对象

所以你可能更本看不出它是子类 接口 还是别的关联属性 在父类里显示为一个对象

对相应的类型做相应的标识

like this

<any name="payment" meta-type="string" id-type="long">
    <meta-value value="CREDIT" class="CreditCardPayment"/>
    <meta-value value="CASH" class="CashPayment"/>
    <meta-value value="CHEQUE" class="ChequePayment"/>
    <column name="PAYMENT_CLASS"/>
    <column name="PAYMENT_ID"/>
</any>

七 Mixing implicit polymorphism with other inheritance mappings隐式多态和其他继承映射混合使用

我要疯了

看官方文档吧 如果用到再仔细研究 这已经花了我两天的时间了

对这一映射还有一点需要注意。因为每个子类都在各自独立的元素<class> 中映射(并且Payment只是一个接口)，每个子类可以很容易的成为另一 个继承体系中的一部分！(你仍然可以对接口Payment使用多态查询。)
<class name="CreditCardPayment" table="CREDIT_PAYMENT">
    <id name="id" type="long" column="CREDIT_PAYMENT_ID">
        <generator class="native"/>
    </id>
    <discriminator column="CREDIT_CARD" type="string"/>
    <property name="amount" column="CREDIT_AMOUNT"/>
    ...
    <subclass name="MasterCardPayment" discriminator-value="MDC"/>
    <subclass name="VisaPayment" discriminator-value="VISA"/>
</class>

<class name="NonelectronicTransaction" table="NONELECTRONIC_TXN">
    <id name="id" type="long" column="TXN_ID">
        <generator class="native"/>
    </id>
    ...
    <joined-subclass name="CashPayment" table="CASH_PAYMENT">
        <key column="PAYMENT_ID"/>
        <property name="amount" column="CASH_AMOUNT"/>
        ...
    </joined-subclass>
    <joined-subclass name="ChequePayment" table="CHEQUE_PAYMENT">
        <key column="PAYMENT_ID"/>
        <property name="amount" column="CHEQUE_AMOUNT"/>
        ...
    </joined-subclass>
</class>

我们还是没有明确的提到Payment。 如果我们针对接口Payment执行查询 ——如from Payment—— Hibernate 自动返回CreditCardPayment(和它的子类，因为 它们也实现了接口Payment)、 CashPayment和Chequepayment的实例， 但不返回NonelectronicTransaction的实例。

限制

对“每个具体类映射一张表”（table per concrete-class）的映射策略而言，隐式多态的 方式有一定的限制。而<union-subclass>映射的限制则没有那 么严格。

下面表格中列出了在Hibernte中“每个具体类一张表”的策略和隐式多态的限制。

Inheritance strategyPolymorphic many-to-onePolymorphic one-to-onePolymorphic one-to-manyPolymorphic many-to-manyPolymorphic load()/get()Polymorphic queriesPolymorphic joinsOuter join fetching
table per class-hierarchy<many-to-one><one-to-one><one-to-many><many-to-many>s.get(Payment.class, id)from Payment pfrom Order o join o.payment psupported
table per subclass<many-to-one><one-to-one><one-to-many><many-to-many>s.get(Payment.class, id)from Payment pfrom Order o join o.payment psupported
table per concrete-class (union-subclass)<many-to-one><one-to-one><one-to-many> (for inverse="true" only)<many-to-many>s.get(Payment.class, id)from Payment pfrom Order o join o.payment psupported
table per concrete class (implicit polymorphism)<any>not supportednot supported<many-to-any>s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()from Payment pnot supportednot supported

 

终于差不多结束这一重要的章节

还有很多值得研究的 毕竟实际运用中 接口 抽象类 一对一 多对一 一对多 多对多 等等关系复杂

而且我们要为数据库的性能着想 选择最好的查询性能的映射方式 最节约储存空间的映射方式等等

                                                                

RainyTooo
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Hibernate3.2 Hibernate tools 的使用
Vincent的造轮子经验
08-15 1万+
 由于新发布的Hibernate Tools是一个比较庞大的工具包 而且已经是作为Eclipse3.2 的插件发布的然而以前的很有用的工具hbm2java和hbm2ddl都是非常有用的工具所以我们应该把这些有用的工具找出来继续使用  环境jdk-1_5_0_07ant 1.6.5Hibernate 3.2 cr2Hibernate Tools-3.2.0.beta6
Hibernate 3.2 学习笔记 查询和检索
Vincent的造轮子经验
08-31 2793
                                                     Hibernate的检索策略-------------------------------------------------------------------------------------------------------------------------------------
继承映射
gao_20022002的专栏
08-27 505
继承映射(Inheritance Mappings)10.1.  三种策略Hibernate支持三种基本的继承映射策略： 每个类分层结构一张表(table per class hierarchy) 每个子类一张表(table per subclass)
Hibernate参考文档 3.0.4
热门推荐
Vincent的造轮子经验
08-27 1万+
HIBERNATE - 符合Java习惯的关系数据库持久化Hibernate参考文档3.0.4目录前言 1. 翻译说明 2. 版权声明1. 在Tomcat中快速上手 1.1. 开始Hibernate之旅 1.2. 第一个持久化类 1.3. 映射cat 1.4. 与Cat同乐 1.5. 结语2. Hibernate入门 2.1. 前言
Hibernate 3.2 学习笔记 映射集合类
Vincent的造轮子经验
08-31 1847
映射值属性集合类值属性集合类没有单独的OID和生命周期 实体类集合有单独的OID和生命周期set   不允许重复            属性:                      name  指定集合的属性名                      table   对应的 表                      lazy    延迟检索策略              
Hibernate3.2 学习笔记 映射的基本元素和属性
Vincent的造轮子经验
08-15 1743
    关系映射文件       0  属性：     default-scheam             指定默认的数据表命名     package                          指定包名                1    属性：    name                       设定类名        table        
深入探索Stage #2：属性中的XSS注入技术
weixin_43822401的博客
06-04 687
在Web安全的学习旅程中，XSS（跨站脚本）注入是一个不可忽视的话题。"XSS Challenges"闯关游戏的Stage #2专为进阶学习者设计，专注于属性中的XSS注入技术。本文将详细介绍这一阶段的实操过程和关键概念。
ssm_078_mysql_高校就业管理系统_.zip
08-09
基于SSM框架及MySQL数据库实现的就业管理系统的设计和开发过程。本论文中所讲的就业管理系统是通过所学的知识创办一个非商业性的网站平台，使所有想要就业信息查看的高校毕业生们与想要宣传自己公司的商家们都可以更方便快捷的进行就业和体验。在现实生活中，如果商家想宣传自己的公司，或者毕业季的大学生们想要就业找工作之前做攻略都需要很高的时间成本。对招聘的公司来说，经常会出现公司缺人但岗位无人问津的情况，一定程度上影响了公司的运营与发展。此网站开发出来之后不管是对所有想要了解就业岗位的学生还是宣传自己公司的商家来说，都节省了时间成本、宣传成本。SSM高校就业管理系统系统提供了丰富的功能，用户可以直接在系统上面获取岗位或公司的信息，如公司图片、岗位名称、岗位信息等，网站的用户可以在网站上直接与管理员进行在线沟通。与传统的就业平台相比，本系统能够提供更及时的服务，大大节省时间成本。
【创新发文无忧】Matlab实现鸽群优化算法PIO-DELM的故障诊断算法研究.rar
08-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
基于Springboot的动物领养平台设计与开发 Javaee项目，springboot项目
最新发布
08-09
资源详情：https://blog.csdn.net/2302_78191516/article/details/141071581
基于python的crazy管理系统 (14).zip
08-09
阿齐archie
38.锂电池点焊机.zip
08-09
38.锂电池点焊机
PHP域名多元探索器.zip
08-09
PHP域名多元探索器是一款基于PHP语言开发的强大工具，旨在帮助开发者在Web开发中高效、精准地处理和管理域名相关的多种任务。该工具集成了多种域名解析、验证及操作功能，包括但不限于提取顶级域名（TLDs）、主域名、子域名等，还支持国际化域名（IDN）的转换，确保了开发者能够轻松应对各种复杂的域名处理场景。 PHP域名多元探索器遵循RFC 2396和RFC 3986等国际域名解析标准，保证了解析结果的准确性和可靠性。它提供了一个丰富的API接口，允许开发者以对象导向的方式轻松调用，快速实现域名的解析、验证和查询等功能。此外，该工具还具备灵活性和可扩展性，通过提供多种获取域名不同部分的方法，如`getRegistrableDomain()`、`getPublicSuffix()`等，满足了不同场景下的多样化需求。 在安全方面，PHP域名多元探索器内置了强大的错误处理机制，能够有效处理无效的或无法解析的域名，并通过抛出异常的方式方便开发者进行错误处理和调试。同时，它还支持HTTPS和客户端证书的安全通信方式，进一步增强了数据传输的安全性。 综上所述，PHP域名多元探索器是一款功能丰富、
财务出纳一览表.xlsx
08-09
工资表，财务报表，对账表，付款申请，财务报告，费用支出表 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
Python面试题.docx
08-09
Python 作为一种广泛应用的编程语言，在面试中经常会涉及到各种类型的问题，以全面考察应聘者的知识和技能。 这份 Python 面试题资源涵盖了基础知识、数据结构与算法、面向对象编程、函数式编程、文件操作、异常处理、模块与包、数据库操作、网络编程等多个重要领域。 在基础知识方面，会询问 Python 的基本语法、变量类型、控制结构（如 if-else、for 循环、while 循环）等。例如，可能会让应聘者解释 Python 中列表和元组的区别，或者如何在 Python 中实现条件判断。 对于数据结构与算法，可能会涉及到链表、栈、队列、树、排序算法（如冒泡排序、快速排序）等的理解和实现。比如，要求应聘者用 Python 实现一个简单的链表数据结构，或者分析某种排序算法的时间复杂度和空间复杂度。 面向对象编程是 Python 中的重要概念，问题可能包括类的定义与使用、继承、多态、封装等。可能会让应聘者设计一个类来表示某种具体的对象，并实现相关的方法。 函数式编程方面，会考察函数的高阶用法、匿名函数、装饰器等。比如，让应聘者使用装饰器实现一个日志记录功能。 文件操作和异常处理也是常见的考
ssm_090_mysql_房屋租赁系统_.zip
08-09
在国家经济的快速发展中，房地产行业是带动国家GDP增速的主力之一，我国的各大城市的房价也都在不断的攀升。而面对城市房价持续保持在高位，进城务工人员暂时无法在城市中实现购房，而对于有经济条件的购房者，有些城市也会有限购令，使得这些购房者暂时无法买房。面对初入城市的外来人口，租房成为了外来人口的首选方案。 本次是基于SSM框架技术来对于租房行业进行深入了解，通过对租房行业的现状，未来发展以及现再存在的问题等进行分析，总结出本次开发程序的必要性，通过搭建一款房屋租赁系统来实现房产新闻的在线推广，房东、租户的在线注册以及在线预约开放、交流等功能，为租户与房东通过线上来搭建一个快速交流的平台，实现很好的线上化撮合平台的作用。本次的系统开发使用了SSM框架以及JSP为主开发工具，通过eclipse开发软件工具来进行整体的内容开发。数据库选择以MySQL作为本次的数据库管理工具。通过本次的系统开发最终实现了需求满足，运行稳定。
购物车.xlsx
08-09
购物车
Bss设计蓝图demo .pdf
08-09
Bss设计蓝图demo .pdf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值