hibernate学习总结

Published by admin on 05月 13, 2008

1. 直观的规则：所有的双向关联需要有一端被设置为inverse。在一对多关联中它必须是代表多（many）的那端。而在多对多（many-to-many）关联中，你可以任意选取一端，因为两端之间并没有差别。

2.hibernate配置文件
·配置方式: 1可编程的配置方式
2传一个java.util.Properties实例给 Configuration.setProperties().
3将hibernate.properties放置在类路径(classpath)的根目录下 (root directory).
4通过java -Dproperty=value来设置系统 (System)属性.
5在hibernate.cfg.xml中加入元素 <property>

·可编程的配置方式
Configuration cfg = new Configuration()
.addResource(”Item.hbm.xml”)
.addResource(”Bid.hbm.xml”);

Configuration cfg = new Configuration()
.addClass(org.hibernate.auction.Item.class)
.addClass(org.hibernate.auction.Bid.class);

Configuration cfg = new Configuration()
.addClass(org.hibernate.auction.Item.class)
.addClass(org.hibernate.auction.Bid.class)
.setProperty(”hibernate.dialect”, “org.hibernate.dialect.MySQLInnoDBDialect”)
.setProperty(”hibernate.connection.datasource”, “java:comp/env/jdbc/test”)
.setProperty(”hibernate.order_updates”, “true”);


·jdbc连接配置
SessionFactory来为你创建和缓存(pool)JDBC连接(连接池)
SessionFactory sessions = cfg.buildSessionFactory();
Session session = sessions.openSession();

Hibernate JDBC属性
属性名 用途
hibernate.connection.driver_class jdbc驱动类
hibernate.connection.url jdbc URL
hibernate.connection.username 数据库用户
hibernate.connection.password 数据库用户密码
hibernate.connection.pool_size 连接池容量上限数目
出于最佳性能和稳定性考虑你应该使用第三方的连接池。只需要用特定连接池的设置替换 hibernate.connection.pool_size即可。

这是一个使用C3P0的hibernate.properties样例文件
如果你设置了hibernate.c3p0.*相关的属性, Hibernate将使用 C3P0ConnectionProvider来缓存JDBC连接.
hibernate.connection.driver_class = org.postgresql.Driver
hibernate.connection.url = jdbc:postgresql://localhost/mydatabase
hibernate.connection.username = myuser
hibernate.connection.password = secret
hibernate.c3p0.min_size=5
hibernate.c3p0.max_size=20
hibernate.c3p0.timeout=1800
hibernate.c3p0.max_statements=50
hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect


·xml数据源配置
为了能在应用程序服务器(application server)中使用Hibernate, 应当总是将Hibernate 配置成从注册在JNDI中的Datasource处获得连接，你至少需要设置下列属性中的一个:

Hibernate数据源属性
属性名 用途
hibernate.connection.datasource 数据源JNDI名字
hibernate.jndi.url JNDI提供者的URL (可选)
hibernate.jndi.class JNDI InitialContextFactory类 (可选)
hibernate.connection.username 数据库用户 (可选)
hibernate.connection.password 数据库用户密码 (可选)

这是一个使用应用程序服务器提供的JNDI数据源的hibernate.properties样例文件:
hibernate.connection.datasource = java:/comp/env/jdbc/test
hibernate.transaction.factory_class = \
org.hibernate.transaction.JTATransactionFactory
hibernate.transaction.manager_lookup_class = \
org.hibernate.transaction.JBossTransactionManagerLookup
hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect

<!– 以/jndi/name绑定到JNDI的SessionFactory实例 –>
<?xml version=”1.0″ encoding=”utf-8″?>
<!DOCTYPE hibernate-configuration PUBLIC
“-//Hibernate/Hibernate Configuration DTD//EN”
“http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd”>

<hibernate-configuration>
<session-factory name=”java:hibernate/SessionFactory”>
<property name=”hibernate.connection.datasource”>
java:comp/env/jdbc/lgs
</property>

<property name=”hibernate.jdbc.batch_size”>16</property>
<property name=”hibernate.show_sql”>false</property>
<property name=”hibernate.dialect”>org.hibernate.dialect.Oracle9Dialect</property>
<property name=”hibernate.use_sql_comments”>true</property>
<property name=”hibernate.connection.charSet”>UTF-8</property>

