From 9b5c1fc8c5196caa1b3214e9b0dff0620933972f Mon Sep 17 00:00:00 2001 From: Xiaogang Cao Date: Thu, 2 Feb 2006 09:08:49 +0000 Subject: [PATCH] reviewed chapters git-svn-id: https://svn.jboss.org/repos/hibernate/trunk/Hibernate3/doc@9197 1b8cb986-b30d-0410-93ca-fae66ebed9b2 --- reference/zh-cn/modules/component_mapping.xml | 288 +++++++++--------- reference/zh-cn/modules/configuration.xml | 65 ++-- .../zh-cn/modules/inheritance_mapping.xml | 11 +- .../zh-cn/modules/persistent_classes.xml | 73 +++-- reference/zh-cn/modules/session_api.xml | 36 +-- reference/zh-cn/modules/xml.xml | 10 +- 6 files changed, 236 insertions(+), 247 deletions(-) diff --git a/reference/zh-cn/modules/component_mapping.xml b/reference/zh-cn/modules/component_mapping.xml index 57eb4e06b4..756e421bf5 100644 --- a/reference/zh-cn/modules/component_mapping.xml +++ b/reference/zh-cn/modules/component_mapping.xml @@ -1,18 +1,18 @@  - 组件（Component）映射 + 组件（Component）映射 + + + 组件(Component)这个概念在Hibernate中几处不同的地方为了不同的目的被重复使用. + + + + 依赖对象（Dependent objects） - Component这个概念在Hibernate中几处不同的地方为了不同的目的被重复使用. + 组件(Component)是一个被包含的对象，在持久化的过程中，它被当作值类型，而并非一个实体的引用。在这篇文档中，组件这一术语指的是面向对象的合成概念（而并不是系统构架层次上的组件的概念）。举个例子, 你对人(Person)这个概念可以像下面这样来建模： - - 依赖对象（Dependent objects） - - - Component是一个被包含的对象,它作为值类型被持久化，而非一个被引用的实体。“component(组件)”这一术语指的是面向对象的合成概念（而并不是系统构架层次上的组件的概念）举个例子, 你可以对人（Person)如以下这样来建模： - - - - - 现在,姓名(Name)是作为人(Person)的一个组成部分。需要注意的是:需要对姓名 - 的持久化属性定义getter和setter方法,但是不需要实现任何的接口或申明标识符字段。 + 在持久化的过程中,姓名(Name)可以作为人(Person)的一个组件。需要注意的是:你应该为姓名的持久化属性定义getter和setter方法,但是你不需要实现任何的接口或申明标识符字段。 - 以下是这个例子的Hibernate映射文件: + 以下是这个例子的Hibernate映射文件: @@ -83,80 +82,82 @@ ]]> - - 人员(Person)表中将包括pid, - birthday, - initial, - first和 - last等字段。 - + + 人员(Person)表中将包括pid, + birthday, + initial, + first和 + last等字段。 - - 就像所有的值类型一样, Component不支持共享引用。 - 换句话说，两个人可能重名，但是两个person对象应该包含两个独立的name对象，只不过是具有“同样”的值。 - Component的值为空从语义学上来讲是专有的(ad hoc)。 每当 - 重新加载一个包含组件的对象,如果component的所有字段为空，那么将Hibernate将假定整个component为 - 空。对于绝大多数目的,这样假定是没有问题的。 - + + 就像所有的值类型一样, 组件不支持共享引用。 + 换句话说，两个人可能重名，但是两个Person对象应该包含两个独立的Name对象，只不过这两个Name对象具有“同样”的值。 + 组件的值可以为空，其定义如下。 + 每当Hibernate重新加载一个包含组件的对象,如果该组件的所有字段为空，Hibernate将假定整个组件为空。 + 在大多数情况下,这样假定应该是没有问题的。 + - - Component的属性可以是Hibernate类型（包括Collections, many-to-one 关联， 以及其它Component - 等等）。嵌套Component不应该作为特殊的应用被考虑(Nested components should not be considered - an exotic usage)。 Hibernate趋向于支持设计细致(fine-grained)的对象模型。 - + + 组件的属性可以是任意一种Hibernate类型（包括集合, 多对多关联， + 以及其它组件等等）。嵌套组件不应该被当作一种特殊的应用(Nested components should not be considered an + exotic usage)。 Hibernate倾向于支持细致的(fine-grained)对象模型。 + + + + <component> 元素还允许有 <parent>子元素，用来表明component类中的一个属性是指向包含它的实体的引用。 + - - <component> 元素还允许有 <parent>子元素 ，用来表明component类中的一个属性返回包含它的实体的引用。 - - - + - - > + + - + ]]> - + - - 在集合中出现的依赖对象 + + 在集合中出现的依赖对象 (Collections of dependent objects) - - Hibernate支持component的集合(例如: 一个元素是“姓名”这种类型的数组)。 你可以使用<composite-element>标签替代<element>标签来定义你的component集合。 - + + Hibernate支持组件的集合(例如: 一个元素是姓名(Name)这种类型的数组)。 + 你可以使用<composite-element>标签替代<element>标签来定义你的组件集合。 + - - + + - + ; ]]> - - 注意，如果你决定定义一个元素是联合元素的Set，正确地实现equals()和hashCode()是非常重要的。 - + + 注意，如果你定义的Set包含组合元素(composite-element)，正确地实现equals()和hashCode()是非常重要的。 + - - 组合元素可以包含component但是不能包含集合。如果你的组合元素自身包含component, 必须使用<nested-composite-element>标签。这是一个相当特殊的案例 - 组合元素的集合自身可以包含component。 这个时候你就应该考虑一下使用one-to-many关联是否会更恰当。 尝试对这个组合元素重新建模为一个实体－但是需要注意的是，虽然Java模型和重新建模前 是一样的，关系模型和持久性语义上仍然存在轻微的区别。 - + + 组合元素可以包含组件，但是不能包含集合。如果你的组合元素自身包含组件, 你必须使用<nested-composite-element>标签。这是一个相当特殊的案例 - 在一个组件的集合里，那些组件本身又可以包含其他的组件。这个时候你就应该考虑一下使用one-to-many关联是否会更恰当。 + 尝试对这个组合元素重新建模为一个实体－但是需要注意的是，虽然Java模型和重新建模前是一样的，关系模型和持久性语义会有细微的变化。 + - - 请注意如果你使用<set>标签,一个组合元素的映射不支持可能为空的属性. 当删除对象时, Hibernate必须使用每一个字段的来确定一条记录(在组合元素表中，没有单个的关键字段), 如果有为null的字段，这样做就不可能了。你必须作出一个选择，要么在组合元素中使用不能为空的属性， 要么选择使用<list>, <map>,<bag> 或者 <idbag>而不是 <set>。 - + + 请注意如果你使用<set>标签,一个组合元素的映射不支持可能为空的属性. 当删除对象时， Hibernate必须使用每一个字段的值来确定一条记录(在组合元素表中，没有单独的关键字段)， + 如果有为null的字段，这样做就不可能了。你必须作出一个选择，要么在组合元素中使用不能为空的属性，要么选择使用<list>,<map>,<bag> 或者 <idbag>而不是 <set>。 + - - 组合元素有个特别的案例，是组合元素可以包含一个<many-to-one> 元素。类似这样的映射允许你映射一个many-to-mang关联表作为组合元素额外的字段。(A mapping like this allows you to map extra columns of a many-to-many association table to the composite element class.) 接下来的的例子是从Order到Item的一个多对多的关联关系,而 purchaseDate, price 和 quantity 是Item的关联属性。 - + + 组合元素有个特别的用法是它可以包含一个<many-to-one>元素。类似这样的映射允许你将一个many-to-many关联表映射为组合元素的集合。(A mapping like this allows you to map extra columns of a many-to-many association table to the composite element class.) 接下来的的例子是从Order到Item的一个多对多的关联关系, 关联属性是 purchaseDate, price 和 quantity 。 + - + .... @@ -168,14 +169,13 @@ ]]> - - 当然，在另一方面，无法存在指向purchase的关联，因此不能实现双向关联查询。记住组建是值类型，并且不允许共享关联。单个Purchase 可以放在包含Order的集合中，但它不能同时被Item所关联。 - + + 当然，当你定义Item时，你无法引用这些purchase，因此你无法实现双向关联查询。记住组件是值类型，并且不允许共享引用。某一个特定的Purchase 可以放在Order的集合中，但它不能同时被Item所引用。 + + 其实组合元素的这个用法可以扩展到三重或多重关联: - 即使三重或多重管理都是可能的: - - + .... @@ -186,52 +186,51 @@ ]]> + + 在查询中，表达组合元素的语法和关联到其他实体的语法是一样的。 + + + + + + 组件作为Map的索引（Components as Map indices ） + + + <composite-map-key>元素允许你映射一个组件类作为一个Map的key，前提是你必须正确的在这个类中重写了hashCode() 和 equals()方法。 + + + + + 组件作为联合标识符(Components as composite identifiers) + + + 你可以使用一个组件作为一个实体类的标识符。 你的组件类必须满足以下要求： + + + + - 在查询中，组合元素使用的语法是和关联到其他实体的语法一样的。 + 它必须实现java.io.Serializable接口 - - - - - 组件作为Map的索引（Components as Map indices ） - + + - <composite-map-key>元素允许你映射一个Component类作为Map的key， 但是你必须确定你正确的在这个类中重写了hashCode() 和 equals()方法。 + 它必须重新实现equals()和hashCode()方法, 始终和组合关键字在数据库中的概念保持一致 - + + - - 组件作为联合标识符(Components as composite identifiers) + + 注意：在Hibernate3中，第二个要求并非是Hibernate强制必须的。但最好这样做。 + - - 你可以使用一个component作为一个实体类的标识符。 你的component类必须满足以下要求： - + + 你不能使用一个IdentifierGenerator产生组合关键字。一个应用程序必须分配它自己的标识符。 + - - - - 它必须实现java.io.Serializable接口 - - - - - 它必须重新实现equals()和hashCode()方法, 始终和组合关键字在数据库中的概念保持一致 - - - - - - 注意：在Hibernate3中，第二种要求并非是Hibernate强制必须的。但最好这样做。 - - - - 你不能使用一个IdentifierGenerator产生组合关键字。作为替代应用程序必须分配它自己的标识符。 - - - -使用<composite-id> 标签(并且内嵌<key-property>元素)代替通常的<id>标签。 比如,OrderLine类具有一个依赖Order的(联合)主键的主键。 - - + + 使用<composite-id> 标签(并且内嵌<key-property>元素)代替通常的<id>标签。比如,OrderLine类具有一个主键，这个主键依赖于Order的(联合)主键。 + @@ -252,10 +251,9 @@ ]]> - - - 现在，任何关联到OrderLine 的外键都是复合的。在你的映射文件中，必须为其他类也这样声明。指向OrderLine的关联可能被这样映射： - + + 现在，任何指向OrderLine的外键都是复合的。在你的映射文件中，必须为其他类也这样声明。例如，一个指向OrderLine的关联可能被这样映射： + @@ -264,16 +262,14 @@ ]]> - - - （注意在各个地方<column>标签都是column属性的替代写法。） - - - - 指向OrderLine的多对多关联也使用联合外键: - - - + + （注意在各个地方<column>标签都是column属性的替代写法。） + + + + 指向OrderLine的多对多关联也使用联合外键: + + @@ -283,9 +279,9 @@ ]]> - - 在Order中, OrderLine的集合则是这样: - + + 在Order中,OrderLine的集合则是这样: + @@ -295,13 +291,13 @@ ]]> - - (与通常一样,<one-to-many>元素不声明任何列.) - - - - 假若OrderLine本身拥有一个集合,它也具有组合外键。 - + + (与通常一样,<one-to-many>元素不声明任何列.) + + + + 假若OrderLine本身拥有一个集合,它也具有组合外键。 + .... @@ -319,13 +315,14 @@ ]]> - + - - 动态组件 （Dynamic components） - - 你甚至可以映射Map类型的属性： - + + 动态组件 （Dynamic components） + + + 你甚至可以映射Map类型的属性： + @@ -333,11 +330,10 @@ ]]> - - 从<dynamic-component>映射的语义上来讲，它和<component>是相同的。 - 这种映射类型的优点在于通过修改映射文件，就可以具有在部署时检测真实属性的能力.利用一个DOM解析器，是有可能在运行时刻操作映射文件的。 - 更好的是，你可以通过Configuration对象来访问（或者修改）Hibernate的运行时元模型。 - - - - + + 从<dynamic-component>映射的语义上来讲，它和<component>是相同的。 + 这种映射类型的优点在于通过修改映射文件，就可以具有在部署时检测真实属性的能力。利用一个DOM解析器，也可以在程序运行时操作映射文件。 + 更好的是，你可以通过Configuration对象来访问（或者修改）Hibernate的运行时元模型。 + + + \ No newline at end of file diff --git a/reference/zh-cn/modules/configuration.xml b/reference/zh-cn/modules/configuration.xml index d7023d2cd6..b4cfe97051 100644 --- a/reference/zh-cn/modules/configuration.xml +++ b/reference/zh-cn/modules/configuration.xml @@ -8,7 +8,7 @@ 由于Hibernate是为了能在各种不同环境下工作而设计的, 因此存在着大量的配置参数. 幸运的是多数配置参数都 有比较直观的默认值, 并有随Hibernate一同分发的配置样例hibernate.properties (位于etc/)来展示各种配置选项. 所需做的仅仅是将这个样例文件复制到类路径 - (classpath)下做一些自定义的修改. + (classpath)下并做一些自定义的修改. @@ -90,11 +90,11 @@ - 如果想尽快体验Hbernate, hibernate.properties是最简单的方式. + 如果想尽快体验Hibernate, hibernate.properties是最简单的方式. - Configuration实例是一个启动期间（startup-time）的对象, + Configuration实例被设计成启动期间（startup-time）对象, 一旦SessionFactory创建完成它就被丢弃了. @@ -211,9 +211,9 @@ 但Hibernate自带的连接池算法相当不成熟. - 它只是为了让你快些上手，不适合用于产品系统或性能测试中。 - 出于最佳性能和稳定性考虑你应该使用第三方的连接池。只需要连接池的特定设置替换 - hibernate.connection.pool_size。这将关闭Hibernate自带的连接池. + 它只是为了让你快些上手，并不适合用于产品系统或性能测试中。 + 出于最佳性能和稳定性考虑你应该使用第三方的连接池。只需要用特定连接池的设置替换 + hibernate.connection.pool_size即可。这将关闭Hibernate自带的连接池. 例如, 你可能会想用C3P0. @@ -239,8 +239,8 @@ hibernate.c3p0.max_statements=50 hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> - 为了能在应用程序服务器(application server)中使用Hibernate, 你应当总是将Hibernate - 配置成注册在JNDI中的Datasource处获得连接，你至少需要设置下列属性中的一个: + 为了能在应用程序服务器(application server)中使用Hibernate, 应当总是将Hibernate + 配置成从注册在JNDI中的Datasource处获得连接，你至少需要设置下列属性中的一个: @@ -306,7 +306,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>
- 这里有一个使用应用程序服务器JNDI数据源的hibernate.properties样例文件: + 这是一个使用应用程序服务器提供的JNDI数据源的hibernate.properties样例文件: - 从JNDI数据源获得的JDBC连接将自动参与应用程序服务器中容器管理的事务(container-managed transactions)中去. + 从JNDI数据源获得的JDBC连接将自动参与到应用程序服务器中容器管理的事务(container-managed transactions)中去. - 任何连接(connection)配置属性的属性名要以"hibernate.connnection"前缀开头. - 例如, 你可能会使用hibernate.connection.charSet来指定charSet. + 任何连接(connection)属性的属性名都要以"hibernate.connnection"开头. + 例如, 你可能会使用hibernate.connection.charSet来指定字符集charSet. @@ -344,7 +344,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> 警告: 其中一些属性是"系统级(system-level)的". - 系统级属性可以通过java -Dproperty=value或 + 系统级属性只能通过java -Dproperty=value或 hibernate.properties来设置, 而不能用上面描述的其他方法来设置. @@ -375,7 +375,8 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> 取值 full.classname.of.Dialect - + + @@ -420,7 +421,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> hibernate.default_catalog - 在生成的SQL中, 将给定的catalog附加于没全限定名的表名上. + 在生成的SQL中, 将给定的catalog附加于非全限定名的表名上. 取值 CATALOG_NAME @@ -781,7 +782,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> hibernate.cache.query_cache_factory - 自定义的实现QueryCache接口的类名, + 自定义实现QueryCache接口的类名, 默认为内建的StandardQueryCache. 取值 @@ -925,8 +926,8 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> hibernate.current_session_context_class - 为界定"当前" - Session指定一个策略。关于内置策略的详情，请参见 。 + 为"当前" + Session指定一个(自定义的)策略。关于内置策略的详情，请参见 。 eg. jta | thread | @@ -965,7 +966,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> hibernate.hbm2ddl.auto - 在SessionFactory创建时，自动检查数据库机构，或者将数据库schema的DDL导出到数据库. 使用 + 在SessionFactory创建时，自动检查数据库结构，或者将数据库schema的DDL导出到数据库. 使用 create-drop时,在显式关闭SessionFactory时，将drop掉数据库schema. 取值 @@ -997,7 +998,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> - 你应当总是为你的数据库属性hibernate.dialect设置正确的 + 你应当总是为你的数据库将hibernate.dialect属性设置成正确的 org.hibernate.dialect.Dialect子类. 如果你指定一种方言, Hibernate将为上面列出的一些属性使用合理的默认值, 为你省去了手工指定它们的功夫. @@ -1096,8 +1097,8 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> - 如果你的数据库支持ANSI, Oracle或Sybase风格的外连接, 外连接抓取常能通过限制往返数据库次数 - (更多的工作交由数据库自己来完成)来提高效率. 外连接允许在单个SELECTSQL语句中， + 如果你的数据库支持ANSI, Oracle或Sybase风格的外连接, 外连接抓取通常能通过限制往返数据库次数 + (更多的工作交由数据库自己来完成)来提高效率. 外连接抓取允许在单个SELECTSQL语句中， 通过many-to-one, one-to-many, many-to-many和one-to-one关联获取连接对象的整个对象图. @@ -1283,7 +1284,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> 在使用Hibernate开发应用程序时, 你应当总是为org.hibernate.SQL - 开启debug级别的日志记录,或者开启hibernate.show_sql属性来代替它。. + 开启debug级别的日志记录,或者开启hibernate.show_sql属性。 @@ -1328,7 +1329,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> 另一个配置方法是在hibernate.cfg.xml文件中指定一套完整的配置. - 这个文件可以当成hibernate.properties的替代。 若两个文件同时存在，它将重载前者的属性. + 这个文件可以当成hibernate.properties的替代。 若两个文件同时存在，它将覆盖前者的属性. @@ -1406,7 +1407,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> 容器管理的数据源(Container-managed datasources): - Hibernate能通过容器管理由JNDI提供的JDBC连接. 通常, 特别是当处理多个数据源的分布式事务的时候, + Hibernate能使用通过容器管理，并由JNDI提供的JDBC连接. 通常, 特别是当处理多个数据源的分布式事务的时候, 由一个JTA兼容的TransactionManager和一个 ResourceManager来处理事务管理(CMT, 容器管理的事务). 当然你可以通过 编程方式来划分事务边界(BMT, Bean管理的事务). 或者为了代码的可移植性，你也也许会想使用可选的 @@ -1430,7 +1431,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> JTA Session绑定: Hibernate Session 可以自动绑定到JTA事务作用的范围. 只需简单地从JNDI查找SessionFactory并获得当前的 Session. 当JTA事务完成时, 让Hibernate来处理 - Session的清洗(flush)与关闭. 在EJB的部署描述符中事务边界是声明式的(CMT),或者自行编程(BMT/UserTransaction). + Session的清洗(flush)与关闭. 事务的划分可以是声明式的(CMT),也可以是编程式的(BMT/UserTransaction). @@ -1440,7 +1441,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> JMX部署: 如果你使用支持JMX应用程序服务器(如, JBoss AS), 那么你可以选择将Hibernate部署成托管MBean. 这将为你省去一行从Configuration构建SessionFactory的启动代码. - 容器将启动你的HibernateService, 并完美地处理好服务间的依赖关系 (在Hibernate启动前，数据源必须是可用的等等). + 容器将启动你的HibernateService, 并完美地处理好服务间的依赖关系 (在Hibernate启动前，数据源必须是可用的，等等). @@ -1466,7 +1467,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> - 存在着三个标准(内建)的选择: + 有三个标准(内建)的选择: @@ -1610,7 +1611,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> 在JTA环境下使用Current Session context (当前session上下文)管理 - 在Hibernate中，管理Session和transaction最好的方法是自动的"当前"Session管理。请参见current sessions一节的讨论。使用"jta"session上下文，假若在当前JTA事务中还没有HibernateSession关联，第一次sessionFactory.getCurrentSession()调用会启动一个Session,并关联到当前的JTA事务。在"jta"上下文中用getCurrentSession()获得的Session，会被设置为在transaction关闭的时候自动flush（清洗）、在transaction关闭之后自动关闭，每句与句之后主动释放JDBC连接。这就可以根据JTA事务的生命周期来管理与之关联的Session，用户代码中就可以不再考虑这些管理。你的代码可以通过UserTransaction用编程方式使用JTA，或者(我们建议，为了便于移植代码）使用Hibernate的Transaction API来设置transaction边界。如果你的代码运行于EJB容器中，建议对CMT使用声明式事务声明。 + 在Hibernate中，管理Session和transaction最好的方法是自动的"当前"Session管理。请参见contextual sessions一节的讨论。使用"jta"session上下文，假若在当前JTA事务中还没有HibernateSession关联，第一次sessionFactory.getCurrentSession()调用会启动一个Session,并关联到当前的JTA事务。在"jta"上下文中调用getCurrentSession()获得的Session，会被设置为在transaction关闭的时候自动flush（清洗）、在transaction关闭之后自动关闭，每句语句之后主动释放JDBC连接。这就可以根据JTA事务的生命周期来管理与之关联的Session，用户代码中就可以不再考虑这些管理。你的代码也可以通过UserTransaction用编程方式使用JTA，或者(我们建议，为了便于移植代码）使用Hibernate的Transaction API来设置transaction边界。如果你的代码运行在EJB容器中，建议对CMT使用声明式事务声明。 @@ -1620,7 +1621,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> - 为了将SessionFactory注册到JNDI中cfg.buildSessionFactory()这行代码仍需在某处被执行. + 为了将SessionFactory注册到JNDI中，cfg.buildSessionFactory()这行代码仍需在某处被执行. 你可在一个static初始化块(像HibernateUtil中的那样)中执行它或将Hibernate部署为一个托管的服务. @@ -1675,9 +1676,9 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]> 这个文件是部署在META-INF目录下的, 并会被打包到以.sar (service archive)为扩展名的JAR文件中. - 同时，你需要打包Hibernate, 它所需要的第三方库, 你编译好的持久化类及你的映射定义文件打包进同一个文档. + 同时，你需要将Hibernate、它所需要的第三方库、你编译好的持久化类以及你的映射定义文件打包进同一个文档. 你的企业Bean(一般为会话Bean)可能会被打包成它们自己的JAR文件, 但你也许会将EJB JAR文件一同包含进能独立(热)部署的主服务文档. - 咨询JBoss AS文档以了解更多的JMX服务与EJB部署的信息. + 参考JBoss AS文档以了解更多的JMX服务与EJB部署的信息. diff --git a/reference/zh-cn/modules/inheritance_mapping.xml b/reference/zh-cn/modules/inheritance_mapping.xml index 8a74f700a8..a4e4240742 100644 --- a/reference/zh-cn/modules/inheritance_mapping.xml +++ b/reference/zh-cn/modules/inheritance_mapping.xml @@ -51,9 +51,8 @@ - 在不同的映射文件中定义 subclass, union-subclass, - 和 joined-subclass是被允许的，只需直接定义在hibernate-mapping之下 。也就是说，你可以仅加入一个新的映射文件就扩展类层次。你必须在subclass的映射中指明extends属性，给出一个之前定义的超类的名字。注意，以前，这一功能对映射文件的顺序有严格的要求。自从Hibernate 3开始，当使用extends关键字的时候，映射文件的顺序不再有影响。但在每个映射文件本身之中，顺序还是必须超类在前，子类在后。 - + 在多个映射文件中，可以直接在hibernate-mapping根下定义subclass，union-subclass和joined-subclass。也就是说，你可以仅加入一个新的映射文件来扩展类层次。你必须在subclass的映射中指明extends属性，给出一个之前定义的超类的名字。注意，在以前，这一功能对映射文件的顺序有严格的要求，从Hibernate 3开始，使用extends关键字的时侯，对映射文件的顺序不再有要求；但在每个映射文件里，超类必须在子类之前定义。 + @@ -142,7 +141,7 @@ 注意，对“每个子类一张表”的映射策略，Hibernate的实现不需要辨别字段，而其他 的对象/关系映射工具使用了一种不同于Hibernate的实现方法，该方法要求在超类 表中有一个类型辨别字段(type discriminator column)。Hibernate采用的方法更 - 难实现，但从关系（数据库）这点上来看，按理说它更正确。若你愿意使用带有辨别字 + 难实现，但从关系（数据库）的角度来看，按理说它更正确。若你愿意使用带有辨别字 段的“每个子类一张表”的策略，你可以结合使用<subclass> 与<join>，如下所示： @@ -408,7 +407,7 @@ 多态 load()/get() 多态查询 多态连接(join) - 外连接(Outer join)抓取 + 外连接(Outer join)读取 @@ -465,4 +464,4 @@ - \ No newline at end of file + diff --git a/reference/zh-cn/modules/persistent_classes.xml b/reference/zh-cn/modules/persistent_classes.xml index 2338bdabcc..bbf4e0b2fe 100644 --- a/reference/zh-cn/modules/persistent_classes.xml +++ b/reference/zh-cn/modules/persistent_classes.xml @@ -10,8 +10,8 @@ - 如果这些持久化类遵循一些简单的规则，Hibernate能够工作得最好，这些规则被称作， - 简单传统Java对象(POJO:Plain Old Java Object)编程模型。但是这些规则没有一个是必需的。 + 如果这些持久化类遵循一些简单的规则，Hibernate能够工作得更好，这些规则也被称作 + 简单传统Java对象(POJO:Plain Old Java Object)编程模型。但是这些规则并不是必需的。 实际上，Hibernate3对于你的持久化类几乎不做任何设想。你可以用其他的方法来表达领域模型： 比如，使用Map实例的树型结构。 @@ -115,7 +115,7 @@ public class Cat { Cat有一个无参数的构造方法。所有的持久化类都必须有一个 默认的构造方法（可以不是public的），这样的话Hibernate就可以使用 Constructor.newInstance()来实例化它们。 - 我们建议，在Hibernate中，为了运行期代理的生成，构造方法至少是 + 我们强烈建议，在Hibernate中，为了运行期代理的生成，构造方法至少是 包(package)内可见的。 @@ -128,14 +128,14 @@ public class Cat { Cat有一个属性叫做id。这个属性映射数据库表的主 键字段。这个属性可以叫任何名字，其类型可以是任何的原始类型、原始类型的包装类型、 java.lang.String 或者是 java.util.Date。 - （如果你的老式数据库表有联合主键，你甚至可以用一个用户自定义的类，该类拥有这些类型 + （如果你的遗留数据库表有联合主键，你甚至可以用一个用户自定义的类，该类拥有这些类型 的属性。参见后面的关于联合标识符的章节。） 标识符属性是可选的。可以不用管它，让Hibernate内部来追踪对象的识别。 - 不推荐使用这个属性。 + 但是我们并不推荐这样做。 @@ -146,7 +146,7 @@ public class Cat { - 托管对象的传播性重新（和session）关联（级联更新或级联合并） + 托管对象的传播性再连接（级联更新或级联合并） ——参阅 @@ -165,8 +165,8 @@ public class Cat { - 我们建议你对持久化类声明命名一致的标识属性。我们还建议你使用一 - 个可以为空（也就是说，不是原始类型）的类型。 + 我们建议你对持久化类声明命名一致的标识属性。我们还建议你使用一 + 个可以为空（也就是说，不是原始类型）的类型。 @@ -185,28 +185,28 @@ public class Cat { - - 你也应该避免在非final类中声明 public final的方法。如果你想使用一 - 个有public final方法的类，你必须通过设置lazy="false" - 来明确的禁用代理。 - + + 你也应该避免在非final类中声明 public final的方法。如果你想使用一 + 个有public final方法的类，你必须通过设置lazy="false" + 来明确地禁用代理。 + - 为持久化字段声明访问器(accessors)和是否可变的标志(mutators)(可选) + 为持久化字段声明访问器(accessors)和是否可变的标志(mutators)(可选) Cat为它的所有持久化字段声明了访问方法。很多其他ORM工具直接对 - 实例变量进行持久化。我们相信,在关系数据库schema和类的内部数据之间引入间接层(原文为"非直接"，indirection)会好一些。默认情况下Hibernate持久化JavaBeans风格的属性，认可如下形式的方法名： - getFoo, isFoo 和 setFoo。 - 如果需要，你总是可以切换特定的属性的指示字段的访问方法。 + 实例变量进行持久化。我们相信，在关系数据库schema和类的内部数据结构之间引入间接层(原文为"非直接"，indirection)会好一些。默认情况下Hibernate持久化JavaBeans风格的属性，认可 + getFoo，isFoo 和 setFoo这种形式的方法名。 + 如果需要，你可以对某些特定属性实行直接字段访问。 - 属性不需要要声明为public的。Hibernate默认使用 - protected或private的get/set方法对， - 对属性进行持久化。 + 属性不需要要声明为public的。Hibernate可以持久化一个有 + default、protected或private的get/set方法对 + 的属性进行持久化。 @@ -254,8 +254,8 @@ public class DomesticCat extends Cat { - Hibernate保证，持久化标识（数据库的行）和仅在特定会话范围内的Java标识是等值的。因此，一旦 - 我们混合了从不同会话中获取的实例，如果我们希望Set有明确的语义，我们必 + Hibernate保证，仅在特定会话范围内，持久化标识（数据库的行）和Java标识是等价的。因此，一旦 + 我们混合了从不同会话中获取的实例，如果希望Set有明确的语义，就必 须实现equals() 和hashCode()。 @@ -264,16 +264,15 @@ public class DomesticCat extends Cat { 标识符的值。如果值相同，则两个对象对应于数据库的同一行，因此它们是相等的（如果都被添加到 Set，则在Set中只有一个元素）。不幸的是，对生成的标识不能 使用这种方法。Hibernate仅对那些持久化对象赋标识值，一个新创建的实例将不会有任何标识值。此外， - 如果一个实例没有被保存(unsaved)，并且在一个Set中，保存它将会给这个对象 + 如果一个实例没有被保存(unsaved)，并且它当前正在一个Set中，保存它将会给这个对象 赋一个标识值。如果equals() 和 hashCode()是基于标识值 - 实现的，则其哈希码将会改变，违反Set的契约。建议去Hibernate的站点看关于这个 - 问题的全部讨论。注意，这不是一个Hibernate问题，而是一般的Java对象标识和相等的语义问题。 + 实现的，则其哈希码将会改变，这违反了Set的契约。建议去Hibernate的站点阅读关于这个 + 问题的全部讨论。注意，这不是Hibernate的问题，而是一般的Java对象标识和Java对象等价的语义问题。 我们建议使用业务键值相等(Business key equality)来实现equals() 和 hashCode()。业务键值相等的意思是，equals()方法 - 仅仅比较来自业务键的属性，一个业务键将标识在真实世界里（一个天生的候选键） - 的实例。 + 仅仅比较形成业务键的属性，它能在现实世界里标识我们的实例（是一个自然的候选码）。 - 注意，业务键不必是象数据库的主键那样是固定不变的（参见）。 - 对业务键而言，不可变或唯一的属性是好的候选。 + 注意，业务键不必像数据库的主键那样固定不变（参见）。 + 对业务键而言，不可变或唯一的属性是不错的选择。 @@ -309,11 +308,11 @@ public class DomesticCat extends Cat { 动态模型(Dynamic models) - 注意，以下特性在当前是基于实验考虑的，可能会在将来改变。 + 注意，以下特性在当前处于试验阶段，将来可能会有变化。 - 运行期的持久化实体没有必要象POJO类或JavaBean对象一样表示。Hibernate也支持动态模型 + 运行期的持久化实体没有必要一定表示为像POJO类或JavaBean对象那样的形式。Hibernate也支持动态模型 （在运行期使用Map的Map）和象DOM4J的树模型那 样的实体表示。使用这种方法，你不用写持久化类，只写映射文件就行了。 @@ -327,7 +326,7 @@ public class DomesticCat extends Cat { 下面是用Map来表示的例子。首先，在映射文件中，要声明 - entity-name来代替（或外加）一个类名。 + entity-name来代替一个类名（或作为一种附属）。 @@ -397,9 +396,9 @@ tx.commit(); s.close();]]> - 动态映射的好处是，使原型在不需要实体类实现的情况下，快速转变时间。然而，你无法进行 + 动态映射的好处是，变化所需要的时间少了，因为原型不需要实现实体类。然而，你无法进行 编译期的类型检查，并可能由此会处理很多的运行期异常。幸亏有了Hibernate映射，它使得数 - 据库的schema能容易的规格化和合理化，并允许稍后添加正确的领域模型的最新实现。 + 据库的schema能容易的规格化和合理化，并允许稍后在此之上添加合适的领域模型实现。 @@ -440,11 +439,11 @@ dynamicSession.close() 元组片断映射(Tuplizers) - org.hibernate.tuple.Tuplizer, 以及其子接口，负责根据给定的org.hibernate.EntityMode,来复现片断数据。对于给定的片断数据来说，可以认为其是一种数据结构， "tuplizer"就是一种映射器，它知道如何创建这样的数据结构，以及如何给这个数据结构赋值。比如说，对于POJO这种Entity Mode，对应的tuplizer知道通过其构造器来创建一个POJO，再通过其属性访问器来访问POJO属性。有两大类Tuplizer，分别是org.hibernate.tuple.EntityTuplizer 和org.hibernate.tuple.ComponentTuplizer接口。如前所示，EntityTuplizer负责管理实体，而ComponentTuplizer则是针对组件。 + org.hibernate.tuple.Tuplizer，以及其子接口，负责根据给定的org.hibernate.EntityMode，来复现片断数据。如果给定的片断数据被认为其是一种数据结构，"tuplizer"就是一个知道如何创建这样的数据结构，以及如何给这个数据结构赋值的东西。比如说，对于POJO这种Entity Mode，对应的tuplizer知道通过其构造方法来创建一个POJO，再通过其属性访问器来访问POJO属性。有两大类高层Tuplizer，分别是org.hibernate.tuple.EntityTuplizer 和org.hibernate.tuple.ComponentTuplizer接口。EntityTuplizer负责管理上面提到的实体的契约，而ComponentTuplizer则是针对组件的。 - 用户也可以插入其自定义的tuplizer。或许您需要一种特别的java.util.Map实现，它不是在dynamic-map entity-mode时使用的 java.util.HashMap ；或许您需要与众不同的特别代理生成策略(proxy generation strategy)。通过自定义tuplizer实现，这两个目标您都可以达到。Tuplizer定义被附加到它们期望管理的entity或者component映射。回到我们的customer entity例子: + 用户也可以插入其自定义的tuplizer。或许您需要一种不同于dynamic-map entity-mode中使用的java.util.HashMap的java.util.Map实现；或许您需要与默认策略不同的代理生成策略(proxy generation strategy)。通过自定义tuplizer实现，这两个目标您都可以达到。Tuplizer定义被附加到它们期望管理的entity或者component映射中。回到我们的customer entity例子： @@ -487,7 +486,7 @@ public class CustomMapTuplizerImpl - TODO：在property和proxy的包里，用户扩展文件框架。 + TODO：property和proxy包里的用户扩展框架文档。 diff --git a/reference/zh-cn/modules/session_api.xml b/reference/zh-cn/modules/session_api.xml index 85b377ace4..5d855c73b5 100644 --- a/reference/zh-cn/modules/session_api.xml +++ b/reference/zh-cn/modules/session_api.xml @@ -28,7 +28,7 @@ 瞬时(Transient) - 由new操作符创建，且尚未与Hibernate Session 关联的对象被认定为瞬时(Transient)的。瞬时(Transient)对象不会被持久化到数据库中，也不会被赋予持久化标识(identifier)。 - 如果程序中没有保持对瞬时(Transient)对象的引用，它会被垃圾回收器(garbage collector)销毁。 + 如果瞬时(Transient)对象在程序中没有被引用，它会被垃圾回收器(garbage collector)销毁。 使用Hibernate Session可以将其变为持久(Persistent)状态。(Hibernate会自动执行必要的SQL语句) @@ -37,7 +37,7 @@ 持久(Persistent) - 持久(Persistent)的实例在数据库中有对应的记录，并拥有一个持久化标识(identifier)。 - 持久(Persistent)的实例可能是刚被保存的，或刚被加载的，无论哪一种，按定义对象都仅在相关联的Session生命周期内的保持这种状态。 + 持久(Persistent)的实例可能是刚被保存的，或刚被加载的，无论哪一种，按定义，它存在于相关联的Session作用范围内。 Hibernate会检测到处于持久(Persistent)状态的对象的任何改动，在当前操作单元(unit of work)执行完毕时将对象数据(state)与数据库同步(synchronize)。 开发者不需要手动执行UPDATE。将对象从持久(Persistent)状态变成瞬时(Transient)状态同样也不需要手动执行DELETE语句。 @@ -46,7 +46,7 @@ 脱管(Detached) - 与持久(Persistent)对象关联的Session被关闭后，对象就变为脱管(Detached)的。 对脱管(Detached)对象的引用依然有效，对象可继续被修改。脱管(Detached)对象如果重新关联到某个新的Session上， - 会再次转变为持久(Persistent)的(Detached其间的改动将被持久化到数据库)。 + 会再次转变为持久(Persistent)的(在Detached其间的改动将被持久化到数据库)。 这个功能使得一种编程模型，即中间会给用户思考时间(user think-time)的长时间运行的操作单元(unit of work)的编程模型成为可能。 我们称之为应用程序事务，即从用户观点看是一个操作单元(unit of work)。 @@ -65,7 +65,7 @@ Hibernate认为持久化类(persistent class)新实例化的对象是瞬时(Transient)的。 - 我们可将瞬时(Transient)对象与session关联而变为持久(Persistent)的。 + 我们可通过将瞬时(Transient)对象与session关联而把它变为持久(Persistent)的。 如果你持久化的对象有关联的对象(associated objects)（例如上例中的kittens集合） 那么对这些对象（译注：pk和kittens）进行持久化的顺序是任意的（也就是说可以先对kittens进行持久化也可以先对pk进行持久化）， 除非你在外键列上有NOT NULL约束。 - Hibernate不会违反外键约束，但是如果你用错误的顺序持久化对象（译注：在pk持久之前持久kitten），那么可能会违反NOT NULL约束。 + Hibernate不会违反外键约束，但是如果你用错误的顺序持久化对象（译注：在pk持久化之前持久化kitten），那么可能会违反NOT NULL约束。 通常你不会为这些细节烦心，因为你很可能会使用Hibernate的 传播性持久化(transitive persistence)功能自动保存相关联那些对象。 - 这样连违反NOT NULL约束情况都不会出现了 - Hibernate会管好所有的事情。 + 这样连违反NOT NULL约束的情况都不会出现了 - Hibernate会管好所有的事情。 传播性持久化(transitive persistence)将在本章稍后讨论。 @@ -146,7 +146,7 @@ Set kittens = cat.getKittens();]]> - 如果你不确定是否有匹配的行存在，应该使用get()方法，它会立刻访问数据库，如果没有对应的行，会返回null。 + 如果你不确定是否有匹配的行存在，应该使用get()方法，它会立刻访问数据库，如果没有对应的记录，会返回null。 如果不知道所要寻找的对象的持久化标识，那么你需要使用查询。Hibernate支持强大且易于使用的面向对象查询语言(HQL)。 如果希望通过编程的方式创建查询，Hibernate提供了完善的按条件(Query By Criteria, QBC)以及按样例(Query By Example, QBE)进行查询的功能。 - 你也可以用原生SQL(native SQL)描述查询，Hibernate提供了将结果集(result set)转化为对象的部分支持。 + 你也可以用原生SQL(native SQL)描述查询，Hibernate额外提供了将结果集(result set)转化为对象的支持。 @@ -507,7 +507,7 @@ List cats = crit.list();]]> - 你可以使用createSQLQuery()方法，用SQL来描述查询，并由Hibernate处理将结果集转换成对象的工作。 + 你可以使用createSQLQuery()方法，用SQL来描述查询，并由Hibernate将结果集转换成对象。 请注意，你可以在任何时候调用session.connection()来获得并使用JDBC Connection对象。 如果你选择使用Hibernate的API, 你必须把SQL别名用大括号包围起来: @@ -577,7 +577,7 @@ sess.flush(); // changes to cat are automatically detected and persisted]]> - Hibernate通过提供使用Session.update()或Session.merge()方法 + Hibernate通过提供Session.update()或Session.merge() 重新关联脱管实例的办法来支持这种模型。 @@ -608,8 +608,8 @@ secondSession.update(mate); // update mate]]> - 希望相关联的脱管对象（通过引用“可到达”的脱管对象）的数据也要更新到数据库时（并且也仅仅在这种情况）， - 应用程序需要对该相关联的脱管对象单独调用update() + 如果希望相关联的脱管对象（通过引用“可到达”的脱管对象）的数据也要更新到数据库时（并且也仅仅在这种情况）， + 可以对该相关联的脱管对象单独调用update() 当然这些可以自动完成，即通过使用传播性持久化(transitive persistence)，请看。 @@ -661,7 +661,7 @@ secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id) saveOrUpdate()用途和语义可能会使新用户感到迷惑。 - 首先，只要你没有尝试在某个session中使用来自另一session的实例，你应该就不需要使用update()， + 首先，只要你没有尝试在某个session中使用来自另一session的实例，你就应该不需要使用update()， saveOrUpdate()，或merge()。有些程序从来不用这些方法。 @@ -808,7 +808,7 @@ session2.close();]]> - ReplicationMode决定数据库中已存在相同行时，replicate()如何处理。 + ReplicationMode决定在和数据库中已存在记录由冲突时，replicate()如何处理。 @@ -1072,13 +1072,7 @@ sess.close();]]> - Finally, note that cascading of operations can be applied to an object graph at - call time or at flush time. All operations, - if enabled, are cascaded to associated entities reachable when the operation is - executed. However, save-upate and delete-orphan - are transitive for all associated entities reachable during flush of the - Session. - 最后，注意操作的级联可能是在调用期(call time)或者写入期(flush time)作用到对象图上的。所有的操作，假若允许，都在操作被执行的时候级联到可触及的关联实体上。然而，save-upate和delete-orphan是在Session flush的时候才作用到所有可触及的被关联对象上的。 + 最后，注意操作的级联可能是在调用期(call time)或者写入期(flush time)作用到对象图上的。所有的操作，如果允许，都在操作被执行的时候级联到可触及的关联实体上。然而，save-upate和delete-orphan是在Session flush的时候才作用到所有可触及的被关联对象上的。 diff --git a/reference/zh-cn/modules/xml.xml b/reference/zh-cn/modules/xml.xml index b035f9cb44..af8d99d069 100644 --- a/reference/zh-cn/modules/xml.xml +++ b/reference/zh-cn/modules/xml.xml @@ -9,11 +9,11 @@ Hibernate使得你可以用XML数据来进行工作，恰如你用持久化的POJO进行工作那样。解析过的XML树 - 可以被认为是另外一种在对象层面上代替POJO来表示关系型数据的途径. + 可以被认为是代替POJO的另外一种在对象层面上表示关系型数据的途径. - Hibernate支持采用dom4j作为操作XML树的API。你可以写一个查询从数据库中检索出 + Hibernate支持采用dom4j作为操作XML树的API。你可以写一些查询从数据库中检索出 dom4j树，随后你对这颗树做的任何修改都将自动同步回数据库。你甚至可以用dom4j解析 一篇XML文档，然后使用Hibernate的任一基本操作将它写入数据库： persist(), saveOrUpdate(), merge(), delete(), replicate() @@ -21,7 +21,7 @@ - 这一特性可以应用在很多场合，包括数据导入导出，通过JMS或SOAP表现实体数据以及 + 这一特性可以应用在很多场合，包括数据导入导出，通过JMS或SOAP具体化实体数据以及 基于XSLT的报表。 @@ -92,7 +92,7 @@ 这个映射使得你既可以把数据作为一棵dom4j树那样访问，又可以作为由属性键值对(java Maps) - 组成的图那样访问。属性名字是纯粹逻辑上的结构，你可以在HQL查询中引用它。 + 组成的图那样访问。属性名字纯粹是逻辑上的结构，你可以在HQL查询中引用它。 @@ -262,7 +262,7 @@ tx.commit(); session.close();]]> - 将这一特色与Hibernate的replicate()操作结合起来而实现的基于XML的数据导入/导出将非常有用. + 将这一特色与Hibernate的replicate()操作结合起来对于实现的基于XML的数据导入/导出将非常有用.