hibernate2 参考文档之五.txt

Hibernate使用说明书

cascade 属性允许下列值： all, save-update, delete, none。设置除了none以外的其它值会传播特定的操作到关联的（子）对象中。参见后面的“Lifecycle Objects(自动管理生命周期的对象）”。 

outer-join参数允许下列三个不同值： 

auto (默认) 使用外连接抓取关联（对象），如果被关联的对象没有代理(proxy) 

true 一直使用外连接来抓取关联 

false 永远不使用外连接来抓取关联 

一个典型的简单many-to-one声明例子： 

<many-to-one name="product" class="Product" column="PRODUCT_ID"/>
property-ref属性只应该用来对付老旧的数据库系统，可能出现外键指向对方关联表的是个非主键字段（但是应该是一个惟一关键字）的情况。这是一种十分丑陋的关系模型。比如说，假设Product类有一个惟一的序列号，它并不是主键。（unique属性控制Hibernate通过SchemaExport工具生成DDL的过程。） 

<property name="serialNumber" unique="true" type="string" column="SERIAL_NUMBER"/>
那么关于OrderItem 的映射可能是： 

<many-to-one name="product" property-ref="serialNumber" column="PRODUCT_SERIAL_NUMBER"/>
当然，我们决不鼓励这种用法。 

5.1.11. 一对一
持久化对象之间一对一的关联关系是通过one-to-one元素定义的。 

<one-to-one
        name="propertyName"                      
        class="ClassName"                        
        cascade="all|none|save-update|delete"    
        constrained="true|false"                 
        outer-join="true|false|auto"             
        property-ref="propertyNameFromAssociatedClass"     
        access="field|property|ClassName"                  
        
/>
 name: 属性的名字。 
 
 class (可选 - 默认是通过反射得到的属性类型)：被关联的类的名字。 
 
 cascade(级联) (可选) 表明操作是否从父对象级联到被关联的对象。 
 
 constrained（约束） (可选) 表明该类对应的表对应的数据库表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。这个选项影响save()和delete()在级联执行时的先后顺序（也在schema export tool中被使用）。 
 
 outer-join（外连接） (可选 - 默认为 自动): 当设置hibernate.use_outer_join的时候，对这个关联允许外连接抓取。 
 
 property-ref: (可选) 指定关联类的一个属性，这个属性将会和本外键相对应。如果没有指定，会使用对方关联类的主键。 
 
 access (可选 - 默认是 property): Hibernate用来访问属性的策略。 
 

有两种不同的一对一关联： 

主键关联 

惟一外键关联 

主键关联不需要额外的表字段;两行是通过这种一对一关系相关联的，那么这两行就共享同样的主关键字值。所以如果你希望两个对象通过主键一对一关联，你必须确认它们被赋予同样的标识值！ 

比如说，对下面的Employee和Person进行主键一对一关联: 

<one-to-one name="person" class="Person"/>
<one-to-one name="employee" class="Employee" constrained="true"/>
Now we must ensure that the primary keys of related rows in the PERSON and EMPLOYEE tables are equal. We use a special Hibernate identifier generation strategy called foreign: 现在我们必须确保PERSON和EMPLOYEE中相关的字段是相等的。我们使用一个特别的称为foreign的Hibernate标识符生成器策略： 

<class name="person" table="PERSON">
    <id name="id" column="PERSON_ID">
        <generator class="foreign">
            <param name="property">employee</param>
        </generator>
    </id>
    ...
    <one-to-one name="employee"
        class="Employee"
        constrained="true"/>
</class>
一个刚刚保存的Person实例被赋予和该Person的employee属性所指向的Employee实例同样的关键字值。 

另一种方式是一个外键和一个惟一关键字对应，上面的Employee和Person的例子，如果使这种关联方式，应该表达成： 

<many-to-one name="person" class="Person" column="PERSON_ID" unique="true"/>
如果在Person的映射加入下面几句，这种关联就是双向的： 

<one-to-one name"employee" class="Employee" property-ref="person"/>
5.1.12. 组件（component）, 动态组件（dynamic-component）
<component>元素把子对象的一些元素与父类对应的表的一些字段映射起来。 然后组件可以声明它们自己的属性、组件或者集合。参见后面的“Components”一章。 

<component 
        name="propertyName"                 
        class="className"                   
        insert="true|false"                 
        upate="true|false"                  
        access="field|property|ClassName">  
        
        <property ...../>
        <many-to-one .... />
        ........
</component>
 name: 属性名 
 
 class (可选 - 默认为通过反射得到的属性类型):组件（子）类的名字。 
 
 insert: 被映射的字段是否出现在SQL的INSERT语句中? 
 
 update: 被映射的字段是否出现在SQL的UPDATE语句中? 
 
 access (可选 - 默认是 property): Hibernate用来访问属性的策略。 
 

其<property>子标签为子类的一些属性和表字段建立映射。 

<component>元素允许加入一个<parent>子元素，在组件类内部就可以有一个指向其容器的实体的反向引用。 

<dynamic-component>元素允许把一个Map映射为组件，其属性名对应map的键值。 

5.1.13. 子类(subclass)
最后，多态持久化需要为父类的每个子类都进行声明。对于我们建议的“每一棵类继承树对应一个表”的策略来说，就需要使用<subclass>声明。 

<subclass
        name="ClassName"                              
        discriminator-value="discriminator_value"     
        proxy="ProxyInterface"                        
        lazy="true|false"                             
        dynamic-update="true|false"
        dynamic-insert="true|false">

        <property .... />
        .....
</subclass>
 name: 子类的全限定名。 
 
 discriminator-value(辨别标志） (可选 - 默认为类名):一个用于区分每个独立的子类的值。 
 
 proxy（代理） (可选): 指定一个类或者接口，在延迟装载时作为代理使用。 
 
 lazy（延迟装载） (可选): 设置lazy="true"是把自己的名字作为proxy接口的一种等价快捷方式。 
 

每个子类都应该声明它自己的持久化属性和子类。 <version> 和<id> 属性可以从根父类继承下来。在一棵继承树上的每个子类都必须声明一个唯一的discriminator-value。如果没有指定，就会使用Java类的全限定名。 

5.1.14. 连接的子类（joined-subclass）
另外一种情况，如果子类是持久化到一个属于它自己的表（每一个子类对应一个表的映射策略），那么就需要使用<joined-subclass>元素。 

<joined-subclass
        name="ClassName"          
        proxy="ProxyInterface"    
        lazy="true|false"                   
        dynamic-update="true|false"
        dynamic-insert="true|false">

        <key .... >

        <property .... />
        .....
</subclass>
 name: 子类的全限定名。 
 
 proxy (可选): 指定一个类或者接口，在延迟装载时作为代理使用。 
 
 lazy（延迟装载） (可选): 设置lazy="true"是把自己的名字作为proxy接口的一种等价快捷方式。 
 

这种映射策略不需要指定辨别标志（discriminator）字段。但是，每一个都必须使用<key>元素指定一个表字段包含对象的标识符。本章开始的映射可以被用如下方式重写： 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping  package="eg">

        <class name="Cat" table="CATS">
                <id name="id" column="uid" type="long">
                        <generator class="hilo"/>
                </id>
                <property name="birthdate" type="date"/>
                <property name="color" not-null="true"/>
                <property name="sex" not-null="true"/>
                <property name="weight"/>
                <many-to-one name="mate"/>
                <set name="kittens">
                        <key column="MOTHER"/>
                        <one-to-many class="Cat"/>
                </set>
                <joined-subclass name="DomesticCat" table="DOMESTIC_CATS">
                	<key column="CAT"/>
                        <property name="name" type="string"/>
                </joined-subclass>
        </class>

        <class name="eg.Dog">
                <!-- mapping for Dog could go here -->
        </class>

</hibernate-mapping>
5.1.15. map, set, list, bag
集合类在后面讨论。 

5.1.16. 引用（import）
假设你的应用程序有两个同样名字的持久化类，但是你不想在Hibernate查询中使用他们的全限定名。除了依赖auto-import="true"以外，类也可以被显式地“import(引用）”。你甚至可以引用没有明确被映射的类和接口。 

<import class="java.lang.Object" rename="Universe"/>
<import
        class="ClassName"                             
        rename="ShortName"                            
/>
 class: 任何Java类的全限定名。 
 
 rename (可选 - 默认为类的全限定名): 在查询语句中可以使用的名字。