<!– 事务设置 –>
<property name=”transaction.factory_class”>
org.hibernate.transaction.JTATransactionFactory
</property>
<property name=”jta.UserTransaction”>java:comp/UserTransaction</property>

<!– 缓存设置 –>
<class-cache class=”org.hibernate.auction.Item” usage=”read-write”/>
<class-cache class=”org.hibernate.auction.Bid” usage=”read-only”/>
<collection-cache collection=”org.hibernate.auction.Item.bids” usage=”read-write”/>

<!– 映射定义文件 –>
<mapping resource=”org/hibernate/auction/Item.hbm.xml”/>
<mapping resource=”org/hibernate/auction/Bid.hbm.xml”/>
</session-factory>
</hibernate-configuration>

xml普通配置
<?xml version=’1.0′ encoding=’utf-8′?>
<!DOCTYPE hibernate-configuration PUBLIC
“-//Hibernate/Hibernate Configuration DTD 3.0//EN”
“http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd”>

<hibernate-configuration>
<session-factory>
<!– Database connection settings –>
<property name=”connection.driver_class”>org.hsqldb.jdbcDriver</property>
<property name=”connection.url>sa</property>
<property name=”connection.passwor”>jdbc:hsqldb:hsql://localhost</property>
<property name=”connection.username”d”></property>

<!– JDBC connection pool (use the built-in) –>
<property name=”connection.pool_size”>1</property>

<!– SQL dialect –>
<property name=”dialect”>org.hibernate.dialect.HSQLDialect</property>

<!– Enable Hibernate’s automatic session context management –>
<property name=”current_session_context_class”>thread</property>

<!– Disable the second-level cache –>
<property name=”cache.provider_class”>org.hibernate.cache.NoCacheProvider</property>

<!– Echo all executed SQL to stdout –>
<property name=”show_sql”>true</property>

<!– Drop and re-create the database schema on startup –>
<property name=”hbm2ddl.auto”>create</property>

<mapping resource=”events/Event.hbm.xml”/>
</session-factory>
</hibernate-configuration>

·Hibernate配置属性
属性名 用途
hibernate.dialect 一个Hibernate Dialect类名允许Hibernate针对特定的关系数据库生成优化的SQL.
取值 full.classname.of.Dialect

hibernate.show_sql 输出所有SQL语句到控制台. 有一个另外的选择是把org.hibernate.SQL这个log category设为debug。
eg. true | false

hibernate.format_sql 在log和console中打印出更漂亮的SQL。
取值 true | false

hibernate.default_schema 在生成的SQL中, 将给定的schema/tablespace附加于非全限定名的表名上.
取值 SCHEMA_NAME

hibernate.default_catalog 在生成的SQL中, 将给定的catalog附加于非全限定名的表名上.
取值 CATALOG_NAME

hibernate.session_factory_name SessionFactory创建后，将自动使用这个名字绑定到JNDI中.
取值 jndi/composite/name

hibernate.max_fetch_depth 为单向关联(一对一, 多对一)的外连接抓取（outer join fetch）树设置最大深度. 值为0意味着将关 闭默认的外连接抓取.
取值 建议在0到3之间取值

hibernate.default_batch_fetch_size 为Hibernate关联的批量抓取设置默认数量.
取值 建议的取值为4, 8, 和16

hibernate.default_entity_mode 为由这个SessionFactory打开的所有Session指定默认的实体表现模式.
取值 dynamic-map, dom4j, pojo

hibernate.order_updates 强制Hibernate按照被更新数据的主键，为SQL更新排序。这么做将减少在高并发系统中事务的死锁。
取值 true | false

hibernate.generate_statistics 如果开启, Hibernate将收集有助于性能调节的统计数据.
取值 true | false

hibernate.use_identifer_rollback 如果开启, 在对象被删除时生成的标识属性将被重设为默认值.
取值 true | false

hibernate.use_sql_comments 如果开启, Hibernate将在SQL中生成有助于调试的注释信息, 默认值为false.
取值 true | false


·Hibernate JDBC和连接(connection)属性
属性名 用途
hibernate.jdbc.fetch_size 非零值，指定JDBC抓取数量的大小 (调用Statement.setFetchSize()).

