[jboss-cvs] JBossAS SVN: r95900 - projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Sun Nov 1 23:57:42 EST 2009
Author: xhuang at jboss.com
Date: 2009-11-01 23:57:42 -0500 (Sun, 01 Nov 2009)
New Revision: 95900
Modified:
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/architecture.po
Log:
update
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/architecture.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/architecture.po 2009-11-02 02:33:17 UTC (rev 95899)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/architecture.po 2009-11-02 04:57:42 UTC (rev 95900)
@@ -6,7 +6,7 @@
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-11-02 14:57+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -28,64 +28,39 @@
#. Tag: para
#: architecture.xml:35
-#, fuzzy, no-c-format
-msgid ""
-"The diagram below provides a high-level view of the Hibernate architecture:"
-msgstr "一个非常简要的 Hibernate 体系结构的概要图："
+#, no-c-format
+msgid "The diagram below provides a high-level view of the Hibernate architecture:"
+msgstr "下面的图表提供了 Hibernate 体系结构的高层视图："
#. Tag: para
#: architecture.xml:48
-#, fuzzy, no-c-format
-msgid ""
-"We do not have the scope in this document to provide a more detailed view of "
-"all the runtime architectures available; Hibernate is flexible and supports "
-"several different approaches. We will, however, show the two extremes: "
-"\"minimal\" architecture and \"comprehensive\" architecture."
-msgstr ""
-"我们来更详细地看一下 Hibernate 运行时体系结构。由于 Hibernate 非常灵活，且支"
-"持多种应用方案， 所以我们这只描述一下两种极端的情况。“轻型”的体系结构方案，要"
-"求应用程序提供自己的 JDBC 连接并管理自己的事务。这种方案使用了Hibernate API "
-"的最小子集："
+#, no-c-format
+msgid "We do not have the scope in this document to provide a more detailed view of all the runtime architectures available; Hibernate is flexible and supports several different approaches. We will, however, show the two extremes: \"minimal\" architecture and \"comprehensive\" architecture."
+msgstr "提供 Hibernate 所有运行时体系结构的更多细节不是本文档的范畴。由于 Hibernate 非常灵活，且支持多种应用方案， 所以我们这只描述一下两种极端的情况：“最小”和“全面解决”的体系结构方案。"
#. Tag: para
#: architecture.xml:54
-#, fuzzy, no-c-format
-msgid ""
-"This next diagram illustrates how Hibernate utilizes database and "
-"configuration data to provide persistence services, and persistent objects, "
-"to the application."
-msgstr ""
-"从这个图可以看出，Hibernate 使用数据库和配置信息来为应用程序提供持久化服务"
-"（以及持久的对象）。"
+#, no-c-format
+msgid "This next diagram illustrates how Hibernate utilizes database and configuration data to provide persistence services, and persistent objects, to the application."
+msgstr "下图演示了 Hibernate 如何使用数据库和配置信息来为应用程序提供持久化服务（以及持久的对象）。"
#. Tag: para
#: architecture.xml:59
-#, fuzzy, no-c-format
-msgid ""
-"The \"minimal\" architecture has the application provide its own JDBC "
-"connections and manage its own transactions. This approach uses a minimal "
-"subset of Hibernate's APIs:"
-msgstr ""
-"我们来更详细地看一下 Hibernate 运行时体系结构。由于 Hibernate 非常灵活，且支"
-"持多种应用方案， 所以我们这只描述一下两种极端的情况。“轻型”的体系结构方案，要"
-"求应用程序提供自己的 JDBC 连接并管理自己的事务。这种方案使用了Hibernate API "
-"的最小子集："
+#, no-c-format
+msgid "The \"minimal\" architecture has the application provide its own JDBC connections and manage its own transactions. This approach uses a minimal subset of Hibernate's APIs:"
+msgstr "“最小”的体系结构方案，要求应用程序提供自己的 JDBC 连接并管理自己的事务。这种方案使用了Hibernate API 的最小子集："
#. Tag: para
#: architecture.xml:74
-#, fuzzy, no-c-format
-msgid ""
-"The \"comprehensive\" architecture abstracts the application away from the "
-"underlying JDBC/JTA APIs and allows Hibernate to manage the details."
-msgstr ""
-"“全面解决”的体系结构方案，将应用层从底层的 JDBC/JTA API 中抽象出来，而让 "
-"Hibernate 来处理这些细节。"
+#, no-c-format
+msgid "The \"comprehensive\" architecture abstracts the application away from the underlying JDBC/JTA APIs and allows Hibernate to manage the details."
+msgstr "“全面解决”的体系结构方案，将应用层从底层的 JDBC/JTA API 中抽象出来，而让 Hibernate 来处理这些细节。"
#. Tag: para
#: architecture.xml:88
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Here are some definitions of the objects depicted in the diagrams:"
-msgstr "图中各个对象的定义如下："
+msgstr "图中各个对象的定义如下： "
#. Tag: term
#: architecture.xml:93
@@ -95,18 +70,9 @@
#. Tag: para
#: architecture.xml:95
-#, fuzzy, no-c-format
-msgid ""
-"A threadsafe, immutable cache of compiled mappings for a single database. A "
-"factory for <literal>Session</literal> and a client of "
-"<literal>ConnectionProvider</literal>, <literal>SessionFactory</literal> can "
-"hold an optional (second-level) cache of data that is reusable between "
-"transactions at a process, or cluster, level."
-msgstr ""
-"针对单个数据库映射关系经过编译后的内存镜像，是线程安全的（不可变）。 它是生"
-"成 <literal>Session</literal> 的工厂，本身要用到 "
-"<literal>ConnectionProvider</literal>。该对象可以在进程或集群的级别上，为那些"
-"事务之间可以重用的数据提供可选的二级缓存。"
+#, no-c-format
+msgid "A threadsafe, immutable cache of compiled mappings for a single database. A factory for <literal>Session</literal> and a client of <literal>ConnectionProvider</literal>, <literal>SessionFactory</literal> can hold an optional (second-level) cache of data that is reusable between transactions at a process, or cluster, level."
+msgstr "针对单个数据库映射关系经过编译后的内存镜像，是线程安全的（不可变）。 作为 <literal>Session</literal> 的工厂和 <literal>ConnectionProvider</literal> 的客户。<literal>SessionFactory</literal> 可以在进程或集群的级别上，为那些事务之间可以重用的数据提供可选的二级缓存。"
#. Tag: term
#: architecture.xml:105
@@ -116,18 +82,9 @@
#. Tag: para
#: architecture.xml:107
-#, fuzzy, no-c-format
-msgid ""
-"A single-threaded, short-lived object representing a conversation between "
-"the application and the persistent store. It wraps a JDBC connection and is "
-"a factory for <literal>Transaction</literal>. <literal>Session</literal> "
-"holds a mandatory first-level cache of persistent objects that are used when "
-"navigating the object graph or looking up objects by identifier."
-msgstr ""
-"表示应用程序与持久储存层之间交互操作的一个单线程对象，此对象生存期很短。 其隐"
-"藏了 JDBC 连接，也是 <literal>Transaction</literal> 的工厂。 其会持有一个针对"
-"持久化对象的必选（第一级）缓存，在遍历对象图或者根据持久化标识查找对象时会用"
-"到。"
+#, no-c-format
+msgid "A single-threaded, short-lived object representing a conversation between the application and the persistent store. It wraps a JDBC connection and is a factory for <literal>Transaction</literal>. <literal>Session</literal> holds a mandatory first-level cache of persistent objects that are used when navigating the object graph or looking up objects by identifier."
+msgstr "表示应用程序与持久储存层之间交互操作的一个单线程对象，此对象生存期很短。其隐藏了 JDBC 连接，也是 <literal>Transaction</literal> 的工厂。它会持有一个针对持久化对象的必选（第一级）缓存，在遍历对象图或者根据持久化标识查找对象时会用到。"
#. Tag: term
#: architecture.xml:117
@@ -137,20 +94,9 @@
#. Tag: para
#: architecture.xml:119
-#, fuzzy, no-c-format
-msgid ""
-"Short-lived, single threaded objects containing persistent state and "
-"business function. These can be ordinary JavaBeans/POJOs. They are "
-"associated with exactly one <literal>Session</literal>. Once the "
-"<literal>Session</literal> is closed, they will be detached and free to use "
-"in any application layer (for example, directly as data transfer objects to "
-"and from presentation)."
-msgstr ""
-"带有持久化状态的、具有业务功能的单线程对象，此对象生存期很短。这些对象可能是"
-"普通的JavaBeans/POJO，唯一特殊的是他们正与（仅仅一个）<literal>Session</"
-"literal> 相关联。一旦这个 <literal>Session</literal> 被关闭，这些对象就会脱离"
-"持久化状态，这样就可被应用程序的任何层自由使用。（例如，用作跟表示层打交道的"
-"数据传输对象。）"
+#, no-c-format
+msgid "Short-lived, single threaded objects containing persistent state and business function. These can be ordinary JavaBeans/POJOs. They are associated with exactly one <literal>Session</literal>. Once the <literal>Session</literal> is closed, they will be detached and free to use in any application layer (for example, directly as data transfer objects to and from presentation)."
+msgstr "带有持久化状态的、具有业务功能的单线程对象，此对象生存期很短。这些对象可能是普通的JavaBeans/POJO，唯一特殊的是他们正与（仅仅一个）<literal>Session</literal> 相关联。一旦这个 <literal>Session</literal> 被关闭，这些对象就会脱离持久化状态，这样就可被应用程序的任何层自由使用（例如，用作跟表示层打交道的数据传输对象）。"
#. Tag: term
#: architecture.xml:129
@@ -160,16 +106,9 @@
#. Tag: para
#: architecture.xml:131
-#, fuzzy, no-c-format
-msgid ""
-"Instances of persistent classes that are not currently associated with a "
-"<literal>Session</literal>. They may have been instantiated by the "
-"application and not yet persisted, or they may have been instantiated by a "
-"closed <literal>Session</literal>."
-msgstr ""
-"那些目前没有与 session 关联的持久化类实例。他们可能是在被应用程序实例化后，尚"
-"未进行持久化的对象。也可能是因为实例化他们的 <literal>Session</literal> 已经"
-"被关闭而脱离持久化的对象。"
+#, no-c-format
+msgid "Instances of persistent classes that are not currently associated with a <literal>Session</literal>. They may have been instantiated by the application and not yet persisted, or they may have been instantiated by a closed <literal>Session</literal>."
+msgstr "那些目前没有与 <literal>Session</literal>关联的持久化类实例。他们可能是在被应用程序实例化后，尚未进行持久化的对象。也可能是因为实例化他们的 <literal>Session</literal> 已经被关闭而脱离持久化的对象。"
#. Tag: term
#: architecture.xml:140
@@ -179,62 +118,33 @@
#. Tag: para
#: architecture.xml:142
-#, fuzzy, no-c-format
-msgid ""
-"(Optional) A single-threaded, short-lived object used by the application to "
-"specify atomic units of work. It abstracts the application from the "
-"underlying JDBC, JTA or CORBA transaction. A <literal>Session</literal> "
-"might span several <literal>Transaction</literal>s in some cases. However, "
-"transaction demarcation, either using the underlying API or "
-"<literal>Transaction</literal>, is never optional."
-msgstr ""
-"（可选的）应用程序用来指定原子操作单元范围的对象，它是单线程的，生命周期很"
-"短。它通过抽象将应用从底层具体的 JDBC、JTA 以及 CORBA 事务隔离开。某些情况"
-"下，一个 <literal>Session</literal> 之内可能包含多个 <literal>Transaction</"
-"literal> 对象。尽管是否使用该对象是可选的，但无论是使用底层的 API 还是使用 "
-"<literal>Transaction</literal> 对象，事务边界的开启与关闭是必需的。"
+#, no-c-format
+msgid "(Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. It abstracts the application from the underlying JDBC, JTA or CORBA transaction. A <literal>Session</literal> might span several <literal>Transaction</literal>s in some cases. However, transaction demarcation, either using the underlying API or <literal>Transaction</literal>, is never optional."
+msgstr "（可选的）应用程序用来指定原子操作单元范围的对象，它是单线程的，生命周期很短。它通过抽象将应用从底层具体的 JDBC、JTA 以及 CORBA 事务隔离开。某些情况下，一个 <literal>Session</literal> 之内可能包含多个 <literal>Transaction</literal> 对象。尽管是否使用该对象是可选的，但无论是使用底层的 API 还是使用 <literal>Transaction</literal> 对象，事务边界的开启与关闭是必需的。 "
#. Tag: term
#: architecture.xml:153
#, no-c-format
-msgid ""
-"ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</"
-"literal>)"
-msgstr ""
-"ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</"
-"literal>)"
+msgid "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+msgstr "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
#. Tag: para
#: architecture.xml:155
-#, fuzzy, no-c-format
-msgid ""
-"(Optional) A factory for, and pool of, JDBC connections. It abstracts the "
-"application from underlying <literal>Datasource</literal> or "
-"<literal>DriverManager</literal>. It is not exposed to application, but it "
-"can be extended and/or implemented by the developer."
-msgstr ""
-"（可选的）生成 JDBC 连接的工厂（同时也起到连接池的作用）。它通过抽象将应用从"
-"底层的 <literal>Datasource</literal> 或 <literal>DriverManager</literal> 隔离"
-"开。仅供开发者扩展/实现用，并不暴露给应用程序使用。"
+#, no-c-format
+msgid "(Optional) A factory for, and pool of, JDBC connections. It abstracts the application from underlying <literal>Datasource</literal> or <literal>DriverManager</literal>. It is not exposed to application, but it can be extended and/or implemented by the developer."
+msgstr "（可选的）生成 JDBC 连接的工厂（同时也起到连接池的作用）。它通过抽象将应用从底层的 <literal>Datasource</literal> 或 <literal>DriverManager</literal> 隔离开。仅供开发者扩展/实现用，并不开放给应用程序使用。"
#. Tag: term
#: architecture.xml:163
#, no-c-format
-msgid ""
-"TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
-msgstr ""
-"TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgid "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgstr "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
#. Tag: para
#: architecture.xml:165
-#, fuzzy, no-c-format
-msgid ""
-"(Optional) A factory for <literal>Transaction</literal> instances. It is not "
-"exposed to the application, but it can be extended and/or implemented by the "
-"developer."
-msgstr ""
-"（可选的）生成 <literal>Transaction</literal> 对象实例的工厂。仅供开发者扩展/"
-"实现用，并不暴露给应用程序使用。"
+#, no-c-format
+msgid "(Optional) A factory for <literal>Transaction</literal> instances. It is not exposed to the application, but it can be extended and/or implemented by the developer."
+msgstr "（可选的）生成 <literal>Transaction</literal> 对象实例的工厂。仅供开发者扩展/实现用，并不开发能够给应用程序使用。"
#. Tag: emphasis
#: architecture.xml:172
@@ -244,27 +154,15 @@
#. Tag: para
#: architecture.xml:174
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate offers a range of optional extension interfaces you can implement "
-"to customize the behavior of your persistence layer. See the API "
-"documentation for details."
-msgstr ""
-"Hibernate 提供了很多可选的扩展接口，你可以通过实现它们来定制你的持久层的行"
-"为。 具体请参考 API 文档。"
+#, no-c-format
+msgid "Hibernate offers a range of optional extension interfaces you can implement to customize the behavior of your persistence layer. See the API documentation for details."
+msgstr "Hibernate 提供了很多可选的扩展接口，你可以通过实现它们来定制你的持久层的行为。具体请参考 API 文档。"
#. Tag: para
#: architecture.xml:183
-#, fuzzy, no-c-format
-msgid ""
-"Given a \"minimal\" architecture, the application bypasses the "
-"<literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or "
-"<literal>ConnectionProvider</literal> APIs to communicate with JTA or JDBC "
-"directly."
-msgstr ""
-"在特定“轻型”的体系结构中，应用程序可能绕过 <literal>Transaction</literal>/"
-"<literal>TransactionFactory</literal> 以及 <literal>ConnectionProvider</"
-"literal> 等 API 直接跟 JTA 或 JDBC 打交道。"
+#, no-c-format
+msgid "Given a \"minimal\" architecture, the application bypasses the <literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or <literal>ConnectionProvider</literal> APIs to communicate with JTA or JDBC directly."
+msgstr "在特定“最小”的体系结构中，应用程序可能绕过 <literal>Transaction</literal>/<literal>TransactionFactory</literal> 以及 <literal>ConnectionProvider</literal> 等 API 直接跟 JTA 或 JDBC 打交道。"
#. Tag: title
#: architecture.xml:191
@@ -274,16 +172,9 @@
#. Tag: para
#: architecture.xml:192
-#, fuzzy, no-c-format
-msgid ""
-"An instance of a persistent class can be in one of three different states. "
-"These states are defined in relation to a <emphasis>persistence context</"
-"emphasis>. The Hibernate <literal>Session</literal> object is the "
-"persistence context. The three different states are as follows:"
-msgstr ""
-"一个持久化类的实例可能处于三种不同状态中的某一种。 这三种状态的定义则与所谓的"
-"<emphasis>持久化上下文（persistence context）</emphasis>有关。 Hibernate 的 "
-"<literal>Session</literal> 对象就是这个所谓的持久化上下文："
+#, no-c-format
+msgid "An instance of a persistent class can be in one of three different states. These states are defined in relation to a <emphasis>persistence context</emphasis>. The Hibernate <literal>Session</literal> object is the persistence context. The three different states are as follows:"
+msgstr "一个持久化类的实例可能处于三种不同状态中的某一种。这三种状态的定义则与所谓的<emphasis>持久化上下文（persistence context）</emphasis>有关。Hibernate 的 <literal>Session</literal> 对象就是这个所谓的持久化上下文。这三种不同的状态如下："
#. Tag: term
#: architecture.xml:200
@@ -293,11 +184,9 @@
#. Tag: para
#: architecture.xml:202
-#, fuzzy, no-c-format
-msgid ""
-"The instance is not associated with any persistence context. It has no "
-"persistent identity or primary key value."
-msgstr "该实例从未与任何持久化上下文关联过。它没有持久化标识（相当于主键值）。"
+#, no-c-format
+msgid "The instance is not associated with any persistence context. It has no persistent identity or primary key value."
+msgstr "该实例从未与任何持久化上下文关联过。它没有持久化标识（相当于主键值）。 "
#. Tag: term
#: architecture.xml:210
@@ -307,17 +196,9 @@
#. Tag: para
#: architecture.xml:212
-#, fuzzy, no-c-format
-msgid ""
-"The instance is currently associated with a persistence context. It has a "
-"persistent identity (primary key value) and can have a corresponding row in "
-"the database. For a particular persistence context, Hibernate "
-"<emphasis>guarantees</emphasis> that persistent identity is equivalent to "
-"Java identity in relation to the in-memory location of the object."
-msgstr ""
-"实例目前与某个持久化上下文有关联。 它拥有持久化标识（相当于主键值），并且可能"
-"在数据库中有一个对应的行。 对于某一个特定的持久化上下文，Hibernate <emphasis>"
-"保证</emphasis> 持久化标识与 Java 标识（其值代表对象在内存中的位置）等价。 "
+#, no-c-format
+msgid "The instance is currently associated with a persistence context. It has a persistent identity (primary key value) and can have a corresponding row in the database. For a particular persistence context, Hibernate <emphasis>guarantees</emphasis> that persistent identity is equivalent to Java identity in relation to the in-memory location of the object."
+msgstr "实例目前与某个持久化上下文有关联。它拥有持久化标识（相当于主键值），并且可能在数据库中有一个对应的行。对于某一个特定的持久化上下文，Hibernate <emphasis>保证</emphasis> 持久化标识与 Java 标识（其值代表对象在内存中的位置）等价。 "
#. Tag: term
#: architecture.xml:224
@@ -327,18 +208,9 @@
#. Tag: para
#: architecture.xml:226
-#, fuzzy, no-c-format
-msgid ""
-"The instance was once associated with a persistence context, but that "
-"context was closed, or the instance was serialized to another process. It "
-"has a persistent identity and can have a corresponding row in the database. "
-"For detached instances, Hibernate does not guarantee the relationship "
-"between persistent identity and Java identity."
-msgstr ""
-"实例曾经与某个持久化上下文发生过关联，不过那个上下文被关闭了，或者这个实例是"
-"被序列化（serialize）到另外的进程。它拥有持久化标识，并且在数据库中可能存在一"
-"个对应的行。对于脱管状态的实例，Hibernate 不保证任何持久化标识和 Java 标识的"
-"关系。"
+#, no-c-format
+msgid "The instance was once associated with a persistence context, but that context was closed, or the instance was serialized to another process. It has a persistent identity and can have a corresponding row in the database. For detached instances, Hibernate does not guarantee the relationship between persistent identity and Java identity."
+msgstr "实例曾经与某个持久化上下文发生过关联，不过那个上下文被关闭了，或者这个实例是被序列化（serialize）到另外的进程。它拥有持久化标识，并且在数据库中可能存在一个对应的行。对于脱管状态的实例，Hibernate 不保证任何持久化标识和 Java 标识的关系。 "
#. Tag: title
#: architecture.xml:241
@@ -348,86 +220,39 @@
#. Tag: para
#: architecture.xml:243
-#, fuzzy, no-c-format
-msgid ""
-"JMX is the J2EE standard for the management of Java components. Hibernate "
-"can be managed via a JMX standard service. AN MBean implementation is "
-"provided in the distribution: <literal>org.hibernate.jmx.HibernateService</"
-"literal>."
-msgstr ""
-"JMX 是管理 Java 组件（Java components）的 J2EE 标准。 Hibernate 可以通过一个 "
-"JMX 标准服务来管理。 在这个发行版本中，我们提供了一个 MBean 接口的实现,即 "
-"<literal>org.hibernate.jmx.HibernateService</literal>。 "
+#, no-c-format
+msgid "JMX is the J2EE standard for the management of Java components. Hibernate can be managed via a JMX standard service. AN MBean implementation is provided in the distribution: <literal>org.hibernate.jmx.HibernateService</literal>."
+msgstr "JMX 是管理 Java 组件的 J2EE 标准。Hibernate 可以通过一个 JMX 标准服务来管理。在这个发行版本中，我们提供了一个 MBean 接口的实现,即 <literal>org.hibernate.jmx.HibernateService</literal>。 "
#. Tag: para
#: architecture.xml:249
-#, fuzzy, no-c-format
-msgid ""
-"For an example of how to deploy Hibernate as a JMX service on the JBoss "
-"Application Server, please see the JBoss User Guide. JBoss AS also provides "
-"these benefits if you deploy using JMX:"
-msgstr ""
-"想要看如何在 JBoss 应用服务器上将 Hibernate 部署为一个 JMX 服务的例子，您可以"
-"参考 JBoss 用户指南。 我们现在说一下在 Jboss 应用服务器上，使用 JMX 来部署 "
-"Hibernate 的好处："
+#, no-c-format
+msgid "For an example of how to deploy Hibernate as a JMX service on the JBoss Application Server, please see the JBoss User Guide. JBoss AS also provides these benefits if you deploy using JMX:"
+msgstr "想要看如何在 JBoss 应用服务器上将 Hibernate 部署为一个 JMX 服务的例子，您可以参考《JBoss 用户指南》。如果你使用 JMX 来部署 Hibernate，JBoss AS 也提供如下好处："
#. Tag: para
#: architecture.xml:257
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis>Session Management</emphasis>: the Hibernate <literal>Session</"
-"literal>'s life cycle can be automatically bound to the scope of a JTA "
-"transaction. This means that you no longer have to manually open and close "
-"the <literal>Session</literal>; this becomes the job of a JBoss EJB "
-"interceptor. You also do not have to worry about transaction demarcation in "
-"your code (if you would like to write a portable persistence layer use the "
-"optional Hibernate <literal>Transaction</literal> API for this). You call "
-"the <literal>HibernateContext</literal> to access a <literal>Session</"
-"literal>."
-msgstr ""
-"<emphasis>Session 管理：</emphasis> Hibernate 的 <literal>Session</literal> "
-"对象的生命周期可以 自动跟一个 JTA 事务边界绑定。这意味着你无需手工开关 "
-"<literal>Session</literal> 了, 这项 工作会由 JBoss EJB 拦截器来完成。你再也不"
-"用担心你的代码中的事务边界了（除非你想利用 Hibernate 提供可选的 "
-"<literal>Transaction</literal> API 来自己写一个便于移植的的持久层）。你通过调"
-"用 <literal>HibernateContext</literal> 来访问 <literal>Session</literal>。"
+#, no-c-format
+msgid "<emphasis>Session Management</emphasis>: the Hibernate <literal>Session</literal>'s life cycle can be automatically bound to the scope of a JTA transaction. This means that you no longer have to manually open and close the <literal>Session</literal>; this becomes the job of a JBoss EJB interceptor. You also do not have to worry about transaction demarcation in your code (if you would like to write a portable persistence layer use the optional Hibernate <literal>Transaction</literal> API for this). You call the <literal>HibernateContext</literal> to access a <literal>Session</literal>."
+msgstr "<emphasis>会话管理：</emphasis> Hibernate 的 <literal>Session</literal> 对象的生命周期可以 自动跟一个 JTA 事务边界绑定。这意味着你无需手工开关 <literal>Session</literal> 了, 这项工作会由 JBoss EJB 拦截器来完成。你再也不用担心你的代码中的事务边界了（除非你想利用 Hibernate 提供可选的 <literal>Transaction</literal> API 来自己写一个便于移植的的持久层）。你通过调用 <literal>HibernateContext</literal> 来访问 <literal>Session</literal>。"
#. Tag: para
#: architecture.xml:269
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis>HAR deployment</emphasis>: the Hibernate JMX service is deployed "
-"using a JBoss service deployment descriptor in an EAR and/or SAR file, as it "
-"supports all the usual configuration options of a Hibernate "
-"<literal>SessionFactory</literal>. However, you still need to name all your "
-"mapping files in the deployment descriptor. If you use the optional HAR "
-"deployment, JBoss will automatically detect all mapping files in your HAR "
-"file."
-msgstr ""
-"<emphasis>HAR 部署:</emphasis> 通常情况下，你会使用 JBoss 的服务部署描述符"
-"（在 EAR 或/和 SAR 文件中）来部署 Hibernate JMX 服务。 这种部署方式支持所有常"
-"见的 Hibernate <literal>SessionFactory</literal> 的配置选项。 不过，你仍需在"
-"部署描述符中，列出你所有的映射文的名字。如果你使用 HAR 部署方式, JBoss 会自动"
-"探测出你的 HAR 文件中所有的映射文件。"
+#, no-c-format
+msgid "<emphasis>HAR deployment</emphasis>: the Hibernate JMX service is deployed using a JBoss service deployment descriptor in an EAR and/or SAR file, as it supports all the usual configuration options of a Hibernate <literal>SessionFactory</literal>. However, you still need to name all your mapping files in the deployment descriptor. If you use the optional HAR deployment, JBoss will automatically detect all mapping files in your HAR file."
+msgstr "<emphasis>HAR 部署:</emphasis> 通常情况下，你会使用 JBoss 的服务部署描述符（在 EAR 或/和 SAR 文件中）来部署 Hibernate JMX 服务。这种部署方式支持所有常见的 Hibernate <literal>SessionFactory</literal> 的配置选项。不过，你仍需在部署描述符中，列出你所有的映射文的名字。如果你使用 HAR 部署方式, JBoss 会自动探测出你的 HAR 文件中所有的映射文件。"
#. Tag: para
#: architecture.xml:280
#, no-c-format
-msgid ""
-"Consult the JBoss AS user guide for more information about these options."
+msgid "Consult the JBoss AS user guide for more information about these options."
msgstr "这些选项更多的描述，请参考 JBoss 应用程序用户指南。"
#. Tag: para
#: architecture.xml:284
-#, fuzzy, no-c-format
-msgid ""
-"Another feature available as a JMX service is runtime Hibernate statistics. "
-"See <xref linkend=\"configuration-optional-statistics\"/> for more "
-"information."
-msgstr ""
-"将 Hibernate 以部署为 JMX 服务的另一个好处，是可以查看 Hibernate 的运行时统计"
-"信息。参看 <xref linkend=\"Optional_configuration_properties-"
-"Hibernate_statistics\"/>。"
+#, no-c-format
+msgid "Another feature available as a JMX service is runtime Hibernate statistics. See <xref linkend=\"configuration-optional-statistics\"/> for more information."
+msgstr "将 Hibernate 以部署为 JMX 服务的另一个好处，是可以查看 Hibernate 的运行时统计信息。参看 <xref linkend=\"configuration-optional-statistics\"/>。"
#. Tag: title
#: architecture.xml:291
@@ -437,182 +262,67 @@
#. Tag: para
#: architecture.xml:292
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate can also be configured as a JCA connector. Please see the website "
-"for more information. Please note, however, that at this stage Hibernate JCA "
-"support is under development."
-msgstr ""
-"Hibernate 也可以被配置为一个 JCA 连接器（JCA connector）。更多信息请参看网"
-"站。 请注意，Hibernate 对 JCA 的支持，仍处于实验性阶段。"
+#, no-c-format
+msgid "Hibernate can also be configured as a JCA connector. Please see the website for more information. Please note, however, that at this stage Hibernate JCA support is under development."
+msgstr "Hibernate 也可以被配置为一个 JCA 连接器（JCA connector）。更多信息请参看网站。请注意，Hibernate 对 JCA 的支持，仍处于实验性阶段。"
#. Tag: title
#: architecture.xml:299
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Contextual sessions"
-msgstr "上下文相关的（Contextual）Session"
+msgstr "上下文相关的会话（Contextual Session）"
#. Tag: para
#: architecture.xml:300
-#, fuzzy, no-c-format
-msgid ""
-"Most applications using Hibernate need some form of \"contextual\" session, "
-"where a given session is in effect throughout the scope of a given context. "
-"However, across applications the definition of what constitutes a context is "
-"typically different; different contexts define different scopes to the "
-"notion of current. Applications using Hibernate prior to version 3.0 tended "
-"to utilize either home-grown <literal>ThreadLocal</literal>-based contextual "
-"sessions, helper classes such as <literal>HibernateUtil</literal>, or "
-"utilized third-party frameworks, such as Spring or Pico, which provided "
-"proxy/interception-based contextual sessions."
-msgstr ""
-"使用 Hibernate 的大多数应用程序需要某种形式的“上下文相关的” session，特定的 "
-"session 在整个特定的上下文范围内始终有效。然而，对不同类型的应用程序而言，要"
-"为什么是组成这种“上下文”下一个定义通常是困难的；不同的上下文对“当前”这个概念"
-"定义了不同的范围。在 3.0 版本之前，使用 Hibernate 的程序要么采用自行编写的基"
-"于 <literal>ThreadLocal</literal> 的上下文 session，要么采用 "
-"<literal>HibernateUtil</literal> 这样的辅助类，要么采用第三方框架（比如 "
-"Spring 或 Pico），它们提供了基于代理（proxy）或者基于拦截器（interception）的"
-"上下文相关 session。"
+#, no-c-format
+msgid "Most applications using Hibernate need some form of \"contextual\" session, where a given session is in effect throughout the scope of a given context. However, across applications the definition of what constitutes a context is typically different; different contexts define different scopes to the notion of current. Applications using Hibernate prior to version 3.0 tended to utilize either home-grown <literal>ThreadLocal</literal>-based contextual sessions, helper classes such as <literal>HibernateUtil</literal>, or utilized third-party frameworks, such as Spring or Pico, which provided proxy/interception-based contextual sessions."
+msgstr "使用 Hibernate 的大多数应用程序需要某种形式的“上下文相关的”会话，特定的会话在整个特定的上下文范围内始终有效。然而，对不同类型的应用程序而言，要为什么是组成这种“上下文”下一个定义通常是困难的；不同的上下文对“当前”这个概念定义了不同的范围。在 3.0 版本之前，使用 Hibernate 的程序要么采用自行编写的基于 <literal>ThreadLocal</literal> 的上下文会话，要么采用 <literal>HibernateUtil</literal> 这样的辅助类，要么采用第三方框架（比如 Spring 或 Pico），它们提供了基于代理（proxy）或者基于拦截器（interception）的上下文相关的会话。"
#. Tag: para
#: architecture.xml:309
-#, fuzzy, no-c-format
-msgid ""
-"Starting with version 3.0.1, Hibernate added the <literal>SessionFactory."
-"getCurrentSession()</literal> method. Initially, this assumed usage of "
-"<literal>JTA</literal> transactions, where the <literal>JTA</literal> "
-"transaction defined both the scope and context of a current session. Given "
-"the maturity of the numerous stand-alone <literal>JTA TransactionManager</"
-"literal> implementations, most, if not all, applications should be using "
-"<literal>JTA</literal> transaction management, whether or not they are "
-"deployed into a <literal>J2EE</literal> container. Based on that, the "
-"<literal>JTA</literal>-based contextual sessions are all you need to use."
-msgstr ""
-"从 3.0.1 版本开始，Hibernate 增加了 <literal>SessionFactory.getCurrentSession"
-"()</literal> 方法。一开始，它假定了采用 <literal>JTA</literal> 事务，"
-"<literal>JTA</literal> 事务定义了当前 session 的范围和上下文（scope and "
-"context）。Hibernate 开发团队坚信，因为有好几个独立的 <literal>JTA "
-"TransactionManager</literal> 实现稳定可用，不论是否被部署到一个 "
-"<literal>J2EE</literal> 容器中，大多数（假若不是所有的）应用程序都应该采用 "
-"<literal>JTA</literal> 事务管理。基于这一点，采用 <literal>JTA</literal> 的上"
-"下文相关 session 可以满足你一切需要。"
+#, no-c-format
+msgid "Starting with version 3.0.1, Hibernate added the <literal>SessionFactory.getCurrentSession()</literal> method. Initially, this assumed usage of <literal>JTA</literal> transactions, where the <literal>JTA</literal> transaction defined both the scope and context of a current session. Given the maturity of the numerous stand-alone <literal>JTA TransactionManager</literal> implementations, most, if not all, applications should be using <literal>JTA</literal> transaction management, whether or not they are deployed into a <literal>J2EE</literal> container. Based on that, the <literal>JTA</literal>-based contextual sessions are all you need to use."
+msgstr "从 3.0.1 版本开始，Hibernate 增加了 <literal>SessionFactory.getCurrentSession()</literal> 方法。一开始，它假定了采用 <literal>JTA</literal> 事务，<literal>JTA</literal> 事务定义了当前 session 的范围和上下文（scope 和 context）。因为有好几个独立的 <literal>JTA TransactionManager</literal> 实现稳定可用，不论是否被部署到一个 <literal>J2EE</literal> 容器中，大多数（假若不是所有的）应用程序都应该采用 <literal>JTA</literal> 事务管理。基于这一点，采用 <literal>JTA</literal> 的上下文相关的会话可以满足你一切需要。"
#. Tag: para
#: architecture.xml:319
-#, fuzzy, no-c-format
-msgid ""
-"However, as of version 3.1, the processing behind <literal>SessionFactory."
-"getCurrentSession()</literal> is now pluggable. To that end, a new extension "
-"interface, <literal>org.hibernate.context.CurrentSessionContext</literal>, "
-"and a new configuration parameter, <literal>hibernate."
-"current_session_context_class</literal>, have been added to allow "
-"pluggability of the scope and context of defining current sessions."
-msgstr ""
-"更好的是，从 3.1 开始，<literal>SessionFactory.getCurrentSession()</literal> "
-"的后台实现是可拔插的。因此，我们引入了新的扩展接口（<literal>org.hibernate."
-"context.CurrentSessionContext</literal>）和新的配置参数（<literal>hibernate."
-"current_session_context_class</literal>），以便对什么是“当前 session”的范围和"
-"上下文（scope and context）的定义进行拔插。"
+#, no-c-format
+msgid "However, as of version 3.1, the processing behind <literal>SessionFactory.getCurrentSession()</literal> is now pluggable. To that end, a new extension interface, <literal>org.hibernate.context.CurrentSessionContext</literal>, and a new configuration parameter, <literal>hibernate.current_session_context_class</literal>, have been added to allow pluggability of the scope and context of defining current sessions."
+msgstr "更好的是，从 3.1 开始，<literal>SessionFactory.getCurrentSession()</literal> 的后台实现是可拔插的。因此，我们引入了新的扩展接口（<literal>org.hibernate.context.CurrentSessionContext</literal>）和新的配置参数（<literal>hibernate.current_session_context_class</literal>），以便对什么是当前会话的范围（scope）和上下文（context）的定义进行拔插。"
#. Tag: para
#: architecture.xml:326
-#, fuzzy, no-c-format
-msgid ""
-"See the Javadocs for the <literal>org.hibernate.context."
-"CurrentSessionContext</literal> interface for a detailed discussion of its "
-"contract. It defines a single method, <literal>currentSession()</literal>, "
-"by which the implementation is responsible for tracking the current "
-"contextual session. Out-of-the-box, Hibernate comes with three "
-"implementations of this interface:"
-msgstr ""
-"请参阅 <literal>org.hibernate.context.CurrentSessionContext</literal> 接口的 "
-"Javadoc，那里有关于它的契约的详细讨论。它定义了单一的方法，"
-"<literal>currentSession()</literal>，特定的实现用它来负责跟踪当前的上下文 "
-"session。Hibernate 内置了此接口的三种实现。"
+#, no-c-format
+msgid "See the Javadocs for the <literal>org.hibernate.context.CurrentSessionContext</literal> interface for a detailed discussion of its contract. It defines a single method, <literal>currentSession()</literal>, by which the implementation is responsible for tracking the current contextual session. Out-of-the-box, Hibernate comes with three implementations of this interface:"
+msgstr "请参阅 <literal>org.hibernate.context.CurrentSessionContext</literal> 接口的 Javadoc，那里有关于它的契约的详细讨论。它定义了单一的方法，<literal>currentSession()</literal>，特定的实现用它来负责跟踪当前的上下文相关的会话。Hibernate 内置了此接口的三种实现："
#. Tag: para
#: architecture.xml:336
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.context.JTASessionContext</literal>: current sessions "
-"are tracked and scoped by a <literal>JTA</literal> transaction. The "
-"processing here is exactly the same as in the older JTA-only approach. See "
-"the Javadocs for details."
-msgstr ""
-"<literal>org.hibernate.context.JTASessionContext</literal> — 当前 session 根"
-"据 <literal>JTA</literal> 来跟踪和界定。这和以前的仅支持 JTA 的方法是完全一样"
-"的。详情请参阅 Javadoc。"
+#, no-c-format
+msgid "<literal>org.hibernate.context.JTASessionContext</literal>: current sessions are tracked and scoped by a <literal>JTA</literal> transaction. The processing here is exactly the same as in the older JTA-only approach. See the Javadocs for details."
+msgstr "<literal>org.hibernate.context.JTASessionContext</literal>：当前会话根据 <literal>JTA</literal> 来跟踪和界定。这和以前的仅支持 JTA 的方法是完全一样的。详情请参阅 Javadoc。"
#. Tag: para
#: architecture.xml:344
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.context.ThreadLocalSessionContext</literal>:current "
-"sessions are tracked by thread of execution. See the Javadocs for details."
-msgstr ""
-"<literal>org.hibernate.context.ThreadLocalSessionContext</literal> — 当前 "
-"session 通过当前执行的线程来跟踪和界定。详情也请参阅 Javadoc。"
+#, no-c-format
+msgid "<literal>org.hibernate.context.ThreadLocalSessionContext</literal>:current sessions are tracked by thread of execution. See the Javadocs for details."
+msgstr "<literal>org.hibernate.context.ThreadLocalSessionContext</literal>：当前会话通过当前执行的线程来跟踪和界定。详情也请参阅 Javadoc。"
#. Tag: para
#: architecture.xml:350
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.context.ManagedSessionContext</literal>: current "
-"sessions are tracked by thread of execution. However, you are responsible to "
-"bind and unbind a <literal>Session</literal> instance with static methods on "
-"this class: it does not open, flush, or close a <literal>Session</literal>."
-msgstr ""
-"<literal>org.hibernate.context.ManagedSessionContext</literal> — 当前 "
-"session 通过当前执行的线程来跟踪和界定。但是，你需要负责使用这个类的静态方法"
-"将 <literal>Session</literal> 实例绑定、或者取消绑定，它并不会打开（open）、"
-"flush 或者关闭（close）任何 <literal>Session</literal>。"
+#, no-c-format
+msgid "<literal>org.hibernate.context.ManagedSessionContext</literal>: current sessions are tracked by thread of execution. However, you are responsible to bind and unbind a <literal>Session</literal> instance with static methods on this class: it does not open, flush, or close a <literal>Session</literal>."
+msgstr "<literal>org.hibernate.context.ManagedSessionContext</literal>：当前会话通过当前执行的线程来跟踪和界定。但是，你需要负责使用这个类的静态方法将 <literal>Session</literal> 实例绑定、或者取消绑定，它并不会打开（open）、flush 或者关闭（close）任何 <literal>Session</literal>。"
#. Tag: para
#: architecture.xml:359
-#, fuzzy, no-c-format
-msgid ""
-"The first two implementations provide a \"one session - one database "
-"transaction\" programming model. This is also also known and used as "
-"<emphasis>session-per-request</emphasis>. The beginning and end of a "
-"Hibernate session is defined by the duration of a database transaction. If "
-"you use programmatic transaction demarcation in plain JSE without JTA, you "
-"are advised to use the Hibernate <literal>Transaction</literal> API to hide "
-"the underlying transaction system from your code. If you use JTA, you can "
-"utilize the JTA interfaces to demarcate transactions. If you execute in an "
-"EJB container that supports CMT, transaction boundaries are defined "
-"declaratively and you do not need any transaction or session demarcation "
-"operations in your code. Refer to <xref linkend=\"transactions\"/> for more "
-"information and code examples."
-msgstr ""
-"前两种实现都提供了“每数据库事务对应一个 session”的编程模型，也称作<emphasis>"
-"每次请求一个session</emphasis>。Hibernate session 的起始和终结由数据库事务的"
-"生存来控制。假若你在纯粹的 Java SE之上采用自行编写代码来管理事务，而不使用 "
-"JTA，建议你使用 Hibernate <literal>Transaction</literal> API 来把底层事务实现"
-"从你的代码中隐藏掉。如果你使用 JTA，请使用 JTA 接口来管理 Transaction。如果你"
-"在支持 CMT 的 EJB 容器中执行代码，事务边界是声明式定义的，你不需要在代码中进"
-"行任何事务或 session 管理操作。请参阅 <xref linkend="
-"\"Transactions_And_Concurrency\"/> 一节来阅读更多的内容和示例代码。"
+#, no-c-format
+msgid "The first two implementations provide a \"one session - one database transaction\" programming model. This is also also known and used as <emphasis>session-per-request</emphasis>. The beginning and end of a Hibernate session is defined by the duration of a database transaction. If you use programmatic transaction demarcation in plain JSE without JTA, you are advised to use the Hibernate <literal>Transaction</literal> API to hide the underlying transaction system from your code. If you use JTA, you can utilize the JTA interfaces to demarcate transactions. If you execute in an EJB container that supports CMT, transaction boundaries are defined declaratively and you do not need any transaction or session demarcation operations in your code. Refer to <xref linkend=\"transactions\"/> for more information and code examples."
+msgstr "前两种实现都提供了“one session - one database transaction”的编程模型，也称作 <emphasis>session-per-request</emphasis>。Hibernate session 的起始和终结由数据库事务的生存来控制。假若你在纯粹的 Java SE之上采用自行编写代码来管理事务，而不使用 JTA，建议你使用 Hibernate <literal>Transaction</literal> API 来把底层事务实现从你的代码中隐藏掉。如果你使用 JTA，请使用 JTA 接口来对事务限界。如果你在支持 CMT 的 EJB 容器中执行代码，事务边界是声明式定义的，你不需要在代码中进行任何事务或会话管理操作。请参阅 <xref linkend=\"transactions\"/> 一节来阅读更多的内容和示例代码。"
#. Tag: para
#: architecture.xml:371
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>hibernate.current_session_context_class</literal> configuration "
-"parameter defines which <literal>org.hibernate.context."
-"CurrentSessionContext</literal> implementation should be used. For backwards "
-"compatibility, if this configuration parameter is not set but a <literal>org."
-"hibernate.transaction.TransactionManagerLookup</literal> is configured, "
-"Hibernate will use the <literal>org.hibernate.context.JTASessionContext</"
-"literal>. Typically, the value of this parameter would just name the "
-"implementation class to use. For the three out-of-the-box implementations, "
-"however, there are three corresponding short names: \"jta\", \"thread\", and "
-"\"managed\"."
-msgstr ""
-"<literal>hibernate.current_session_context_class</literal> 配置参数定义了应该"
-"采用哪个 <literal>org.hibernate.context.CurrentSessionContext</literal> 实"
-"现。注意，为了向下兼容，如果未配置此参数，但是存在 <literal>org.hibernate."
-"transaction.TransactionManagerLookup</literal> 的配置，Hibernate 会采用"
-"<literal>org.hibernate.context.JTASessionContext</literal>。一般而言，此参数"
-"的值指明了要使用的实现类的全名，但那三种内置的实现可以使用简写，即 \"jta\"、"
-"\"thread\" 和 \"managed\"。"
+#, no-c-format
+msgid "The <literal>hibernate.current_session_context_class</literal> configuration parameter defines which <literal>org.hibernate.context.CurrentSessionContext</literal> implementation should be used. For backwards compatibility, if this configuration parameter is not set but a <literal>org.hibernate.transaction.TransactionManagerLookup</literal> is configured, Hibernate will use the <literal>org.hibernate.context.JTASessionContext</literal>. Typically, the value of this parameter would just name the implementation class to use. For the three out-of-the-box implementations, however, there are three corresponding short names: \"jta\", \"thread\", and \"managed\"."
+msgstr "<literal>hibernate.current_session_context_class</literal> 配置参数定义了应该采用哪个 <literal>org.hibernate.context.CurrentSessionContext</literal> 实现。注意，为了向下兼容，如果未配置此参数，但是存在 <literal>org.hibernate.transaction.TransactionManagerLookup</literal> 的配置，Hibernate 会采用<literal>org.hibernate.context.JTASessionContext</literal>。一般而言，此参数的值指明了要使用的实现类的全名，但那三种内置的实现可以使用简写，即 \"jta\"、\"thread\" 和 \"managed\"。 "
+
More information about the jboss-cvs-commits
mailing list