Hibernate 关联属性详解_关联属性是什么-CSDN博客

1.<class>元素
name=”ClassName”                              (1)
table=”tableName”                             (2)
discriminator-value=”discriminator_value”     (3)
mutable=”true|false”                          (4)
schema=”owner”                                (5)
catalog=”catalog”                             (6)
proxy=”ProxyInterface”                        (7)
dynamic-update=”true|false”                   (8)
dynamic-insert=”true|false”                   (9)
select-before-update=”true|false” (10)
polymorphism=”implicit|explicit”              (11)
where=”arbitrary sql where condition”         (12)
persister=”PersisterClass”                    (13)
batch-size=”N”                                (14)
optimistic-lock=”none|version|dirty|all”      (15)
lazy=”true|false”                             (16)
entity-name=”EntityName”                      (17)
check=”arbitrary sql check condition”         (18)
rowid=”rowid”                                 (19)
subselect=”SQL expression”                    (20)
abstract=”true|false”                         (21)
entity-name=”EntityName”                      (22)
node=”element-name”                           (23)
/>
(1) name (可选): 持久化类（或者接口）的Java全限定名。如果这个属性不存在，Hibernate将假定这是一个非POJO的实体映射。
(2) table (可选 – 默认是类的非全限定名): 对应的数据库表名。
(3) discriminator-value (可选 – 默认和类名一样): 一个用于区分不同的子类的值，在多态行为时使用。它可以接受的值包括 null 和 not null。
(4) mutable (可选，默认值为true): 表明该类的实例是可变的或者可变的。
(5) schema (可选): 覆盖在根<hibernate-mapping>元素中指定的schema名字。
(6) catalog (可选): 覆盖在根<hibernate-mapping>元素中指定的catalog名字。
(7) proxy (可选): 指定一个接口，在延迟装载时作为代理使用。你可以在这里使用该类自己的名字。
(8) dynamic-update (可选, 默认为 false): 指定用于UPDATE 的SQL将会在运行时动态生成，并且只更新那些改变过的字段。
(9) dynamic-insert (可选, 默认为 false): 指定用于INSERT的 SQL 将会在运行时动态生成，并且只包含那些非空值字段。
(10)select-before-update (可选, 默认为 false): 指定Hibernate除非确定对象真正被修改了（如果该值为true－译注），否则不会执行SQL UPDATE操作。在特定场合（实际上，它只在一个瞬时对象（transient object）关联到一个新的session中时执行的update()中生效），这说明Hibernate会在UPDATE 之前执行一次额外的SQL SELECT操作，来决定是否应该执行 UPDATE。
(11) polymorphism（多态） (可选, 默认值为 implicit (隐式) ): 界定是隐式还是显式的使用多态查询（这只在Hibernate的具体表继承策略中用到－译注）。
(12) where (可选) 指定一个附加的SQLWHERE 条件，在抓取这个类的对象时会一直增加这个条件。
(13) persister (可选): 指定一个定制的ClassPersister。
(14) batch-size (可选,默认是1) 指定一个用于根据标识符（identifier）抓取实例时使用的”batch size”（批次抓取数量）
(15) optimistic-lock（乐观锁定） (可选，默认是version): 决定乐观锁定的策略。
optimistic-lock：乐观锁大多是基于数据版本（Version）记录机制实现，Hibernate中可以通过class描述符的optimistic-lock属性结合version 描述符指定。
optimistic-lock属性有如下可选取值：
none 无乐观锁
version 通过版本机制实现乐观锁
dirty 通过检查发生变动过的属性实现乐观锁
all 通过检查所有属性实现乐观锁
Pessimistic-Lock：指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。
一个典型的倚赖数据库的悲观锁调用： select * from account where name=”Erica” for update 这条sql 语句锁定了account 表中所有符合检索条件（name=”Erica”）的记录。本次事务提交之前（事务提交时会释放事务过程中的锁），外界无法修改这些记录。
========================================>
Hibernate的加锁模式有：
Ø LockMode.NONE ：无锁机制。
Ø LockMode.WRITE ：Hibernate在Insert和Update记录的时候会自动    获取。
Ø LockMode.READ ： Hibernate在读取记录的时候会自动获取。
以上这三种锁机制一般由Hibernate内部使用，如Hibernate为了保证Update过程中对象不会被外界修改，会在save方法实现中自动为目标对象加上WRITE锁。
Ø LockMode.UPGRADE ：利用数据库的for update子句加锁。
Ø LockMode. UPGRADE_NOWAIT ：Oracle的特定实现，利用Oracle的for update nowait子句实现加锁。
<=======================================
(16) lazy (optional): 通过设置lazy=”false”，所有的延迟加载（Lazy fetching）功能将未被激活（disabled）。
(17) entity-name (可选): Hibernate3允许一个类进行多次映射（默认情况是映射到不同的表），并且允许使用Maps或XML代替Java层次的实体映射（也就是实现动态领域模型，不用写持久化类－译注）。
(18) check (可选): 这是一个SQL表达式，用于为自动生成的schema添加多行（multi-row）约束检查。
(19) rowid (可选): Hibernate可以使用数据库支持的所谓的ROWIDs，例如： Oracle数据库，如果你设置这个可选的rowid， Hibernate可以使用额外的字段rowid实现快速更新。ROWID是这个功能实现的重点，它代表了一个存储元组（tuple）的物理位置。
(20) subselect (可选): 它将一个不可变（immutable）并且只读的实体映射到一个数据库的子查询中。它用于实现一个视图代替一张基本表，但是最好不要这样做。更多的介绍请看下面内容。
(21) abstract (可选): 用于在<union-subclass>的继承结构（hierarchies）中标识抽象超类。
(22) entity-name (可选, 默认为类名): 显式指定实体名