hibernate.jdbc.batch_size 非零值，允许Hibernate使用JDBC2的批量更新.
取值 建议取5到30之间的值

hibernate.jdbc.batch_versioned_data 如果你想让你的JDBC驱动从executeBatch()返回正确的行计数 , 那么将此属性设为true(开启这个选 项通常是安全的). 同时，Hibernate将为自动版本化的数据使用批量DML. 默认值为false.
eg. true | false

hibernate.jdbc.factory_class 选择一个自定义的Batcher. 多数应用程序不需要这个配置属性.
eg. classname.of.Batcher

hibernate.jdbc.use_scrollable_resultset 允许Hibernate使用JDBC2的可滚动结果集. 只有在使用用户提供的JDBC连接时，这个选项才是必 要的, 否则Hibernate会使用连接的元数据.
取值 true | false

hibernate.jdbc.use_streams_for_binary 在JDBC读写binary (二进制)或serializable (可序列化) 的类型时使用流(stream)(系统级属性).
取值 true | false

hibernate.jdbc.use_get_generated_keys 在数据插入数据库之后，允许使用JDBC3 PreparedStatement.getGeneratedKeys() 来获取数据库生 成的key(键)。需要JDBC3+驱动和JRE1.4+, 如果你的数据库驱动在使用Hibernate的标 识生成器时遇 到问题，请将此值设为false. 默认情况下将使用连接的元数据来判定驱动的能力.
取值 true|false

hibernate.connection.provider_class 自定义ConnectionProvider的类名, 此类用来向Hibernate提供JDBC连接.
取值 classname.of.ConnectionProvider

hibernate.connection.isolation 设置JDBC事务隔离级别. 查看java.sql.Connection来了解各个值的具体意义, 但请注意多数数据库都 不支持所有的隔离级别.
取值 1, 2, 4, 8

hibernate.connection.autocommit 允许被缓存的JDBC连接开启自动提交(autocommit) (不建议).
取值 true | false

hibernate.connection.release_mode 指定Hibernate在何时释放JDBC连接. 默认情况下,直到Session被显式关闭或被断开连接时,才会释放 JDBC连接. 对于应用程序服务器的JTA数据源, 你应当使用after_statement, 这样在每次JDBC调用 后，都会主动的释放连接. 对于非JTA的连接, 使用after_transaction在每个事务结束时释放连接是 合理的. auto将为JTA和CMT事务策略选择after_statement, 为JDBC事务策略选择after_transaction.
取值 on_close | after_transaction | after_statement | auto

hibernate.connection.<propertyName> 将JDBC属性propertyName传递到DriverManager.getConnection()中去.

hibernate.jndi.<propertyName> 将属性propertyName传递到JNDI InitialContextFactory中去.


·Hibernate缓存属性
属性名 用途
hibernate.cache.provider_class 自定义的CacheProvider的类名.
取值 classname.of.CacheProvider

hibernate.cache.use_minimal_puts 以频繁的读操作为代价, 优化二级缓存来最小化写操作. 在Hibernate3中，这个设置对的集群缓存非 常有用, 对集群缓存的实现而言，默认是开启的.
取值 true|false

hibernate.cache.use_query_cache 允许查询缓存, 个别查询仍然需要被设置为可缓存的.
取值 true|false

hibernate.cache.use_second_level_cache 能用来完全禁止使用二级缓存. 对那些在类的映射定义中指定<cache>的类，会默认开启二级缓存.
取值 true|false

hibernate.cache.query_cache_factory 自定义实现QueryCache接口的类名, 默认为内建的StandardQueryCache.
取值 classname.of.QueryCache

hibernate.cache.region_prefix 二级缓存区域名的前缀.
取值 prefix

hibernate.cache.use_structured_entries 强制Hibernate以更人性化的格式将数据存入二级缓存.
取值 true|false


·Hibernate事务属性
属性名 用途
hibernate.transaction.factory_class 一个TransactionFactory的类名, 用于Hibernate Transaction API (默认为
JDBCTransactionFactory).
取值 classname.of.TransactionFactory

