[jboss-cvs] JBossAS SVN: r97498 - projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Mon Dec 7 06:52:20 EST 2009
Author: xhuang at jboss.com
Date: 2009-12-07 06:52:20 -0500 (Mon, 07 Dec 2009)
New Revision: 97498
Modified:
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/tutorial.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/xml.po
Log:
update
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/tutorial.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/tutorial.po 2009-12-07 11:18:59 UTC (rev 97497)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/tutorial.po 2009-12-07 11:52:20 UTC (rev 97498)
@@ -7,7 +7,7 @@
"Project-Id-Version: tutorial\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-12-03T00:15:27\n"
-"PO-Revision-Date: 2009-11-18 11:24+1000\n"
+"PO-Revision-Date: 2009-12-07 21:51+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -22,34 +22,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Intended for new users, this chapter provides an step-by-step introduction "
-"to Hibernate, starting with a simple application using an in-memory "
-"database. The tutorial is based on an earlier tutorial developed by Michael "
-"Gloegl. All code is contained in the <filename>tutorials/web</filename> "
-"directory of the project source."
-msgstr ""
-"面向新用户，从一个简单的使用内存数据库的例子开始，本章提供对 Hibernate 的逐步"
-"介绍。本教程基于 Michael Gloegl 早期编写的手册。所有代码都包含在 "
-"<filename>tutorials/web</filename> 目录下。"
+msgid "Intended for new users, this chapter provides an step-by-step introduction to Hibernate, starting with a simple application using an in-memory database. The tutorial is based on an earlier tutorial developed by Michael Gloegl. All code is contained in the <filename>tutorials/web</filename> directory of the project source."
+msgstr "面向新用户，从一个简单的使用内存数据库的例子开始，本章提供对 Hibernate 的逐步介绍。本教程基于 Michael Gloegl 早期编写的手册。所有代码都包含在 <filename>tutorials/web</filename> 目录下。"
#. Tag: para
#, no-c-format
-msgid ""
-"This tutorial expects the user have knowledge of both Java and SQL. If you "
-"have a limited knowledge of JAVA or SQL, it is advised that you start with a "
-"good introduction to that technology prior to attempting to learn Hibernate."
-msgstr ""
-"本教程期望用户具备 Java 和 SQL 知识。如果你这方面的知识有限，我们建议你在学"
-"习 Hibernate 之前先好好了解这些技术。"
+msgid "This tutorial expects the user have knowledge of both Java and SQL. If you have a limited knowledge of JAVA or SQL, it is advised that you start with a good introduction to that technology prior to attempting to learn Hibernate."
+msgstr "本教程期望用户具备 Java 和 SQL 知识。如果你这方面的知识有限，我们建议你在学习 Hibernate 之前先好好了解这些技术。"
#. Tag: para
#, no-c-format
-msgid ""
-"The distribution contains another example application under the "
-"<filename>tutorial/eg</filename> project source directory."
-msgstr ""
-"本版本在源代码目录 <filename>tutorial/eg</filename> 下还包含另外一个例程。"
+msgid "The distribution contains another example application under the <filename>tutorial/eg</filename> project source directory."
+msgstr "本版本在源代码目录 <filename>tutorial/eg</filename> 下还包含另外一个例程。"
#. Tag: title
#, no-c-format
@@ -58,25 +42,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"For this example, we will set up a small database application that can store "
-"events we want to attend and information about the host(s) of these events."
-msgstr ""
-"在这个例子里，我们将设立一个小应用程序可以保存我们希望参加的活动（events）和"
-"这些活动主办方的相关信息。（译者注：在本教程的后面部分，我们将直接使用 event "
-"而不是它的中文翻译“活动”，以免混淆。）"
+msgid "For this example, we will set up a small database application that can store events we want to attend and information about the host(s) of these events."
+msgstr "在这个例子里，我们将设立一个小应用程序可以保存我们希望参加的活动（events）和这些活动主办方的相关信息。（译者注：在本教程的后面部分，我们将直接使用 event 而不是它的中文翻译“活动”，以免混淆。）"
#. Tag: para
#, no-c-format
-msgid ""
-"Although you can use whatever database you feel comfortable using, we will "
-"use <ulink url=\"http://hsqldb.org/\">HSQLDB</ulink> (an in-memory, Java "
-"database) to avoid describing installation/setup of any particular database "
-"servers."
-msgstr ""
-"虽然你可以使用任何数据库，我们还是用 <ulink url=\"http://hsqldb.org/"
-"\">HSQLDB</ulink>（一个用 Java 编写的内存数据库）来避免花费篇章对数据库服务器"
-"的安装/配置进行解释。"
+msgid "Although you can use whatever database you feel comfortable using, we will use <ulink url=\"http://hsqldb.org/\">HSQLDB</ulink> (an in-memory, Java database) to avoid describing installation/setup of any particular database servers."
+msgstr "虽然你可以使用任何数据库，我们还是用 <ulink url=\"http://hsqldb.org/\">HSQLDB</ulink>（一个用 Java 编写的内存数据库）来避免花费篇章对数据库服务器的安装/配置进行解释。"
#. Tag: title
#, no-c-format
@@ -85,65 +57,22 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The first thing we need to do is to set up the development environment. We "
-"will be using the \"standard layout\" advocated by alot of build tools such "
-"as <ulink url=\"http://maven.org\">Maven</ulink>. Maven, in particular, has "
-"a good resource describing this <ulink url=\"http://maven.apache.org/guides/"
-"introduction/introduction-to-the-standard-directory-layout.html\">layout</"
-"ulink>. As this tutorial is to be a web application, we will be creating and "
-"making use of <filename>src/main/java</filename>, <filename>src/main/"
-"resources</filename> and <filename>src/main/webapp</filename> directories."
-msgstr ""
-"我们需要做的第一件事情是设置开发环境。我们将使用许多构建工具如 <ulink url="
-"\"http://maven.org\">Maven</ulink> 所鼓吹的“标准格式”。特别是 Maven，它的资源"
-"对这个<ulink url=\"http://maven.apache.org/guides/introduction/introduction-"
-"to-the-standard-directory-layout.html\">格式（layout）</ulink>有着很好的描"
-"述。因为本教程使用的是 web 应用程序，我么将创建和使用 <filename>src/main/"
-"java</filename>、<filename>src/main/resources</filename> 和 <filename>src/"
-"main/webapp</filename> 目录。"
+msgid "The first thing we need to do is to set up the development environment. We will be using the \"standard layout\" advocated by alot of build tools such as <ulink url=\"http://maven.org\">Maven</ulink>. Maven, in particular, has a good resource describing this <ulink url=\"http://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html\">layout</ulink>. As this tutorial is to be a web application, we will be creating and making use of <filename>src/main/java</filename>, <filename>src/main/resources</filename> and <filename>src/main/webapp</filename> directories."
+msgstr "我们需要做的第一件事情是设置开发环境。我们将使用许多构建工具如 <ulink url=\"http://maven.org\">Maven</ulink> 所鼓吹的“标准格式”。特别是 Maven，它的资源对这个<ulink url=\"http://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html\">格式（layout）</ulink>有着很好的描述。因为本教程使用的是 web 应用程序，我么将创建和使用 <filename>src/main/java</filename>、<filename>src/main/resources</filename> 和 <filename>src/main/webapp</filename> 目录。"
#. Tag: para
#, no-c-format
-msgid ""
-"We will be using Maven in this tutorial, taking advantage of its transitive "
-"dependency management capabilities as well as the ability of many IDEs to "
-"automatically set up a project for us based on the maven descriptor."
-msgstr ""
-"在本教程里我们将使用 Maven，利用其 transitive dependency 管理以及根据 Maven "
-"描述符用 IDE 自动设置项目的能力。"
+msgid "We will be using Maven in this tutorial, taking advantage of its transitive dependency management capabilities as well as the ability of many IDEs to automatically set up a project for us based on the maven descriptor."
+msgstr "在本教程里我们将使用 Maven，利用其 transitive dependency 管理以及根据 Maven 描述符用 IDE 自动设置项目的能力。"
#. Tag: para
#, no-c-format
-msgid ""
-"It is not a requirement to use Maven. If you wish to use another technology "
-"to build this tutoial (such as Ant), the layout will remain the same. The "
-"only change is that you will need to manually account for all the needed "
-"dependencies. If you use <ulink url=\"http://ant.apache.org/ivy/\">Ivy</"
-"ulink> to provide transitive dependency management you would still use the "
-"dependencies mentioned below. Otherwise, you will need to find all the "
-"dependencies, both explicit and transitive, and add them to the projects "
-"classpath. If working from the Hibernate distribution bundle, this would "
-"mean <filename>hibernate3.jar</filename>, all artifacts in the <filename>lib/"
-"required</filename> directory and all files from either the <filename>lib/"
-"bytecode/cglib</filename> or <filename>lib/bytecode/javassist</filename> "
-"directory; additionally you will need both the servlet-api jar and one of "
-"the slf4j logging backends."
-msgstr ""
-"Maven 并不要求这样。如果你希望使用其他技术来构建这个教程（如 Ant），格式将保"
-"持不变。唯一的改变是你将需要手工管理所有的依赖关系。如果你使用 <ulink url="
-"\"http://ant.apache.org/ivy/\">Ivy</ulink> 来提供 transitive dependency 管"
-"理，你将仍然下面提到的依赖关系。否则，你将需要找到所有的依赖关系（显性的和过"
-"渡的）并把它们添加到项目的 classpath 里。如果使用 Hibernate 捆绑版本，这意味"
-"着 <filename>hibernate3.jar</filename>、<filename>lib/required</filename> 目"
-"录下的所有 artifact 和 <filename>lib/bytecode/cglib</filename> 或 "
-"<filename>lib/bytecode/javassist</filename> 下的所有文件，此外你将需要 "
-"servlet-api jar 和一个 slf4j 日志后台文件。"
+msgid "It is not a requirement to use Maven. If you wish to use another technology to build this tutoial (such as Ant), the layout will remain the same. The only change is that you will need to manually account for all the needed dependencies. If you use <ulink url=\"http://ant.apache.org/ivy/\">Ivy</ulink> to provide transitive dependency management you would still use the dependencies mentioned below. Otherwise, you will need to find all the dependencies, both explicit and transitive, and add them to the projects classpath. If working from the Hibernate distribution bundle, this would mean <filename>hibernate3.jar</filename>, all artifacts in the <filename>lib/required</filename> directory and all files from either the <filename>lib/bytecode/cglib</filename> or <filename>lib/bytecode/javassist</filename> directory; additionally you will need both the servlet-api jar and one of the slf4j logging backends."
+msgstr "Maven 并不要求这样。如果你希望使用其他技术来构建这个教程（如 Ant），格式将保持不变。唯一的改变是你将需要手工管理所有的依赖关系。如果你使用 <ulink url=\"http://ant.apache.org/ivy/\">Ivy</ulink> 来提供 transitive dependency 管理，你将仍然下面提到的依赖关系。否则，你将需要找到所有的依赖关系（显性的和过渡的）并把它们添加到项目的 classpath 里。如果使用 Hibernate 捆绑版本，这意味着 <filename>hibernate3.jar</filename>、<filename>lib/required</filename> 目录下的所有 artifact 和 <filename>lib/bytecode/cglib</filename> 或 <filename>lib/bytecode/javassist</filename> 下的所有文件，此外你将需要 servlet-api jar 和一个 slf4j 日志后台文件。"
#. Tag: para
#, no-c-format
-msgid ""
-"Save this file as <filename>pom.xml</filename> in the project root directory."
+msgid "Save this file as <filename>pom.xml</filename> in the project root directory."
msgstr "把这个文件保存为项目根目录下的 <filename>pom.xml</filename>。"
#. Tag: title
@@ -153,75 +82,28 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Next, we create a class that represents the event we want to store in the "
-"database; it is a simple JavaBean class with some properties:"
-msgstr ""
-"接下来我们创建一个类，用来代表那些我们希望储存在数据库里的 event，这是一个具"
-"有一些属性的简单 JavaBean 类："
+msgid "Next, we create a class that represents the event we want to store in the database; it is a simple JavaBean class with some properties:"
+msgstr "接下来我们创建一个类，用来代表那些我们希望储存在数据库里的 event，这是一个具有一些属性的简单 JavaBean 类："
#. Tag: para
#, no-c-format
-msgid ""
-"This class uses standard JavaBean naming conventions for property getter and "
-"setter methods, as well as private visibility for the fields. Although this "
-"is the recommended design, it is not required. Hibernate can also access "
-"fields directly, the benefit of accessor methods is robustness for "
-"refactoring."
-msgstr ""
-"你可以看到这个类对属性的存取方法（getter and setter method）使用了标准 "
-"JavaBean 命名约定，同时把类属性（field）的访问级别设成私有的（private）。这是"
-"推荐的设计，但并不是必须的。Hibernate 也可以直接访问这些 field，而使用访问方"
-"法（accessor method）的好处是提供了重构时的健壮性（robustness）。"
+msgid "This class uses standard JavaBean naming conventions for property getter and setter methods, as well as private visibility for the fields. Although this is the recommended design, it is not required. Hibernate can also access fields directly, the benefit of accessor methods is robustness for refactoring."
+msgstr "你可以看到这个类对属性的存取方法（getter and setter method）使用了标准 JavaBean 命名约定，同时把类属性（field）的访问级别设成私有的（private）。这是推荐的设计，但并不是必须的。Hibernate 也可以直接访问这些 field，而使用访问方法（accessor method）的好处是提供了重构时的健壮性（robustness）。"
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>id</literal> property holds a unique identifier value for a "
-"particular event. All persistent entity classes (there are less important "
-"dependent classes as well) will need such an identifier property if we want "
-"to use the full feature set of Hibernate. In fact, most applications, "
-"especially web applications, need to distinguish objects by identifier, so "
-"you should consider this a feature rather than a limitation. However, we "
-"usually do not manipulate the identity of an object, hence the setter method "
-"should be private. Only Hibernate will assign identifiers when an object is "
-"saved. Hibernate can access public, private, and protected accessor methods, "
-"as well as public, private and protected fields directly. The choice is up "
-"to you and you can match it to fit your application design."
-msgstr ""
-"对一特定的 event, <literal>id</literal> 属性持有唯一的标识符（identifier）的"
-"值。如果我们希望使用 Hibernate 提供的所有特性，那么所有的持久化实体"
-"（persistent entity）类（这里也包括一些次要依赖类）都需要一个这样的标识符属"
-"性。而事实上，大多数应用程序（特别是 web 应用程序）都需要通过标识符来区别对"
-"象，所以你应该考虑使用标识符属性而不是把它当作一种限制。然而，我们通常不会操"
-"作对象的标识（identity），因此它的 setter 方法的访问级别应该声明 private。这"
-"样当对象被保存的时候，只有 Hibernate 可以为它分配标识符值。你可看到Hibernate"
-"可以直接访问 public，private 和 protected 的访问方法和 field。所以选择哪种方"
-"式完全取决于你，你可以使你的选择与你的应用程序设计相吻合。 "
+msgid "The <literal>id</literal> property holds a unique identifier value for a particular event. All persistent entity classes (there are less important dependent classes as well) will need such an identifier property if we want to use the full feature set of Hibernate. In fact, most applications, especially web applications, need to distinguish objects by identifier, so you should consider this a feature rather than a limitation. However, we usually do not manipulate the identity of an object, hence the setter method should be private. Only Hibernate will assign identifiers when an object is saved. Hibernate can access public, private, and protected accessor methods, as well as public, private and protected fields directly. The choice is up to you and you can match it to fit your application design."
+msgstr "对一特定的 event, <literal>id</literal> 属性持有唯一的标识符（identifier）的值。如果我们希望使用 Hibernate 提供的所有特性，那么所有的持久化实体（persistent entity）类（这里也包括一些次要依赖类）都需要一个这样的标识符属性。而事实上，大多数应用程序（特别是 web 应用程序）都需要通过标识符来区别对象，所以你应该考虑使用标识符属性而不是把它当作一种限制。然而，我们通常不会操作对象的标识（identity），因此它的 setter 方法的访问级别应该声明 private。这样当对象被保存的时候，只有 Hibernate 可以为它分配标识符值。你可看到Hibernate可以直接访问 public，private 和 protected 的访问方法和 field。所以选择哪种方式完全取决于你，你可以使你的选择与你的应用程序设计相吻合。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The no-argument constructor is a requirement for all persistent classes; "
-"Hibernate has to create objects for you, using Java Reflection. The "
-"constructor can be private, however package or public visibility is required "
-"for runtime proxy generation and efficient data retrieval without bytecode "
-"instrumentation."
-msgstr ""
-"所有的持久化类（persistent classes）都要求有无参的构造器，因为 Hibernate 必须"
-"使用 Java 反射机制来为你创建对象。构造器（constructor）的访问级别可以是 "
-"private，然而当生成运行时代理（runtime proxy）的时候则要求使用至少是 package "
-"级别的访问控制，这样在没有字节码指令（bytecode instrumentation）的情况下，从"
-"持久化类里获取数据会更有效率。 "
+msgid "The no-argument constructor is a requirement for all persistent classes; Hibernate has to create objects for you, using Java Reflection. The constructor can be private, however package or public visibility is required for runtime proxy generation and efficient data retrieval without bytecode instrumentation."
+msgstr "所有的持久化类（persistent classes）都要求有无参的构造器，因为 Hibernate 必须使用 Java 反射机制来为你创建对象。构造器（constructor）的访问级别可以是 private，然而当生成运行时代理（runtime proxy）的时候则要求使用至少是 package 级别的访问控制，这样在没有字节码指令（bytecode instrumentation）的情况下，从持久化类里获取数据会更有效率。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Save this file to the <filename>src/main/java/org/hibernate/tutorial/domain</"
-"filename> directory."
-msgstr ""
-"把这个文件保存到 <filename>src/main/java/org/hibernate/tutorial/domain</"
-"filename> 目录下。"
+msgid "Save this file to the <filename>src/main/java/org/hibernate/tutorial/domain</filename> directory."
+msgstr "把这个文件保存到 <filename>src/main/java/org/hibernate/tutorial/domain</filename> 目录下。"
#. Tag: title
#, no-c-format
@@ -230,15 +112,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate needs to know how to load and store objects of the persistent "
-"class. This is where the Hibernate mapping file comes into play. The mapping "
-"file tells Hibernate what table in the database it has to access, and what "
-"columns in that table it should use."
-msgstr ""
-"Hibernate 需要知道怎样去加载（load）和存储（store）持久化类的对象。这正是 "
-"Hibernate 映射文件发挥作用的地方。映射文件告诉 Hibernate 它应该访问数据库"
-"（database）里面的哪个表（table）及应该使用表里面的哪些字段（column）。"
+msgid "Hibernate needs to know how to load and store objects of the persistent class. This is where the Hibernate mapping file comes into play. The mapping file tells Hibernate what table in the database it has to access, and what columns in that table it should use."
+msgstr "Hibernate 需要知道怎样去加载（load）和存储（store）持久化类的对象。这正是 Hibernate 映射文件发挥作用的地方。映射文件告诉 Hibernate 它应该访问数据库（database）里面的哪个表（table）及应该使用表里面的哪些字段（column）。"
#. Tag: para
#, no-c-format
@@ -247,192 +122,68 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate DTD is sophisticated. You can use it for auto-completion of XML "
-"mapping elements and attributes in your editor or IDE. Opening up the DTD "
-"file in your text editor is the easiest way to get an overview of all "
-"elements and attributes, and to view the defaults, as well as some comments. "
-"Hibernate will not load the DTD file from the web, but first look it up from "
-"the classpath of the application. The DTD file is included in "
-"<filename>hibernate-core.jar</filename> (it is also included in the "
-"<filename>hibernate3.jar</filename>, if using the distribution bundle)."
-msgstr ""
-"注意 Hibernate 的 DTD 是非常复杂的。你的编辑器或者 IDE 里使用它来自动完成那些"
-"用来映射的 XML 元素（element）和属性（attribute）。你也可以在文本编辑器里打"
-"开 DTD — 这是最简单的方式来概览所有的元素和 attribute，并查看它们的缺省值以及"
-"注释。注意 Hibernate 不会从 web 加载 DTD 文件，但它会首先在应用程序的 "
-"classpath 中查找。DTD 文件已包括在 <literal>hibernate3.jar</literal> 里，同时"
-"也在 Hibernate 发布包的 <literal>src/</literal> 目录下。 "
+msgid "Hibernate DTD is sophisticated. You can use it for auto-completion of XML mapping elements and attributes in your editor or IDE. Opening up the DTD file in your text editor is the easiest way to get an overview of all elements and attributes, and to view the defaults, as well as some comments. Hibernate will not load the DTD file from the web, but first look it up from the classpath of the application. The DTD file is included in <filename>hibernate-core.jar</filename> (it is also included in the <filename>hibernate3.jar</filename>, if using the distribution bundle)."
+msgstr "注意 Hibernate 的 DTD 是非常复杂的。你的编辑器或者 IDE 里使用它来自动完成那些用来映射的 XML 元素（element）和属性（attribute）。你也可以在文本编辑器里打开 DTD — 这是最简单的方式来概览所有的元素和 attribute，并查看它们的缺省值以及注释。注意 Hibernate 不会从 web 加载 DTD 文件，但它会首先在应用程序的 classpath 中查找。DTD 文件已包括在 <literal>hibernate3.jar</literal> 里，同时也在 Hibernate 发布包的 <literal>src/</literal> 目录下。 "
#. Tag: para
#, no-c-format
-msgid ""
-"We will omit the DTD declaration in future examples to shorten the code. It "
-"is, of course, not optional."
-msgstr ""
-"为缩短代码长度，在以后的例子里我们会省略 DTD 的声明。当然，在实际的应用程序"
-"中，DTD 声明是必需的。 "
+msgid "We will omit the DTD declaration in future examples to shorten the code. It is, of course, not optional."
+msgstr "为缩短代码长度，在以后的例子里我们会省略 DTD 的声明。当然，在实际的应用程序中，DTD 声明是必需的。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Between the two <literal>hibernate-mapping</literal> tags, include a "
-"<literal>class</literal> element. All persistent entity classes (again, "
-"there might be dependent classes later on, which are not first-class "
-"entities) need a mapping to a table in the SQL database:"
-msgstr ""
-"在 <literal>hibernate-mapping</literal> 标签（tag）之间, 含有一个 "
-"<literal>class</literal> 元素。所有的持久化实体类（再次声明，或许接下来会有依"
-"赖类，就是那些次要的实体）都需要一个这样的映射，来把类对象映射到 SQL 数据库里"
-"的表："
+msgid "Between the two <literal>hibernate-mapping</literal> tags, include a <literal>class</literal> element. All persistent entity classes (again, there might be dependent classes later on, which are not first-class entities) need a mapping to a table in the SQL database:"
+msgstr "在 <literal>hibernate-mapping</literal> 标签（tag）之间, 含有一个 <literal>class</literal> 元素。所有的持久化实体类（再次声明，或许接下来会有依赖类，就是那些次要的实体）都需要一个这样的映射，来把类对象映射到 SQL 数据库里的表："
#. Tag: para
#, no-c-format
-msgid ""
-"So far we have told Hibernate how to persist and load object of class "
-"<literal>Event</literal> to the table <literal>EVENTS</literal>. Each "
-"instance is now represented by a row in that table. Now we can continue by "
-"mapping the unique identifier property to the tables primary key. As we do "
-"not want to care about handling this identifier, we configure Hibernate's "
-"identifier generation strategy for a surrogate primary key column:"
-msgstr ""
-"到目前为止，我们告诉了 Hibernate 怎样把 <literal>Events</literal> 类的对象持"
-"久化到数据库的 <literal>EVENTS</literal> 表里，以及怎样从 <literal>EVENTS</"
-"literal> 表加载到 <literal>Events</literal> 类的对象。每个实例对应着数据库表"
-"中的一行。现在我们将继续讨论有关唯一标识符属性到数据库表的映射。另外，由于我"
-"们不关心怎样处理这个标识符，我们就配置由 Hibernate 的标识符生成策略来产生代理"
-"主键字段："
+msgid "So far we have told Hibernate how to persist and load object of class <literal>Event</literal> to the table <literal>EVENTS</literal>. Each instance is now represented by a row in that table. Now we can continue by mapping the unique identifier property to the tables primary key. As we do not want to care about handling this identifier, we configure Hibernate's identifier generation strategy for a surrogate primary key column:"
+msgstr "到目前为止，我们告诉了 Hibernate 怎样把 <literal>Events</literal> 类的对象持久化到数据库的 <literal>EVENTS</literal> 表里，以及怎样从 <literal>EVENTS</literal> 表加载到 <literal>Events</literal> 类的对象。每个实例对应着数据库表中的一行。现在我们将继续讨论有关唯一标识符属性到数据库表的映射。另外，由于我们不关心怎样处理这个标识符，我们就配置由 Hibernate 的标识符生成策略来产生代理主键字段："
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>id</literal> element is the declaration of the identifier "
-"property. The <literal>name=\"id\"</literal> mapping attribute declares the "
-"name of the JavaBean property and tells Hibernate to use the <literal>getId()"
-"</literal> and <literal>setId()</literal> methods to access the property. "
-"The column attribute tells Hibernate which column of the <literal>EVENTS</"
-"literal> table holds the primary key value."
-msgstr ""
-"<literal>id</literal> 元素是对 identifier 属性的声明。<literal>name=\"id\"</"
-"literal> 映射属性声明了 JavaBean 属性的名称并告诉 Hibernate 使用 "
-"<literal>getId()</literal> 和 <literal>setId()</literal> 方法来访问这个属性。"
-"column 属性告诉 Hibernate <literal>EVENTS</literal> 表的哪个字段持有主键值。"
+msgid "The <literal>id</literal> element is the declaration of the identifier property. The <literal>name=\"id\"</literal> mapping attribute declares the name of the JavaBean property and tells Hibernate to use the <literal>getId()</literal> and <literal>setId()</literal> methods to access the property. The column attribute tells Hibernate which column of the <literal>EVENTS</literal> table holds the primary key value."
+msgstr "<literal>id</literal> 元素是对 identifier 属性的声明。<literal>name=\"id\"</literal> 映射属性声明了 JavaBean 属性的名称并告诉 Hibernate 使用 <literal>getId()</literal> 和 <literal>setId()</literal> 方法来访问这个属性。column 属性告诉 Hibernate <literal>EVENTS</literal> 表的哪个字段持有主键值。"
#. Tag: para
#, no-c-format
-msgid ""
-"The nested <literal>generator</literal> element specifies the identifier "
-"generation strategy (aka how are identifier values generated?). In this case "
-"we choose <literal>native</literal>, which offers a level of portability "
-"depending on the configured database dialect. Hibernate supports database "
-"generated, globally unique, as well as application assigned, identifiers. "
-"Identifier value generation is also one of Hibernate's many extension points "
-"and you can plugin in your own strategy."
-msgstr ""
-"嵌套的 <literal>generator</literal> 元素指定标识符的生成策略（也就是标识符值"
-"是怎么产生的）。在这个例子里，我们选择 <literal>native</literal>，它提供了取"
-"决于数据库方言的可移植性。Hibernate 数据库生成的、全局性唯一的以及应用程序分"
-"配的标识符。标识符值的生成也是 Hibernate 的扩展功能之一，你可以插入自己的策"
-"略。"
+msgid "The nested <literal>generator</literal> element specifies the identifier generation strategy (aka how are identifier values generated?). In this case we choose <literal>native</literal>, which offers a level of portability depending on the configured database dialect. Hibernate supports database generated, globally unique, as well as application assigned, identifiers. Identifier value generation is also one of Hibernate's many extension points and you can plugin in your own strategy."
+msgstr "嵌套的 <literal>generator</literal> 元素指定标识符的生成策略（也就是标识符值是怎么产生的）。在这个例子里，我们选择 <literal>native</literal>，它提供了取决于数据库方言的可移植性。Hibernate 数据库生成的、全局性唯一的以及应用程序分配的标识符。标识符值的生成也是 Hibernate 的扩展功能之一，你可以插入自己的策略。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>native</literal> is no longer considered the best strategy in terms "
-"of portability. for further discussion, see <xref linkend=\"portability-idgen"
-"\" />"
-msgstr ""
-"从移植性来说，<literal>native</literal> 不再被认为是最好的策略。进一步的讨"
-"论，请参考："
+#, no-c-format
+msgid "<literal>native</literal> is no longer considered the best strategy in terms of portability. for further discussion, see <xref linkend=\"portability-idgen\" />"
+msgstr "从移植性来说，<literal>native</literal> 不再被认为是最好的策略。进一步的讨论，请参考 <xref linkend=\"portability-idgen\" />。"
#. Tag: para
#, no-c-format
-msgid ""
-"Lastly, we need to tell Hibernate about the remaining entity class "
-"properties. By default, no properties of the class are considered persistent:"
-msgstr ""
-"最后我们在映射文件里面包含需要持久化属性的声明。默认情况下，类里面的属性都被"
-"视为非持久化的： "
+msgid "Lastly, we need to tell Hibernate about the remaining entity class properties. By default, no properties of the class are considered persistent:"
+msgstr "最后我们在映射文件里面包含需要持久化属性的声明。默认情况下，类里面的属性都被视为非持久化的： "
#. Tag: para
#, no-c-format
-msgid ""
-"Similar to the <literal>id</literal> element, the <literal>name</literal> "
-"attribute of the <literal>property</literal> element tells Hibernate which "
-"getter and setter methods to use. In this case, Hibernate will search for "
-"<literal>getDate()</literal>, <literal>setDate()</literal>, <literal>getTitle"
-"()</literal> and <literal>setTitle()</literal> methods."
-msgstr ""
-"和 <literal>id</literal> 元素一样，<literal>property</literal> 元素的 "
-"<literal>name</literal> 属性告诉 Hibernate 使用哪个 getter 和 setter 方法。在"
-"此例中，Hibernate 会寻找 <literal>getDate()</literal>、<literal>setDate()</"
-"literal>、<literal>getTitle()</literal> 和 <literal>setTitle()</literal> 方"
-"法。 "
+msgid "Similar to the <literal>id</literal> element, the <literal>name</literal> attribute of the <literal>property</literal> element tells Hibernate which getter and setter methods to use. In this case, Hibernate will search for <literal>getDate()</literal>, <literal>setDate()</literal>, <literal>getTitle()</literal> and <literal>setTitle()</literal> methods."
+msgstr "和 <literal>id</literal> 元素一样，<literal>property</literal> 元素的 <literal>name</literal> 属性告诉 Hibernate 使用哪个 getter 和 setter 方法。在此例中，Hibernate 会寻找 <literal>getDate()</literal>、<literal>setDate()</literal>、<literal>getTitle()</literal> 和 <literal>setTitle()</literal> 方法。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Why does the <literal>date</literal> property mapping include the "
-"<literal>column</literal> attribute, but the <literal>title</literal> does "
-"not? Without the <literal>column</literal> attribute, Hibernate by default "
-"uses the property name as the column name. This works for <literal>title</"
-"literal>, however, <literal>date</literal> is a reserved keyword in most "
-"databases so you will need to map it to a different name."
-msgstr ""
-"为什么 <literal>date</literal> 属性的映射含有 <literal>column</literal> "
-"attribute，而 <literal>title</literal> 却没有？当没有设定 <literal>column</"
-"literal> attribute 的时候，Hibernate 缺省地使用 JavaBean 的属性名作为字段名。"
-"对于 <literal>title</literal>，这样工作得很好。然而，<literal>date</literal> "
-"在多数的数据库里，是一个保留关键字，所以我们最好把它映射成一个不同的名字。 "
+msgid "Why does the <literal>date</literal> property mapping include the <literal>column</literal> attribute, but the <literal>title</literal> does not? Without the <literal>column</literal> attribute, Hibernate by default uses the property name as the column name. This works for <literal>title</literal>, however, <literal>date</literal> is a reserved keyword in most databases so you will need to map it to a different name."
+msgstr "为什么 <literal>date</literal> 属性的映射含有 <literal>column</literal> attribute，而 <literal>title</literal> 却没有？当没有设定 <literal>column</literal> attribute 的时候，Hibernate 缺省地使用 JavaBean 的属性名作为字段名。对于 <literal>title</literal>，这样工作得很好。然而，<literal>date</literal> 在多数的数据库里，是一个保留关键字，所以我们最好把它映射成一个不同的名字。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>title</literal> mapping also lacks a <literal>type</literal> "
-"attribute. The types declared and used in the mapping files are not Java "
-"data types; they are not SQL database types either. These types are called "
-"<emphasis>Hibernate mapping types</emphasis>, converters which can translate "
-"from Java to SQL data types and vice versa. Again, Hibernate will try to "
-"determine the correct conversion and mapping type itself if the "
-"<literal>type</literal> attribute is not present in the mapping. In some "
-"cases this automatic detection using Reflection on the Java class might not "
-"have the default you expect or need. This is the case with the "
-"<literal>date</literal> property. Hibernate cannot know if the property, "
-"which is of <literal>java.util.Date</literal>, should map to a SQL "
-"<literal>date</literal>, <literal>timestamp</literal>, or <literal>time</"
-"literal> column. Full date and time information is preserved by mapping the "
-"property with a <literal>timestamp</literal> converter."
-msgstr ""
-"另一有趣的事情是 <literal>title</literal> 属性缺少一个 <literal>type</"
-"literal> attribute。我们在映射文件里声明并使用的类型，却不是我们期望的那样，"
-"是 Java 数据类型，同时也不是 SQL 数据库的数据类型。这些类型就是所谓的 "
-"Hibernate 映射类型<emphasis>（mapping types）</emphasis>，它们能把 Java 数据"
-"类型转换到 SQL 数据类型，反之亦然。再次重申，如果在映射文件中没有设置 "
-"<literal>type</literal> 属性的话，Hibernate 会自己试着去确定正确的转换类型和"
-"它的映射类型。在某些情况下这个自动检测机制（在 Java 类上使用反射机制）不会产"
-"生你所期待或需要的缺省值。<literal>date</literal> 属性就是个很好的例子，"
-"Hibernate 无法知道这个属性（<literal>java.util.Date</literal> 类型的）应该被"
-"映射成：SQL <literal>date</literal>，或 <literal>timestamp</literal>，还是 "
-"<literal>time</literal> 字段。在此例中，把这个属性映射成 <literal>timestamp</"
-"literal> 转换器，这样我们预留了日期和时间的全部信息。 "
+msgid "The <literal>title</literal> mapping also lacks a <literal>type</literal> attribute. The types declared and used in the mapping files are not Java data types; they are not SQL database types either. These types are called <emphasis>Hibernate mapping types</emphasis>, converters which can translate from Java to SQL data types and vice versa. Again, Hibernate will try to determine the correct conversion and mapping type itself if the <literal>type</literal> attribute is not present in the mapping. In some cases this automatic detection using Reflection on the Java class might not have the default you expect or need. This is the case with the <literal>date</literal> property. Hibernate cannot know if the property, which is of <literal>java.util.Date</literal>, should map to a SQL <literal>date</literal>, <literal>timestamp</literal>, or <literal>time</literal> column. Full date and time information is preserved by mapping the property with a <literal>timestamp</literal>!
converter."
+msgstr "另一有趣的事情是 <literal>title</literal> 属性缺少一个 <literal>type</literal> attribute。我们在映射文件里声明并使用的类型，却不是我们期望的那样，是 Java 数据类型，同时也不是 SQL 数据库的数据类型。这些类型就是所谓的 Hibernate 映射类型<emphasis>（mapping types）</emphasis>，它们能把 Java 数据类型转换到 SQL 数据类型，反之亦然。再次重申，如果在映射文件中没有设置 <literal>type</literal> 属性的话，Hibernate 会自己试着去确定正确的转换类型和它的映射类型。在某些情况下这个自动检测机制（在 Java 类上使用反射机制）不会产生你所期待或需要的缺省值。<literal>date</literal> 属性就是个很好的例子，Hibernate 无法知道这个属性（<literal>java.util.Date</literal> 类型的）应该被映射成：SQL <literal>date</literal>，或 <literal>timestamp</literal>，还是 <literal>time</litera!
l> 字段。在此例中，把这个属性映射成 <literal>timestamp</literal> 转换器，这样我们预留了日期和时间的全部信息。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate makes this mapping type determination using reflection when the "
-"mapping files are processed. This can take time and resources, so if startup "
-"performance is important you should consider explicitly defining the type to "
-"use."
+msgid "Hibernate makes this mapping type determination using reflection when the mapping files are processed. This can take time and resources, so if startup performance is important you should consider explicitly defining the type to use."
msgstr ""
#. Tag: para
#, no-c-format
-msgid ""
-"Save this mapping file as <filename>src/main/resources/org/hibernate/"
-"tutorial/domain/Event.hbm.xml</filename>."
-msgstr ""
-"把这个映射文件保存为 <filename>src/main/resources/org/hibernate/tutorial/"
-"domain/Event.hbm.xml</filename>。"
+msgid "Save this mapping file as <filename>src/main/resources/org/hibernate/tutorial/domain/Event.hbm.xml</filename>."
+msgstr "把这个映射文件保存为 <filename>src/main/resources/org/hibernate/tutorial/domain/Event.hbm.xml</filename>。"
#. Tag: title
#, no-c-format
@@ -441,10 +192,7 @@
#. Tag: para
#, no-c-format
-msgid ""
-"At this point, you should have the persistent class and its mapping file in "
-"place. It is now time to configure Hibernate. First let's set up HSQLDB to "
-"run in \"server mode\""
+msgid "At this point, you should have the persistent class and its mapping file in place. It is now time to configure Hibernate. First let's set up HSQLDB to run in \"server mode\""
msgstr ""
#. Tag: para
@@ -453,55 +201,24 @@
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"We will utilize the Maven exec plugin to launch the HSQLDB server by "
-"running: <command> mvn exec:java -Dexec.mainClass=\"org.hsqldb.Server\" -"
-"Dexec.args=\"-database.0 file:target/data/tutorial\"</command> You will see "
-"it start up and bind to a TCP/IP socket; this is where our application will "
-"connect later. If you want to start with a fresh database during this "
-"tutorial, shutdown HSQLDB, delete all files in the <filename>target/data</"
-"filename> directory, and start HSQLDB again."
-msgstr ""
-"在开发的根目录下创建一个 <literal>data</literal> 目录 － 这是 HSQL DB 存储数"
-"据文件的地方。此时在 data 目录中运行 <literal>java -classpath ../lib/hsqldb."
-"jar org.hsqldb.Server</literal> 就可启动数据库。你可以在 log 中看到它的启动，"
-"及绑定到 TCP/IP 套接字，这正是我们的应用程序稍后会连接的地方。如果你希望在本"
-"例中运行一个全新的数据库，就在窗口中按下 <literal>CTRL + C</literal> 来关闭 "
-"HSQL 数据库，并删除 <literal>data/</literal> 目录下的所有文件，再重新启动 "
-"HSQL 数据库。"
+#, no-c-format
+msgid "We will utilize the Maven exec plugin to launch the HSQLDB server by running: <command> mvn exec:java -Dexec.mainClass=\"org.hsqldb.Server\" -Dexec.args=\"-database.0 file:target/data/tutorial\"</command> You will see it start up and bind to a TCP/IP socket; this is where our application will connect later. If you want to start with a fresh database during this tutorial, shutdown HSQLDB, delete all files in the <filename>target/data</filename> directory, and start HSQLDB again."
+msgstr "在开发的根目录下创建一个 <literal>data</literal> 目录 － 这是 HSQL DB 存储数据文件的地方。此时在 data 目录中运行 <literal>java -classpath ../lib/hsqldb.jar org.hsqldb.Server</literal> 就可启动数据库。你可以在 log 中看到它的启动，及绑定到 TCP/IP 套接字，这正是我们的应用程序稍后会连接的地方。如果你希望在本例中运行一个全新的数据库，就在窗口中按下 <literal>CTRL + C</literal> 来关闭 HSQL 数据库，并删除 <literal>data/</literal> 目录下的所有文件，再重新启动 HSQL 数据库。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate will be connecting to the database on behalf of your application, "
-"so it needs to know how to obtain connections. For this tutorial we will be "
-"using a standalone connection pool (as opposed to a <interfacename>javax.sql."
-"DataSource</interfacename>). Hibernate comes with support for two third-"
-"party open source JDBC connection pools: <ulink url=\"https://sourceforge."
-"net/projects/c3p0\">c3p0</ulink> and <ulink url=\"http://proxool.sourceforge."
-"net/\">proxool</ulink>. However, we will be using the Hibernate built-in "
-"connection pool for this tutorial."
+msgid "Hibernate will be connecting to the database on behalf of your application, so it needs to know how to obtain connections. For this tutorial we will be using a standalone connection pool (as opposed to a <interfacename>javax.sql.DataSource</interfacename>). Hibernate comes with support for two third-party open source JDBC connection pools: <ulink url=\"https://sourceforge.net/projects/c3p0\">c3p0</ulink> and <ulink url=\"http://proxool.sourceforge.net/\">proxool</ulink>. However, we will be using the Hibernate built-in connection pool for this tutorial."
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The built-in Hibernate connection pool is not intended for production use."
-msgstr "Hashtable （not intended for production use）"
+#, no-c-format
+msgid "The built-in Hibernate connection pool is not intended for production use."
+msgstr "嵌入的 Hibernate 连接池不用于产品环境。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"For Hibernate's configuration, we can use a simple <literal>hibernate."
-"properties</literal> file, a more sophisticated <literal>hibernate.cfg.xml</"
-"literal> file, or even complete programmatic setup. Most users prefer the "
-"XML configuration file:"
-msgstr ""
-"为了保存 Hibernate 的配置，我们可以使用一个简单的 <literal>hibernate."
-"properties</literal> 文件，或者一个稍微复杂的 <literal>hibernate.cfg.xml</"
-"literal>，甚至可以完全使用程序来配置 Hibernate。多数用户更喜欢使用 XML 配置文"
-"件："
+#, no-c-format
+msgid "For Hibernate's configuration, we can use a simple <literal>hibernate.properties</literal> file, a more sophisticated <literal>hibernate.cfg.xml</literal> file, or even complete programmatic setup. Most users prefer the XML configuration file:"
+msgstr "为了保存 Hibernate 的配置，我们可以使用一个简单的 <literal>hibernate.properties</literal> 文件，或者一个稍微复杂的 <literal>hibernate.cfg.xml</literal>，甚至可以完全使用程序来配置 Hibernate。多数用户更喜欢使用 XML 配置文件： "
#. Tag: para
#, no-c-format
@@ -509,73 +226,38 @@
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You configure Hibernate's <literal>SessionFactory</literal>. SessionFactory "
-"is a global factory responsible for a particular database. If you have "
-"several databases, for easier startup you should use several <literal><"
-"session-factory></literal> configurations in several configuration files."
-msgstr ""
-"注意这个 XML 配置使用了一个不同的 DTD。在这里，我们配置了 Hibernate 的"
-"<literal>SessionFactory</literal> — 一个关联于特定数据库全局的工厂"
-"（factory）。如果你要使用多个数据库，就要用多个的 <literal><session-"
-"factory></literal>，通常把它们放在多个配置文件中（为了更容易启动）。"
+#, no-c-format
+msgid "You configure Hibernate's <literal>SessionFactory</literal>. SessionFactory is a global factory responsible for a particular database. If you have several databases, for easier startup you should use several <literal><session-factory></literal> configurations in several configuration files."
+msgstr "注意这个 XML 配置使用了一个不同的 DTD。在这里，我们配置了 Hibernate 的<literal>SessionFactory</literal> — 一个关联于特定数据库全局的工厂（factory）。如果你要使用多个数据库，就要用多个的 <literal><session-factory></literal>，通常把它们放在多个配置文件中（为了更容易启动）。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The first four <literal>property</literal> elements contain the necessary "
-"configuration for the JDBC connection. The dialect <literal>property</"
-"literal> element specifies the particular SQL variant Hibernate generates."
+msgid "The first four <literal>property</literal> elements contain the necessary configuration for the JDBC connection. The dialect <literal>property</literal> element specifies the particular SQL variant Hibernate generates."
msgstr ""
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate is able to correctly determine which dialect to use in most cases. "
-"See <xref linkend=\"portability-dialectresolver\" /> for more information."
+msgid "Hibernate is able to correctly determine which dialect to use in most cases. See <xref linkend=\"portability-dialectresolver\" /> for more information."
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate's automatic session management for persistence contexts is "
-"particularly useful in this context. The <literal>hbm2ddl.auto</literal> "
-"option turns on automatic generation of database schemas directly into the "
-"database. This can also be turned off by removing the configuration option, "
-"or redirected to a file with the help of the <literal>SchemaExport</literal> "
-"Ant task. Finally, add the mapping file(s) for persistent classes to the "
-"configuration."
-msgstr ""
-"最开始的 4 个 <literal>property</literal> 元素包含必要的 JDBC 连接信息。方言"
-"（dialect）的 <literal>property</literal> 元素指明 Hibernate 生成的特定 SQL "
-"变量。你很快会看到，Hibernate 对持久化上下文的自动 session 管理就会派上用"
-"场。 打开 <literal>hbm2ddl.auto</literal> 选项将自动生成数据库模式（schema）"
-"－ 直接加入数据库中。当然这个选项也可以被关闭（通过去除这个配置选项）或者通"
-"过 Ant 任务 <literal>SchemaExport</literal> 的帮助来把数据库 schema 重定向到"
-"文件中。最后，在配置中为持久化类加入映射文件。"
+#, no-c-format
+msgid "Hibernate's automatic session management for persistence contexts is particularly useful in this context. The <literal>hbm2ddl.auto</literal> option turns on automatic generation of database schemas directly into the database. This can also be turned off by removing the configuration option, or redirected to a file with the help of the <literal>SchemaExport</literal> Ant task. Finally, add the mapping file(s) for persistent classes to the configuration."
+msgstr "最开始的 4 个 <literal>property</literal> 元素包含必要的 JDBC 连接信息。方言（dialect）的 <literal>property</literal> 元素指明 Hibernate 生成的特定 SQL 变量。你很快会看到，Hibernate 对持久化上下文的自动 session 管理就会派上用场。 打开 <literal>hbm2ddl.auto</literal> 选项将自动生成数据库模式（schema）－ 直接加入数据库中。当然这个选项也可以被关闭（通过去除这个配置选项）或者通过 Ant 任务 <literal>SchemaExport</literal> 的帮助来把数据库 schema 重定向到文件中。最后，在配置中为持久化类加入映射文件。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Save this file as <filename>hibernate.cfg.xml</filename> into the "
-"<filename>src/main/resources</filename> directory."
+msgid "Save this file as <filename>hibernate.cfg.xml</filename> into the <filename>src/main/resources</filename> directory."
msgstr ""
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Building with Maven"
-msgstr "用 Ant 构建"
+msgstr "用 Maven 构建 "
#. Tag: para
#, no-c-format
-msgid ""
-"We will now build the tutorial with Maven. You will need to have Maven "
-"installed; it is available from the <ulink url=\"http://maven.apache.org/"
-"download.html\">Maven download page</ulink>. Maven will read the <filename>/"
-"pom.xml</filename> file we created earlier and know how to perform some "
-"basic project tasks. First, lets run the <literal>compile</literal> goal to "
-"make sure we can compile everything so far:"
+msgid "We will now build the tutorial with Maven. You will need to have Maven installed; it is available from the <ulink url=\"http://maven.apache.org/download.html\">Maven download page</ulink>. Maven will read the <filename>/pom.xml</filename> file we created earlier and know how to perform some basic project tasks. First, lets run the <literal>compile</literal> goal to make sure we can compile everything so far:"
msgstr ""
#. Tag: title
@@ -584,102 +266,39 @@
msgstr "启动和辅助类"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"It is time to load and store some <literal>Event</literal> objects, but "
-"first you have to complete the setup with some infrastructure code. You have "
-"to startup Hibernate by building a global <interfacename>org.hibernate."
-"SessionFactory</interfacename> object and storing it somewhere for easy "
-"access in application code. A <interfacename>org.hibernate.SessionFactory</"
-"interfacename> is used to obtain <interfacename>org.hibernate.Session</"
-"interfacename> instances. A <interfacename>org.hibernate.Session</"
-"interfacename> represents a single-threaded unit of work. The "
-"<interfacename>org.hibernate.SessionFactory</interfacename> is a thread-safe "
-"global object that is instantiated once."
-msgstr ""
-"是时候来加载和储存一些 <literal>Event</literal> 对象了，但首先我们得编写一些"
-"基础的代码以完成设置。我们必须启动 Hibernate，此过程包括创建一个全局的 "
-"<literal>SessoinFactory</literal>，并把它储存在应用程序代码容易访问的地方。"
-"<literal>SessionFactory</literal> 可以创建并打开新的 <literal>Session</"
-"literal>。一个 <literal>Session</literal> 代表一个单线程的单元操作，"
-"<literal>SessionFactory</literal> 则是个线程安全的全局对象，只需要被实例化一"
-"次。"
+#, no-c-format
+msgid "It is time to load and store some <literal>Event</literal> objects, but first you have to complete the setup with some infrastructure code. You have to startup Hibernate by building a global <interfacename>org.hibernate.SessionFactory</interfacename> object and storing it somewhere for easy access in application code. A <interfacename>org.hibernate.SessionFactory</interfacename> is used to obtain <interfacename>org.hibernate.Session</interfacename> instances. A <interfacename>org.hibernate.Session</interfacename> represents a single-threaded unit of work. The <interfacename>org.hibernate.SessionFactory</interfacename> is a thread-safe global object that is instantiated once."
+msgstr "是时候来加载和储存一些 <literal>Event</literal> 对象了，但首先我们得编写一些基础的代码以完成设置。我们必须启动 Hibernate，此过程包括创建一个全局的 <literal>SessoinFactory</literal>，并把它储存在应用程序代码容易访问的地方。<literal>SessionFactory</literal> 可以创建并打开新的 <literal>Session</literal>。一个 <literal>Session</literal> 代表一个单线程的单元操作，<interfacename>org.hibernate.SessionFactory</interfacename> 则是个线程安全的全局对象，只需要被实例化一次。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"We will create a <literal>HibernateUtil</literal> helper class that takes "
-"care of startup and makes accessing the <interfacename>org.hibernate."
-"SessionFactory</interfacename> more convenient."
-msgstr ""
-"我们将创建一个 <literal>HibernateUtil</literal> 辅助类（helper class）来负责"
-"启动 Hibernate 和更方便地操作 <literal>SessionFactory</literal>。让我们来看一"
-"下它的实现："
+#, no-c-format
+msgid "We will create a <literal>HibernateUtil</literal> helper class that takes care of startup and makes accessing the <interfacename>org.hibernate.SessionFactory</interfacename> more convenient."
+msgstr "我们将创建一个 <literal>HibernateUtil</literal> 辅助类（helper class）来负责启动 Hibernate 和更方便地操作 <interfacename>org.hibernate.SessionFactory</interfacename>。让我们来看一下它的实现："
#. Tag: para
#, no-c-format
-msgid ""
-"Save this code as <filename>src/main/java/org/hibernate/tutorial/util/"
-"HibernateUtil.java</filename>"
+msgid "Save this code as <filename>src/main/java/org/hibernate/tutorial/util/HibernateUtil.java</filename>"
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This class not only produces the global <interfacename>org.hibernate."
-"SessionFactory</interfacename> reference in its static initializer; it also "
-"hides the fact that it uses a static singleton. We might just as well have "
-"looked up the <interfacename>org.hibernate.SessionFactory</interfacename> "
-"reference from JNDI in an application server or any other location for that "
-"matter."
-msgstr ""
-"这个类不但在它的静态初始化过程（仅当加载这个类的时候被 JVM 执行一次）中产生全"
-"局的 <literal>SessionFactory</literal>，而且隐藏了它使用了静态 singleton 的事"
-"实。它也可能在应用程序服务器中的 JNDI 查找 <literal>SessionFactory</"
-"literal>。"
+#, no-c-format
+msgid "This class not only produces the global <interfacename>org.hibernate.SessionFactory</interfacename> reference in its static initializer; it also hides the fact that it uses a static singleton. We might just as well have looked up the <interfacename>org.hibernate.SessionFactory</interfacename> reference from JNDI in an application server or any other location for that matter."
+msgstr "这个类不但在它的静态初始化过程（仅当加载这个类的时候被 JVM 执行一次）中产生全局的 <interfacename>org.hibernate.SessionFactory</interfacename>，而且隐藏了它使用了静态 singleton 的事实。它也可能在应用程序服务器中的 JNDI 查找 <interfacename>org.hibernate.SessionFactory</interfacename>。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"If you give the <interfacename>org.hibernate.SessionFactory</interfacename> "
-"a name in your configuration, Hibernate will try to bind it to JNDI under "
-"that name after it has been built. Another, better option is to use a JMX "
-"deployment and let the JMX-capable container instantiate and bind a "
-"<literal>HibernateService</literal> to JNDI. Such advanced options are "
-"discussed later."
-msgstr ""
-"如果你在配置文件中给 <literal>SessionFactory</literal> 一个名字，在 "
-"<literal>SessionFactory</literal> 创建后，Hibernate 会试着把它绑定到 JNDI。要"
-"完全避免这样的代码，你也可以使用 JMX 部署，让具有 JMX 能力的容器来实例化 "
-"<literal>HibernateService</literal> 并把它绑定到 JNDI。这些高级可选项在后面的"
-"章节中会讨论到。"
+#, no-c-format
+msgid "If you give the <interfacename>org.hibernate.SessionFactory</interfacename> a name in your configuration, Hibernate will try to bind it to JNDI under that name after it has been built. Another, better option is to use a JMX deployment and let the JMX-capable container instantiate and bind a <literal>HibernateService</literal> to JNDI. Such advanced options are discussed later."
+msgstr "如果你在配置文件中给 <interfacename>org.hibernate.SessionFactory</interfacename> 一个名字，在 它创建后，Hibernate 会试着把它绑定到 JNDI。要完全避免这样的代码，你也可以使用 JMX 部署，让具有 JMX 能力的容器来实例化 <literal>HibernateService</literal> 并把它绑定到 JNDI。这些高级可选项在后面的章节中会讨论到。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You now need to configure a logging system. Hibernate uses commons logging "
-"and provides two choices: Log4j and JDK 1.4 logging. Most developers prefer "
-"Log4j: copy <literal>log4j.properties</literal> from the Hibernate "
-"distribution in the <literal>etc/</literal> directory to your <literal>src</"
-"literal> directory, next to <literal>hibernate.cfg.xml</literal>. If you "
-"prefer to have more verbose output than that provided in the example "
-"configuration, you can change the settings. By default, only the Hibernate "
-"startup message is shown on stdout."
-msgstr ""
-"再次编译这个应用程序应该不会有问题。最后我们需要配置一个日志（logging)系统 — "
-"Hibernate 使用通用日志接口，允许你在 Log4j 和 JDK 1.4 日志之间进行选择。多数"
-"开发者更喜欢 Log4j：从 Hibernate 的发布包中（它在 <literal>etc/</literal> 目"
-"录下）拷贝 <literal>log4j.properties</literal> 到你的 <literal>src</literal> "
-"目录，与 <literal>hibernate.cfg.xml</literal> 放在一起。看一下配置示例，如果"
-"你希望看到更加详细的输出信息，你可以修改配置。默认情况下，只有 Hibernate 的启"
-"动信息才会显示在标准输出上。"
+#, no-c-format
+msgid "You now need to configure a logging system. Hibernate uses commons logging and provides two choices: Log4j and JDK 1.4 logging. Most developers prefer Log4j: copy <literal>log4j.properties</literal> from the Hibernate distribution in the <literal>etc/</literal> directory to your <literal>src</literal> directory, next to <literal>hibernate.cfg.xml</literal>. If you prefer to have more verbose output than that provided in the example configuration, you can change the settings. By default, only the Hibernate startup message is shown on stdout."
+msgstr "再次编译这个应用程序应该不会有问题。最后我们需要配置一个日志（logging)系统 — Hibernate 使用通用日志接口，允许你在 Log4j 和 JDK 1.4 日志之间进行选择。多数开发者更喜欢 Log4j：从 Hibernate 的发布包中（它在 <literal>etc/</literal> 目录下）拷贝 <literal>log4j.properties</literal> 到你的 <literal>src</literal> 目录，与 <literal>hibernate.cfg.xml</literal> 放在一起。看一下配置示例，如果你希望看到更加详细的输出信息，你可以修改配置。默认情况下，只有 Hibernate 的启动信息才会显示在标准输出上。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The tutorial infrastructure is complete and you are now ready to do some "
-"real work with Hibernate."
-msgstr "示例的基本框架完成了 — 现在我们可以用 Hibernate 来做些真正的工作。"
+#, no-c-format
+msgid "The tutorial infrastructure is complete and you are now ready to do some real work with Hibernate."
+msgstr "示例的基本框架完成了 — 现在我们可以用 Hibernate 来做些真正的工作。 "
#. Tag: title
#, no-c-format
@@ -687,139 +306,48 @@
msgstr "加载并存储对象"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"We are now ready to start doing some real worjk with Hibernate. Let's start "
-"by writing an <literal>EventManager</literal> class with a <literal>main()</"
-"literal> method:"
-msgstr ""
-"我们终于可以使用 Hibernate 来加载和存储对象了，编写一个带有 <literal>main()</"
-"literal> 方法的 <literal>EventManager</literal> 类："
+#, no-c-format
+msgid "We are now ready to start doing some real worjk with Hibernate. Let's start by writing an <literal>EventManager</literal> class with a <literal>main()</literal> method:"
+msgstr "我们终于可以使用 Hibernate 来加载和存储对象了，编写一个带有 <literal>main()</literal> 方法的 <literal>EventManager</literal> 类： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"In <literal>createAndStoreEvent()</literal> we created a new <literal>Event</"
-"literal> object and handed it over to Hibernate. At that point, Hibernate "
-"takes care of the SQL and executes an <literal>INSERT</literal> on the "
-"database."
-msgstr ""
-"我们创建了个新的 <literal>Event</literal> 对象并把它传递给 Hibernate。现在 "
-"Hibernate 负责与 SQL 打交道，并把 <literal>INSERT</literal> 命令传给数据库。"
-"在运行之前，让我们看一下处理 <literal>Session</literal> 和 "
-"<literal>Transaction</literal> 的代码。"
+#, no-c-format
+msgid "In <literal>createAndStoreEvent()</literal> we created a new <literal>Event</literal> object and handed it over to Hibernate. At that point, Hibernate takes care of the SQL and executes an <literal>INSERT</literal> on the database."
+msgstr "在 <literal>createAndStoreEvent()</literal> 来里我们创建了一个新的 <literal>Event</literal> 对象并把它传递给 Hibernate。现在 Hibernate 负责与 SQL 打交道，并把 <literal>INSERT</literal> 命令传给数据库。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A <interface>org.hibernate.Session</interface> is designed to represent a "
-"single unit of work (a single atmoic piece of work to be performed). For now "
-"we will keep things simple and assume a one-to-one granularity between a "
-"Hibernate <interface>org.hibernate.Session</interface> and a database "
-"transaction. To shield our code from the actual underlying transaction "
-"system we use the Hibernate <interfacename>org.hibernate.Transaction</"
-"interfacename> API. In this particular case we are using JDBC-based "
-"transactional semantics, but it could also run with JTA."
-msgstr ""
-"一个 <literal>Session</literal> 就是个单一的工作单元。我们暂时让事情简单一"
-"些，并假设 Hibernate<literal>Session</literal> 和数据库事务是一一对应的。为了"
-"让我们的代码从底层的事务系统中脱离出来（此例中是 JDBC，但也可能是 JTA），我们"
-"使用 Hibernate <literal>Session</literal> 中的 <literal>Transaction</"
-"literal> API。"
+#, no-c-format
+msgid "A <interface>org.hibernate.Session</interface> is designed to represent a single unit of work (a single atmoic piece of work to be performed). For now we will keep things simple and assume a one-to-one granularity between a Hibernate <interface>org.hibernate.Session</interface> and a database transaction. To shield our code from the actual underlying transaction system we use the Hibernate <interfacename>org.hibernate.Transaction</interfacename> API. In this particular case we are using JDBC-based transactional semantics, but it could also run with JTA."
+msgstr "一个 <interface>org.hibernate.Session</interface> 就是个单一的工作单元。我们暂时让事情简单一些，并假设 Hibernate <interface>org.hibernate.Session</interface> 和数据库事务是一一对应的。为了让我们的代码从底层的事务系统中脱离出来（此例中是 JDBC，但也可能是 JTA），我们使用 <interfacename>org.hibernate.Transaction</interfacename> API。在这个例子里我们使用基于 JDBC 的事务性 semantic，但它也可以和 JTA 一起运行。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"What does <literal>sessionFactory.getCurrentSession()</literal> do? First, "
-"you can call it as many times and anywhere you like once you get hold of "
-"your <interfacename>org.hibernate.SessionFactory</interfacename>. The "
-"<literal>getCurrentSession()</literal> method always returns the \"current\" "
-"unit of work. Remember that we switched the configuration option for this "
-"mechanism to \"thread\" in our <filename>src/main/resources/hibernate.cfg."
-"xml</filename>? Due to that setting, the context of a current unit of work "
-"is bound to the current Java thread that executes the application."
-msgstr ""
-"<literal>sessionFactory.getCurrentSession()</literal> 是干什么的呢？首先，只"
-"要你持有 <literal>SessionFactory</literal>（幸亏我们有 "
-"<literal>HibernateUtil</literal>，可以随时获得），大可在任何时候、任何地点调"
-"用这个方法。<literal>getCurrentSession()</literal> 方法总会返回“当前的”工作单"
-"元。记得我们在 <literal>hibernate.cfg.xml</literal> 中把这一配置选项调整为 "
-"\"thread\" 了吗？因此，因此，当前工作单元被绑定到当前执行我们应用程序的 Java "
-"线程。但是，这并非是完全准确的,你还得考虑工作单元的生命周期范围（scope），它"
-"何时开始,又何时结束。"
+#, no-c-format
+msgid "What does <literal>sessionFactory.getCurrentSession()</literal> do? First, you can call it as many times and anywhere you like once you get hold of your <interfacename>org.hibernate.SessionFactory</interfacename>. The <literal>getCurrentSession()</literal> method always returns the \"current\" unit of work. Remember that we switched the configuration option for this mechanism to \"thread\" in our <filename>src/main/resources/hibernate.cfg.xml</filename>? Due to that setting, the context of a current unit of work is bound to the current Java thread that executes the application."
+msgstr "<literal>sessionFactory.getCurrentSession()</literal> 是干什么的呢？首先，只要你持有 <interfacename>org.hibernate.SessionFactory</interfacename>，大可在任何时候、任何地点调用这个方法。<literal>getCurrentSession()</literal> 方法总会返回“当前的”工作单元。记得我们在 <filename>src/main/resources/hibernate.cfg.xml</filename> 中把这一配置选项调整为 \"thread\" 了吗？因此，因此，当前工作单元被绑定到当前执行我们应用程序的 Java 线程。但是，这并非是完全准确的,你还得考虑工作单元的生命周期范围（scope），它何时开始,又何时结束。"
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate offers three methods of current session tracking. The \"thread\" "
-"based method is not intended for production use; it is merely useful for "
-"prototyping and tutorials such as this one. Current session tracking is "
-"discussed in more detail later on."
+msgid "Hibernate offers three methods of current session tracking. The \"thread\" based method is not intended for production use; it is merely useful for prototyping and tutorials such as this one. Current session tracking is discussed in more detail later on."
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A <interface>org.hibernate.Session</interface> begins when the first call to "
-"<literal>getCurrentSession()</literal> is made for the current thread. It is "
-"then bound by Hibernate to the current thread. When the transaction ends, "
-"either through commit or rollback, Hibernate automatically unbinds the "
-"<interface>org.hibernate.Session</interface> from the thread and closes it "
-"for you. If you call <literal>getCurrentSession()</literal> again, you get a "
-"new <interface>org.hibernate.Session</interface> and can start a new unit of "
-"work."
-msgstr ""
-"<literal>Session</literal> 在第一次被使用的时候,即第一次调用 "
-"<literal>getCurrentSession()</literal> 的时候,其生命周期就开始。然后它被 "
-"Hibernate 绑定到当前线程。当事务结束的时候，不管是提交还是回滚，Hibernate 会"
-"自动把 <literal>Session</literal> 从当前线程剥离，并且关闭它。假若你再次调用 "
-"<literal>getCurrentSession()</literal>，你会得到一个新的 <literal>Session</"
-"literal>，并且开始一个新的工作单元。这种<emphasis>线程绑定（thread-bound）</"
-"emphasis>的编程模型（model）是使用 Hibernate 的最广泛的方式,因为它支持对你的"
-"代码灵活分层（事务划分可以和你的数据访问代码分离开来，在本教程的后面部分就会"
-"这么做）。"
+#, no-c-format
+msgid "A <interface>org.hibernate.Session</interface> begins when the first call to <literal>getCurrentSession()</literal> is made for the current thread. It is then bound by Hibernate to the current thread. When the transaction ends, either through commit or rollback, Hibernate automatically unbinds the <interface>org.hibernate.Session</interface> from the thread and closes it for you. If you call <literal>getCurrentSession()</literal> again, you get a new <interface>org.hibernate.Session</interface> and can start a new unit of work."
+msgstr "<interface>org.hibernate.Session</interface> 在第一次被使用的时候，即第一次调用 <literal>getCurrentSession()</literal> 的时候,其生命周期就开始。然后它被 Hibernate 绑定到当前线程。当事务结束的时候，不管是提交还是回滚，Hibernate 会自动把 <interface>org.hibernate.Session</interface> 从当前线程剥离，并且关闭它。假若你再次调用 <literal>getCurrentSession()</literal>，你会得到一个新的 <interface>org.hibernate.Session</interface>，并且开始一个新的工作单元。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Related to the unit of work scope, should the Hibernate <interface>org."
-"hibernate.Session</interface> be used to execute one or several database "
-"operations? The above example uses one <interface>org.hibernate.Session</"
-"interface> for one operation. However this is pure coincidence; the example "
-"is just not complex enough to show any other approach. The scope of a "
-"Hibernate <interface>org.hibernate.Session</interface> is flexible but you "
-"should never design your application to use a new Hibernate <interface>org."
-"hibernate.Session</interface> for <emphasis>every</emphasis> database "
-"operation. Even though it is used in the following examples, consider "
-"<emphasis>session-per-operation</emphasis> an anti-pattern. A real web "
-"application is shown later in the tutorial which will help illustrate this."
-msgstr ""
-"和工作单元的生命周期这个话题相关，Hibernate <literal>Session</literal> 是否被"
-"应该用来执行多次数据库操作？上面的例子对每一次操作使用了一个 "
-"<literal>Session</literal>，这完全是巧合，这个例子不是很复杂，无法展示其他方"
-"式。Hibernate <literal>Session</literal> 的生命周期可以很灵活，但是你绝不要把"
-"你的应用程序设计成为<emphasis>每一次</emphasis>数据库操作都用一个新的 "
-"Hibernate <literal>Session</literal>。因此就算下面的例子（它们都很简单）中你"
-"可以看到这种用法，记住<emphasis>每次操作一个 session</emphasis> 是一个反模"
-"式。在本教程的后面会展示一个真正的（web）程序。"
+#, no-c-format
+msgid "Related to the unit of work scope, should the Hibernate <interface>org.hibernate.Session</interface> be used to execute one or several database operations? The above example uses one <interface>org.hibernate.Session</interface> for one operation. However this is pure coincidence; the example is just not complex enough to show any other approach. The scope of a Hibernate <interface>org.hibernate.Session</interface> is flexible but you should never design your application to use a new Hibernate <interface>org.hibernate.Session</interface> for <emphasis>every</emphasis> database operation. Even though it is used in the following examples, consider <emphasis>session-per-operation</emphasis> an anti-pattern. A real web application is shown later in the tutorial which will help illustrate this."
+msgstr "和工作单元的生命周期这个话题相关，Hibernate <interface>org.hibernate.Session</interface> 是否被应该用来执行多次数据库操作？上面的例子对每一次操作使用了一个 <interface>org.hibernate.Session</interface>，这完全是巧合，这个例子不是很复杂，无法展示其他方式。Hibernate <interface>org.hibernate.Session</interface> 的生命周期可以很灵活，但是你绝不要把你的应用程序设计成为<emphasis>每一次</emphasis>数据库操作都用一个新的 Hibernate <interface>org.hibernate.Session</interface>。因此就算下面的例子（它们都很简单）中你可以看到这种用法，记住<emphasis>每次操作一个 session</emphasis> 是一个反模式。在本教程的后面会展示一个真正的（web）程序。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"See <xref linkend=\"transactions\" /> for more information about transaction "
-"handling and demarcation. The previous example also skipped any error "
-"handling and rollback."
-msgstr ""
-"关于事务处理及事务边界界定的详细信息，请参看 <xref linkend="
-"\"Transactions_And_Concurrency\"/> 。在上面的例子中，我们也忽略了所有的错误与"
-"回滚的处理。"
+#, no-c-format
+msgid "See <xref linkend=\"transactions\" /> for more information about transaction handling and demarcation. The previous example also skipped any error handling and rollback."
+msgstr "关于事务处理及事务边界界定的详细信息，请参看 <xref linkend=\"transactions\" /> 。在上面的例子中，我们也忽略了所有的错误与回滚的处理。"
#. Tag: para
#, no-c-format
-msgid ""
-"To run this, we will make use of the Maven exec plugin to call our class "
-"with the necessary classpath setup: <command>mvn exec:java -Dexec.mainClass="
-"\"org.hibernate.tutorial.EventManager\" -Dexec.args=\"store\"</command>"
+msgid "To run this, we will make use of the Maven exec plugin to call our class with the necessary classpath setup: <command>mvn exec:java -Dexec.mainClass=\"org.hibernate.tutorial.EventManager\" -Dexec.args=\"store\"</command>"
msgstr ""
#. Tag: para
@@ -828,51 +356,33 @@
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You should see Hibernate starting up and, depending on your configuration, "
-"lots of log output. Towards the end, the following line will be displayed:"
-msgstr ""
-"你应该会看到，编译以后，Hibernate 根据你的配置启动，并产生一大堆的输出日志。"
-"在日志最后你会看到下面这行："
+#, no-c-format
+msgid "You should see Hibernate starting up and, depending on your configuration, lots of log output. Towards the end, the following line will be displayed:"
+msgstr "你应该会看到，编译以后，Hibernate 根据你的配置启动，并产生一大堆的输出日志。在日志最后你会看到下面这行： "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "This is the <literal>INSERT</literal> executed by Hibernate."
-msgstr "执行 HQL <literal>INSERT</literal> 语句的例子如下："
+msgstr "执行 HQL <literal>INSERT</literal> 语句的例子如下： "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "To list stored events an option is added to the main method:"
-msgstr ""
-"我们想要列出所有已经被存储的 events，就要增加一个条件分支选项到 main 方法中"
-"去。"
+msgstr "我们想要列出所有已经被存储的 events，就要增加一个条件分支选项到 main 方法中："
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "A new <literal>listEvents() method is also added</literal>:"
-msgstr "我们也增加一个新的 <literal>listEvents()</literal> 方法："
+msgstr "我们也增加一个新的 <literal>listEvents()</literal> 方法： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Here, we are using a Hibernate Query Language (HQL) query to load all "
-"existing <literal>Event</literal> objects from the database. Hibernate will "
-"generate the appropriate SQL, send it to the database and populate "
-"<literal>Event</literal> objects with the data. You can create more complex "
-"queries with HQL. See <xref linkend=\"queryhql\" /> for more information."
-msgstr ""
-"我们在这里是用一个 HQL（Hibernate Query Language－Hibernate查询语言）查询语句"
-"来从数据库中加载所有存在的 <literal>Event</literal> 对象。Hibernate 会生成适"
-"当的 SQL，把它发送到数据库，并操作从查询得到数据的 <literal>Event</literal> "
-"对象。当然，你可以使用 HQL 来创建更加复杂的查询。"
+#, no-c-format
+msgid "Here, we are using a Hibernate Query Language (HQL) query to load all existing <literal>Event</literal> objects from the database. Hibernate will generate the appropriate SQL, send it to the database and populate <literal>Event</literal> objects with the data. You can create more complex queries with HQL. See <xref linkend=\"queryhql\" /> for more information."
+msgstr "我们在这里是用一个 HQL（Hibernate Query Language－Hibernate查询语言）查询语句来从数据库中加载所有存在的 <literal>Event</literal> 对象。Hibernate 会生成适当的 SQL，把它发送到数据库，并操作从查询得到数据的 <literal>Event</literal> 对象。当然，你可以使用 HQL 来创建更加复杂的查询。更多信息请参考 <xref linkend=\"queryhql\"/>。"
#. Tag: para
#, no-c-format
-msgid ""
-"Now we can call our new functionality, again using the Maven exec plugin: "
-"<command>mvn exec:java -Dexec.mainClass=\"org.hibernate.tutorial.EventManager"
-"\" -Dexec.args=\"list\"</command>"
+msgid "Now we can call our new functionality, again using the Maven exec plugin: <command>mvn exec:java -Dexec.mainClass=\"org.hibernate.tutorial.EventManager\" -Dexec.args=\"list\"</command>"
msgstr ""
#. Tag: title
@@ -881,17 +391,9 @@
msgstr "第二部分 － 关联映射"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"So far we have mapped a single persistent entity class to a table in "
-"isolation. Let's expand on that a bit and add some class associations. We "
-"will add people to the application and store a list of events in which they "
-"participate."
-msgstr ""
-"我们已经映射了一个持久化实体类到表上。让我们在这个基础上增加一些类之间的关"
-"联。首先我们往应用程序里增加人（people）的概念，并存储他们所参与的一个 Event "
-"列表。（译者注：与 Event 一样，我们在后面将直接使用 person 来表示“人”而不是它"
-"的中文翻译）"
+#, no-c-format
+msgid "So far we have mapped a single persistent entity class to a table in isolation. Let's expand on that a bit and add some class associations. We will add people to the application and store a list of events in which they participate."
+msgstr "我们已经映射了一个持久化实体类到表上。让我们在这个基础上增加一些类之间的关联。首先我们往应用程序里增加人（people）的概念，并存储他们所参与的一个 Event 列表。（译者注：与 Event 一样，我们在后面将直接使用 person 来表示“人”而不是它的中文翻译） "
#. Tag: title
#, no-c-format
@@ -899,22 +401,18 @@
msgstr "映射 Person 类"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The first cut of the <literal>Person</literal> class looks like this:"
-msgstr "最初简单的 <literal>Person</literal> 类："
+msgstr "最初简单的 <literal>Person</literal> 类： "
#. Tag: para
#, no-c-format
-msgid ""
-"Save this to a file named <filename>src/main/java/org/hibernate/tutorial/"
-"domain/Person.java</filename>"
+msgid "Save this to a file named <filename>src/main/java/org/hibernate/tutorial/domain/Person.java</filename>"
msgstr ""
#. Tag: para
#, no-c-format
-msgid ""
-"Next, create the new mapping file as <filename>src/main/resources/org/"
-"hibernate/tutorial/domain/Person.hbm.xml</filename>"
+msgid "Next, create the new mapping file as <filename>src/main/resources/org/hibernate/tutorial/domain/Person.hbm.xml</filename>"
msgstr ""
#. Tag: para
@@ -923,15 +421,9 @@
msgstr "最后，把新的映射加入到 Hibernate 的配置中："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Create an association between these two entities. Persons can participate in "
-"events, and events have participants. The design questions you have to deal "
-"with are: directionality, multiplicity, and collection behavior."
-msgstr ""
-"现在我们在这两个实体之间创建一个关联。显然，persons 可以参与一系列 events，"
-"而 events 也有不同的参加者（persons）。我们需要处理的设计问题是关联方向"
-"（directionality），阶数（multiplicity）和集合（collection）的行为。"
+#, no-c-format
+msgid "Create an association between these two entities. Persons can participate in events, and events have participants. The design questions you have to deal with are: directionality, multiplicity, and collection behavior."
+msgstr "现在我们在这两个实体之间创建一个关联。显然，persons 可以参与一系列 events，而 events 也有不同的参加者（persons）。我们需要处理的设计问题是关联方向（directionality），阶数（multiplicity）和集合（collection）的行为。 "
#. Tag: title
#, no-c-format
@@ -939,66 +431,19 @@
msgstr "单向 Set-based 的关联"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"By adding a collection of events to the <literal>Person</literal> class, you "
-"can easily navigate to the events for a particular person, without executing "
-"an explicit query - by calling <literal>Person#getEvents</literal>. Multi-"
-"valued associations are represented in Hibernate by one of the Java "
-"Collection Framework contracts; here we choose a <interfacename>java.util."
-"Set</interfacename> because the collection will not contain duplicate "
-"elements and the ordering is not relevant to our examples:"
-msgstr ""
-"我们将向 <literal>Person</literal> 类增加一连串的 events。那样，通过调用 "
-"<literal>aPerson.getEvents()</literal>，就可以轻松地导航到特定 person 所参与"
-"的 events，而不用去执行一个显式的查询。我们使用 Java 的集合类（collection）："
-"<literal>Set</literal>，因为 set 不包含重复的元素及与我们无关的排序。"
+#, no-c-format
+msgid "By adding a collection of events to the <literal>Person</literal> class, you can easily navigate to the events for a particular person, without executing an explicit query - by calling <literal>Person#getEvents</literal>. Multi-valued associations are represented in Hibernate by one of the Java Collection Framework contracts; here we choose a <interfacename>java.util.Set</interfacename> because the collection will not contain duplicate elements and the ordering is not relevant to our examples:"
+msgstr "我们将向 <literal>Person</literal> 类增加一连串的 events。那样，通过调用 <literal>aPerson.getEvents()</literal>，就可以轻松地导航到特定 person 所参与的 events，而不用去执行一个显式的查询。我们使用 Java 的集合类（collection）：<literal>Set</literal>，因为 set 不包含重复的元素及与我们无关的排序。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Before mapping this association, let's consider the other side. We could "
-"just keep this unidirectional or create another collection on the "
-"<literal>Event</literal>, if we wanted to be able to navigate it from both "
-"directions. This is not necessary, from a functional perspective. You can "
-"always execute an explicit query to retrieve the participants for a "
-"particular event. This is a design choice left to you, but what is clear "
-"from this discussion is the multiplicity of the association: \"many\" valued "
-"on both sides is called a <emphasis>many-to-many</emphasis> association. "
-"Hence, we use Hibernate's many-to-many mapping:"
-msgstr ""
-"在映射这个关联之前，先考虑一下此关联的另外一端。很显然，我们可以保持这个关联"
-"是单向的。或者，我们可以在 <literal>Event</literal> 里创建另外一个集合，如果"
-"希望能够双向地导航，如：<literal>anEvent.getParticipants()</literal>。从功能"
-"的角度来说，这并不是必须的。因为你总可以显式地执行一个查询，以获得某个特定 "
-"event 的所有参与者。这是个在设计时需要做出的选择，完全由你来决定，但此讨论中"
-"关于关联的阶数是清楚的：即两端都是“多”值的，我们把它叫做<emphasis>多对多"
-"（many-to-many）</emphasis>关联。因而，我们使用 Hibernate 的多对多映射："
+#, no-c-format
+msgid "Before mapping this association, let's consider the other side. We could just keep this unidirectional or create another collection on the <literal>Event</literal>, if we wanted to be able to navigate it from both directions. This is not necessary, from a functional perspective. You can always execute an explicit query to retrieve the participants for a particular event. This is a design choice left to you, but what is clear from this discussion is the multiplicity of the association: \"many\" valued on both sides is called a <emphasis>many-to-many</emphasis> association. Hence, we use Hibernate's many-to-many mapping:"
+msgstr "在映射这个关联之前，先考虑一下此关联的另外一端。很显然，我们可以保持这个关联是单向的。或者，我们可以在 <literal>Event</literal> 里创建另外一个集合，如果希望能够双向地导航，如：<literal>anEvent.getParticipants()</literal>。从功能的角度来说，这并不是必须的。因为你总可以显式地执行一个查询，以获得某个特定 event 的所有参与者。这是个在设计时需要做出的选择，完全由你来决定，但此讨论中关于关联的阶数是清楚的：即两端都是“多”值的，我们把它叫做<emphasis>多对多（many-to-many）</emphasis>关联。因而，我们使用 Hibernate 的多对多映射： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate supports a broad range of collection mappings, a <literal>set</"
-"literal> being most common. For a many-to-many association, or <emphasis>n:"
-"m</emphasis> entity relationship, an association table is required. Each row "
-"in this table represents a link between a person and an event. The table "
-"name is decalred using the <literal>table</literal> attribute of the "
-"<literal>set</literal> element. The identifier column name in the "
-"association, for the person side, is defined with the <literal>key</literal> "
-"element, the column name for the event's side with the <literal>column</"
-"literal> attribute of the <literal>many-to-many</literal>. You also have to "
-"tell Hibernate the class of the objects in your collection (the class on the "
-"other side of the collection of references)."
-msgstr ""
-"Hibernate 支持各种各样的集合映射，<literal><set></literal> 使用的最为普"
-"遍。对于多对多关联（或叫 <emphasis>n:m</emphasis> 实体关系）, 需要一个关联表"
-"（association table）。<literal>表</literal>里面的每一行代表从 person 到 "
-"event 的一个关联。表名是由 <literal>set</literal> 元素的 <literal>table</"
-"literal> 属性配置的。关联里面的标识符字段名，对于 person 的一端，是由 "
-"<literal><key></literal> 元素定义，而 event 一端的字段名是由 "
-"<literal><many-to-many></literal> 元素的 <literal>column</literal> 属性"
-"定义。你也必须告诉 Hibernate 集合中对象的类（也就是位于这个集合所代表的关联另"
-"外一端的类）。"
+#, no-c-format
+msgid "Hibernate supports a broad range of collection mappings, a <literal>set</literal> being most common. For a many-to-many association, or <emphasis>n:m</emphasis> entity relationship, an association table is required. Each row in this table represents a link between a person and an event. The table name is decalred using the <literal>table</literal> attribute of the <literal>set</literal> element. The identifier column name in the association, for the person side, is defined with the <literal>key</literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal>many-to-many</literal>. You also have to tell Hibernate the class of the objects in your collection (the class on the other side of the collection of references)."
+msgstr "Hibernate 支持各种各样的集合映射，<literal><set></literal> 使用的最为普遍。对于多对多关联（或叫 <emphasis>n:m</emphasis> 实体关系）, 需要一个关联表（association table）。<literal>表</literal>里面的每一行代表从 person 到 event 的一个关联。表名是由 <literal>set</literal> 元素的 <literal>table</literal> 属性配置的。关联里面的标识符字段名，对于 person 的一端，是由 <literal><key></literal> 元素定义，而 event 一端的字段名是由 <literal><many-to-many></literal> 元素的 <literal>column</literal> 属性定义。你也必须告诉 Hibernate 集合中对象的类（也就是位于这个集合所代表的关联另外一端的类）。 "
#. Tag: para
#, no-c-format
@@ -1011,123 +456,39 @@
msgstr "使关联工作"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Now we will bring some people and events together in a new method in "
-"<literal>EventManager</literal>:"
-msgstr ""
-"我们把一些 people 和 events 一起放到 <literal>EventManager</literal> 的新方法"
-"中："
+#, no-c-format
+msgid "Now we will bring some people and events together in a new method in <literal>EventManager</literal>:"
+msgstr "我们把一些 people 和 events 一起放到 <literal>EventManager</literal> 的新方法中： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"After loading a <literal>Person</literal> and an <literal>Event</literal>, "
-"simply modify the collection using the normal collection methods. There is "
-"no explicit call to <literal>update()</literal> or <literal>save()</"
-"literal>; Hibernate automatically detects that the collection has been "
-"modified and needs to be updated. This is called <emphasis>automatic dirty "
-"checking</emphasis>. You can also try it by modifying the name or the date "
-"property of any of your objects. As long as they are in "
-"<emphasis>persistent</emphasis> state, that is, bound to a particular "
-"Hibernate <interfacename>org.hibernate.Session</interfacename>, Hibernate "
-"monitors any changes and executes SQL in a write-behind fashion. The process "
-"of synchronizing the memory state with the database, usually only at the end "
-"of a unit of work, is called <emphasis>flushing</emphasis>. In our code, the "
-"unit of work ends with a commit, or rollback, of the database transaction."
-msgstr ""
-"在加载一 <literal>Person</literal> 和 <literal>Event</literal> 后，使用普通的"
-"集合方法就可容易地修改我们定义的集合。如你所见，没有显式的 <literal>update()"
-"</literal> 或 <literal>save()</literal>，Hibernate 会自动检测到集合已经被修改"
-"并需要更新回数据库。这叫做自动脏检查（<emphasis>automatic dirty checking</"
-"emphasis>），你也可以尝试修改任何对象的 name 或者 date 属性，只要他们处于"
-"<emphasis>持久化</emphasis>状态，也就是被绑定到某个 Hibernate 的 "
-"<literal>Session</literal> 上（如：他们刚刚在一个单元操作被加载或者保存），"
-"Hibernate 监视任何改变并在后台隐式写的方式执行 SQL。同步内存状态和数据库的过"
-"程，通常只在单元操作结束的时候发生，称此过程为清理缓存<emphasis>（flushing）"
-"</emphasis>。在我们的代码中，工作单元由数据库事务的提交（或者回滚）来结束——这"
-"是由 <literal>CurrentSessionContext</literal> 类的 <literal>thread</literal> "
-"配置选项定义的。"
+#, no-c-format
+msgid "After loading a <literal>Person</literal> and an <literal>Event</literal>, simply modify the collection using the normal collection methods. There is no explicit call to <literal>update()</literal> or <literal>save()</literal>; Hibernate automatically detects that the collection has been modified and needs to be updated. This is called <emphasis>automatic dirty checking</emphasis>. You can also try it by modifying the name or the date property of any of your objects. As long as they are in <emphasis>persistent</emphasis> state, that is, bound to a particular Hibernate <interfacename>org.hibernate.Session</interfacename>, Hibernate monitors any changes and executes SQL in a write-behind fashion. The process of synchronizing the memory state with the database, usually only at the end of a unit of work, is called <emphasis>flushing</emphasis>. In our code, the unit of work ends with a commit, or rollback, of the database transaction."
+msgstr "在加载一 <literal>Person</literal> 和 <literal>Event</literal> 后，使用普通的集合方法就可容易地修改我们定义的集合。如你所见，没有显式的 <literal>update()</literal> 或 <literal>save()</literal>，Hibernate 会自动检测到集合已经被修改并需要更新回数据库。这叫做自动脏检查（<emphasis>automatic dirty checking</emphasis>），你也可以尝试修改任何对象的 name 或者 date 属性，只要他们处于<emphasis>持久化</emphasis>状态，也就是被绑定到某个 Hibernate 的 <literal>Session</literal> 上（如：他们刚刚在一个单元操作被加载或者保存），Hibernate 监视任何改变并在后台隐式写的方式执行 SQL。同步内存状态和数据库的过程，通常只在单元操作结束的时候发生，称此过程为清理缓存<emphasis>（flushing）</emphasis>。在我们的代码中，工作单元由数据库事务的提交（或者回滚）来结束——!
这是由 <literal>CurrentSessionContext</literal> 类的 <literal>thread</literal> 配置选项定义的。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can load person and event in different units of work. Or you can modify "
-"an object outside of a <interfacename>org.hibernate.Session</interfacename>, "
-"when it is not in persistent state (if it was persistent before, this state "
-"is called <emphasis>detached</emphasis>). You can even modify a collection "
-"when it is detached:"
-msgstr ""
-"当然，你也可以在不同的单元操作里面加载 person 和 event。或在 "
-"<literal>Session</literal> 以外修改不是处在持久化（persistent）状态下的对象"
-"（如果该对象以前曾经被持久化，那么我们称这个状态为<emphasis>脱管（detached）"
-"</emphasis>）。你甚至可以在一个集合被脱管时修改它："
+#, no-c-format
+msgid "You can load person and event in different units of work. Or you can modify an object outside of a <interfacename>org.hibernate.Session</interfacename>, when it is not in persistent state (if it was persistent before, this state is called <emphasis>detached</emphasis>). You can even modify a collection when it is detached:"
+msgstr "当然，你也可以在不同的单元操作里面加载 person 和 event。或在 <literal>Session</literal> 以外修改不是处在持久化（persistent）状态下的对象（如果该对象以前曾经被持久化，那么我们称这个状态为<emphasis>脱管（detached）</emphasis>）。你甚至可以在一个集合被脱管时修改它： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The call to <literal>update</literal> makes a detached object persistent "
-"again by binding it to a new unit of work, so any modifications you made to "
-"it while detached can be saved to the database. This includes any "
-"modifications (additions/deletions) you made to a collection of that entity "
-"object."
-msgstr ""
-"对 <literal>update</literal> 的调用使一个脱管对象重新持久化，你可以说它被绑定"
-"到一个新的单元操作上，所以在脱管状态下对它所做的任何修改都会被保存到数据库"
-"里。这也包括你对这个实体对象的集合所作的任何改动（增加/删除）。"
+#, no-c-format
+msgid "The call to <literal>update</literal> makes a detached object persistent again by binding it to a new unit of work, so any modifications you made to it while detached can be saved to the database. This includes any modifications (additions/deletions) you made to a collection of that entity object."
+msgstr "对 <literal>update</literal> 的调用使一个脱管对象重新持久化，你可以说它被绑定到一个新的单元操作上，所以在脱管状态下对它所做的任何修改都会被保存到数据库里。这也包括你对这个实体对象的集合所作的任何改动（增加/删除）。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This is not much use in our example, but it is an important concept you can "
-"incorporate into your own application. Complete this exercise by adding a "
-"new action to the main method of the <literal>EventManager</literal> and "
-"call it from the command line. If you need the identifiers of a person and "
-"an event - the <literal>save()</literal> method returns it (you might have "
-"to modify some of the previous methods to return that identifier):"
-msgstr ""
-"这对我们当前的情形不是很有用，但它是非常重要的概念，你可以把它融入到你自己的"
-"应用程序设计中。在<literal>EventManager</literal>的 main 方法中添加一个新的动"
-"作，并从命令行运行它来完成我们所做的练习。如果你需要 person 及 event 的标识"
-"符 — 那就用 <literal>save()</literal> 方法返回它（你可能需要修改前面的一些方"
-"法来返回那个标识符）："
+#, no-c-format
+msgid "This is not much use in our example, but it is an important concept you can incorporate into your own application. Complete this exercise by adding a new action to the main method of the <literal>EventManager</literal> and call it from the command line. If you need the identifiers of a person and an event - the <literal>save()</literal> method returns it (you might have to modify some of the previous methods to return that identifier):"
+msgstr "这对我们当前的情形不是很有用，但它是非常重要的概念，你可以把它融入到你自己的应用程序设计中。在<literal>EventManager</literal>的 main 方法中添加一个新的动作，并从命令行运行它来完成我们所做的练习。如果你需要 person 及 event 的标识符 — 那就用 <literal>save()</literal> 方法返回它（你可能需要修改前面的一些方法来返回那个标识符）： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This is an example of an association between two equally important classes : "
-"two entities. As mentioned earlier, there are other classes and types in a "
-"typical model, usually \"less important\". Some you have already seen, like "
-"an <literal>int</literal> or a <classname>java.lang.String</classname>. We "
-"call these classes <emphasis>value types</emphasis>, and their instances "
-"<emphasis>depend</emphasis> on a particular entity. Instances of these types "
-"do not have their own identity, nor are they shared between entities. Two "
-"persons do not reference the same <literal>firstname</literal> object, even "
-"if they have the same first name. Value types cannot only be found in the "
-"JDK , but you can also write dependent classes yourself such as an "
-"<literal>Address</literal> or <literal>MonetaryAmount</literal> class. In "
-"fact, in a Hibernate application all JDK classes are considered value types."
-msgstr ""
-"上面是个关于两个同等重要的实体类间关联的例子。像前面所提到的那样，在特定的模"
-"型中也存在其它的类和类型，这些类和类型通常是“次要的”。你已看到过其中的一些，"
-"像 <literal>int</literal> 或 <literal>String</literal>。我们称这些类为"
-"<emphasis>值类型（value type）</emphasis>，它们的实例<emphasis>依赖（depend）"
-"</emphasis>在某个特定的实体上。这些类型的实例没有它们自己的标识（identity），"
-"也不能在实体间被共享（比如，两个 person 不能引用同一个 <literal>firstname</"
-"literal> 对象，即使他们有相同的 first name）。当然，值类型并不仅仅在 JDK 中存"
-"在（事实上，在一个 Hibernate 应用程序中，所有的 JDK 类都被视为值类型），而且"
-"你也可以编写你自己的依赖类，例如 <literal>Address</literal>，"
-"<literal>MonetaryAmount</literal>。"
+#, no-c-format
+msgid "This is an example of an association between two equally important classes : two entities. As mentioned earlier, there are other classes and types in a typical model, usually \"less important\". Some you have already seen, like an <literal>int</literal> or a <classname>java.lang.String</classname>. We call these classes <emphasis>value types</emphasis>, and their instances <emphasis>depend</emphasis> on a particular entity. Instances of these types do not have their own identity, nor are they shared between entities. Two persons do not reference the same <literal>firstname</literal> object, even if they have the same first name. Value types cannot only be found in the JDK , but you can also write dependent classes yourself such as an <literal>Address</literal> or <literal>MonetaryAmount</literal> class. In fact, in a Hibernate application all JDK classes are considered value types."
+msgstr "上面是个关于两个同等重要的实体类间关联的例子。像前面所提到的那样，在特定的模型中也存在其它的类和类型，这些类和类型通常是“次要的”。你已看到过其中的一些，像 <literal>int</literal> 或 <literal>String</literal>。我们称这些类为<emphasis>值类型（value type）</emphasis>，它们的实例<emphasis>依赖（depend）</emphasis>在某个特定的实体上。这些类型的实例没有它们自己的标识（identity），也不能在实体间被共享（比如，两个 person 不能引用同一个 <literal>firstname</literal> 对象，即使他们有相同的 first name）。当然，值类型并不仅仅在 JDK 中存在（事实上，在一个 Hibernate 应用程序中，所有的 JDK 类都被视为值类型），而且你也可以编写你自己的依赖类，例如 <literal>Address</literal>，<literal>MonetaryAmount</literal>。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can also design a collection of value types. This is conceptually "
-"different from a collection of references to other entities, but looks "
-"almost the same in Java."
-msgstr ""
-"你也可以设计一个值类型的集合，这在概念上与引用其它实体的集合有很大的不同，但"
-"是在 Java 里面看起来几乎是一样的。"
+#, no-c-format
+msgid "You can also design a collection of value types. This is conceptually different from a collection of references to other entities, but looks almost the same in Java."
+msgstr "你也可以设计一个值类型的集合，这在概念上与引用其它实体的集合有很大的不同，但是在 Java 里面看起来几乎是一样的。 "
#. Tag: title
#, no-c-format
@@ -1136,76 +497,38 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Let's add a collection of email addresses to the <literal>Person</literal> "
-"entity. This will be represented as a <interfacename>java.util.Set</"
-"interfacename> of <classname>java.lang.String</classname> instances:"
+msgid "Let's add a collection of email addresses to the <literal>Person</literal> entity. This will be represented as a <interfacename>java.util.Set</interfacename> of <classname>java.lang.String</classname> instances:"
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The mapping of this <literal>Set</literal> is as follows:"
-msgstr "这个 <literal>Set</literal> 的映射"
+msgstr "这个 <literal>Set</literal> 的映射如下："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The difference compared with the earlier mapping is the use of the "
-"<literal>element</literal> part which tells Hibernate that the collection "
-"does not contain references to another entity, but is rather a collection "
-"whose elements are values types, here specifically of type <literal>string</"
-"literal>. The lowercase name tells you it is a Hibernate mapping type/"
-"converter. Again the <literal>table</literal> attribute of the <literal>set</"
-"literal> element determines the table name for the collection. The "
-"<literal>key</literal> element defines the foreign-key column name in the "
-"collection table. The <literal>column</literal> attribute in the "
-"<literal>element</literal> element defines the column name where the email "
-"address values will actually be stored."
-msgstr ""
-"比较这次和此前映射的差别，主要在于 <literal>element</literal> 部分，这次并没"
-"有包含对其它实体引用的集合，而是元素类型为 <literal>String</literal> 的集合"
-"（在映射中使用小写的名字”string“是向你表明它是一个 Hibernate 的映射类型或者类"
-"型转换器）。和之前一样，<literal>set</literal> 元素的 <literal>table</"
-"literal> 属性决定了用于集合的表名。<literal>key</literal> 元素定义了在集合表"
-"中外键的字段名。<literal>element</literal> 元素的 <literal>column</literal> "
-"属性定义用于实际保存 <literal>String</literal> 值的字段名。"
+#, no-c-format
+msgid "The difference compared with the earlier mapping is the use of the <literal>element</literal> part which tells Hibernate that the collection does not contain references to another entity, but is rather a collection whose elements are values types, here specifically of type <literal>string</literal>. The lowercase name tells you it is a Hibernate mapping type/converter. Again the <literal>table</literal> attribute of the <literal>set</literal> element determines the table name for the collection. The <literal>key</literal> element defines the foreign-key column name in the collection table. The <literal>column</literal> attribute in the <literal>element</literal> element defines the column name where the email address values will actually be stored."
+msgstr "比较这次和此前映射的差别，主要在于 <literal>element</literal> 部分，这次并没有包含对其它实体引用的集合，而是元素类型为 <literal>String</literal> 的集合（在映射中使用小写的名字”string“是向你表明它是一个 Hibernate 的映射类型或者类型转换器）。和之前一样，<literal>set</literal> 元素的 <literal>table</literal> 属性决定了用于集合的表名。<literal>key</literal> 元素定义了在集合表中外键的字段名。<literal>element</literal> 元素的 <literal>column</literal> 属性定义用于实际保存 <literal>String</literal> 值的字段名。 "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Here is the updated schema:"
-msgstr "看一下修改后的数据库 schema。"
+msgstr "看一下修改后的数据库 schema。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can see that the primary key of the collection table is in fact a "
-"composite key that uses both columns. This also implies that there cannot be "
-"duplicate email addresses per person, which is exactly the semantics we need "
-"for a set in Java."
-msgstr ""
-"你可以看到集合表的主键实际上是个复合主键，同时使用了 2 个字段。这也暗示了对于"
-"同一个 person 不能有重复的 email 地址，这正是 Java 里面使用 Set 时候所需要的"
-"语义（Set 里元素不能重复）。"
+#, no-c-format
+msgid "You can see that the primary key of the collection table is in fact a composite key that uses both columns. This also implies that there cannot be duplicate email addresses per person, which is exactly the semantics we need for a set in Java."
+msgstr "你可以看到集合表的主键实际上是个复合主键，同时使用了两个字段。这也暗示了对于同一个 person 不能有重复的 email 地址，这正是 Java 里面使用 Set 时候所需要的语义（Set 里元素不能重复）。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can now try to add elements to this collection, just like we did before "
-"by linking persons and events. It is the same code in Java:"
-msgstr ""
-"你现在可以试着把元素加入到这个集合，就像我们在之前关联 person 和 event 的那"
-"样。其实现的 Java 代码是相同的："
+#, no-c-format
+msgid "You can now try to add elements to this collection, just like we did before by linking persons and events. It is the same code in Java:"
+msgstr "你现在可以试着把元素加入到这个集合，就像我们在之前关联 person 和 event 的那样。其实现的 Java 代码是相同的： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This time we did not use a <emphasis>fetch</emphasis> query to initialize "
-"the collection. Monitor the SQL log and try to optimize this with an eager "
-"fetch."
-msgstr ""
-"这次我们没有使用 <emphasis>fetch</emphasis> 查询来初始化集合。因此，调用其 "
-"getter 方法会触发另一附加的 select 来初始化集合，这样我们才能把元素添加进去。"
-"检查 SQL log，试着通过预先抓取来优化它。"
+#, no-c-format
+msgid "This time we did not use a <emphasis>fetch</emphasis> query to initialize the collection. Monitor the SQL log and try to optimize this with an eager fetch."
+msgstr "这次我们没有使用 <emphasis>fetch</emphasis> 查询来初始化集合。因此，调用其 getter 方法会触发另一附加的 select 来初始化集合，这样我们才能把元素添加进去。检查 SQL log，试着通过预先抓取来优化它。 "
#. Tag: title
#, no-c-format
@@ -1213,66 +536,34 @@
msgstr "双向关联"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Next you will map a bi-directional association. You will make the "
-"association between person and event work from both sides in Java. The "
-"database schema does not change, so you will still have many-to-many "
-"multiplicity."
-msgstr ""
-"接下来我们将映射双向关联（bi-directional association）— 在 Java 里让 person "
-"和 event 可以从关联的任何一端访问另一端。当然，数据库 schema 没有改变，我们仍"
-"然需要多对多的阶数。一个关系型数据库要比网络编程语言更加灵活，所以它并不需要"
-"任何像导航方向（navigation direction）的东西 — 数据可以用任何可能的方式进行查"
-"看和获取。"
+#, no-c-format
+msgid "Next you will map a bi-directional association. You will make the association between person and event work from both sides in Java. The database schema does not change, so you will still have many-to-many multiplicity."
+msgstr "接下来我们将映射双向关联（bi-directional association）— 在 Java 里让 person 和 event 可以从关联的任何一端访问另一端。当然，数据库 schema 没有改变，我们仍然需要多对多的阶数。一个关系型数据库要比网络编程语言更加灵活，所以它并不需要任何像导航方向（navigation direction）的东西 — 数据可以用任何可能的方式进行查看和获取。 "
#. Tag: para
#, no-c-format
-msgid ""
-"A relational database is more flexible than a network programming language, "
-"in that it does not need a navigation direction; data can be viewed and "
-"retrieved in any possible way."
+msgid "A relational database is more flexible than a network programming language, in that it does not need a navigation direction; data can be viewed and retrieved in any possible way."
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"First, add a collection of participants to the <literal>Event</literal> "
-"class:"
-msgstr "首先，把一个参与者（person）的集合加入 <literal>Event</literal> 类中："
+#, no-c-format
+msgid "First, add a collection of participants to the <literal>Event</literal> class:"
+msgstr "首先，把一个参与者（person）的集合加入 <literal>Event</literal> 类中： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Now map this side of the association in <literal>Event.hbm.xml</literal>."
-msgstr "在 <literal>Event.hbm.xml</literal> 里面也映射这个关联。"
+#, no-c-format
+msgid "Now map this side of the association in <literal>Event.hbm.xml</literal>."
+msgstr "在 <literal>Event.hbm.xml</literal> 里面也映射这个关联。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"These are normal <literal>set</literal> mappings in both mapping documents. "
-"Notice that the column names in <literal>key</literal> and <literal>many-to-"
-"many</literal> swap in both mapping documents. The most important addition "
-"here is the <literal>inverse=\"true\"</literal> attribute in the "
-"<literal>set</literal> element of the <literal>Event</literal>'s collection "
-"mapping."
-msgstr ""
-"如你所见，两个映射文件里都有普通的 <literal>set</literal> 映射。注意在两个映"
-"射文件中，互换了 <literal>key</literal> 和 <literal>many-to-many</literal> 的"
-"字段名。这里最重要的是 <literal>Event</literal> 映射文件里增加了 "
-"<literal>set</literal> 元素的 <literal>inverse=\"true\"</literal> 属性。"
+#, no-c-format
+msgid "These are normal <literal>set</literal> mappings in both mapping documents. Notice that the column names in <literal>key</literal> and <literal>many-to-many</literal> swap in both mapping documents. The most important addition here is the <literal>inverse=\"true\"</literal> attribute in the <literal>set</literal> element of the <literal>Event</literal>'s collection mapping."
+msgstr "如你所见，两个映射文件里都有普通的 <literal>set</literal> 映射。注意在两个映射文件中，互换了 <literal>key</literal> 和 <literal>many-to-many</literal> 的字段名。这里最重要的是 <literal>Event</literal> 映射文件里增加了 <literal>set</literal> 元素的 <literal>inverse=\"true\"</literal> 属性。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"What this means is that Hibernate should take the other side, the "
-"<literal>Person</literal> class, when it needs to find out information about "
-"the link between the two. This will be a lot easier to understand once you "
-"see how the bi-directional link between our two entities is created."
-msgstr ""
-"这意味着在需要的时候，Hibernate 能在关联的另一端 — <literal>Person</literal> "
-"类得到两个实体间关联的信息。这将会极大地帮助你理解双向关联是如何在两个实体间"
-"被创建的。"
+#, no-c-format
+msgid "What this means is that Hibernate should take the other side, the <literal>Person</literal> class, when it needs to find out information about the link between the two. This will be a lot easier to understand once you see how the bi-directional link between our two entities is created."
+msgstr "这意味着在需要的时候，Hibernate 能在关联的另一端 — <literal>Person</literal> 类得到两个实体间关联的信息。这将会极大地帮助你理解双向关联是如何在两个实体间被创建的。 "
#. Tag: title
#, no-c-format
@@ -1280,74 +571,24 @@
msgstr "使双向连起来"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"First, keep in mind that Hibernate does not affect normal Java semantics. "
-"How did we create a link between a <literal>Person</literal> and an "
-"<literal>Event</literal> in the unidirectional example? You add an instance "
-"of <literal>Event</literal> to the collection of event references, of an "
-"instance of <literal>Person</literal>. If you want to make this link bi-"
-"directional, you have to do the same on the other side by adding a "
-"<literal>Person</literal> reference to the collection in an <literal>Event</"
-"literal>. This process of \"setting the link on both sides\" is absolutely "
-"necessary with bi-directional links."
-msgstr ""
-"首先请记住，Hibernate 并不影响通常的 Java 语义。 在单向关联的例子中，我们是怎"
-"样在 <literal>Person</literal> 和 <literal>Event</literal> 之间创建联系的？我"
-"们把 <literal>Event</literal> 实例添加到 <literal>Person</literal> 实例内的 "
-"event 引用集合里。因此很显然，如果我们要让这个关联可以双向地工作，我们需要在"
-"另外一端做同样的事情 － 把 <literal>Person</literal> 实例加入 "
-"<literal>Event</literal> 类内的 Person 引用集合。这“在关联的两端设置联系”是完"
-"全必要的而且你都得这么做。"
+#, no-c-format
+msgid "First, keep in mind that Hibernate does not affect normal Java semantics. How did we create a link between a <literal>Person</literal> and an <literal>Event</literal> in the unidirectional example? You add an instance of <literal>Event</literal> to the collection of event references, of an instance of <literal>Person</literal>. If you want to make this link bi-directional, you have to do the same on the other side by adding a <literal>Person</literal> reference to the collection in an <literal>Event</literal>. This process of \"setting the link on both sides\" is absolutely necessary with bi-directional links."
+msgstr "首先请记住，Hibernate 并不影响通常的 Java 语义。 在单向关联的例子中，我们是怎样在 <literal>Person</literal> 和 <literal>Event</literal> 之间创建联系的？我们把 <literal>Event</literal> 实例添加到 <literal>Person</literal> 实例内的 event 引用集合里。因此很显然，如果我们要让这个关联可以双向地工作，我们需要在另外一端做同样的事情 － 把 <literal>Person</literal> 实例加入 <literal>Event</literal> 类内的 Person 引用集合。这“在关联的两端设置联系”是完全必要的而且你都得这么做。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Many developers program defensively and create link management methods to "
-"correctly set both sides (for example, in <literal>Person</literal>):"
-msgstr ""
-"许多开发人员防御式地编程，创建管理关联的方法来保证正确的设置了关联的两端，比"
-"如在 <literal>Person</literal> 里："
+#, no-c-format
+msgid "Many developers program defensively and create link management methods to correctly set both sides (for example, in <literal>Person</literal>):"
+msgstr "许多开发人员防御式地编程，创建管理关联的方法来保证正确的设置了关联的两端，比如在 <literal>Person</literal> 里： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The get and set methods for the collection are now protected. This allows "
-"classes in the same package and subclasses to still access the methods, but "
-"prevents everybody else from altering the collections directly. Repeat the "
-"steps for the collection on the other side."
-msgstr ""
-"注意现在对于集合的 get 和 set 方法的访问级别是 protected — 这允许在位于同一个"
-"包（package）中的类以及继承自这个类的子类可以访问这些方法，但禁止其他任何人的"
-"直接访问，避免了集合内容的混乱。你应尽可能地在另一端也把集合的访问级别设成 "
-"protected。"
+#, no-c-format
+msgid "The get and set methods for the collection are now protected. This allows classes in the same package and subclasses to still access the methods, but prevents everybody else from altering the collections directly. Repeat the steps for the collection on the other side."
+msgstr "注意现在对于集合的 get 和 set 方法的访问级别是 protected — 这允许在位于同一个包（package）中的类以及继承自这个类的子类可以访问这些方法，但禁止其他任何人的直接访问，避免了集合内容的混乱。你应尽可能地在另一端也把集合的访问级别设成 protected。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"What about the <literal>inverse</literal> mapping attribute? For you, and "
-"for Java, a bi-directional link is simply a matter of setting the references "
-"on both sides correctly. Hibernate, however, does not have enough "
-"information to correctly arrange SQL <literal>INSERT</literal> and "
-"<literal>UPDATE</literal> statements (to avoid constraint violations). "
-"Making one side of the association <literal>inverse</literal> tells "
-"Hibernate to consider it a <emphasis>mirror</emphasis> of the other side. "
-"That is all that is necessary for Hibernate to resolve any issues that arise "
-"when transforming a directional navigation model to a SQL database schema. "
-"The rules are straightforward: all bi-directional associations need one side "
-"as <literal>inverse</literal>. In a one-to-many association it has to be the "
-"many-side, and in many-to-many association you can select either side."
-msgstr ""
-"<literal>inverse</literal> 映射属性究竟表示什么呢？对于你和 Java 来说，一个双"
-"向关联仅仅是在两端简单地正确设置引用。然而，Hibernate 并没有足够的信息去正确"
-"地执行 <literal>INSERT</literal> 和 <literal>UPDATE</literal> 语句（以避免违"
-"反数据库约束），所以它需要一些帮助来正确的处理双向关联。把关联的一端设置为 "
-"<literal>inverse</literal> 将告诉 Hibernate 忽略关联的这一端，把这端看成是另"
-"外一端的一个<emphasis>镜象（mirror）</emphasis>。这就是所需的全部信息，"
-"Hibernate 利用这些信息来处理把一个有向导航模型转移到数据库 schema 时的所有问"
-"题。你只需要记住这个直观的规则：所有的双向关联需要有一端被设置为 "
-"<literal>inverse</literal>。在一对多关联中它必须是代表多（many）的那端。而在"
-"多对多（many-to-many）关联中，你可以任意选取一端，因为两端之间并没有差别。"
+#, no-c-format
+msgid "What about the <literal>inverse</literal> mapping attribute? For you, and for Java, a bi-directional link is simply a matter of setting the references on both sides correctly. Hibernate, however, does not have enough information to correctly arrange SQL <literal>INSERT</literal> and <literal>UPDATE</literal> statements (to avoid constraint violations). Making one side of the association <literal>inverse</literal> tells Hibernate to consider it a <emphasis>mirror</emphasis> of the other side. That is all that is necessary for Hibernate to resolve any issues that arise when transforming a directional navigation model to a SQL database schema. The rules are straightforward: all bi-directional associations need one side as <literal>inverse</literal>. In a one-to-many association it has to be the many-side, and in many-to-many association you can select either side."
+msgstr "<literal>inverse</literal> 映射属性究竟表示什么呢？对于你和 Java 来说，一个双向关联仅仅是在两端简单地正确设置引用。然而，Hibernate 并没有足够的信息去正确地执行 <literal>INSERT</literal> 和 <literal>UPDATE</literal> 语句（以避免违反数据库约束），所以它需要一些帮助来正确的处理双向关联。把关联的一端设置为 <literal>inverse</literal> 将告诉 Hibernate 忽略关联的这一端，把这端看成是另外一端的一个<emphasis>镜象（mirror）</emphasis>。这就是所需的全部信息，Hibernate 利用这些信息来处理把一个有向导航模型转移到数据库 schema 时的所有问题。你只需要记住这个直观的规则：所有的双向关联需要有一端被设置为 <literal>inverse</literal>。在一对多关联中它必须是代表多（many）的那端。而在多对多（many-to-many）关联中，你可以任意选取一端，因为两端之!
间并没有差别。 "
#. Tag: title
#, no-c-format
@@ -1355,19 +596,9 @@
msgstr "第三部分 - EventManager web 应用程序"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A Hibernate web application uses <literal>Session</literal> and "
-"<literal>Transaction</literal> almost like a standalone application. "
-"However, some common patterns are useful. You can now write an "
-"<literal>EventManagerServlet</literal>. This servlet can list all events "
-"stored in the database, and it provides an HTML form to enter new events."
-msgstr ""
-"Hibernate web 应用程序使用 <literal>Session</literal> 和 "
-"<literal>Transaction</literal> 的方式几乎和独立应用程序是一样的。但是，有一些"
-"常见的模式（pattern）非常有用。现在我们编写一个 "
-"<literal>EventManagerServlet</literal>。这个 servlet 可以列出数据库中保存的所"
-"有的 events，还提供一个 HTML 表单来增加新的 events。"
+#, no-c-format
+msgid "A Hibernate web application uses <literal>Session</literal> and <literal>Transaction</literal> almost like a standalone application. However, some common patterns are useful. You can now write an <literal>EventManagerServlet</literal>. This servlet can list all events stored in the database, and it provides an HTML form to enter new events."
+msgstr "Hibernate web 应用程序使用 <literal>Session</literal> 和 <literal>Transaction</literal> 的方式几乎和独立应用程序是一样的。但是，有一些常见的模式（pattern）非常有用。现在我们编写一个 <literal>EventManagerServlet</literal>。这个 servlet 可以列出数据库中保存的所有的 events，还提供一个 HTML 表单来增加新的 events。 "
#. Tag: title
#, no-c-format
@@ -1375,79 +606,34 @@
msgstr "编写基本的 servlet"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"First we need create our basic processing servlet. Since our servlet only "
-"handles HTTP <literal>GET</literal> requests, we will only implement the "
-"<literal>doGet()</literal> method:"
-msgstr ""
-"这个 servlet 只处理 HTTP <literal>GET</literal> 请求，因此，我们要实现的是 "
-"<literal>doGet()</literal> 方法："
+#, no-c-format
+msgid "First we need create our basic processing servlet. Since our servlet only handles HTTP <literal>GET</literal> requests, we will only implement the <literal>doGet()</literal> method:"
+msgstr "这个 servlet 只处理 HTTP <literal>GET</literal> 请求，因此，我们要实现的是 <literal>doGet()</literal> 方法： "
#. Tag: para
#, no-c-format
-msgid ""
-"Save this servlet as <filename>src/main/java/org/hibernate/tutorial/web/"
-"EventManagerServlet.java</filename>"
+msgid "Save this servlet as <filename>src/main/java/org/hibernate/tutorial/web/EventManagerServlet.java</filename>"
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The pattern applied here is called <emphasis>session-per-request</emphasis>. "
-"When a request hits the servlet, a new Hibernate <literal>Session</literal> "
-"is opened through the first call to <literal>getCurrentSession()</literal> "
-"on the <literal>SessionFactory</literal>. A database transaction is then "
-"started. All data access occurs inside a transaction irrespective of whether "
-"the data is read or written. Do not use the auto-commit mode in applications."
-msgstr ""
-"我们称这里应用的模式为每次请求一个 session<emphasis>(session-per-request)</"
-"emphasis>。当有请求到达这个 servlet 的时候，通过对 <literal>SessionFactory</"
-"literal> 的第一次调用，打开一个新的 Hibernate <literal>Session</literal>。然"
-"后启动一个数据库事务 — 所有的数据访问都是在事务中进行，不管是读还是写（我们在"
-"应用程序中不使用 auto-commit 模式）。"
+#, no-c-format
+msgid "The pattern applied here is called <emphasis>session-per-request</emphasis>. When a request hits the servlet, a new Hibernate <literal>Session</literal> is opened through the first call to <literal>getCurrentSession()</literal> on the <literal>SessionFactory</literal>. A database transaction is then started. All data access occurs inside a transaction irrespective of whether the data is read or written. Do not use the auto-commit mode in applications."
+msgstr "我们称这里应用的模式为每次请求一个 session<emphasis>(session-per-request)</emphasis>。当有请求到达这个 servlet 的时候，通过对 <literal>SessionFactory</literal> 的第一次调用，打开一个新的 Hibernate <literal>Session</literal>。然后启动一个数据库事务 — 所有的数据访问都是在事务中进行，不管是读还是写（我们在应用程序中不使用 auto-commit 模式）。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Do <emphasis>not</emphasis> use a new Hibernate <literal>Session</literal> "
-"for every database operation. Use one Hibernate <literal>Session</literal> "
-"that is scoped to the whole request. Use <literal>getCurrentSession()</"
-"literal>, so that it is automatically bound to the current Java thread."
-msgstr ""
-"<emphasis>不要</emphasis>为每次数据库操作都使用一个新的 Hibernate "
-"<literal>Session</literal>。将 Hibernate <literal>Session</literal> 的范围设"
-"置为整个请求。要用 <literal>getCurrentSession()</literal>，这样它自动会绑定到"
-"当前 Java 线程。"
+msgid "Do <emphasis>not</emphasis> use a new Hibernate <literal>Session</literal> for every database operation. Use one Hibernate <literal>Session</literal> that is scoped to the whole request. Use <literal>getCurrentSession()</literal>, so that it is automatically bound to the current Java thread."
+msgstr "<emphasis>不要</emphasis>为每次数据库操作都使用一个新的 Hibernate <literal>Session</literal>。将 Hibernate <literal>Session</literal> 的范围设置为整个请求。要用 <literal>getCurrentSession()</literal>，这样它自动会绑定到当前 Java 线程。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Next, the possible actions of the request are processed and the response "
-"HTML is rendered. We will get to that part soon."
-msgstr ""
-"下一步，对请求的可能动作进行处理，渲染出反馈的 HTML。我们很快就会涉及到那部"
-"分。"
+#, no-c-format
+msgid "Next, the possible actions of the request are processed and the response HTML is rendered. We will get to that part soon."
+msgstr "下一步，对请求的可能动作进行处理，渲染出反馈的 HTML。我们很快就会涉及到那部分。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Finally, the unit of work ends when processing and rendering are complete. "
-"If any problems occurred during processing or rendering, an exception will "
-"be thrown and the database transaction rolled back. This completes the "
-"<literal>session-per-request</literal> pattern. Instead of the transaction "
-"demarcation code in every servlet, you could also write a servlet filter. "
-"See the Hibernate website and Wiki for more information about this pattern "
-"called <emphasis>Open Session in View</emphasis>. You will need it as soon "
-"as you consider rendering your view in JSP, not in a servlet."
-msgstr ""
-"最后，当处理与渲染都结束的时候，这个工作单元就结束了。假若在处理或渲染的时候"
-"有任何错误发生，会抛出一个异常，回滚数据库事务。这样，<literal>session-per-"
-"request</literal> 模式就完成了。为了避免在每个 servlet 中都编写事务边界界定的"
-"代码，可以考虑写一个 servlet 过滤器（filter）来更好地解决。关于这一模式的更多"
-"信息，请参阅 Hibernate 网站和 Wiki，这一模式叫做 <emphasis>Open Session in "
-"View</emphasis> — 只要你考虑用JSP来渲染你的视图（view），而不是在servlet中，"
-"你就会很快用到它。"
+#, no-c-format
+msgid "Finally, the unit of work ends when processing and rendering are complete. If any problems occurred during processing or rendering, an exception will be thrown and the database transaction rolled back. This completes the <literal>session-per-request</literal> pattern. Instead of the transaction demarcation code in every servlet, you could also write a servlet filter. See the Hibernate website and Wiki for more information about this pattern called <emphasis>Open Session in View</emphasis>. You will need it as soon as you consider rendering your view in JSP, not in a servlet."
+msgstr "最后，当处理与渲染都结束的时候，这个工作单元就结束了。假若在处理或渲染的时候有任何错误发生，会抛出一个异常，回滚数据库事务。这样，<literal>session-per-request</literal> 模式就完成了。为了避免在每个 servlet 中都编写事务边界界定的代码，可以考虑写一个 servlet 过滤器（filter）来更好地解决。关于这一模式的更多信息，请参阅 Hibernate 网站和 Wiki，这一模式叫做 <emphasis>Open Session in View</emphasis> — 只要你考虑用JSP来渲染你的视图（view），而不是在servlet中，你就会很快用到它。 "
#. Tag: title
#, no-c-format
@@ -1455,64 +641,29 @@
msgstr "处理与渲染"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Now you can implement the processing of the request and the rendering of the "
-"page."
-msgstr "我们来实现处理请求以及渲染页面的工作。"
+#, no-c-format
+msgid "Now you can implement the processing of the request and the rendering of the page."
+msgstr "我们来实现处理请求以及渲染页面的工作。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This coding style, with a mix of Java and HTML, would not scale in a more "
-"complex application—keep in mind that we are only illustrating basic "
-"Hibernate concepts in this tutorial. The code prints an HTML header and a "
-"footer. Inside this page, an HTML form for event entry and a list of all "
-"events in the database are printed. The first method is trivial and only "
-"outputs HTML:"
-msgstr ""
-"必须承认，这种编码风格把 Java 和 HTML 混在一起，在更复杂的应用程序里不应该大"
-"量使用 — 记住，在本章里我们仅仅是展示了 Hibernate 的基本概念。这段代码打印出"
-"了 HTML 页眉和页脚，在这个页面里，还打印了一个输入 events 条目的表单单并列出"
-"了数据库里的有的 events。第一个方法微不足道，仅仅是输出 HTML：由"
+#, no-c-format
+msgid "This coding style, with a mix of Java and HTML, would not scale in a more complex application—keep in mind that we are only illustrating basic Hibernate concepts in this tutorial. The code prints an HTML header and a footer. Inside this page, an HTML form for event entry and a list of all events in the database are printed. The first method is trivial and only outputs HTML:"
+msgstr "必须承认，这种编码风格把 Java 和 HTML 混在一起，在更复杂的应用程序里不应该大量使用 — 记住，在本章里我们仅仅是展示了 Hibernate 的基本概念。这段代码打印出了 HTML 页眉和页脚，在这个页面里，还打印了一个输入 events 条目的表单单并列出了数据库里的有的 events。第一个方法微不足道，仅仅是输出 HTML："
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>listEvents()</literal> method uses the Hibernate "
-"<literal>Session</literal> bound to the current thread to execute a query:"
-msgstr ""
-"<literal>listEvents()</literal> 方法使用绑定到当前线程的 Hibernate "
-"<literal>Session</literal> 来执行查询："
+msgid "The <literal>listEvents()</literal> method uses the Hibernate <literal>Session</literal> bound to the current thread to execute a query:"
+msgstr "<literal>listEvents()</literal> 方法使用绑定到当前线程的 Hibernate <literal>Session</literal> 来执行查询："
#. Tag: para
#, no-c-format
-msgid ""
-"Finally, the <literal>store</literal> action is dispatched to the "
-"<literal>createAndStoreEvent()</literal> method, which also uses the "
-"<literal>Session</literal> of the current thread:"
-msgstr ""
-"最后，<literal>store</literal> 动作会被导向到 <literal>createAndStoreEvent()"
-"</literal> 方法，它也使用当前线程的 <literal>Session</literal>："
+msgid "Finally, the <literal>store</literal> action is dispatched to the <literal>createAndStoreEvent()</literal> method, which also uses the <literal>Session</literal> of the current thread:"
+msgstr "最后，<literal>store</literal> 动作会被导向到 <literal>createAndStoreEvent()</literal> 方法，它也使用当前线程的 <literal>Session</literal>："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The servlet is now complete. A request to the servlet will be processed in a "
-"single <literal>Session</literal> and <literal>Transaction</literal>. As "
-"earlier in the standalone application, Hibernate can automatically bind "
-"these objects to the current thread of execution. This gives you the freedom "
-"to layer your code and access the <literal>SessionFactory</literal> in any "
-"way you like. Usually you would use a more sophisticated design and move the "
-"data access code into data access objects (the DAO pattern). See the "
-"Hibernate Wiki for more examples."
-msgstr ""
-"大功告成，这个 servlet 写完了。Hibernate 会在单一的 <literal>Session</"
-"literal> 和 <literal>Transaction</literal> 中处理到达的 servlet 请求。如同在"
-"前面的独立应用程序中那样，Hibernate 可以自动的把这些对象绑定到当前运行的线程"
-"中。这给了你用任何你喜欢的方式来对代码分层及访问 <literal>SessionFactory</"
-"literal> 的自由。通常，你会用更加完备的设计，把数据访问代码转移到数据访问对象"
-"中（DAO 模式）。请参见 Hibernate Wiki，那里有更多的例子。"
+#, no-c-format
+msgid "The servlet is now complete. A request to the servlet will be processed in a single <literal>Session</literal> and <literal>Transaction</literal>. As earlier in the standalone application, Hibernate can automatically bind these objects to the current thread of execution. This gives you the freedom to layer your code and access the <literal>SessionFactory</literal> in any way you like. Usually you would use a more sophisticated design and move the data access code into data access objects (the DAO pattern). See the Hibernate Wiki for more examples."
+msgstr "大功告成，这个 servlet 写完了。Hibernate 会在单一的 <literal>Session</literal> 和 <literal>Transaction</literal> 中处理到达的 servlet 请求。如同在前面的独立应用程序中那样，Hibernate 可以自动的把这些对象绑定到当前运行的线程中。这给了你用任何你喜欢的方式来对代码分层及访问 <literal>SessionFactory</literal> 的自由。通常，你会用更加完备的设计，把数据访问代码转移到数据访问对象中（DAO 模式）。请参见 Hibernate Wiki，那里有更多的例子。 "
#. Tag: title
#, no-c-format
@@ -1521,47 +672,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"To deploy this application for testing we must create a Web ARchive (WAR). "
-"First we must define the WAR descriptor as <filename>src/main/webapp/WEB-INF/"
-"web.xml</filename>"
+msgid "To deploy this application for testing we must create a Web ARchive (WAR). First we must define the WAR descriptor as <filename>src/main/webapp/WEB-INF/web.xml</filename>"
msgstr ""
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"To build and deploy call <literal>mvn package</literal> in your project "
-"directory and copy the <filename>hibernate-tutorial.war</filename> file into "
-"your Tomcat <filename>webapps</filename> directory."
-msgstr ""
-"在你的开发目录中，调用 <literal>ant war</literal> 来构建、打包，然后把 "
-"<literal>hibernate-tutorial.war</literal> 文件拷贝到你的 tomcat 的 "
-"<literal>webapps</literal> 目录下。假若你还没安装 Tomcat，就去下载一个，按照"
-"指南来安装。对此应用的发布，你不需要修改任何 Tomcat 的配置。"
+#, no-c-format
+msgid "To build and deploy call <literal>mvn package</literal> in your project directory and copy the <filename>hibernate-tutorial.war</filename> file into your Tomcat <filename>webapps</filename> directory."
+msgstr "在你的开发目录中，调用 <literal>ant war</literal> 来构建、打包，然后把 <literal>hibernate-tutorial.war</literal> 文件拷贝到你的 tomcat 的 <literal>webapps</literal> 目录下。假若你还没安装 Tomcat，就去下载一个，按照指南来安装。对此应用的发布，你不需要修改任何 Tomcat 的配置。 "
#. Tag: para
#, no-c-format
-msgid ""
-"If you do not have Tomcat installed, download it from <ulink url=\"http://"
-"tomcat.apache.org/\" /> and follow the installation instructions. Our "
-"application requires no changes to the standard Tomcat configuration."
+msgid "If you do not have Tomcat installed, download it from <ulink url=\"http://tomcat.apache.org/\" /> and follow the installation instructions. Our application requires no changes to the standard Tomcat configuration."
msgstr ""
#. Tag: para
#, no-c-format
-msgid ""
-"Once deployed and Tomcat is running, access the application at "
-"<literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>. "
-"Make sure you watch the Tomcat log to see Hibernate initialize when the "
-"first request hits your servlet (the static initializer in "
-"<literal>HibernateUtil</literal> is called) and to get the detailed output "
-"if any exceptions occurs."
-msgstr ""
-"在部署完，启动 Tomcat 之后，通过 <literal>http://localhost:8080/hibernate-"
-"tutorial/eventmanager</literal> 进行访问你的应用，在第一次 servlet 请求发生"
-"时，请在 Tomcat log 中确认你看到 Hibernate 被初始化了"
-"（<literal>HibernateUtil</literal> 的静态初始化器被调用），假若有任何异常抛"
-"出，也可以看到详细的输出。"
+msgid "Once deployed and Tomcat is running, access the application at <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>. Make sure you watch the Tomcat log to see Hibernate initialize when the first request hits your servlet (the static initializer in <literal>HibernateUtil</literal> is called) and to get the detailed output if any exceptions occurs."
+msgstr "在部署完，启动 Tomcat 之后，通过 <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal> 进行访问你的应用，在第一次 servlet 请求发生时，请在 Tomcat log 中确认你看到 Hibernate 被初始化了（<literal>HibernateUtil</literal> 的静态初始化器被调用），假若有任何异常抛出，也可以看到详细的输出。"
#. Tag: title
#, no-c-format
@@ -1569,14 +696,9 @@
msgstr "总结"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This tutorial covered the basics of writing a simple standalone Hibernate "
-"application and a small web application. More tutorials are available from "
-"the Hibernate <ulink url=\"http://hibernate.org\">website</ulink>."
-msgstr ""
-"本章覆盖了如何编写一个简单独立的 Hibernate 命令行应用程序及小型的 Hibernate "
-"web 应用程序的基本要素。"
+#, no-c-format
+msgid "This tutorial covered the basics of writing a simple standalone Hibernate application and a small web application. More tutorials are available from the Hibernate <ulink url=\"http://hibernate.org\">website</ulink>."
+msgstr "本章覆盖了如何编写一个简单独立的 Hibernate 命令行应用程序及小型的 Hibernate web 应用程序的基本要素。更多的教程可以在 <ulink url=\"http://hibernate.org\">website</ulink> 上找到。"
#~ msgid ""
#~ "<![CDATA[<project xmlns=\"http://maven.apache.org/POM/4.0.0\"\n"
@@ -1674,7 +796,6 @@
#~ " </dependencies>\n"
#~ "\n"
#~ "</project>]]>"
-
#~ msgid ""
#~ "<![CDATA[package org.hibernate.tutorial.domain;\n"
#~ "\n"
@@ -1749,7 +870,6 @@
#~ " this.title = title;\n"
#~ " }\n"
#~ "}]]>"
-
#~ msgid ""
#~ "<![CDATA[<?xml version=\"1.0\"?>\n"
#~ "<!DOCTYPE hibernate-mapping PUBLIC\n"
@@ -1768,7 +888,6 @@
#~ "<hibernate-mapping package=\"org.hibernate.tutorial.domain\">\n"
#~ "[...]\n"
#~ "</hibernate-mapping>]]>"
-
#~ msgid ""
#~ "<![CDATA[<hibernate-mapping package=\"org.hibernate.tutorial.domain\">\n"
#~ "\n"
@@ -1785,7 +904,6 @@
#~ " </class>\n"
#~ "\n"
#~ "</hibernate-mapping>]]>"
-
#~ msgid ""
#~ "<![CDATA[<hibernate-mapping package=\"org.hibernate.tutorial.domain\">\n"
#~ "\n"
@@ -1806,7 +924,6 @@
#~ " </class>\n"
#~ "\n"
#~ "</hibernate-mapping>]]>"
-
#~ msgid ""
#~ "<![CDATA[\n"
#~ "<hibernate-mapping package=\"org.hibernate.tutorial.domain\">\n"
@@ -1835,7 +952,6 @@
#~ " </class>\n"
#~ "\n"
#~ "</hibernate-mapping>]]>"
-
#~ msgid ""
#~ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
#~ "<!DOCTYPE hibernate-configuration PUBLIC\n"
@@ -2846,3 +1962,4 @@
#~ " <url-pattern>/eventmanager</url-pattern>\n"
#~ " </servlet-mapping>\n"
#~ "</web-app>"
+
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/xml.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/xml.po 2009-12-07 11:18:59 UTC (rev 97497)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/xml.po 2009-12-07 11:52:20 UTC (rev 97498)
@@ -6,7 +6,7 @@
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-12-03T00:15:27\n"
-"PO-Revision-Date: 2009-11-27 13:57+1000\n"
+"PO-Revision-Date: 2009-12-07 21:18+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -20,12 +20,9 @@
msgstr "XML 映射"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis> XML Mapping is an experimental feature in Hibernate 3.0 and is "
-"currently under active development. </emphasis>"
-msgstr ""
-"注意 XML 映射只是 Hibernate 3.0 的一个实验性的特性。这一特性仍在积极开发中。"
+#, no-c-format
+msgid "<emphasis> XML Mapping is an experimental feature in Hibernate 3.0 and is currently under active development. </emphasis>"
+msgstr "<emphasis>注意 XML 映射只是 Hibernate 3.0 的一个实验性的特性。这一特性仍在积极开发中。</emphasis>"
#. Tag: title
#, no-c-format
@@ -34,51 +31,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate allows you to work with persistent XML data in much the same way "
-"you work with persistent POJOs. A parsed XML tree can be thought of as "
-"another way of representing the relational data at the object level, instead "
-"of POJOs."
-msgstr ""
-"Hibernate 使得你可以用 XML 数据来进行工作，恰如你用持久化的 POJO 进行工作那"
-"样。解析过的 XML 树 可以被认为是代替 POJO 的另外一种在对象层面上表示关系型数"
-"据的途径。"
+msgid "Hibernate allows you to work with persistent XML data in much the same way you work with persistent POJOs. A parsed XML tree can be thought of as another way of representing the relational data at the object level, instead of POJOs."
+msgstr "Hibernate 使得你可以用 XML 数据来进行工作，恰如你用持久化的 POJO 进行工作那样。解析过的 XML 树 可以被认为是代替 POJO 的另外一种在对象层面上表示关系型数据的途径。"
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate supports dom4j as API for manipulating XML trees. You can write "
-"queries that retrieve dom4j trees from the database and have any "
-"modification you make to the tree automatically synchronized to the "
-"database. You can even take an XML document, parse it using dom4j, and write "
-"it to the database with any of Hibernate's basic operations: <literal>persist"
-"(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merging is not "
-"yet supported)."
-msgstr ""
-"Hibernate 支持采用 dom4j 作为操作 XML 树的 API。你可以写一些查询从数据库中检"
-"索出 dom4j 树，随后你对这颗树做的任何修改都将自动同步回数据库。你甚至可以用 "
-"dom4j 解析 一篇 XML 文档，然后使用 Hibernate 的任一基本操作将它写入数据库："
-"<literal>persist()，saveOrUpdate()，merge()，delete()，replicate()</literal> "
-"（合并操作merge()目前还不支持）。"
+msgid "Hibernate supports dom4j as API for manipulating XML trees. You can write queries that retrieve dom4j trees from the database and have any modification you make to the tree automatically synchronized to the database. You can even take an XML document, parse it using dom4j, and write it to the database with any of Hibernate's basic operations: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merging is not yet supported)."
+msgstr "Hibernate 支持采用 dom4j 作为操作 XML 树的 API。你可以写一些查询从数据库中检索出 dom4j 树，随后你对这颗树做的任何修改都将自动同步回数据库。你甚至可以用 dom4j 解析 一篇 XML 文档，然后使用 Hibernate 的任一基本操作将它写入数据库：<literal>persist()，saveOrUpdate()，merge()，delete()，replicate()</literal> （合并操作merge()目前还不支持）。"
#. Tag: para
#, no-c-format
-msgid ""
-"This feature has many applications including data import/export, "
-"externalization of entity data via JMS or SOAP and XSLT-based reporting."
-msgstr ""
-"这一特性可以应用在很多场合，包括数据导入导出，通过 JMS 或 SOAP 具体化实体数据"
-"以及 基于 XSLT 的报表。"
+msgid "This feature has many applications including data import/export, externalization of entity data via JMS or SOAP and XSLT-based reporting."
+msgstr "这一特性可以应用在很多场合，包括数据导入导出，通过 JMS 或 SOAP 具体化实体数据以及 基于 XSLT 的报表。"
#. Tag: para
#, no-c-format
-msgid ""
-"A single mapping can be used to simultaneously map properties of a class and "
-"nodes of an XML document to the database, or, if there is no class to map, "
-"it can be used to map just the XML."
-msgstr ""
-"一个单一的映射就可以将类的属性和 XML 文档的节点同时映射到数据库。如果不需要映"
-"射类，它也可以用来只映射 XML 文档。 "
+msgid "A single mapping can be used to simultaneously map properties of a class and nodes of an XML document to the database, or, if there is no class to map, it can be used to map just the XML."
+msgstr "一个单一的映射就可以将类的属性和 XML 文档的节点同时映射到数据库。如果不需要映射类，它也可以用来只映射 XML 文档。 "
#. Tag: title
#, no-c-format
@@ -102,14 +71,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"This mapping allows you to access the data as a dom4j tree, or as a graph of "
-"property name/value pairs or java <literal>Map</literal>s. The property "
-"names are purely logical constructs that can be referred to in HQL queries."
-msgstr ""
-"这个映射使得你既可以把数据作为一棵 dom4j 树那样访问，又可以作为由属性键值对"
-"（java <literal>Map</literal>）组成的图那样访问。属性名字纯粹是逻辑上的结构，"
-"你可以在 HQL 查询中引用它。"
+msgid "This mapping allows you to access the data as a dom4j tree, or as a graph of property name/value pairs or java <literal>Map</literal>s. The property names are purely logical constructs that can be referred to in HQL queries."
+msgstr "这个映射使得你既可以把数据作为一棵 dom4j 树那样访问，又可以作为由属性键值对（java <literal>Map</literal>）组成的图那样访问。属性名字纯粹是逻辑上的结构，你可以在 HQL 查询中引用它。"
#. Tag: title
#, no-c-format
@@ -118,15 +81,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"A range of Hibernate mapping elements accept the <literal>node</literal> "
-"attribute. This lets you specify the name of an XML attribute or element "
-"that holds the property or entity data. The format of the <literal>node</"
-"literal> attribute must be one of the following:"
-msgstr ""
-"许多 Hibernate 映射元素具有 <literal>node</literal> 属性。这使你可以指定用来"
-"保存 属性或实体数据的 XML 属性或元素。<literal>node</literal> 属性必须是下列"
-"格式之一： "
+msgid "A range of Hibernate mapping elements accept the <literal>node</literal> attribute. This lets you specify the name of an XML attribute or element that holds the property or entity data. The format of the <literal>node</literal> attribute must be one of the following:"
+msgstr "许多 Hibernate 映射元素具有 <literal>node</literal> 属性。这使你可以指定用来保存 属性或实体数据的 XML 属性或元素。<literal>node</literal> 属性必须是下列格式之一： "
#. Tag: para
#, no-c-format
@@ -145,47 +101,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>\"element-name/@attribute-name\"</literal>: map to the named "
-"attribute of the named element"
-msgstr ""
-"<literal>\"element-name/@attribute-name\"</literal>：映射为指定元素的指定属性"
+msgid "<literal>\"element-name/@attribute-name\"</literal>: map to the named attribute of the named element"
+msgstr "<literal>\"element-name/@attribute-name\"</literal>：映射为指定元素的指定属性"
#. Tag: para
#, no-c-format
-msgid ""
-"For collections and single valued associations, there is an additional "
-"<literal>embed-xml</literal> attribute. If <literal>embed-xml=\"true\"</"
-"literal>, the default, the XML tree for the associated entity (or collection "
-"of value type) will be embedded directly in the XML tree for the entity that "
-"owns the association. Otherwise, if <literal>embed-xml=\"false\"</literal>, "
-"then only the referenced identifier value will appear in the XML for single "
-"point associations and collections will not appear at all."
-msgstr ""
-"对于集合和单值的关联，有一个额外的 <literal>embed-xml</literal> 属性可用。这"
-"个属性的缺省值是真（<literal>embed-xml=\"true\"</literal>）。如果 "
-"<literal>embed-xml=\"true\"</literal>，则对应于被关联实体或值类型的集合的XML"
-"树将直接嵌入拥有这些关联的实体的 XML 树中。否则，如果 <literal>embed-xml="
-"\"false\"</literal>，那么对于单值的关联，仅被引用的实体的标识符出现在 XML 树"
-"中（被引用实体本身不出现），而集合则根本不出现。"
+msgid "For collections and single valued associations, there is an additional <literal>embed-xml</literal> attribute. If <literal>embed-xml=\"true\"</literal>, the default, the XML tree for the associated entity (or collection of value type) will be embedded directly in the XML tree for the entity that owns the association. Otherwise, if <literal>embed-xml=\"false\"</literal>, then only the referenced identifier value will appear in the XML for single point associations and collections will not appear at all."
+msgstr "对于集合和单值的关联，有一个额外的 <literal>embed-xml</literal> 属性可用。这个属性的缺省值是真（<literal>embed-xml=\"true\"</literal>）。如果 <literal>embed-xml=\"true\"</literal>，则对应于被关联实体或值类型的集合的XML树将直接嵌入拥有这些关联的实体的 XML 树中。否则，如果 <literal>embed-xml=\"false\"</literal>，那么对于单值的关联，仅被引用的实体的标识符出现在 XML 树中（被引用实体本身不出现），而集合则根本不出现。"
#. Tag: para
#, no-c-format
-msgid ""
-"Do not leave <literal>embed-xml=\"true\"</literal> for too many "
-"associations, since XML does not deal well with circularity."
-msgstr ""
-"你应该小心，不要让太多关联的 embed-xml 属性为真（<literal>embed-xml=\"true"
-"\"</literal>），因为 XML 不能很好地处理循环引用。"
+msgid "Do not leave <literal>embed-xml=\"true\"</literal> for too many associations, since XML does not deal well with circularity."
+msgstr "你应该小心，不要让太多关联的 embed-xml 属性为真（<literal>embed-xml=\"true\"</literal>），因为 XML 不能很好地处理循环引用。"
#. Tag: para
#, no-c-format
-msgid ""
-"In this case, the collection of account ids is embedded, but not the actual "
-"account data. The following HQL query:"
-msgstr ""
-"在这个例子中，我们决定嵌入帐目号码（account id）的集合，但不嵌入实际的帐目数"
-"据。下面的 HQL 查询： "
+msgid "In this case, the collection of account ids is embedded, but not the actual account data. The following HQL query:"
+msgstr "在这个例子中，我们决定嵌入帐目号码（account id）的集合，但不嵌入实际的帐目数据。下面的 HQL 查询： "
#. Tag: para
#, no-c-format
@@ -194,12 +126,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"If you set <literal>embed-xml=\"true\"</literal> on the <literal><one-to-"
-"many></literal> mapping, the data might look more like this:"
-msgstr ""
-"如果你把一对多映射 <literal><one-to-many></literal> 的 embed-xml 属性置"
-"为真（<literal>embed-xml=\"true\"</literal>），则数据看上去就像这样："
+msgid "If you set <literal>embed-xml=\"true\"</literal> on the <literal><one-to-many></literal> mapping, the data might look more like this:"
+msgstr "如果你把一对多映射 <literal><one-to-many></literal> 的 embed-xml 属性置为真（<literal>embed-xml=\"true\"</literal>），则数据看上去就像这样："
#. Tag: title
#, no-c-format
@@ -208,21 +136,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"You can also re-read and update XML documents in the application. You can do "
-"this by obtaining a dom4j session:"
-msgstr ""
-"你也可以重新读入和更新应用程序中的 XML 文档。通过获取一个 dom4j 会话可以做到"
-"这一点："
+msgid "You can also re-read and update XML documents in the application. You can do this by obtaining a dom4j session:"
+msgstr "你也可以重新读入和更新应用程序中的 XML 文档。通过获取一个 dom4j 会话可以做到这一点："
#. Tag: para
#, no-c-format
-msgid ""
-"When implementing XML-based data import/export, it is useful to combine this "
-"feature with Hibernate's <literal>replicate()</literal> operation."
-msgstr ""
-"将这一特色与 Hibernate 的 <literal>replicate()</literal> 操作结合起来对于实现"
-"的基于 XML 的数据导入/导出将非常有用。"
+msgid "When implementing XML-based data import/export, it is useful to combine this feature with Hibernate's <literal>replicate()</literal> operation."
+msgstr "将这一特色与 Hibernate 的 <literal>replicate()</literal> 操作结合起来对于实现的基于 XML 的数据导入/导出将非常有用。"
#~ msgid ""
#~ "<![CDATA[<class name=\"Account\" \n"
@@ -266,7 +186,6 @@
#~ " ...\n"
#~ " \n"
#~ "</class>]]>"
-
#~ msgid ""
#~ "<![CDATA[<class entity-name=\"Account\" \n"
#~ " table=\"ACCOUNTS\" \n"
@@ -315,7 +234,6 @@
#~ " ...\n"
#~ " \n"
#~ "</class>]]>"
-
#~ msgid ""
#~ "<![CDATA[<class name=\"Customer\" \n"
#~ " table=\"CUSTOMER\" \n"
@@ -386,14 +304,12 @@
#~ " ...\n"
#~ " \n"
#~ "</class>]]>"
-
#~ msgid ""
#~ "<![CDATA[from Customer c left join fetch c.accounts where c.lastName "
#~ "like :lastName]]>"
#~ msgstr ""
#~ "<![CDATA[from Customer c left join fetch c.accounts where c.lastName "
#~ "like :lastName]]>"
-
#~ msgid ""
#~ "<![CDATA[<customer id=\"123456789\">\n"
#~ " <account short-desc=\"Savings\">987632567</account>\n"
@@ -416,7 +332,6 @@
#~ " </name>\n"
#~ " ...\n"
#~ "</customer>]]>"
-
#~ msgid ""
#~ "<![CDATA[<customer id=\"123456789\">\n"
#~ " <account id=\"987632567\" short-desc=\"Savings\">\n"
@@ -451,7 +366,6 @@
#~ " </name>\n"
#~ " ...\n"
#~ "</customer>]]>"
-
#~ msgid ""
#~ "<![CDATA[Document doc = ....;\n"
#~ " \n"
@@ -490,7 +404,6 @@
#~ "\n"
#~ "tx.commit();\n"
#~ "session.close();]]>"
-
#~ msgid ""
#~ "<![CDATA[Session session = factory.openSession();\n"
#~ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
@@ -525,3 +438,4 @@
#~ "\n"
#~ "tx.commit();\n"
#~ "session.close();]]>"
+
More information about the jboss-cvs-commits
mailing list