2.<id>元素
被映射的类必须定义对应数据库表主键字段。大多数类有一个JavaBeans风格的属性，为每一个实例包含唯一的标识。<id> 元素定义了该属性到数据库表主键字段的映射。
<id     name=”propertyName”                                          (1)
type=”typename”                                              (2)
column=”column_name”                                         (3)
unsaved-value=”null|any|none|undefined|id_value”             (4)
access=”field|property|ClassName”                            (5)
node=”element-name|@attribute-name|element/@attribute|.”>
<generator class=”generatorClass”/>
</id>
(1) name (可选): 标识属性的名字。
(2) type (可选): 标识Hibernate类型的名字。
(3) column (可选 – 默认为属性名): 主键字段的名字。
(4) unsaved-value (可选 – 默认为一个字段判断（sensible）的值): 一个特定的标识属性值，用来标志该实例是刚刚创建的，尚未保存。这可以把这种实例和从以前的session中装载过（可能又做过修改–译者注）但未再次持久化的实例区分开来。
(5) access (可选 – 默认为property): Hibernate用来访问属性值的策略。如果 name属性不存在，会认为这个类没有标识属性。
unsaved-value 属性很重要！如果你的类的标识属性不是默认为正常的Java默认值（null或零），你应该指定正确的默认值。
还有一个另外的<composite-id>定义可以访问旧式的多主键数据。我们强烈不建议使用这种方式。

<generator>元素
可选的<generator>子元素是一个Java类的名字，用来为该持久化类的实例生成唯一的标识。如果这个生成器实例需要某些配置值或者初始化参数，用<param>元素来传递。
<id name=”id” type=”long” column=”cat_id”>
<generator class=”org.hibernate.id.TableHiLoGenerator”>
<param name=”table”>uid_table</param>
<param name=”column”>next_hi_value_column</param>
</generator>
</id>
所有的生成器都实现net.sf.hibernate.id.IdentifierGenerator接口。这是一个非常简单的接口；某些应用程序可以选择提供他们自己特定的实现。当然， Hibernate提供了很多内置的实现。下面是一些内置生成器的快捷名字：