jta.UserTransaction 一个JNDI名字，被JTATransactionFactory用来从应用服务器获取JTA UserTransaction.
取值 jndi/composite/name

hibernate.transaction.manager_lookup_class 一个TransactionManagerLookup的类名 - 当使用JVM级缓存，或在JTA环境中使用hilo生成器 的时候需要该类.
取值 classname.of.TransactionManagerLookup

hibernate.transaction.flush_before_completion 如果开启, session在事务完成后将被自动清洗(flush)。 现在更好的方法是使用自动 session上下文管理。
取值 true | false

hibernate.transaction.auto_close_session 如果开启, session在事务完成后将被自动关闭。 现在更好的方法是使用自动session上下文管 理。
取值 true | false


·其他属性
属性名 用途
hibernate.current_session_context_class 为”当前” Session指定一个(自定义的)策略。关于内置策略的详情，请参见第 2.5 节 “上下文 相关的（Contextual）Session” 。
eg. jta | thread | custom.Class

hibernate.query.factory_class 选择HQL解析器的实现.
取值 org.hibernate.hql.ast.ASTQueryTranslatorFactory or
org.hibernate.hql.classic.ClassicQueryTranslatorFactory

hibernate.query.substitutions 将Hibernate查询中的符号映射到SQL查询中的符号 (符号可能是函数名或常量名字).
取值 hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC

hibernate.hbm2ddl.auto 在SessionFactory创建时，自动检查数据库结构，或者将数据库schema的DDL导出到数据库. 使用 create-drop时,在显式关闭SessionFactory时，将drop掉数据库schema.
取值 validate | update | create | create-drop

hibernate.cglib.use_reflection_optimizer 开启CGLIB来替代运行时反射机制(系统级属性). 反射机制有时在除错时比较有用. 注意即使关 闭这个优化, Hibernate还是需要CGLIB. 你不能在hibernate.cfg.xml中设置此属性.
取值 true | false



·Hibernate SQL方言 (hibernate.dialect)
RDBMS 方言
DB2 org.hibernate.dialect.DB2Dialect
DB2 AS/400 org.hibernate.dialect.DB2400Dialect
DB2 OS390 org.hibernate.dialect.DB2390Dialect
PostgreSQL org.hibernate.dialect.PostgreSQLDialect
MySQL org.hibernate.dialect.MySQLDialect
MySQL with InnoDB org.hibernate.dialect.MySQLInnoDBDialect
MySQL with MyISAM org.hibernate.dialect.MySQLMyISAMDialect
Oracle (any version) org.hibernate.dialect.OracleDialect
Oracle 9i/10g org.hibernate.dialect.Oracle9Dialect
Sybase org.hibernate.dialect.SybaseDialect
Sybase Anywhere org.hibernate.dialect.SybaseAnywhereDialect
Microsoft SQL Server org.hibernate.dialect.SQLServerDialect
SAP DB org.hibernate.dialect.SAPDBDialect
Informix org.hibernate.dialect.InformixDialect
HypersonicSQL org.hibernate.dialect.HSQLDialect
Ingres org.hibernate.dialect.IngresDialect
Progress org.hibernate.dialect.ProgressDialect
Mckoi SQL org.hibernate.dialect.MckoiDialect
Interbase org.hibernate.dialect.InterbaseDialect
Pointbase org.hibernate.dialect.PointbaseDialect
FrontBase org.hibernate.dialect.FrontbaseDialect
Firebird org.hibernate.dialect.FirebirdDialect


·日志
Hibernate使用Apache commons-logging来为各种事件记录日志.

Hibernate日志类别
类别 功能
org.hibernate.SQL 在所有SQL DML语句被执行时为它们记录日志
org.hibernate.type 为所有JDBC参数记录日志
org.hibernate.tool.hbm2ddl 在所有SQL DDL语句执行时为它们记录日志
org.hibernate.pretty 在session清洗(flush)时，为所有与其关联的实体(最多20个)的状态记录日志
org.hibernate.cache 为所有二级缓存的活动记录日志
org.hibernate.transaction 为事务相关的活动记录日志
org.hibernate.jdbc 为所有JDBC资源的获取记录日志
org.hibernate.hql.AST 在解析查询的时候,记录HQL和SQL的AST分析日志
org.hibernate.secure 为JAAS认证请求做日志
org.hibernate 为任何Hibernate相关信息做日志 (信息量较大, 但对查错非常有帮助)