increment
用于为long, short或者int类型生成唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用。在集群下不要使用。
identity
对DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的内置标识字段提供支持。返回的标识符是long, short 或者int类型的。
sequence
在DB2,PostgreSQL, Oracle, SAP DB, McKoi中使用序列（sequence)，而在Interbase中使用生成器(generator)。返回的标识符是long, short或者 int类型的。
hilo
使用一个高/低位算法高效的生成long, short 或者 int类型的标识符。给定一个表和字段（默认分别是是 hibernate_unique_key 和next_hi）作为高位值的来源。高/低位算法生成的标识符只在一个特定的数据库中是唯一的。
seqhilo
使用一个高/低位算法来高效的生成long, short 或者 int类型的标识符，给定一个数据库序列（sequence)的名字。
uuid
用一个128-bit的UUID算法生成字符串类型的标识符，这在一个网络中是唯一的（使用了IP地址）。UUID被编码为一个32位16进制数字的字符串。
guid
在MS SQL Server 和 MySQL 中使用数据库生成的GUID字符串。
native
根据底层数据库的能力选择identity, sequence 或者hilo中的一个。
assigned
让应用程序在save()之前为对象分配一个标示符。这是 <generator>元素没有指定时的默认生成策略。
select
通过数据库触发器选择一些唯一主键的行并返回主键值来分配一个主键。
foreign
使用另外一个相关联的对象的标识符。通常和<one-to-one>联合起来使用。

<properties> 元素允许定义一个命名的逻辑分组(grouping)包含一个类中的多个属性。这个元素最重要的用处是允许多个属性的组合作为property-ref的目标(target)。这也是定义多字段唯一约束的一种方便途径。

(1) name: 分组的逻辑名称 – 不是实际属性的名称.
(2) insert: 被映射的字段是否出现在SQL的 INSERT语句中?
(3) update: 被映射的字段是否出现在SQL的 UPDATE语句中?
(4) optimistic-lock (可选 – 默认是 true):表明更新此组件是否需要获取乐观锁。换句话说，当这个属性变脏时，是否增加版本号(Version)
(5) unique (可选 – 默认是 false):表明组件映射的所有字段上都有唯一性约束

(1)name: 子类的全限定名。
(2)discriminator-value(辨别标志) (可选 – 默认为类名):一个用于区分每个独立的子类的值。
(3)proxy(代理) (可选): 指定一个类或者接口，在延迟装载时作为代理使用。
(4)lazy (可选, 默认是true): 设置为 lazy=”false” 禁止使用延迟抓取

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

可以在单独的映射文件中，直接在hibernate-mapping下定义subclass，union-subclass和joined-subclass映射。这样你只要增加一个新的映射文件就可以继承一棵类继承树。你必须在子类的映射中指定extends 属性来指定已映射的超类。注意：以前，这个特性使得映射文件的顺序变得很重要。从Hibernate3开始，当使用extends关键字的时候，映射文件的次序便不重要了。而在单一映射文件中，依旧需要保持将超类定义在子类之前这样的次序。

<hibernate-mapping>
<subclass name=”DomesticCat” extends=”Cat” discriminator-value=”D”>
<property name=”name” type=”string”/>
</subclass>
</hibernate-mapping>

连接的子类(joined-subclass)

此外，每个子类可能被映射到他自己的表中(每个子类一个表的策略)。被继承的状态通过和超类的表关联得到。我们使用<joined-subclass>元素。
<joined-subclass
name=”ClassName”                    (1)
table=”tablename”                   (2)
proxy=”ProxyInterface”              (3)
lazy=”true|false”                   (4)
dynamic-update=”true|false”
dynamic-insert=”true|false”
schema=”schema”
catalog=”catalog”
extends=”SuperclassName”
persister=”ClassName”
subselect=”SQL expression”
entity-name=”EntityName”
node=”element-name”>

<key …. >
<property …. />
…..
</joined-subclass>
(1)name: 子类的全限定名。
(2)table: 子类的表名.
(3)proxy (可选): 指定一个类或者接口，在延迟装载时作为代理使用。
(4)lazy (可选, 默认是 true): 设置为 lazy=”false” 禁止使用延迟装载。

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