·启动hibernate方式
SessionFactory sf = new Configuration().configure().buildSessionFactory();

SessionFactory sf = new Configuration()
.configure(”hibernate.cfg.xml”)
.buildSessionFactory();


·针对J2EE体系,Hibernate有如下几个集成的方面:
容器管理的数据源(Container-managed datasources):
自动JNDI绑定:
JTA Session绑定:
JMX部署:
如果应用程序服务器抛出”connection containment”异常, 根据你的环境，也许该将配置属性 hibernate.connection.release_mode设为 after_statement.

·事务策略配置
通过设置Hibernate配置属性hibernate.transaction.factory_class来指定 一个Transaction实例的工厂类.

有三个标准(内建)的选择:
org.hibernate.transaction.JDBCTransactionFactory 委托给数据库(JDBC)事务（默认）

org.hibernate.transaction.JTATransactionFactory 如果在上下文环境中存在运行着的事务(如, EJB会话Bean的方法), 则委托给容 器管 理的事务, 否则，将启动一个新的事务，并使用Bean管理的事务.

org.hibernate.transaction.CMTTransactionFactory 委托给容器管理的JTA事务

JTA TransactionManagers
Transaction工厂类 应用程序服务器
org.hibernate.transaction.JBossTransactionManagerLookup JBoss
org.hibernate.transaction.WeblogicTransactionManagerLookup Weblogic
org.hibernate.transaction.WebSphereTransactionManagerLookup WebSphere
org.hibernate.transaction.WebSphereExtendedJTATransactionLookup WebSphere 6
org.hibernate.transaction.OrionTransactionManagerLookup Orion
org.hibernate.transaction.ResinTransactionManagerLookup Resin
org.hibernate.transaction.JOTMTransactionManagerLookup JOTM
org.hibernate.transaction.JOnASTransactionManagerLookup JOnAS
org.hibernate.transaction.JRun4TransactionManagerLookup JRun4
org.hibernate.transaction.BESTransactionManagerLookup Borland ES


·JNDI绑定的SessionFactory



3.辅助类 HibernateUtil
public class HibernateUtil {

private static final SessionFactory sessionFactory;

static {
try {
// Create the SessionFactory from hibernate.cfg.xml
sessionFactory = new Configuration().configure().buildSessionFactory();
} catch (Throwable ex) {
// Make sure you log the exception, as it might be swallowed
System.err.println(”Initial SessionFactory creation failed.” + ex);
throw new ExceptionInInitializerError(ex);
}
}

public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}

4.加载存储
public class EventManager {

public static void main(String[] args) {
EventManager mgr = new EventManager();
if (args[0].equals(”store”)) {
mgr.createAndStoreEvent(”My Event”, new Date());}
HibernateUtil.getSessionFactory().close();//关闭session
}

private void createAndStoreEvent(String title, Date theDate) {

Session session = HibernateUtil.getSessionFactory().getCurrentSession();//打开session
session.beginTransaction();//事务开始
….
….
session.save(theEvent);//hql处理
session.getTransaction().commit();//事务提交
}
}

5.对象/关系数据库映射基础(Basic O/R Mapping)
有一些工具可以用来生成映射文档， 包括XDoclet,Middlegen和AndroMDA。
·Doctype

·hibernate-mapping
<hibernate-mapping
schema=”schemaName” (1)
catalog=”catalogName” (2)
default-cascade=”cascade_style” (3)
default-access=”field|property|ClassName” (4)
default-lazy=”true|false” (5)
auto-import=”true|false” (6)
package=”package.name” (7)
/>
(1) schema (可选): 数据库schema的名称。

(2) catalog (可选): 数据库catalog的名称。

(3) default-cascade (可选 - 默认为 none): 默认的级联风格。

(4) default-access (可选 - 默认为 property): Hibernate用来访问所有属性的策略。可以通过实现PropertyAccessor接口 自定义。

(5) default-lazy (可选 - 默认为 true): 指定了未明确注明lazy属性的Java属性和集合类， Hibernate会采取什么样的默认加载风格。