<?xml version=”1.0″?>
<!DOCTYPE hibernate-mapping PUBLIC
“-//Hibernate/Hibernate Mapping DTD//EN”
“http://hibernate.sourceforge.net/hibernate-mapping-3.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>

联合子类(union-subclass)
第三种选择是仅仅映射类继承树中具体类部分到表中(每个具体类一张表的策略)。其中，每张表定义了类的所有持久化状态，包括继承的状态。在 Hibernate 中，并不需要完全显式地映射这样的继承树。你可以简单地使用单独的<class>定义映射每个类。然而，如果你想使用多态关联(例如，一个对类继承树中超类的关联)，你需要使用<union-subclass>映射。
<union-subclass
name=”ClassName”                    (1)
table=”tablename”                   (2)
proxy=”ProxyInterface”              (3)
lazy=”true|false”                   (4)
dynamic-update=”true|false”
dynamic-insert=”true|false”
schema=”schema”
catalog=”catalog”
extends=”SuperclassName”
abstract=”true|false”
persister=”ClassName”
subselect=”SQL expression”
entity-name=”EntityName”
node=”element-name”>

<property …. />
…..
</union-subclass>
(1)name: 子类的全限定名。
(2)table: 子类的表名
(3)proxy (可选): 指定一个类或者接口，在延迟装载时作为代理使用。
(4)lazy (可选, 默认是 true): 设置为 lazy=”false” 禁止使用延迟装载。
这种映射策略不需要指定辨别标志(discriminator)字段。

多对一（many-to-one）
通过many-to-one元素,可以定义一种常见的与另一个持久化类的关联。这种关系模型是多对一关联（实际上是一个对象引用－译注）：这个表的一个外键引用目标表的主键字段。
<many-to-one
name=”propertyName”                                          (1)
column=”column_name”                                         (2)
class=”ClassName”                                            (3)
cascade=”cascade_style”                                      (4)
fetch=”join|select”                                          (5)
update=”true|false”                                          (6)
insert=”true|false”                                          (6)
property-ref=”propertyNameFromAssociatedClass”               (7)
access=”field|property|ClassName”                            (8)
unique=”true|false”                                          (9)
not-null=”true|false”                                        (10)
optimistic-lock=”true|false”                                 (11)
lazy=”true|proxy|false”                                      (12)
not-found=”ignore|exception”                                 (13)
entity-name=”EntityName”                                     (14)
node=”element-name|@attribute-name|element/@attribute|.”
embed-xml=”true|false”