(6) auto-import (可选 - 默认为 true): 指定我们是否可以在查询语言中使用非全限定的类名（仅限于本映射文件中的类）。

(7) package (可选): 指定一个包前缀，如果在映射文档中没有指定全限定的类名， 就使用这个作为包名。

*假若你有两个持久化类，它们的非全限定名是一样的(就是两个类的名字一样，所在的包不一样–译者注),
你应该设置auto-import=”false”。如果你把一个“import过”的名字同时对应两个类， Hibernate会抛出一个异常。

*注意hibernate-mapping 元素允许你嵌套多个如上所示的 <class>映射。
但是最好的做法（也许一些工具需要的）是一个 持久化类（或一个类的继承层次）对应一个映射文件，并以持久化的超类名称命名.
例如： Cat.hbm.xml， Dog.hbm.xml，或者如果使用继承，Animal.hbm.xml。


·class
<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)
node=”element-name”
/>
(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): 决定乐观锁定的策略。

(16) lazy (可选): 通过设置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）中标识抽象超类。

*若指明的持久化类实际上是一个接口，这也是完全可以接受的。
之后你可以用元素<subclass>来指定该接口的实际实现类。 你可以持久化任何static（静态的）内部类。
你应该使用标准的类名格式来指定类名，比如：Foo$Bar。

*不可变类，mutable=”false”不可以被应用程序更新或者删除。 这可以让Hibernate做一些小小的性能优化。

*可选的proxy属性允许延迟加载类的持久化实例。 Hibernate开始会返回实现了这个命名接口的CGLIB代理。
当代理的某个方法被实际调用的时候， 真实的持久化对象才会被装载。参见下面的“用于延迟装载的代理”。

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

*persister属性可以让你定制这个类使用的持久化策略。
你可以指定你自己实现 org.hibernate.persister.EntityPersister的子类，你甚至可以完全从头开始编写一个 org.hibernate.persister.ClassPersister接口的实现，
比如是用储存过程调用、序列化到文件或者LDAP数据库来实现。
参阅org.hibernate.test.CustomPersister，这是一个简单的例子 （“持久化”到一个Hashtable）。

*请注意dynamic-update和dynamic-insert的设置并不会继承到子类，
所以在<subclass>或者<joined-subclass>元素中可能 需要再次设置。
这些设置是否能够提高效率要视情形而定。请用你的智慧决定是否使用。

*使用select-before-update通常会降低性能。如果你重新连接一个脱管（detache）对象实例 到一个Session中时，
它可以防止数据库不必要的触发update。 这就很有用了。

*如果你打开了dynamic-update，你可以选择几种乐观锁定的策略：
version（版本检查） 检查version/timestamp字段
all（全部） 检查全部字段
dirty（脏检查）只检察修改过的字段
none（不检查）不使用乐观锁定

*我们非常强烈建议你在Hibernate中使用version/timestamp字段来进行乐观锁定。
对性能来说，这是最好的选择，并且这也是唯一能够处理在session外进行操作的策略（例如： 在使用Session.merge()的时候）。

·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 属性在Hibernate3中几乎不再需要。
还有一个另外的<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>
*所有的生成器都实现org.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>联合起来使用。


·composite-id
<composite-id
name=”propertyName”
class=”ClassName”
mapped=”true|false”
access=”field|property|ClassName”
node=”element-name|.”
>

<key-property name=”propertyName” type=”typename” column=”column_name”/>
<key-many-to-one name=”propertyName class=”ClassName” column=”column_name”/>
……
</composite-id>

*如果表使用联合主键，你可以映射类的多个属性为标识符属性。
<composite-id>元素接受<key-property> 属性映射和<key-many-to-one>属性映射作为子元素。
有3种方式：
embedded（嵌入式）组合标识符。
mapped(映射式) 组合标识符
identifier component(标识符组件)是我们对几乎所有应用都推荐使用的方式。

*下面的属性仅对第三种方法有效：
name (可选,但对这种方法而言必须): 包含此组件标识符的组件类型的名字
access (可选 - 默认为property): Hibernate应该使用的访问此属性值的策略
class (可选 - 默认会用反射来自动判定属性类型 ): 用来作为组合标识符的组件类的类名