/>
(1) name: 属性名。
(2) column (可选): 外间字段名。它也可以通过嵌套的 <column>元素指定。
(3) class (可选 – 默认是通过反射得到属性类型): 关联的类的名字。
(4) cascade（级联） (可选): 指明哪些操作会从父对象级联到关联的对象。
(5) fetch (可选 – 默认为 select): 在外连接抓取（outer-join fetching）和序列选择抓取（sequential select fetching）两者中选择其一。
(6) update, insert (可选 – defaults to true) 指定对应的字段是否包含在用于UPDATE 和/或 INSERT 的SQL语句中。如果二者都是false,则这是一个纯粹的 “外源性（derived）”关联，它的值是通过映射到同一个（或多个）字段的某些其他属性得到或者通过trigger(触发器）、或其他程序。
(7) property-ref: (可选) 指定关联类的一个属性，这个属性将会和本外键相对应。如果没有指定，会使用对方关联类的主键。
(8) access (可选 – 默认是 property): Hibernate用来访问属性的策略。
(9) unique (可选): 使用DDL为外键字段生成一个唯一约束。此外，这也可以用作property-ref的目标属性。这使关联同时具有一对一的效果。
(10)not-null (可选): 使用DDL为外键字段生成一个非空约束。
(11) optimistic-lock (可选 – 默认为 true): 指定这个属性在做更新时是否需要获得乐观锁定（optimistic lock）。换句话说，它决定这个属性发生脏数据时版本（version）的值是否增长。
(12) lazy (可选 – 默认为 proxy): 默认情况下，单点关联是经过代理的。lazy=”true”指定此属性应该在实例变量第一次被访问时应该延迟抓取（fetche lazily）（需要运行时字节码的增强）。 lazy=”false”指定此关联总是被预先抓取。
(13) not-found (可选 – 默认为 exception): 指定外键引用的数据不存在时如何处理： ignore会将数据不存在作为关联到一个空对象（null）处理。
(14) entity-name (optional): 被关联的类的实体名。

cascade属性设置为除了none以外任何有意义的值，它将把特定的操作传播到关联对象中。这个值就代表着Hibernate基本操作的名称， persist, merge, delete, save-update, evict, replicate, lock, refresh，以及特别的值delete-orphan和all，并且可以用逗号分隔符来合并这些操作，例如，cascade=”persist,merge,evict”或 cascade=”all,delete-orphan”。更全面的解释请参考第 11.11 节 “传播性持久化(transitive persistence)”.

一个典型的简单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”/>
当然，我们决不鼓励这种用法。
如果被引用的唯一主键由关联实体的多个属性组成，你应该在名称为<properties>的元素里面映射所有关联的属性。

一对一
持久化对象之间一对一的关联关系是通过one-to-one元素定义的。
<one-to-one
name=”propertyName”                                          (1)
class=”ClassName”                                            (2)
cascade=”cascade_style”                                      (3)
constrained=”true|false”                                     (4)
fetch=”join|select”                                          (5)
property-ref=”propertyNameFromAssociatedClass”               (6)
access=”field|property|ClassName”                            (7)
formula=”any SQL expression”                                 (8)
lazy=”true|proxy|false”                                      (9)
entity-name=”EntityName”                                     (10)
node=”element-name|@attribute-name|element/@attribute|.”
embed-xml=”true|false”
/>
(1) name: 属性的名字。
(2) class (可选 – 默认是通过反射得到的属性类型)：被关联的类的名字。
(3) cascade(级联) (可选) 表明操作是否从父对象级联到被关联的对象。
(4) constrained(约束) (可选) 表明该类对应的表对应的数据库表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。这个选项影响save()和delete()在级联执行时的先后顺序以及决定该关联能否被委托(也在schema export tool中被使用).
(5) fetch (可选 – 默认设置为选择): 在外连接抓取或者序列选择抓取选择其一.
(6) property-ref: (可选) 指定关联类的属性名，这个属性将会和本类的主键相对应。如果没有指定，会使用对方关联类的主键。
(7) access (可选 – 默认是 property): Hibernate用来访问属性的策略。
(8) formula (可选):绝大多数一对一的关联都指向其实体的主键。在一些少见的情况中，你可能会指向其他的一个或多个字段，或者是一个表达式，这些情况下，你可以用一个SQL公式来表示。（可以在org.hibernate.test.onetooneformula找到例子）
(9) lazy (可选 – 默认为 proxy): 默认情况下，单点关联是经过代理的。lazy=”true”指定此属性应该在实例变量第一次被访问时应该延迟抓取（fetche lazily）（需要运行时字节码的增强）。 lazy=”false”指定此关联总是被预先抓取。注意，如果constrained=”false”, 不可能使用代理，Hibernate会采取预先抓取！
(10) entity-name (可选): 被关联的类的实体名。

有两种不同的一对一关联：
* 主键关联
* 惟一外键关联
主键关联不需要额外的表字段；如果两行是通过这种一对一关系相关联的，那么这两行就共享同样的主关键字值。所以如果你希望两个对象通过主键一对一关联，你必须确认它们被赋予同样的标识值！
比如说，对下面的Employee和Person进行主键一对一关联:
<one-to-one name=”person” class=”Person”/>
<one-to-one name=”employee” class=”Employee” constrained=”true”/>
现在我们必须确保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”/>