[jboss-cvs] JBossAS SVN: r97060 - projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN.

[jboss-cvs-commits at lists.jboss.org]

Author: xhuang at jboss.com
Date: 2009-11-26 23:12:59 -0500 (Thu, 26 Nov 2009)
New Revision: 97060

Modified:
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_parentchild.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_weblog.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/filters.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/transactions.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/example_parentchild.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_parentchild.po	2009-11-27 03:48:07 UTC (rev 97059)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_parentchild.po	2009-11-27 04:12:59 UTC (rev 97060)
@@ -6,7 +6,7 @@
 "Project-Id-Version: Collection_Mapping\n"
 "Report-Msgid-Bugs-To: http://bugs.kde.org\n"
 "POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2009-11-20 18:35+1000\n"
+"PO-Revision-Date: 2009-11-27 13:54+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -162,15 +162,15 @@
 
 #. Tag: programlisting
 #: example_parentchild.xml:137
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
-msgstr "&lt;many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/&gt;"
+msgstr "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
 
 #. Tag: para
 #: example_parentchild.xml:139
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "You also need to add the <literal>parent</literal> property to the <literal>Child</literal> class."
-msgstr "（我们还需要为类 <literal>Child</literal> æ·»åŠ  <literal>parent</literal> 属性）"
+msgstr "ä½ è¿˜éœ€è¦ä¸ºç±» <literal>Child</literal> æ·»åŠ  <literal>parent</literal> 属性。"
 
 #. Tag: para
 #: example_parentchild.xml:143
@@ -336,7 +336,7 @@
 
 #. Tag: programlisting
 #: example_parentchild.xml:202
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
 "Child c = (Child) p.getChildren().iterator().next();\n"
@@ -344,11 +344,11 @@
 "c.setParent(null);\n"
 "session.flush();]]>"
 msgstr ""
-"Parent p = (Parent) session.load(Parent.class, pid);\n"
+"<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
 "Child c = (Child) p.getChildren().iterator().next();\n"
 "p.getChildren().remove(c);\n"
 "c.setParent(null);\n"
-"session.flush();"
+"session.flush();]]>"
 
 #. Tag: para
 #: example_parentchild.xml:204

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_weblog.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_weblog.po	2009-11-27 03:48:07 UTC (rev 97059)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_weblog.po	2009-11-27 04:12:59 UTC (rev 97060)
@@ -6,7 +6,7 @@
 "Project-Id-Version: Collection_Mapping\n"
 "Report-Msgid-Bugs-To: http://bugs.kde.org\n"
 "POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2009-11-20 17:35+1000\n"
+"PO-Revision-Date: 2009-11-27 13:54+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -18,7 +18,7 @@
 #: example_weblog.xml:29
 #, no-c-format
 msgid "Example: Weblog Application"
-msgstr "示例：Weblog 应用程序"
+msgstr "示例：Weblog 应用程序 "
 
 #. Tag: title
 #: example_weblog.xml:32

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/filters.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/filters.po	2009-11-27 03:48:07 UTC (rev 97059)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/filters.po	2009-11-27 04:12:59 UTC (rev 97060)
@@ -6,7 +6,7 @@
 "Project-Id-Version: Collection_Mapping\n"
 "Report-Msgid-Bugs-To: http://bugs.kde.org\n"
 "POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-11-27 13:53+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -22,17 +22,9 @@
 
 #. Tag: para
 #: filters.xml:31
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate3 provides an innovative new approach to handling data with "
-"\"visibility\" rules. A <emphasis>Hibernate filter</emphasis> is a global, "
-"named, parameterized filter that can be enabled or disabled for a particular "
-"Hibernate session."
-msgstr ""
-"Hibernate3 提供了一种创新的方式来处理具有“显性（visibility）”规则的数据，那就"
-"是使用<emphasis>Hibernate filter</emphasis>。<emphasis>Hibernate filter</"
-"emphasis> 是全局有效的、具有名字、可以带参数的过滤器， 对于某个特定的 "
-"Hibernate session 您可以选择是否启用（或禁用）某个过滤器。"
+#, no-c-format
+msgid "Hibernate3 provides an innovative new approach to handling data with \"visibility\" rules. A <emphasis>Hibernate filter</emphasis> is a global, named, parameterized filter that can be enabled or disabled for a particular Hibernate session."
+msgstr "Hibernate3 提供了一种创新的方式来处理具有“显性（visibility）”规则的数据，那就是使用<emphasis>Hibernate 过滤器</emphasis>。<emphasis>Hibernate 过滤器</emphasis>是全局有效的、具有名字、可以带参数的过滤器，对于某个特定的 Hibernate session 您可以选择是否启用（或禁用）某个过滤器。"
 
 #. Tag: title
 #: filters.xml:38
@@ -42,149 +34,99 @@
 
 #. Tag: para
 #: filters.xml:40
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate3 has the ability to pre-define filter criteria and attach those "
-"filters at both a class level and a collection level. A filter criteria "
-"allows you to define a restriction clause similar to the existing \"where\" "
-"attribute available on the class and various collection elements. These "
-"filter conditions, however, can be parameterized. The application can then "
-"decide at runtime whether certain filters should be enabled and what their "
-"parameter values should be. Filters can be used like database views, but "
-"they are parameterized inside the application."
-msgstr ""
-"Hibernate3 新增了对某个类或者集合使用预先定义的过滤器条件（filter criteria）"
-"的功能。过滤器条件相当于定义一个 非常类似于类和各种集合上的“where”属性的约束"
-"子句，但是过滤器条件可以带参数。 应用程序可以在运行时决定是否启用给定的过滤"
-"å™¨ï¼Œä»¥åŠä½¿ç”¨ä»€ä¹ˆæ ·çš„å‚æ•°å€¼ã€‚è¿‡æ»¤å™¨çš„ç”¨æ³•å¾ˆåƒæ•°æ®åº“è§†å›¾ï¼Œåªä¸è¿‡æ˜¯åœ¨åº”ç”¨ç¨‹åºä¸­"
-"ç¡®å®šä½¿ç”¨ä»€ä¹ˆæ ·çš„å‚æ•°çš„ã€‚"
+#, no-c-format
+msgid "Hibernate3 has the ability to pre-define filter criteria and attach those filters at both a class level and a collection level. A filter criteria allows you to define a restriction clause similar to the existing \"where\" attribute available on the class and various collection elements. These filter conditions, however, can be parameterized. The application can then decide at runtime whether certain filters should be enabled and what their parameter values should be. Filters can be used like database views, but they are parameterized inside the application."
+msgstr "Hibernate3 新增了对某个类或者集合使用预先定义的过滤器条件（filter criteria）的功能。过滤器条件相当于定义一个 非常类似于类和各种集合上的“where”属性的约束子句，但是过滤器条件可以带参数。 åº”ç”¨ç¨‹åºå¯ä»¥åœ¨è¿è¡Œæ—¶å†³å®šæ˜¯å¦å¯ç”¨ç»™å®šçš„è¿‡æ»¤å™¨ï¼Œä»¥åŠä½¿ç”¨ä»€ä¹ˆæ ·çš„å‚æ•°å€¼ã€‚è¿‡æ»¤å™¨çš„ç”¨æ³•å¾ˆåƒæ•°æ®åº“è§†å›¾ï¼Œåªä¸è¿‡æ˜¯åœ¨åº”ç”¨ç¨‹åºä¸­ç¡®å®šä½¿ç”¨ä»€ä¹ˆæ ·çš„å‚æ•°çš„ã€‚ "
 
 #. Tag: para
 #: filters.xml:50
 #, no-c-format
-msgid ""
-"In order to use filters, they must first be defined and then attached to the "
-"appropriate mapping elements. To define a filter, use the <literal>&lt;"
-"filter-def/&gt;</literal> element within a <literal>&lt;hibernate-mapping/"
-"&gt;</literal> element:"
-msgstr ""
-"è¦ä½¿ç”¨è¿‡æ»¤å™¨ï¼Œå¿…é¡»é¦–å…ˆåœ¨ç›¸åº”çš„æ˜ å°„èŠ‚ç‚¹ä¸­å®šä¹‰ã€‚è€Œå®šä¹‰ä¸€ä¸ªè¿‡æ»¤å™¨ï¼Œè¦ç”¨åˆ°ä½äºŽ "
-"<literal>&lt;hibernate-mapping/&gt;</literal> 节点之内的 <literal>&lt;filter-"
-"def/&gt;</literal> 节点："
+msgid "In order to use filters, they must first be defined and then attached to the appropriate mapping elements. To define a filter, use the <literal>&lt;filter-def/&gt;</literal> element within a <literal>&lt;hibernate-mapping/&gt;</literal> element:"
+msgstr "è¦ä½¿ç”¨è¿‡æ»¤å™¨ï¼Œå¿…é¡»é¦–å…ˆåœ¨ç›¸åº”çš„æ˜ å°„èŠ‚ç‚¹ä¸­å®šä¹‰ã€‚è€Œå®šä¹‰ä¸€ä¸ªè¿‡æ»¤å™¨ï¼Œè¦ç”¨åˆ°ä½äºŽ <literal>&lt;hibernate-mapping/&gt;</literal> 节点之内的 <literal>&lt;filter-def/&gt;</literal> 节点："
 
 #. Tag: programlisting
 #: filters.xml:56
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[<filter-def name=\"myFilter\">\n"
 "    <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
 "</filter-def>]]>"
 msgstr ""
-"&lt;filter-def name=\"myFilter\"&gt;\n"
-"    &lt;filter-param name=\"myFilterParam\" type=\"string\"/&gt;\n"
-"&lt;/filter-def&gt;"
+"<![CDATA[<filter-def name=\"myFilter\">\n"
+"    <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
+"</filter-def>]]>"
 
 #. Tag: para
 #: filters.xml:58
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "This filter can then be attached to a class:"
-msgstr "定义好之后，就可以在某个类中使用这个过滤器："
+msgstr "定义好之后，就可以在某个类中使用这个过滤器： "
 
 #. Tag: programlisting
 #: filters.xml:62
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[<class name=\"myClass\" ...>\n"
 "    ...\n"
-"    <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN"
-"\"/>\n"
+"    <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
 "</class>]]>"
 msgstr ""
-"&lt;class name=\"myClass\" ...&gt;\n"
+"<![CDATA[<class name=\"myClass\" ...>\n"
 "    ...\n"
-"    &lt;filter name=\"myFilter\" condition=\":myFilterParam = "
-"MY_FILTERED_COLUMN\"/&gt;\n"
-"&lt;/class&gt;"
+"    <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+"</class>]]>"
 
 #. Tag: para
 #: filters.xml:64
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Or, to a collection:"
-msgstr "也可以在某个集合使用它："
+msgstr "或者也可以在某个集合使用它："
 
 #. Tag: programlisting
 #: filters.xml:68
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[<set ...>\n"
-"    <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN"
-"\"/>\n"
+"    <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
 "</set>]]>"
 msgstr ""
-"&lt;set ...&gt;\n"
-"    &lt;filter name=\"myFilter\" condition=\":myFilterParam = "
-"MY_FILTERED_COLUMN\"/&gt;\n"
-"&lt;/set&gt;"
+"<![CDATA[<set ...>\n"
+"    <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+"</set>]]>"
 
 #. Tag: para
 #: filters.xml:70
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Or, to both or multiples of each at the same time."
-msgstr ""
-"可以在多个类或集合中使用某个过滤器；某个类或者集合中也可以使用多个过滤器。"
+msgstr "或者在同时可以使用多个过滤器。"
 
 #. Tag: para
 #: filters.xml:74
-#, fuzzy, no-c-format
-msgid ""
-"The methods on <literal>Session</literal> are: <literal>enableFilter(String "
-"filterName)</literal>, <literal>getEnabledFilter(String filterName)</"
-"literal>, and <literal>disableFilter(String filterName)</literal>. By "
-"default, filters are <emphasis>not</emphasis> enabled for a given session. "
-"Filters must be enabled through use of the <literal>Session.enableFilter()</"
-"literal> method, which returns an instance of the <literal>Filter</literal> "
-"interface. If you used the simple filter defined above, it would look like "
-"this:"
-msgstr ""
-"<literal>Session</literal> 对象中会用到的方法有：<literal>enableFilter"
-"(String filterName)</literal>，<literal>getEnabledFilter(String filterName)</"
-"literal>，和 <literal>disableFilter(String filterName)</literal>。Session 中"
-"默认是<emphasis>不</emphasis>启用过滤器的，必须通过 <literal>Session."
-"enabledFilter()</literal> 方法显式的启用。 该方法返回被启用的 "
-"<literal>Filter</literal> 的实例。以上文定义的过滤器为例："
+#, no-c-format
+msgid "The methods on <literal>Session</literal> are: <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, and <literal>disableFilter(String filterName)</literal>. By default, filters are <emphasis>not</emphasis> enabled for a given session. Filters must be enabled through use of the <literal>Session.enableFilter()</literal> method, which returns an instance of the <literal>Filter</literal> interface. If you used the simple filter defined above, it would look like this:"
+msgstr "<literal>Session</literal> 对象中会用到的方法有：<literal>enableFilter(String filterName)</literal>，<literal>getEnabledFilter(String filterName)</literal>，和 <literal>disableFilter(String filterName)</literal>。Session 中默认是<emphasis>不</emphasis>启用过滤器的，必须通过 <literal>Session.enabledFilter()</literal> 方法显式的启用。该方法返回被启用的 <literal>Filter</literal> 的实例。以上文定义的过滤器为例："
 
 #. Tag: programlisting
 #: filters.xml:83
-#, fuzzy, no-c-format
-msgid ""
-"<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", "
-"\"some-value\");]]>"
-msgstr ""
-"session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-"
-"value\");"
+#, no-c-format
+msgid "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+msgstr "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
 
 #. Tag: para
 #: filters.xml:85
-#, fuzzy, no-c-format
-msgid ""
-"Methods on the org.hibernate.Filter interface do allow the method-chaining "
-"common to much of Hibernate."
-msgstr ""
-"注意，org.hibernate.Filter 的方法允许链式方法调用。（类似上面例子中启用 "
-"Filter 之后设定 Filter 参数这个“方法链”） Hibernate 的其他部分也大多有这个特"
-"性。"
+#, no-c-format
+msgid "Methods on the org.hibernate.Filter interface do allow the method-chaining common to much of Hibernate."
+msgstr "注意，org.hibernate.Filter 的方法允许链式方法调用。（类似上面例子中启用 Filter 之后设定 Filter 参数这个“方法链”） Hibernate 的其他部分也大多有这个特性。 "
 
 #. Tag: para
 #: filters.xml:89
-#, fuzzy, no-c-format
-msgid ""
-"The following is a full example, using temporal data with an effective "
-"record date pattern:"
-msgstr "下面是一个比较完整的例子，使用了记录生效日期模式过滤有时效的数据："
+#, no-c-format
+msgid "The following is a full example, using temporal data with an effective record date pattern:"
+msgstr "下面是一个比较完整的例子，使用了记录生效日期模式过滤有时效的数据： "
 
 #. Tag: programlisting
 #: filters.xml:93
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[<filter-def name=\"effectiveDate\">\n"
 "    <filter-param name=\"asOfDate\" type=\"date\"/>\n"
@@ -192,16 +134,12 @@
 "\n"
 "<class name=\"Employee\" ...>\n"
 "...\n"
-"    <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/"
-">\n"
-"    <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt"
-"\"/>\n"
-"    <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/"
-">\n"
+"    <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+"    <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+"    <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
 "...\n"
 "    <!--\n"
-"        Note that this assumes non-terminal records have an eff_end_dt set "
-"to\n"
+"        Note that this assumes non-terminal records have an eff_end_dt set to\n"
 "        a max db date for simplicity-sake\n"
 "    -->\n"
 "    <filter name=\"effectiveDate\"\n"
@@ -214,135 +152,93 @@
 "        <key column=\"dept_id\"/>\n"
 "        <one-to-many class=\"Employee\"/>\n"
 "        <filter name=\"effectiveDate\"\n"
-"                condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/"
-">\n"
+"                condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
 "    </set>\n"
 "</class>]]>"
 msgstr ""
-"&lt;filter-def name=\"effectiveDate\"&gt;\n"
-"    &lt;filter-param name=\"asOfDate\" type=\"date\"/&gt;\n"
-"&lt;/filter-def&gt;\n"
+"<![CDATA[<filter-def name=\"effectiveDate\">\n"
+"    <filter-param name=\"asOfDate\" type=\"date\"/>\n"
+"</filter-def>\n"
 "\n"
-"&lt;class name=\"Employee\" ...&gt;\n"
+"<class name=\"Employee\" ...>\n"
 "...\n"
-"    &lt;many-to-one name=\"department\" column=\"dept_id\" class=\"Department"
-"\"/&gt;\n"
-"    &lt;property name=\"effectiveStartDate\" type=\"date\" column="
-"\"eff_start_dt\"/&gt;\n"
-"    &lt;property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt"
-"\"/&gt;\n"
+"    <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+"    <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+"    <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
 "...\n"
-"    &lt;!--\n"
-"        Note that this assumes non-terminal records have an eff_end_dt set "
-"to\n"
+"    <!--\n"
+"        Note that this assumes non-terminal records have an eff_end_dt set to\n"
 "        a max db date for simplicity-sake\n"
-"    --&gt;\n"
-"    &lt;filter name=\"effectiveDate\"\n"
-"            condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/"
-"&gt;\n"
-"&lt;/class&gt;\n"
+"    -->\n"
+"    <filter name=\"effectiveDate\"\n"
+"            condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+"</class>\n"
 "\n"
-"&lt;class name=\"Department\" ...&gt;\n"
+"<class name=\"Department\" ...>\n"
 "...\n"
-"    &lt;set name=\"employees\" lazy=\"true\"&gt;\n"
-"        &lt;key column=\"dept_id\"/&gt;\n"
-"        &lt;one-to-many class=\"Employee\"/&gt;\n"
-"        &lt;filter name=\"effectiveDate\"\n"
-"                condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/"
-"&gt;\n"
-"    &lt;/set&gt;\n"
-"&lt;/class&gt;"
+"    <set name=\"employees\" lazy=\"true\">\n"
+"        <key column=\"dept_id\"/>\n"
+"        <one-to-many class=\"Employee\"/>\n"
+"        <filter name=\"effectiveDate\"\n"
+"                condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+"    </set>\n"
+"</class>]]>"
 
 #. Tag: para
 #: filters.xml:95
-#, fuzzy, no-c-format
-msgid ""
-"In order to ensure that you are provided with currently effective records, "
-"enable the filter on the session prior to retrieving employee data:"
-msgstr ""
-"定义好后，如果想要保证取回的都是目前处于生效期的记录，只需在获取雇员数据的操"
-"作之前先开启过滤器即可："
+#, no-c-format
+msgid "In order to ensure that you are provided with currently effective records, enable the filter on the session prior to retrieving employee data:"
+msgstr "定义好后，如果想要保证取回的都是目前处于生效期的记录，只需在获取雇员数据的操作之前先开启过滤器即可： "
 
 #. Tag: programlisting
 #: filters.xml:100
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[Session session = ...;\n"
-"session.enableFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date"
-"());\n"
-"List results = session.createQuery(\"from Employee as e where e.salary > :"
-"targetSalary\")\n"
+"session.enableFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+"List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
 "         .setLong(\"targetSalary\", new Long(1000000))\n"
 "         .list();\n"
 "]]>"
 msgstr ""
-"Session session = ...;\n"
-"session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date"
-"());\n"
-"List results = session.createQuery(\"from Employee as e where e.salary &gt; :"
-"targetSalary\")\n"
+"<![CDATA[Session session = ...;\n"
+"session.enableFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+"List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
 "         .setLong(\"targetSalary\", new Long(1000000))\n"
-"         .list();"
+"         .list();\n"
+"]]>"
 
 #. Tag: para
 #: filters.xml:102
-#, fuzzy, no-c-format
-msgid ""
-"Even though a salary constraint was mentioned explicitly on the results in "
-"the above HQL, because of the enabled filter, the query will return only "
-"currently active employees who have a salary greater than one million "
-"dollars."
-msgstr ""
-"在上面的 HQL ä¸­ï¼Œè™½ç„¶æˆ‘ä»¬ä»…ä»…æ˜¾å¼çš„ä½¿ç”¨äº†ä¸€ä¸ªè–ªæ°´æ¡ä»¶ï¼Œä½†å› ä¸ºå¯ç”¨äº†è¿‡æ»¤å™¨ï¼ŒæŸ¥"
-"询将仅返回那些目前雇用关系处于生效期的，并且薪水高于一百万美元的雇员的数据。"
+#, no-c-format
+msgid "Even though a salary constraint was mentioned explicitly on the results in the above HQL, because of the enabled filter, the query will return only currently active employees who have a salary greater than one million dollars."
+msgstr "在上面的 HQL ä¸­ï¼Œè™½ç„¶æˆ‘ä»¬ä»…ä»…æ˜¾å¼çš„ä½¿ç”¨äº†ä¸€ä¸ªè–ªæ°´æ¡ä»¶ï¼Œä½†å› ä¸ºå¯ç”¨äº†è¿‡æ»¤å™¨ï¼ŒæŸ¥è¯¢å°†ä»…è¿”å›žé‚£äº›ç›®å‰é›‡ç”¨å…³ç³»å¤„äºŽç”Ÿæ•ˆæœŸçš„ï¼Œå¹¶ä¸”è–ªæ°´é«˜äºŽä¸€ç™¾ä¸‡ç¾Žå…ƒçš„é›‡å‘˜çš„æ•°æ®ã€‚ "
 
 #. Tag: para
 #: filters.xml:108
-#, fuzzy, no-c-format
-msgid ""
-"If you want to use filters with outer joining, either through HQL or load "
-"fetching, be careful of the direction of the condition expression. It is "
-"safest to set this up for left outer joining. Place the parameter first "
-"followed by the column name(s) after the operator."
-msgstr ""
-"æ³¨æ„ï¼šå¦‚æžœä½ æ‰“ç®—åœ¨ä½¿ç”¨å¤–è¿žæŽ¥ï¼ˆæˆ–è€…é€šè¿‡ HQL 或 load fetching）的同时使用过滤"
-"器，要注意条件表达式的方向（左还是右）。最安全的方式是使用左外连接（left "
-"outer joining）。并且通常来说，先写参数，然后是操作符，最后写数据库字段名。"
+#, no-c-format
+msgid "If you want to use filters with outer joining, either through HQL or load fetching, be careful of the direction of the condition expression. It is safest to set this up for left outer joining. Place the parameter first followed by the column name(s) after the operator."
+msgstr "æ³¨æ„ï¼šå¦‚æžœä½ æ‰“ç®—åœ¨ä½¿ç”¨å¤–è¿žæŽ¥ï¼ˆæˆ–è€…é€šè¿‡ HQL 或 load fetching）的同时使用过滤器，要注意条件表达式的方向（左还是右）。最安全的方式是使用左外连接（left outer joining）。并且通常来说，先写参数，然后是操作符，最后写数据库字段名。"
 
 #. Tag: para
 #: filters.xml:115
-#, fuzzy, no-c-format
-msgid ""
-"After being defined, a filter might be attached to multiple entities and/or "
-"collections each with its own condition. This can be problematic when the "
-"conditions are the same each time. Using <literal>&lt;filter-def/&gt;</"
-"literal> allows you to definine a default condition, either as an attribute "
-"or CDATA:"
-msgstr ""
-"在 Filter 定义之后,å®ƒå¯èƒ½è¢«é™„åŠ åˆ°å¤šä¸ªå®žä½“å’Œ/或集合类,每个都有自己的条件。假若"
-"è¿™äº›æ¡ä»¶éƒ½æ˜¯ä¸€æ ·çš„ï¼Œæ¯æ¬¡éƒ½è¦å®šä¹‰å°±æ˜¾å¾—å¾ˆç¹çã€‚å› æ­¤ï¼Œ<literal>&lt;filter-def/"
-"&gt;</literal> 被用来定义一个默认条件，它可能作为属性或者 CDATA 出现："
+#, no-c-format
+msgid "After being defined, a filter might be attached to multiple entities and/or collections each with its own condition. This can be problematic when the conditions are the same each time. Using <literal>&lt;filter-def/&gt;</literal> allows you to definine a default condition, either as an attribute or CDATA:"
+msgstr "在 Filter 定义之后,å®ƒå¯èƒ½è¢«é™„åŠ åˆ°å¤šä¸ªå®žä½“å’Œ/或集合类,æ¯ä¸ªéƒ½æœ‰è‡ªå·±çš„æ¡ä»¶ã€‚å‡è‹¥è¿™äº›æ¡ä»¶éƒ½æ˜¯ä¸€æ ·çš„ï¼Œæ¯æ¬¡éƒ½è¦å®šä¹‰å°±æ˜¾å¾—å¾ˆç¹çã€‚å› æ­¤ï¼Œ<literal>&lt;filter-def/&gt;</literal> 被用来定义一个默认条件，它可能作为属性或者 CDATA 出现： "
 
 #. Tag: programlisting
 #: filters.xml:122
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
-"<![CDATA[<filter-def name=\"myFilter\" condition=\"abc > xyz\">...</filter-"
-"def>\n"
+"<![CDATA[<filter-def name=\"myFilter\" condition=\"abc > xyz\">...</filter-def>\n"
 "<filter-def name=\"myOtherFilter\">abc=xyz</filter-def>]]>"
 msgstr ""
-"&lt;filter-def name=\"myFilter\" condition=\"abc &gt; xyz\"&gt;...&lt;/"
-"filter-def&gt;\n"
-"&lt;filter-def name=\"myOtherFilter\"&gt;abc=xyz&lt;/filter-def&gt;"
+"<![CDATA[<filter-def name=\"myFilter\" condition=\"abc > xyz\">...</filter-def>\n"
+"<filter-def name=\"myOtherFilter\">abc=xyz</filter-def>]]>"
 
 #. Tag: para
 #: filters.xml:124
-#, fuzzy, no-c-format
-msgid ""
-"This default condition will be used whenever the filter is attached to "
-"something without specifying a condition. This means you can give a specific "
-"condition as part of the attachment of the filter that overrides the default "
-"condition in that particular case."
-msgstr ""
-"当这个 filter è¢«é™„åŠ åˆ°ä»»ä½•ç›®çš„åœ°ï¼Œè€Œåˆæ²¡æœ‰æŒ‡æ˜Žæ¡ä»¶æ—¶ï¼Œè¿™ä¸ªæ¡ä»¶å°±ä¼šè¢«ä½¿ç”¨ã€‚æ³¨"
-"æ„ï¼Œæ¢å¥è¯è¯´ï¼Œä½ å¯ä»¥é€šè¿‡ç»™ filter é™„åŠ ç‰¹åˆ«çš„æ¡ä»¶æ¥é‡è½½é»˜è®¤æ¡ä»¶ã€‚"
+#, no-c-format
+msgid "This default condition will be used whenever the filter is attached to something without specifying a condition. This means you can give a specific condition as part of the attachment of the filter that overrides the default condition in that particular case."
+msgstr "当这个 filter è¢«é™„åŠ åˆ°ä»»ä½•ç›®çš„åœ°ï¼Œè€Œåˆæ²¡æœ‰æŒ‡æ˜Žæ¡ä»¶æ—¶ï¼Œè¿™ä¸ªç¼ºçœæ¡ä»¶å°±ä¼šè¢«ä½¿ç”¨ã€‚æ³¨æ„ï¼Œæ¢å¥è¯è¯´ï¼Œä½ å¯ä»¥é€šè¿‡ç»™ filter é™„åŠ ç‰¹åˆ«çš„æ¡ä»¶æ¥é‡è½½é»˜è®¤æ¡ä»¶ã€‚"
+

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/transactions.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/transactions.po	2009-11-27 03:48:07 UTC (rev 97059)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/transactions.po	2009-11-27 04:12:59 UTC (rev 97060)
@@ -6,7 +6,7 @@
 "Project-Id-Version: Collection_Mapping\n"
 "Report-Msgid-Bugs-To: http://bugs.kde.org\n"
 "POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-11-27 14:11+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -16,64 +16,33 @@
 
 #. Tag: title
 #: transactions.xml:29
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Transactions and Concurrency"
-msgstr "事务和并发"
+msgstr "事务和并发 "
 
 #. Tag: para
 #: transactions.xml:31
-#, fuzzy, no-c-format
-msgid ""
-"The most important point about Hibernate and concurrency control is that it "
-"is easy to understand. Hibernate directly uses JDBC connections and JTA "
-"resources without adding any additional locking behavior. It is recommended "
-"that you spend some time with the JDBC, ANSI, and transaction isolation "
-"specification of your database management system."
-msgstr ""
-"Hibernate 的事务和并发控制很容易掌握。Hibernate 直接使用 JDBC 连接和 JTA 资"
-"æºï¼Œä¸æ·»åŠ ä»»ä½•é™„åŠ é”å®šè¡Œä¸ºã€‚æˆ‘ä»¬å¼ºçƒˆæŽ¨èä½ èŠ±ç‚¹æ—¶é—´äº†è§£ JDBC 编程，ANSI SQL 查"
-"è¯¢è¯­è¨€å’Œä½ ä½¿ç”¨çš„æ•°æ®åº“ç³»ç»Ÿçš„äº‹åŠ¡éš”ç¦»è§„èŒƒã€‚"
+#, no-c-format
+msgid "The most important point about Hibernate and concurrency control is that it is easy to understand. Hibernate directly uses JDBC connections and JTA resources without adding any additional locking behavior. It is recommended that you spend some time with the JDBC, ANSI, and transaction isolation specification of your database management system."
+msgstr "Hibernate 的事务和并发控制很容易掌握。Hibernate 直接使用 JDBC 连接和 JTA èµ„æºï¼Œä¸æ·»åŠ ä»»ä½•é™„åŠ é”å®šè¡Œä¸ºã€‚æˆ‘ä»¬å¼ºçƒˆæŽ¨èä½ èŠ±ç‚¹æ—¶é—´äº†è§£ JDBC 编程，ANSI SQL æŸ¥è¯¢è¯­è¨€å’Œä½ ä½¿ç”¨çš„æ•°æ®åº“ç³»ç»Ÿçš„äº‹åŠ¡éš”ç¦»è§„èŒƒã€‚ "
 
 #. Tag: para
 #: transactions.xml:38
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate does not lock objects in memory. Your application can expect the "
-"behavior as defined by the isolation level of your database transactions. "
-"Through <literal>Session</literal>, which is also a transaction-scoped "
-"cache, Hibernate provides repeatable reads for lookup by identifier and "
-"entity queries and not reporting queries that return scalar values."
-msgstr ""
-"Hibernate ä¸é”å®šå†…å­˜ä¸­çš„å¯¹è±¡ã€‚ä½ çš„åº”ç”¨ç¨‹åºä¼šæŒ‰ç…§ä½ çš„æ•°æ®åº“äº‹åŠ¡çš„éš”ç¦»çº§åˆ«è§„å®š"
-"çš„é‚£æ ·è¿ä½œã€‚å¹¸äºæœ‰äº† <literal>Session</literal>，使得 Hibernate é€šè¿‡æ ‡è¯†ç¬¦æŸ¥"
-"æ‰¾ï¼Œå’Œå®žä½“æŸ¥è¯¢ï¼ˆä¸æ˜¯è¿”å›žæ ‡é‡å€¼çš„æŠ¥è¡¨æŸ¥è¯¢ï¼‰æä¾›äº†å¯é‡å¤çš„è¯»å–ï¼ˆRepeatable "
-"reads）功能，<literal>Session</literal> 同时也是事务范围内的缓存（cache）。"
+#, no-c-format
+msgid "Hibernate does not lock objects in memory. Your application can expect the behavior as defined by the isolation level of your database transactions. Through <literal>Session</literal>, which is also a transaction-scoped cache, Hibernate provides repeatable reads for lookup by identifier and entity queries and not reporting queries that return scalar values."
+msgstr "Hibernate ä¸é”å®šå†…å­˜ä¸­çš„å¯¹è±¡ã€‚ä½ çš„åº”ç”¨ç¨‹åºä¼šæŒ‰ç…§ä½ çš„æ•°æ®åº“äº‹åŠ¡çš„éš”ç¦»çº§åˆ«è§„å®šçš„é‚£æ ·è¿ä½œã€‚å¹¸äºæœ‰äº† <literal>Session</literal>，使得 Hibernate é€šè¿‡æ ‡è¯†ç¬¦æŸ¥æ‰¾ï¼Œå’Œå®žä½“æŸ¥è¯¢ï¼ˆä¸æ˜¯è¿”å›žæ ‡é‡å€¼çš„æŠ¥è¡¨æŸ¥è¯¢ï¼‰æä¾›äº†å¯é‡å¤çš„è¯»å–ï¼ˆRepeatable reads）功能，<literal>Session</literal> 同时也是事务范围内的缓存（cache）。 "
 
 #. Tag: para
 #: transactions.xml:46
-#, fuzzy, no-c-format
-msgid ""
-"In addition to versioning for automatic optimistic concurrency control, "
-"Hibernate also offers, using the <literal>SELECT FOR UPDATE</literal> "
-"syntax, a (minor) API for pessimistic locking of rows. Optimistic "
-"concurrency control and this API are discussed later in this chapter."
-msgstr ""
-"除了对自动乐观并发控制提供版本管理，针对行级悲观锁定，Hibernate 也提供了辅助"
-"的（较小的）API，它使用了 <literal>SELECT FOR UPDATE</literal> 的 SQL 语法。"
-"æœ¬ç« åŽé¢ä¼šè®¨è®ºä¹è§‚å¹¶å‘æŽ§åˆ¶å’Œè¿™ä¸ªAPI。"
+#, no-c-format
+msgid "In addition to versioning for automatic optimistic concurrency control, Hibernate also offers, using the <literal>SELECT FOR UPDATE</literal> syntax, a (minor) API for pessimistic locking of rows. Optimistic concurrency control and this API are discussed later in this chapter."
+msgstr "除了对自动乐观并发控制提供版本管理，针对行级悲观锁定，Hibernate 也提供了辅助的（较小的）API，它使用了 <literal>SELECT FOR UPDATE</literal> çš„ SQL è¯­æ³•ã€‚æœ¬ç« åŽé¢ä¼šè®¨è®ºä¹è§‚å¹¶å‘æŽ§åˆ¶å’Œè¿™ä¸ªAPI。 "
 
 #. Tag: para
 #: transactions.xml:53
-#, fuzzy, no-c-format
-msgid ""
-"The discussion of concurrency control in Hibernate begins with the "
-"granularity of <literal>Configuration</literal>, <literal>SessionFactory</"
-"literal>, and <literal>Session</literal>, as well as database transactions "
-"and long conversations."
-msgstr ""
-"我们从 <literal>Configuration</literal>层、<literal>SessionFactory</literal> "
-"层，和 <literal>Session</literal> 层开始讨论 Hibernate 的并行控制、数据库事务"
-"和应用程序的长事务。"
+#, no-c-format
+msgid "The discussion of concurrency control in Hibernate begins with the granularity of <literal>Configuration</literal>, <literal>SessionFactory</literal>, and <literal>Session</literal>, as well as database transactions and long conversations."
+msgstr "我们从 <literal>Configuration</literal>层、<literal>SessionFactory</literal> 层，和 <literal>Session</literal> 层开始讨论 Hibernate 的并行控制、数据库事务和应用程序的长事务。 "
 
 #. Tag: title
 #: transactions.xml:60
@@ -83,61 +52,27 @@
 
 #. Tag: para
 #: transactions.xml:62
-#, fuzzy, no-c-format
-msgid ""
-"A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe "
-"object, intended to be shared by all application threads. It is created "
-"once, usually on application startup, from a <literal>Configuration</"
-"literal> instance."
-msgstr ""
-"<literal>SessionFactory</literal> 对象的创建代价很昂贵，它是线程安全的对象，"
-"它为所有的应用程序线程所共享。它只创建一次，通常是在应用程序启动的时候，由一"
-"个 <literal>Configuraion</literal> 的实例来创建。"
+#, no-c-format
+msgid "A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe object, intended to be shared by all application threads. It is created once, usually on application startup, from a <literal>Configuration</literal> instance."
+msgstr "<literal>SessionFactory</literal> 对象的创建代价很昂贵，它是线程安全的对象，它为所有的应用程序线程所共享。它只创建一次，通常是在应用程序启动的时候，由一个 <literal>Configuraion</literal> 的实例来创建。 "
 
 #. Tag: para
 #: transactions.xml:68
-#, fuzzy, no-c-format
-msgid ""
-"A <literal>Session</literal> is an inexpensive, non-threadsafe object that "
-"should be used once and then discarded for: a single request, a conversation "
-"or a single unit of work. A <literal>Session</literal> will not obtain a "
-"JDBC <literal>Connection</literal>, or a <literal>Datasource</literal>, "
-"unless it is needed. It will not consume any resources until used."
-msgstr ""
-"<literal>Session</literal> 对象的创建代价比较小，是非线程安全的，对于单个请"
-"求，单个会话、单个的 工作单元而言，它只被使用一次，然后就丢弃。只有在需要的时"
-"候，一个 <literal>Session</literal> 对象 才会获取一个 JDBC 的 "
-"<literal>Connection</literal>（或一个<literal>Datasource</literal>ï¼‰å¯¹è±¡ï¼Œå› "
-"此假若不使用的时候它不消费任何资源。"
+#, no-c-format
+msgid "A <literal>Session</literal> is an inexpensive, non-threadsafe object that should be used once and then discarded for: a single request, a conversation or a single unit of work. A <literal>Session</literal> will not obtain a JDBC <literal>Connection</literal>, or a <literal>Datasource</literal>, unless it is needed. It will not consume any resources until used."
+msgstr "<literal>Session</literal> 对象的创建代价比较小，是非线程安全的，对于单个请求，单个会话、单个的 工作单元而言，它只被使用一次，然后就丢弃。只有在需要的时候，一个 <literal>Session</literal> 对象 才会获取一个 JDBC çš„ <literal>Connection</literal>（或一个<literal>Datasource</literal>ï¼‰å¯¹è±¡ï¼Œå› æ­¤å‡è‹¥ä¸ä½¿ç”¨çš„æ—¶å€™å®ƒä¸æ¶ˆè´¹ä»»ä½•èµ„æºã€‚ "
 
 #. Tag: para
 #: transactions.xml:76
-#, fuzzy, no-c-format
-msgid ""
-"In order to reduce lock contention in the database, a database transaction "
-"has to be as short as possible. Long database transactions will prevent your "
-"application from scaling to a highly concurrent load. It is not recommended "
-"that you hold a database transaction open during user think time until the "
-"unit of work is complete."
-msgstr ""
-"此外我们还要考虑数据库事务。数据库事务应该尽可能的短，降低数据库中的锁争用。"
-"æ•°æ®åº“é•¿äº‹åŠ¡ä¼šé˜»æ­¢ä½ çš„åº”ç”¨ç¨‹åºæ‰©å±•åˆ°é«˜çš„å¹¶å‘è´Ÿè½½ã€‚å› æ­¤ï¼Œå‡è‹¥åœ¨ç”¨æˆ·æ€è€ƒæœŸé—´è®©"
-"数据库事务开着，直到整个工作单元完成才关闭这个事务，这绝不是一个好的设计。"
+#, no-c-format
+msgid "In order to reduce lock contention in the database, a database transaction has to be as short as possible. Long database transactions will prevent your application from scaling to a highly concurrent load. It is not recommended that you hold a database transaction open during user think time until the unit of work is complete."
+msgstr "æ­¤å¤–æˆ‘ä»¬è¿˜è¦è€ƒè™‘æ•°æ®åº“äº‹åŠ¡ã€‚æ•°æ®åº“äº‹åŠ¡åº”è¯¥å°½å¯èƒ½çš„çŸ­ï¼Œé™ä½Žæ•°æ®åº“ä¸­çš„é”äº‰ç”¨ã€‚æ•°æ®åº“é•¿äº‹åŠ¡ä¼šé˜»æ­¢ä½ çš„åº”ç”¨ç¨‹åºæ‰©å±•åˆ°é«˜çš„å¹¶å‘è´Ÿè½½ã€‚å› æ­¤ï¼Œå‡è‹¥åœ¨ç”¨æˆ·æ€è€ƒæœŸé—´è®©æ•°æ®åº“äº‹åŠ¡å¼€ç€ï¼Œç›´åˆ°æ•´ä¸ªå·¥ä½œå•å…ƒå®Œæˆæ‰å…³é—­è¿™ä¸ªäº‹åŠ¡ï¼Œè¿™ç»ä¸æ˜¯ä¸€ä¸ªå¥½çš„è®¾è®¡ã€‚ "
 
 #. Tag: para
 #: transactions.xml:84
-#, fuzzy, no-c-format
-msgid ""
-"What is the scope of a unit of work? Can a single Hibernate "
-"<literal>Session</literal> span several database transactions, or is this a "
-"one-to-one relationship of scopes? When should you open and close a "
-"<literal>Session</literal> and how do you demarcate the database transaction "
-"boundaries? These questions are addressed in the following sections."
-msgstr ""
-"一个操作单元（Unit of work）的范围是多大？单个的 Hibernate <literal>Session</"
-"literal> 能跨越多个数据库事务吗？还是一个 <literal>Session</literal> 的作用范"
-"围对应一个数据库事务的范围？应该何时打开 <literal>Session</literal>，何时关"
-"é—­ <literal>Session</literal>ï¼Œä½ åˆå¦‚ä½•åˆ’åˆ†æ•°æ®åº“äº‹åŠ¡çš„è¾¹ç•Œå‘¢ï¼Ÿ"
+#, no-c-format
+msgid "What is the scope of a unit of work? Can a single Hibernate <literal>Session</literal> span several database transactions, or is this a one-to-one relationship of scopes? When should you open and close a <literal>Session</literal> and how do you demarcate the database transaction boundaries? These questions are addressed in the following sections."
+msgstr "一个操作单元（Unit of work）的范围是多大？单个的 Hibernate <literal>Session</literal> 能跨越多个数据库事务吗？还是一个 <literal>Session</literal> 的作用范围对应一个数据库事务的范围？应该何时打开 <literal>Session</literal>，何时关闭 <literal>Session</literal>ï¼Œä½ åˆå¦‚ä½•åˆ’åˆ†æ•°æ®åº“äº‹åŠ¡çš„è¾¹ç•Œå‘¢ï¼Ÿæˆ‘ä»¬å°†åœ¨åŽç»­ç« èŠ‚è§£å†³è¿™äº›é—®é¢˜ã€‚"
 
 #. Tag: title
 #: transactions.xml:92
@@ -148,134 +83,38 @@
 #. Tag: para
 #: transactions.xml:94
 #, no-c-format
-msgid ""
-"First, let's define a unit of work. A unit of work is a design pattern "
-"described by Martin Fowler as <quote> [maintaining] a list of objects "
-"affected by a business transaction and coordinates the writing out of "
-"changes and the resolution of concurrency problems. </quote><citation>PoEAA</"
-"citation> In other words, its a series of operations we wish to carry out "
-"against the database together. Basically, it is a transaction, though "
-"fulfilling a unit of work will often span multiple physical database "
-"transactions (see <xref linkend=\"transactions-basics-apptx\"/>). So really "
-"we are talking about a more abstract notion of a transaction. The term "
-"\"business transaction\" is also sometimes used in lieu of unit of work."
-msgstr ""
+msgid "First, let's define a unit of work. A unit of work is a design pattern described by Martin Fowler as <quote> [maintaining] a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems. </quote><citation>PoEAA</citation> In other words, its a series of operations we wish to carry out against the database together. Basically, it is a transaction, though fulfilling a unit of work will often span multiple physical database transactions (see <xref linkend=\"transactions-basics-apptx\"/>). So really we are talking about a more abstract notion of a transaction. The term \"business transaction\" is also sometimes used in lieu of unit of work."
+msgstr "首先，让我们定义一个工作单元（unit of work）。工作单元是一个设计模式，Martin Fowler 把它描述为 <quote> [maintaining] a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems. </quote><citation>PoEAA</citation> 换句话说，它是我们希望对数据库执行的一系列操作。基本上，它是一个事务，虽然完成一个工作单元经常将跨越多个物理数据库事务（请参考 <xref linkend=\"transactions-basics-apptx\"/>）。所以，实际上我们在讨论一个更抽象的事务概念。术语 \"business transaction\" 有时也和工作单元一起使用。"
 
 #. Tag: para
 #: transactions.xml:111
-#, fuzzy, no-c-format
-msgid ""
-"Do not use the <emphasis>session-per-operation</emphasis> antipattern: do "
-"not open and close a <literal>Session</literal> for every simple database "
-"call in a single thread. The same is true for database transactions. "
-"Database calls in an application are made using a planned sequence; they are "
-"grouped into atomic units of work. This also means that auto-commit after "
-"every single SQL statement is useless in an application as this mode is "
-"intended for ad-hoc SQL console work. Hibernate disables, or expects the "
-"application server to disable, auto-commit mode immediately. Database "
-"transactions are never optional. All communication with a database has to "
-"occur inside a transaction. Auto-commit behavior for reading data should be "
-"avoided, as many small transactions are unlikely to perform better than one "
-"clearly defined unit of work. The latter is also more maintainable and "
-"extensible."
-msgstr ""
-"首先，别用 <emphasis>session-per-operation</emphasis> 这种反模式了，也就是"
-"说，在单个线程中， ä¸è¦å› ä¸ºä¸€æ¬¡ç®€å•çš„æ•°æ®åº“è°ƒç”¨ï¼Œå°±æ‰“å¼€å’Œå…³é—­ä¸€æ¬¡ "
-"<literal>Session</literal>！数据库事务也是如此。 应用程序中的数据库调用是按照"
-"计划好的次序，分组为原子的操作单元。（注意，这也意味着，应用程 序中，在单个"
-"的 SQL 语句发送之后，自动事务提交（auto-commit）模式失效了。这种模式专门为SQL"
-"控制台操作设计的。 Hibernate 禁止立即自动事务提交模式，或者期望应用服务器禁止"
-"ç«‹å³è‡ªåŠ¨äº‹åŠ¡æäº¤æ¨¡å¼ã€‚ï¼‰æ•°æ®åº“äº‹åŠ¡ç»ä¸æ˜¯å¯æœ‰å¯æ— çš„ï¼Œä»»ä½•ä¸Žæ•°æ®åº“ä¹‹é—´çš„é€šè®¯éƒ½"
-"å¿…é¡»åœ¨æŸä¸ªäº‹åŠ¡ä¸­è¿›è¡Œï¼Œä¸ç®¡ä½ æ˜¯åœ¨è¯»è¿˜æ˜¯åœ¨å†™æ•°æ®ã€‚å¯¹è¯»æ•°æ®è€Œè¨€ï¼Œåº”è¯¥é¿å… auto-"
-"commit è¡Œä¸ºï¼Œå› ä¸ºå¾ˆå¤šå°çš„äº‹åŠ¡æ¯”ä¸€ä¸ªæ¸…æ™°å®šä¹‰çš„å·¥ä½œå•å…ƒæ€§èƒ½å·®ã€‚åŽè€…ä¹Ÿæ›´å®¹æ˜“ç»´æŠ¤"
-"和扩展。"
+#, no-c-format
+msgid "Do not use the <emphasis>session-per-operation</emphasis> antipattern: do not open and close a <literal>Session</literal> for every simple database call in a single thread. The same is true for database transactions. Database calls in an application are made using a planned sequence; they are grouped into atomic units of work. This also means that auto-commit after every single SQL statement is useless in an application as this mode is intended for ad-hoc SQL console work. Hibernate disables, or expects the application server to disable, auto-commit mode immediately. Database transactions are never optional. All communication with a database has to occur inside a transaction. Auto-commit behavior for reading data should be avoided, as many small transactions are unlikely to perform better than one clearly defined unit of work. The latter is also more maintainable and extensible."
+msgstr "首先，别用 <emphasis>session-per-operation</emphasis> 这种反模式了，也就是说，在单个线程中， ä¸è¦å› ä¸ºä¸€æ¬¡ç®€å•çš„æ•°æ®åº“è°ƒç”¨ï¼Œå°±æ‰“å¼€å’Œå…³é—­ä¸€æ¬¡ <literal>Session</literal>！数据库事务也是如此。 应用程序中的数据库调用是按照计划好的次序，分组为原子的操作单元。（注意，这也意味着，应用程 序中，在单个的 SQL 语句发送之后，自动事务提交（auto-commit）模式失效了。这种模式专门为SQL控制台操作设计的。 Hibernate ç¦æ­¢ç«‹å³è‡ªåŠ¨äº‹åŠ¡æäº¤æ¨¡å¼ï¼Œæˆ–è€…æœŸæœ›åº”ç”¨æœåŠ¡å™¨ç¦æ­¢ç«‹å³è‡ªåŠ¨äº‹åŠ¡æäº¤æ¨¡å¼ã€‚ï¼‰æ•°æ®åº“äº‹åŠ¡ç»ä¸æ˜¯å¯æœ‰å¯æ— çš„ï¼Œä»»ä½•ä¸Žæ•°æ®åº“ä¹‹é—´çš„é€šè®¯éƒ½å¿…é¡»åœ¨æŸä¸ªäº‹åŠ¡ä¸­è¿›è¡Œï¼Œä¸ç®¡ä½ æ˜¯åœ¨è¯»è¿˜æ˜¯åœ¨å†™æ•°æ®ã€‚å¯¹è¯»æ•°æ®è€Œè¨€ï¼Œåº”è¯¥é¿å… auto-commit è¡Œä¸ºï¼Œå› ä¸ºå¾ˆå¤šå°çš„äº‹åŠ¡æ¯”ä¸€ä¸ªæ¸…æ™°å®šä¹‰çš„å·¥ä½œå•å…ƒæ€§èƒ½å·®ã€‚åŽè€…ä¹Ÿæ›´å®¹æ˜“ç»´æŠ¤å’Œæ‰©å±•ã€‚ "
 
 #. Tag: para
 #: transactions.xml:126
-#, fuzzy, no-c-format
-msgid ""
-"The most common pattern in a multi-user client/server application is "
-"<emphasis>session-per-request</emphasis>. In this model, a request from the "
-"client is sent to the server, where the Hibernate persistence layer runs. A "
-"new Hibernate <literal>Session</literal> is opened, and all database "
-"operations are executed in this unit of work. On completion of the work, and "
-"once the response for the client has been prepared, the session is flushed "
-"and closed. Use a single database transaction to serve the clients request, "
-"starting and committing it when you open and close the <literal>Session</"
-"literal>. The relationship between the two is one-to-one and this model is a "
-"perfect fit for many applications."
-msgstr ""
-"在多用户的 client/server 应用程序中，最常用的模式是 <emphasis>每个请求一个会"
-"话（session-per-request）</emphasis>。 在这种模式下，来自客户端的请求被发送到"
-"服务器端（即 Hibernate 持久化层运行的地方），一个新的 Hibernate "
-"<literal>Session</literal> 被打开，并且执行这个操作单元中所有的数据库操作。一"
-"旦操作完成（同时对客户端的响应也准备就绪），session è¢«åŒæ­¥ï¼Œç„¶åŽå…³é—­ã€‚ä½ ä¹Ÿå¯"
-"以使用单 ä¸ªæ•°æ®åº“äº‹åŠ¡æ¥å¤„ç†å®¢æˆ·ç«¯è¯·æ±‚ï¼Œåœ¨ä½ æ‰“å¼€ <literal>Session</literal> 之"
-"åŽå¯åŠ¨äº‹åŠ¡ï¼Œåœ¨ä½ å…³é—­ <literal>Session</literal> 之前提交事务。会话和请求之间"
-"的关系是一对一的关系，这种模式对 于大多数应用程序来说是很棒的。"
+#, no-c-format
+msgid "The most common pattern in a multi-user client/server application is <emphasis>session-per-request</emphasis>. In this model, a request from the client is sent to the server, where the Hibernate persistence layer runs. A new Hibernate <literal>Session</literal> is opened, and all database operations are executed in this unit of work. On completion of the work, and once the response for the client has been prepared, the session is flushed and closed. Use a single database transaction to serve the clients request, starting and committing it when you open and close the <literal>Session</literal>. The relationship between the two is one-to-one and this model is a perfect fit for many applications."
+msgstr "在多用户的 client/server 应用程序中，最常用的模式是 <emphasis>每个请求一个会话（session-per-request）</emphasis>。 在这种模式下，来自客户端的请求被发送到服务器端（即 Hibernate 持久化层运行的地方），一个新的 Hibernate <literal>Session</literal> 被打开，并且执行这个操作单元中所有的数据库操作。一旦操作完成（同时对客户端的响应也准备就绪），session è¢«åŒæ­¥ï¼Œç„¶åŽå…³é—­ã€‚ä½ ä¹Ÿå¯ä»¥ä½¿ç”¨å• ä¸ªæ•°æ®åº“äº‹åŠ¡æ¥å¤„ç†å®¢æˆ·ç«¯è¯·æ±‚ï¼Œåœ¨ä½ æ‰“å¼€ <literal>Session</literal> ä¹‹åŽå¯åŠ¨äº‹åŠ¡ï¼Œåœ¨ä½ å…³é—­ <literal>Session</literal> 之前提交事务。会话和请求之间的关系是一对一的关系，这种模式对 于大多数应用程序来说是很棒的。 "
 
 #. Tag: para
 #: transactions.xml:138
-#, fuzzy, no-c-format
-msgid ""
-"The challenge lies in the implementation. Hibernate provides built-in "
-"management of the \"current session\" to simplify this pattern. Start a "
-"transaction when a server request has to be processed, and end the "
-"transaction before the response is sent to the client. Common solutions are "
-"<literal>ServletFilter</literal>, AOP interceptor with a pointcut on the "
-"service methods, or a proxy/interception container. An EJB container is a "
-"standardized way to implement cross-cutting aspects such as transaction "
-"demarcation on EJB session beans, declaratively with CMT. If you use "
-"programmatic transaction demarcation, for ease of use and code portability "
-"use the Hibernate <literal>Transaction</literal> API shown later in this "
-"chapter."
-msgstr ""
-"实现才是真正的挑战。Hibernate 内置了对\"当前 session（current session）\" 的"
-"ç®¡ç†ï¼Œç”¨äºŽç®€åŒ–æ­¤æ¨¡å¼ã€‚ä½ è¦åšçš„ä¸€åˆ‡å°±æ˜¯åœ¨æœåŠ¡å™¨ç«¯è¦å¤„ç†è¯·æ±‚çš„æ—¶å€™ï¼Œå¼€å¯äº‹åŠ¡ï¼Œ"
-"åœ¨å“åº”å‘é€ç»™å®¢æˆ·ä¹‹å‰ç»“æŸäº‹åŠ¡ã€‚ä½ å¯ä»¥ç”¨ä»»ä½•æ–¹å¼æ¥å®Œæˆè¿™ä¸€æ“ä½œï¼Œé€šå¸¸çš„æ–¹æ¡ˆæœ‰ "
-"<literal>ServletFilter</literal>，在 service 方法中进行 pointcut 的 AOP 拦截"
-"器，或者 proxy/interception 容器。EJB 容器是实现横切诸如 EJB session bean 上"
-"的事务分界，用 CMT å¯¹äº‹åŠ¡è¿›è¡Œå£°æ˜Žç­‰æ–¹é¢çš„æ ‡å‡†æ‰‹æ®µã€‚å‡è‹¥ä½ å†³å®šä½¿ç”¨ç¼–ç¨‹å¼çš„äº‹åŠ¡"
-"åˆ†ç•Œï¼Œè¯·å‚è€ƒæœ¬ç« åŽé¢è®²åˆ°çš„ Hibernate <literal>Transaction</literal> API，这对"
-"æ˜“ç”¨æ€§å’Œä»£ç å¯ç§»æ¤æ€§éƒ½æœ‰å¥½å¤„ã€‚"
+#, no-c-format
+msgid "The challenge lies in the implementation. Hibernate provides built-in management of the \"current session\" to simplify this pattern. Start a transaction when a server request has to be processed, and end the transaction before the response is sent to the client. Common solutions are <literal>ServletFilter</literal>, AOP interceptor with a pointcut on the service methods, or a proxy/interception container. An EJB container is a standardized way to implement cross-cutting aspects such as transaction demarcation on EJB session beans, declaratively with CMT. If you use programmatic transaction demarcation, for ease of use and code portability use the Hibernate <literal>Transaction</literal> API shown later in this chapter."
+msgstr "实现才是真正的挑战。Hibernate 内置了对\"当前 session（current session）\" çš„ç®¡ç†ï¼Œç”¨äºŽç®€åŒ–æ­¤æ¨¡å¼ã€‚ä½ è¦åšçš„ä¸€åˆ‡å°±æ˜¯åœ¨æœåŠ¡å™¨ç«¯è¦å¤„ç†è¯·æ±‚çš„æ—¶å€™ï¼Œå¼€å¯äº‹åŠ¡ï¼Œåœ¨å“åº”å‘é€ç»™å®¢æˆ·ä¹‹å‰ç»“æŸäº‹åŠ¡ã€‚ä½ å¯ä»¥ç”¨ä»»ä½•æ–¹å¼æ¥å®Œæˆè¿™ä¸€æ“ä½œï¼Œé€šå¸¸çš„æ–¹æ¡ˆæœ‰ <literal>ServletFilter</literal>，在 service 方法中进行 pointcut çš„ AOP 拦截器，或者 proxy/interception 容器。EJB 容器是实现横切诸如 EJB session bean 上的事务分界，用 CMT å¯¹äº‹åŠ¡è¿›è¡Œå£°æ˜Žç­‰æ–¹é¢çš„æ ‡å‡†æ‰‹æ®µã€‚å‡è‹¥ä½ å†³å®šä½¿ç”¨ç¼–ç¨‹å¼çš„äº‹åŠ¡åˆ†ç•Œï¼Œè¯·å‚è€ƒæœ¬ç« åŽé¢è®²åˆ°çš„ Hibernate <literal>Transaction</literal> APIï¼Œè¿™å¯¹æ˜“ç”¨æ€§å’Œä»£ç å¯ç§»æ¤æ€§éƒ½æœ‰å¥½å¤„ã€‚ "
 
 #. Tag: para
 #: transactions.xml:150
-#, fuzzy, no-c-format
-msgid ""
-"Your application code can access a \"current session\" to process the "
-"request by calling <literal>sessionFactory.getCurrentSession()</literal>. "
-"You will always get a <literal>Session</literal> scoped to the current "
-"database transaction. This has to be configured for either resource-local or "
-"JTA environments, see <xref linkend=\"architecture-current-session\"/>."
-msgstr ""
-"åœ¨ä»»ä½•æ—¶é—´ï¼Œä»»ä½•åœ°æ–¹ï¼Œä½ çš„åº”ç”¨ä»£ç å¯ä»¥é€šè¿‡ç®€å•çš„è°ƒç”¨<literal>sessionFactory."
-"getCurrentSession()</literal> 来访问\"当前 session\"ï¼Œç”¨äºŽå¤„ç†è¯·æ±‚ã€‚ä½ æ€»æ˜¯ä¼š"
-"得到当前数据库事务范围内的 <literal>Session</literal>。在使用本地资源或 JTA "
-"环境时，必须配置它，请参见 <xref linkend=\"Architecture-Contextual_Sessions"
-"\"/>。"
+#, no-c-format
+msgid "Your application code can access a \"current session\" to process the request by calling <literal>sessionFactory.getCurrentSession()</literal>. You will always get a <literal>Session</literal> scoped to the current database transaction. This has to be configured for either resource-local or JTA environments, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "åœ¨ä»»ä½•æ—¶é—´ï¼Œä»»ä½•åœ°æ–¹ï¼Œä½ çš„åº”ç”¨ä»£ç å¯ä»¥é€šè¿‡ç®€å•çš„è°ƒç”¨<literal>sessionFactory.getCurrentSession()</literal> 来访问\"当前 session\"ï¼Œç”¨äºŽå¤„ç†è¯·æ±‚ã€‚ä½ æ€»æ˜¯ä¼šå¾—åˆ°å½“å‰æ•°æ®åº“äº‹åŠ¡èŒƒå›´å†…çš„ <literal>Session</literal>。在使用本地资源或 JTA 环境时，必须配置它，请参见 <xref linkend=\"architecture-current-session\"/>。"
 
 #. Tag: para
 #: transactions.xml:158
-#, fuzzy, no-c-format
-msgid ""
-"You can extend the scope of a <literal>Session</literal> and database "
-"transaction until the \"view has been rendered\". This is especially useful "
-"in servlet applications that utilize a separate rendering phase after the "
-"request has been processed. Extending the database transaction until view "
-"rendering, is achieved by implementing your own interceptor. However, this "
-"will be difficult if you rely on EJBs with container-managed transactions. A "
-"transaction will be completed when an EJB method returns, before rendering "
-"of any view can start. See the Hibernate website and forum for tips and "
-"examples relating to this <emphasis>Open Session in View</emphasis> pattern."
-msgstr ""
-"有时，将 <literal>Session</literal> 和数据库事务的边界延伸到\"展示层被渲染后"
-"\"会带来便利。有些 serlvet 应用程序在对请求进行处理后，有个单独的渲染期，这种"
-"å»¶ä¼¸å¯¹è¿™ç§ç¨‹åºç‰¹åˆ«æœ‰ç”¨ã€‚å‡è‹¥ä½ å®žçŽ°ä½ è‡ªå·±çš„æ‹¦æˆªå™¨ï¼ŒæŠŠäº‹åŠ¡è¾¹ç•Œå»¶ä¼¸åˆ°å±•ç¤ºå±‚æ¸²æŸ“"
-"ç»“æŸåŽéžå¸¸å®¹æ˜“ã€‚ç„¶è€Œï¼Œå‡è‹¥ä½ ä¾èµ–æœ‰å®¹å™¨ç®¡ç†äº‹åŠ¡çš„ EJBï¼Œè¿™å°±ä¸å¤ªå®¹æ˜“äº†ï¼Œå› ä¸ºäº‹"
-"务会在 EJB 方法返回后结束，而那是在任何展示层渲染开始之前。请访问  Hibernate "
-"ç½‘ç«™å’Œè®ºå›ï¼Œä½ å¯ä»¥æ‰¾åˆ° <emphasis>Open Session in View</emphasis> 这一模式的提"
-"示和示例。"
+#, no-c-format
+msgid "You can extend the scope of a <literal>Session</literal> and database transaction until the \"view has been rendered\". This is especially useful in servlet applications that utilize a separate rendering phase after the request has been processed. Extending the database transaction until view rendering, is achieved by implementing your own interceptor. However, this will be difficult if you rely on EJBs with container-managed transactions. A transaction will be completed when an EJB method returns, before rendering of any view can start. See the Hibernate website and forum for tips and examples relating to this <emphasis>Open Session in View</emphasis> pattern."
+msgstr "有时，将 <literal>Session</literal> 和数据库事务的边界延伸到\"展示层被渲染后\"会带来便利。有些 serlvet åº”ç”¨ç¨‹åºåœ¨å¯¹è¯·æ±‚è¿›è¡Œå¤„ç†åŽï¼Œæœ‰ä¸ªå•ç‹¬çš„æ¸²æŸ“æœŸï¼Œè¿™ç§å»¶ä¼¸å¯¹è¿™ç§ç¨‹åºç‰¹åˆ«æœ‰ç”¨ã€‚å‡è‹¥ä½ å®žçŽ°ä½ è‡ªå·±çš„æ‹¦æˆªå™¨ï¼ŒæŠŠäº‹åŠ¡è¾¹ç•Œå»¶ä¼¸åˆ°å±•ç¤ºå±‚æ¸²æŸ“ç»“æŸåŽéžå¸¸å®¹æ˜“ã€‚ç„¶è€Œï¼Œå‡è‹¥ä½ ä¾èµ–æœ‰å®¹å™¨ç®¡ç†äº‹åŠ¡çš„ EJBï¼Œè¿™å°±ä¸å¤ªå®¹æ˜“äº†ï¼Œå› ä¸ºäº‹åŠ¡ä¼šåœ¨ EJB 方法返回后结束，而那是在任何展示层渲染开始之前。请访问  Hibernate ç½‘ç«™å’Œè®ºå›ï¼Œä½ å¯ä»¥æ‰¾åˆ° <emphasis>Open Session in View</emphasis> 这一模式的提示和示例。 "
 
 #. Tag: title
 #: transactions.xml:173
@@ -285,151 +124,63 @@
 
 #. Tag: para
 #: transactions.xml:175
-#, fuzzy, no-c-format
-msgid ""
-"The session-per-request pattern is not the only way of designing units of "
-"work. Many business processes require a whole series of interactions with "
-"the user that are interleaved with database accesses. In web and enterprise "
-"applications, it is not acceptable for a database transaction to span a user "
-"interaction. Consider the following example:"
-msgstr ""
-"session-per-request 模式不仅仅是一个可以用来设计操作单元的有用概念。很多业务"
-"处理都需 要一系列完整的与用户之间的交互，而这些用户是指对数据库有交叉访问的用"
-"户。在基于 web çš„åº”ç”¨å’Œä¼ä¸šåº”ç”¨ä¸­ï¼Œè·¨ç”¨æˆ·äº¤äº’çš„æ•°æ®åº“äº‹åŠ¡æ˜¯æ— æ³•æŽ¥å—çš„ã€‚è€ƒè™‘ä¸‹"
-"面的例子："
+#, no-c-format
+msgid "The session-per-request pattern is not the only way of designing units of work. Many business processes require a whole series of interactions with the user that are interleaved with database accesses. In web and enterprise applications, it is not acceptable for a database transaction to span a user interaction. Consider the following example:"
+msgstr "session-per-request 模式不仅仅是一个可以用来设计操作单元的有用概念。很多业务处理都需 要一系列完整的与用户之间的交互，而这些用户是指对数据库有交叉访问的用户。在基于 web çš„åº”ç”¨å’Œä¼ä¸šåº”ç”¨ä¸­ï¼Œè·¨ç”¨æˆ·äº¤äº’çš„æ•°æ®åº“äº‹åŠ¡æ˜¯æ— æ³•æŽ¥å—çš„ã€‚è€ƒè™‘ä¸‹é¢çš„ä¾‹å­ï¼š "
 
 #. Tag: para
 #: transactions.xml:185
-#, fuzzy, no-c-format
-msgid ""
-"The first screen of a dialog opens. The data seen by the user has been "
-"loaded in a particular <literal>Session</literal> and database transaction. "
-"The user is free to modify the objects."
-msgstr ""
-"在界面的第一屏，打开对话框，用户所看到的数据是被一个特定的 <literal>Session</"
-"literal> 和数据 库事务载入（load）的。用户可以随意修改对话框中的数据对象。"
+#, no-c-format
+msgid "The first screen of a dialog opens. The data seen by the user has been loaded in a particular <literal>Session</literal> and database transaction. The user is free to modify the objects."
+msgstr "在界面的第一屏，打开对话框，用户所看到的数据是被一个特定的 <literal>Session</literal> 和数据 库事务载入（load）的。用户可以随意修改对话框中的数据对象。 "
 
 #. Tag: para
 #: transactions.xml:192
-#, fuzzy, no-c-format
-msgid ""
-"The user clicks \"Save\" after 5 minutes and expects their modifications to "
-"be made persistent. The user also expects that they were the only person "
-"editing this information and that no conflicting modification has occurred."
-msgstr ""
-"5 分钟后，用户点击“保存”，期望所做出的修改被持久化；同时他也期望自己是唯一修"
-"改这个信息的人，不会出现修改冲突。"
+#, no-c-format
+msgid "The user clicks \"Save\" after 5 minutes and expects their modifications to be made persistent. The user also expects that they were the only person editing this information and that no conflicting modification has occurred."
+msgstr "5 分钟后，用户点击“保存”，期望所做出的修改被持久化；同时他也期望自己是唯一修改这个信息的人，不会出现修改冲突。 "
 
 #. Tag: para
 #: transactions.xml:200
-#, fuzzy, no-c-format
-msgid ""
-"From the point of view of the user, we call this unit of work a long-running "
-"<emphasis>conversation</emphasis> or <emphasis>application transaction</"
-"emphasis>. There are many ways to implement this in your application."
-msgstr ""
-"从用户的角度来看，我们把这个操作单元称为长时间运行的<emphasis>对话</emphasis>"
-"（conversation），或者<emphasis>应用事务</emphasis>（application "
-"transaction）。 åœ¨ä½ çš„åº”ç”¨ç¨‹åºä¸­ï¼Œå¯ä»¥æœ‰å¾ˆå¤šç§æ–¹æ³•æ¥å®žçŽ°å®ƒã€‚"
+#, no-c-format
+msgid "From the point of view of the user, we call this unit of work a long-running <emphasis>conversation</emphasis> or <emphasis>application transaction</emphasis>. There are many ways to implement this in your application."
+msgstr "从用户的角度来看，我们把这个操作单元称为长时间运行的<emphasis>对话</emphasis>（conversation），或者<emphasis>应用事务</emphasis>（application transactionï¼‰ã€‚åœ¨ä½ çš„åº”ç”¨ç¨‹åºä¸­ï¼Œå¯ä»¥æœ‰å¾ˆå¤šç§æ–¹æ³•æ¥å®žçŽ°å®ƒã€‚"
 
 #. Tag: para
 #: transactions.xml:206
-#, fuzzy, no-c-format
-msgid ""
-"A first naive implementation might keep the <literal>Session</literal> and "
-"database transaction open during user think time, with locks held in the "
-"database to prevent concurrent modification and to guarantee isolation and "
-"atomicity. This is an anti-pattern, since lock contention would not allow "
-"the application to scale with the number of concurrent users."
-msgstr ""
-"头一个幼稚的做法是，在用户思考的过程中，保持 <literal>Session</literal> 和数"
-"据库事务是打开的，保持数据库锁定，以阻止并发修改，从而保证数据库事务隔离级别"
-"å’ŒåŽŸå­æ“ä½œã€‚è¿™ç§æ–¹å¼å½“ç„¶æ˜¯ä¸€ä¸ªåæ¨¡å¼ï¼Œå› ä¸ºé”äº‰ç”¨ä¼šå¯¼è‡´åº”ç”¨ç¨‹åºæ— æ³•æ‰©å±•å¹¶å‘ç”¨"
-"户的数目。"
+#, no-c-format
+msgid "A first naive implementation might keep the <literal>Session</literal> and database transaction open during user think time, with locks held in the database to prevent concurrent modification and to guarantee isolation and atomicity. This is an anti-pattern, since lock contention would not allow the application to scale with the number of concurrent users."
+msgstr "头一个幼稚的做法是，在用户思考的过程中，保持 <literal>Session</literal> å’Œæ•°æ®åº“äº‹åŠ¡æ˜¯æ‰“å¼€çš„ï¼Œä¿æŒæ•°æ®åº“é”å®šï¼Œä»¥é˜»æ­¢å¹¶å‘ä¿®æ”¹ï¼Œä»Žè€Œä¿è¯æ•°æ®åº“äº‹åŠ¡éš”ç¦»çº§åˆ«å’ŒåŽŸå­æ“ä½œã€‚è¿™ç§æ–¹å¼å½“ç„¶æ˜¯ä¸€ä¸ªåæ¨¡å¼ï¼Œå› ä¸ºé”äº‰ç”¨ä¼šå¯¼è‡´åº”ç”¨ç¨‹åºæ— æ³•æ‰©å±•å¹¶å‘ç”¨æˆ·çš„æ•°ç›®ã€‚ "
 
 #. Tag: para
 #: transactions.xml:214
-#, fuzzy, no-c-format
-msgid ""
-"You have to use several database transactions to implement the conversation. "
-"In this case, maintaining isolation of business processes becomes the "
-"partial responsibility of the application tier. A single conversation "
-"usually spans several database transactions. It will be atomic if only one "
-"of these database transactions (the last one) stores the updated data. All "
-"others simply read data (for example, in a wizard-style dialog spanning "
-"several request/response cycles). This is easier to implement than it might "
-"sound, especially if you utilize some of Hibernate's features:"
-msgstr ""
-"很明显，我们必须使用多个数据库事务来实现这个对话。在这个例子中，维护业务处理"
-"的 事务隔离变成了应用程序层的部分责任。一个对话通常跨越多个数据库事务。如果仅"
-"仅只有一个数据库事务（最后的那个事务）保存更新过的数据，而所有其他事务只是单"
-"纯的读取数据（例如在一个跨越多个请求/å“åº”å‘¨æœŸçš„å‘å¯¼é£Žæ ¼çš„å¯¹è¯æ¡†ä¸­ï¼‰ï¼Œé‚£ä¹ˆåº”ç”¨"
-"ç¨‹åºäº‹åŠ¡å°†ä¿è¯å…¶åŽŸå­æ€§ã€‚è¿™ç§æ–¹å¼æ¯”å¬èµ·æ¥è¿˜è¦å®¹æ˜“å®žçŽ°ï¼Œç‰¹åˆ«æ˜¯å½“ä½ ä½¿ç”¨äº† "
-"Hibernate 的下述特性的时候："
+#, no-c-format
+msgid "You have to use several database transactions to implement the conversation. In this case, maintaining isolation of business processes becomes the partial responsibility of the application tier. A single conversation usually spans several database transactions. It will be atomic if only one of these database transactions (the last one) stores the updated data. All others simply read data (for example, in a wizard-style dialog spanning several request/response cycles). This is easier to implement than it might sound, especially if you utilize some of Hibernate's features:"
+msgstr "很明显，我们必须使用多个数据库事务来实现这个对话。在这个例子中，维护业务处理的 事务隔离变成了应用程序层的部分责任。一个对话通常跨越多个数据库事务。如果仅仅只有一个数据库事务（最后的那个事务）保存更新过的数据，而所有其他事务只是单纯的读取数据（例如在一个跨越多个请求/å“åº”å‘¨æœŸçš„å‘å¯¼é£Žæ ¼çš„å¯¹è¯æ¡†ä¸­ï¼‰ï¼Œé‚£ä¹ˆåº”ç”¨ç¨‹åºäº‹åŠ¡å°†ä¿è¯å…¶åŽŸå­æ€§ã€‚è¿™ç§æ–¹å¼æ¯”å¬èµ·æ¥è¿˜è¦å®¹æ˜“å®žçŽ°ï¼Œç‰¹åˆ«æ˜¯å½“ä½ ä½¿ç”¨äº† Hibernate 的下述特性的时候： "
 
 #. Tag: para
 #: transactions.xml:227
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis>Automatic Versioning</emphasis>: Hibernate can perform automatic "
-"optimistic concurrency control for you. It can automatically detect if a "
-"concurrent modification occurred during user think time. Check for this at "
-"the end of the conversation."
-msgstr ""
-"<emphasis>自动版本化</emphasis> — Hibernate 能够自动进行乐观并发控制，如果在"
-"用户思考的过程中发生并发修改，Hibernate 能够自动检测到。一般我们只在对话结束"
-"时才检查。"
+#, no-c-format
+msgid "<emphasis>Automatic Versioning</emphasis>: Hibernate can perform automatic optimistic concurrency control for you. It can automatically detect if a concurrent modification occurred during user think time. Check for this at the end of the conversation."
+msgstr "<emphasis>自动版本化</emphasis>：Hibernate 能够自动进行乐观并发控制，如果在用户思考的过程中发生并发修改，Hibernate 能够自动检测到。一般我们只在对话结束时才检查。"
 
 #. Tag: para
 #: transactions.xml:235
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis>Detached Objects</emphasis>: if you decide to use the "
-"<emphasis>session-per-request</emphasis> pattern, all loaded instances will "
-"be in the detached state during user think time. Hibernate allows you to "
-"reattach the objects and persist the modifications. The pattern is called "
-"<emphasis>session-per-request-with-detached-objects</emphasis>. Automatic "
-"versioning is used to isolate concurrent modifications."
-msgstr ""
-"<emphasis>脱管对象</emphasis>（Detached Objects）— å¦‚æžœä½ å†³å®šé‡‡ç”¨å‰é¢å·²ç»è®¨è®º"
-"过的  <emphasis>session-per-request</emphasis> 模式，所有载入的实例在用户思考"
-"的过程中都处于与 Session 脱离的状态。Hibernate å…è®¸ä½ æŠŠä¸Ž Session 脱离的对象"
-"重新关联到 Session 上，并且对修改进行持久化，这种模式被称为 "
-"<emphasis>session-per-request-with-detached-objects</emphasis>。自动版本化被"
-"用来隔离并发修改。"
+#, no-c-format
+msgid "<emphasis>Detached Objects</emphasis>: if you decide to use the <emphasis>session-per-request</emphasis> pattern, all loaded instances will be in the detached state during user think time. Hibernate allows you to reattach the objects and persist the modifications. The pattern is called <emphasis>session-per-request-with-detached-objects</emphasis>. Automatic versioning is used to isolate concurrent modifications."
+msgstr "<emphasis>脱管对象</emphasis>（Detached Objectsï¼‰ï¼šå¦‚æžœä½ å†³å®šé‡‡ç”¨å‰é¢å·²ç»è®¨è®ºè¿‡çš„  <emphasis>session-per-request</emphasis> 模式，所有载入的实例在用户思考的过程中都处于与 Session 脱离的状态。Hibernate å…è®¸ä½ æŠŠä¸Ž Session 脱离的对象重新关联到 Session 上，并且对修改进行持久化，这种模式被称为 <emphasis>session-per-request-with-detached-objects</emphasis>。自动版本化被用来隔离并发修改。"
 
 #. Tag: para
 #: transactions.xml:245
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis>Extended (or Long) Session</emphasis>: the Hibernate "
-"<literal>Session</literal> can be disconnected from the underlying JDBC "
-"connection after the database transaction has been committed and reconnected "
-"when a new client request occurs. This pattern is known as <emphasis>session-"
-"per-conversation</emphasis> and makes even reattachment unnecessary. "
-"Automatic versioning is used to isolate concurrent modifications and the "
-"<literal>Session</literal> will not be allowed to be flushed automatically, "
-"but explicitly."
-msgstr ""
-"<emphasis>Extended (or Long) Session</emphasis> — Hibernate 的 "
-"<literal>Session</literal> 可以在数据库事务提交之后和底层的 JDBC 连接断开，当"
-"一个新的客户端请求到来的时候，它又重新连接上底层的 JDBC 连接。这种模式被称之"
-"为<emphasis>session-per-conversation</emphasis>，这种情况可 èƒ½ä¼šé€ æˆä¸å¿…è¦çš„ "
-"Session 和 JDBC 连接的重新关联。自动版本化被用来隔离并发修改，"
-"<literal>Session</literal> 通常不允许自动 flush，而是明确 flush。 "
+#, no-c-format
+msgid "<emphasis>Extended (or Long) Session</emphasis>: the Hibernate <literal>Session</literal> can be disconnected from the underlying JDBC connection after the database transaction has been committed and reconnected when a new client request occurs. This pattern is known as <emphasis>session-per-conversation</emphasis> and makes even reattachment unnecessary. Automatic versioning is used to isolate concurrent modifications and the <literal>Session</literal> will not be allowed to be flushed automatically, but explicitly."
+msgstr "<emphasis>Extended (or Long) Session</emphasis>：Hibernate çš„ <literal>Session</literal> 可以在数据库事务提交之后和底层的 JDBC 连接断开，当一个新的客户端请求到来的时候，它又重新连接上底层的 JDBC 连接。这种模式被称之为<emphasis>session-per-conversation</emphasis>，这种情况可 èƒ½ä¼šé€ æˆä¸å¿…è¦çš„ Session å’Œ JDBC 连接的重新关联。自动版本化被用来隔离并发修改，<literal>Session</literal> 通常不允许自动 flush，而是显性地 flush。 "
 
 #. Tag: para
 #: transactions.xml:258
-#, fuzzy, no-c-format
-msgid ""
-"Both <emphasis>session-per-request-with-detached-objects</emphasis> and "
-"<emphasis>session-per-conversation</emphasis> have advantages and "
-"disadvantages. These disadvantages are discussed later in this chapter in "
-"the context of optimistic concurrency control."
-msgstr ""
-"<emphasis>session-per-request-with-detached-objects</emphasis> 和  "
-"<emphasis>session-per-conversation</emphasis> å„æœ‰ä¼˜ç¼ºç‚¹ï¼Œæˆ‘ä»¬åœ¨æœ¬ç« åŽé¢ä¹è§‚"
-"并发控制那部分再进行讨论。"
+#, no-c-format
+msgid "Both <emphasis>session-per-request-with-detached-objects</emphasis> and <emphasis>session-per-conversation</emphasis> have advantages and disadvantages. These disadvantages are discussed later in this chapter in the context of optimistic concurrency control."
+msgstr "<emphasis>session-per-request-with-detached-objects</emphasis> å’Œ  <emphasis>session-per-conversation</emphasis> å„æœ‰ä¼˜ç¼ºç‚¹ï¼Œæˆ‘ä»¬åœ¨æœ¬ç« åŽé¢ä¹è§‚å¹¶å‘æŽ§åˆ¶é‚£éƒ¨åˆ†å†è¿›è¡Œè®¨è®ºã€‚ "
 
 #. Tag: title
 #: transactions.xml:267
@@ -439,16 +190,9 @@
 
 #. Tag: para
 #: transactions.xml:269
-#, fuzzy, no-c-format
-msgid ""
-"An application can concurrently access the same persistent state in two "
-"different <literal>Session</literal>s. However, an instance of a persistent "
-"class is never shared between two <literal>Session</literal> instances. It "
-"is for this reason that there are two different notions of identity:"
-msgstr ""
-"应用程序可能在两个不同的 <literal>Session</literal> 中并发访问同一持久化状"
-"æ€ï¼Œä½†æ˜¯ï¼Œä¸€ä¸ªæŒä¹…åŒ–ç±»çš„å®žä¾‹æ— æ³•åœ¨ä¸¤ä¸ª <literal>Session</literal> ä¸­å…±äº«ã€‚å› "
-"æ­¤æœ‰ä¸¤ç§ä¸åŒçš„æ ‡è¯†è¯­ä¹‰ï¼š"
+#, no-c-format
+msgid "An application can concurrently access the same persistent state in two different <literal>Session</literal>s. However, an instance of a persistent class is never shared between two <literal>Session</literal> instances. It is for this reason that there are two different notions of identity:"
+msgstr "应用程序可能在两个不同的 <literal>Session</literal> ä¸­å¹¶å‘è®¿é—®åŒä¸€æŒä¹…åŒ–çŠ¶æ€ï¼Œä½†æ˜¯ï¼Œä¸€ä¸ªæŒä¹…åŒ–ç±»çš„å®žä¾‹æ— æ³•åœ¨ä¸¤ä¸ª <literal>Session</literal> ä¸­å…±äº«ã€‚å› æ­¤æœ‰ä¸¤ç§ä¸åŒçš„æ ‡è¯†è¯­ä¹‰ï¼š "
 
 #. Tag: term
 #: transactions.xml:278
@@ -476,82 +220,21 @@
 
 #. Tag: para
 #: transactions.xml:295
-#, fuzzy, no-c-format
-msgid ""
-"For objects attached to a <emphasis>particular</emphasis> <literal>Session</"
-"literal> (i.e., in the scope of a <literal>Session</literal>), the two "
-"notions are equivalent and JVM identity for database identity is guaranteed "
-"by Hibernate. While the application might concurrently access the \"same"
-"\" (persistent identity) business object in two different sessions, the two "
-"instances will actually be \"different\" (JVM identity). Conflicts are "
-"resolved using an optimistic approach and automatic versioning at flush/"
-"commit time."
-msgstr ""
-"对于那些关联到 <emphasis>特定</emphasis> <literal>Session</literal>（也就是在"
-"单个 <literal>Session</literal> çš„èŒƒå›´å†…ï¼‰ä¸Šçš„å¯¹è±¡æ¥è¯´ï¼Œè¿™ä¸¤ç§æ ‡è¯†çš„è¯­ä¹‰æ˜¯ç­‰"
-"ä»·çš„ï¼Œä¸Žæ•°æ®åº“æ ‡è¯†å¯¹åº”çš„ JVM æ ‡è¯†æ˜¯ç”± Hibernate 来保证的。不过，当应用程序在"
-"两个不同的 session ä¸­å¹¶å‘è®¿é—®å…·æœ‰åŒä¸€æŒä¹…åŒ–æ ‡è¯†çš„ä¸šåŠ¡å¯¹è±¡å®žä¾‹çš„æ—¶å€™ï¼Œè¿™ä¸ªä¸šåŠ¡"
-"对象的两个实例事实上是不相同的（从 JVM 识别来看）。这种冲突可以通过在同步和提"
-"交的时候使用自动版本化和乐观锁定方法来解决。"
+#, no-c-format
+msgid "For objects attached to a <emphasis>particular</emphasis> <literal>Session</literal> (i.e., in the scope of a <literal>Session</literal>), the two notions are equivalent and JVM identity for database identity is guaranteed by Hibernate. While the application might concurrently access the \"same\" (persistent identity) business object in two different sessions, the two instances will actually be \"different\" (JVM identity). Conflicts are resolved using an optimistic approach and automatic versioning at flush/commit time."
+msgstr "对于那些关联到 <emphasis>特定</emphasis> <literal>Session</literal>（也就是在单个 <literal>Session</literal> çš„èŒƒå›´å†…ï¼‰ä¸Šçš„å¯¹è±¡æ¥è¯´ï¼Œè¿™ä¸¤ç§æ ‡è¯†çš„è¯­ä¹‰æ˜¯ç­‰ä»·çš„ï¼Œä¸Žæ•°æ®åº“æ ‡è¯†å¯¹åº”çš„ JVM æ ‡è¯†æ˜¯ç”± Hibernate 来保证的。不过，当应用程序在两个不同的 session ä¸­å¹¶å‘è®¿é—®å…·æœ‰åŒä¸€æŒä¹…åŒ–æ ‡è¯†çš„ä¸šåŠ¡å¯¹è±¡å®žä¾‹çš„æ—¶å€™ï¼Œè¿™ä¸ªä¸šåŠ¡å¯¹è±¡çš„ä¸¤ä¸ªå®žä¾‹äº‹å®žä¸Šæ˜¯ä¸ç›¸åŒçš„ï¼ˆä»Ž JVM 识别来看）。这种冲突可以通过在同步和提交的时候使用自动版本化和乐观锁定方法来解决。 "
 
 #. Tag: para
 #: transactions.xml:304
-#, fuzzy, no-c-format
-msgid ""
-"This approach leaves Hibernate and the database to worry about concurrency. "
-"It also provides the best scalability, since guaranteeing identity in single-"
-"threaded units of work means that it does not need expensive locking or "
-"other means of synchronization. The application does not need to synchronize "
-"on any business object, as long as it maintains a single thread per "
-"<literal>Session</literal>. Within a <literal>Session</literal> the "
-"application can safely use <literal>==</literal> to compare objects."
-msgstr ""
-"这种方式把关于并发的头疼问题留给了 Hibernate 和数据库；由于在单个线程内，操作"
-"单元中的对象识别不 éœ€è¦ä»£ä»·æ˜‚è´µçš„é”å®šæˆ–å…¶ä»–æ„ä¹‰ä¸Šçš„åŒæ­¥ï¼Œå› æ­¤å®ƒåŒæ—¶å¯ä»¥æä¾›æœ€"
-"好的可伸缩性。只要在单个线程只持有一个 <literal>Session</literal>，应用程序就"
-"不需要同步任何业务对象。在 <literal>Session</literal> 的范围内，应用程序可以"
-"放心的使用 <literal>==</literal> 进行对象比较。"
+#, no-c-format
+msgid "This approach leaves Hibernate and the database to worry about concurrency. It also provides the best scalability, since guaranteeing identity in single-threaded units of work means that it does not need expensive locking or other means of synchronization. The application does not need to synchronize on any business object, as long as it maintains a single thread per <literal>Session</literal>. Within a <literal>Session</literal> the application can safely use <literal>==</literal> to compare objects."
+msgstr "这种方式把关于并发的头疼问题留给了 Hibernate 和数据库；由于在单个线程内，操作单元中的对象识别不 éœ€è¦ä»£ä»·æ˜‚è´µçš„é”å®šæˆ–å…¶ä»–æ„ä¹‰ä¸Šçš„åŒæ­¥ï¼Œå› æ­¤å®ƒåŒæ—¶å¯ä»¥æä¾›æœ€å¥½çš„å¯ä¼¸ç¼©æ€§ã€‚åªè¦åœ¨å•ä¸ªçº¿ç¨‹åªæŒæœ‰ä¸€ä¸ª <literal>Session</literal>，应用程序就不需要同步任何业务对象。在 <literal>Session</literal> 的范围内，应用程序可以放心的使用 <literal>==</literal> 进行对象比较。 "
 
 #. Tag: para
 #: transactions.xml:313
-#, fuzzy, no-c-format
-msgid ""
-"However, an application that uses <literal>==</literal> outside of a "
-"<literal>Session</literal> might produce unexpected results. This might "
-"occur even in some unexpected places. For example, if you put two detached "
-"instances into the same <literal>Set</literal>, both might have the same "
-"database identity (i.e., they represent the same row). JVM identity, "
-"however, is by definition not guaranteed for instances in a detached state. "
-"The developer has to override the <literal>equals()</literal> and "
-"<literal>hashCode()</literal> methods in persistent classes and implement "
-"their own notion of object equality. There is one caveat: never use the "
-"database identifier to implement equality. Use a business key that is a "
-"combination of unique, usually immutable, attributes. The database "
-"identifier will change if a transient object is made persistent. If the "
-"transient instance (usually together with detached instances) is held in a "
-"<literal>Set</literal>, changing the hashcode breaks the contract of the "
-"<literal>Set</literal>. Attributes for business keys do not have to be as "
-"stable as database primary keys; you only have to guarantee stability as "
-"long as the objects are in the same <literal>Set</literal>. See the "
-"Hibernate website for a more thorough discussion of this issue. Please note "
-"that this is not a Hibernate issue, but simply how Java object identity and "
-"equality has to be implemented."
-msgstr ""
-"不过，应用程序在 <literal>Session</literal> 的外面使用 <literal>==</literal> "
-"进行对象比较可能会 å¯¼è‡´æ— æ³•é¢„æœŸçš„ç»“æžœã€‚åœ¨ä¸€äº›æ— æ³•é¢„æ–™çš„åœºåˆï¼Œä¾‹å¦‚ï¼Œå¦‚æžœä½ æŠŠä¸¤"
-"个脱管对象实例放进同一个  <literal>Set</literal> 的时候，就可能发生。这两个对"
-"è±¡å®žä¾‹å¯èƒ½æœ‰åŒä¸€ä¸ªæ•°æ®åº“æ ‡è¯†ï¼ˆä¹Ÿå°±æ˜¯è¯´ï¼Œ 他们代表了表的同一行数据），从 JVM "
-"æ ‡è¯†çš„å®šä¹‰ä¸Šæ¥è¯´ï¼Œå¯¹è„±ç®¡çš„å¯¹è±¡è€Œè¨€ï¼ŒHibernate æ— æ³•ä¿è¯ä»–ä»¬ çš„çš„ JVM æ ‡è¯†ä¸€"
-"致。开发人员必须覆盖持久化类的 <literal>equals()</literal> 方法和  "
-"<literal>hashCode()</literal> 方法，从而实现自定义的对象相等语义。警告：不要"
-"ä½¿ç”¨æ•°æ®åº“æ ‡è¯†æ¥å®žçŽ°å¯¹è±¡ç›¸ç­‰ï¼Œåº”è¯¥ä½¿ç”¨ä¸šåŠ¡é”®å€¼ï¼Œç”±å”¯ä¸€çš„ï¼Œé€šå¸¸ä¸å˜çš„å±žæ€§ç»„"
-"æˆã€‚å½“ä¸€ä¸ªçž¬æ—¶å¯¹è±¡è¢«æŒä¹…åŒ–çš„æ—¶å€™ï¼Œå®ƒçš„æ•°æ®åº“æ ‡è¯†ä¼šå‘ç”Ÿæ”¹å˜ã€‚å¦‚æžœä¸€ä¸ªçž¬æ—¶å¯¹è±¡"
-"（通常也包括脱管对象实例）被放入一个 <literal>Set</literal>，改变它的 "
-"hashcode 会导致与这个 <literal>Set</literal> 的关系中断。虽 然业务键值的属性"
-"ä¸è±¡æ•°æ®åº“ä¸»é”®é‚£æ ·ç¨³å®šä¸å˜ï¼Œä½†æ˜¯ä½ åªéœ€è¦ä¿è¯åœ¨åŒä¸€ä¸ª <literal>Set</literal> "
-"中的对象属性的稳定性就足够了。请到 Hibernate 网站去寻求这个问题更多的详细的讨"
-"论。请注意，这不是一个有关 Hibernate 的问题，而仅仅是一个关于 Java å¯¹è±¡æ ‡è¯†å’Œ"
-"判等行为如何实现的问题。"
+#, no-c-format
+msgid "However, an application that uses <literal>==</literal> outside of a <literal>Session</literal> might produce unexpected results. This might occur even in some unexpected places. For example, if you put two detached instances into the same <literal>Set</literal>, both might have the same database identity (i.e., they represent the same row). JVM identity, however, is by definition not guaranteed for instances in a detached state. The developer has to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods in persistent classes and implement their own notion of object equality. There is one caveat: never use the database identifier to implement equality. Use a business key that is a combination of unique, usually immutable, attributes. The database identifier will change if a transient object is made persistent. If the transient instance (usually together with detached instances) is held in a <literal>Set</literal>, changing the hashcode bre!
 aks the contract of the <literal>Set</literal>. Attributes for business keys do not have to be as stable as database primary keys; you only have to guarantee stability as long as the objects are in the same <literal>Set</literal>. See the Hibernate website for a more thorough discussion of this issue. Please note that this is not a Hibernate issue, but simply how Java object identity and equality has to be implemented."
+msgstr "不过，应用程序在 <literal>Session</literal> 的外面使用 <literal>==</literal> 进行对象比较可能会 å¯¼è‡´æ— æ³•é¢„æœŸçš„ç»“æžœã€‚åœ¨ä¸€äº›æ— æ³•é¢„æ–™çš„åœºåˆï¼Œä¾‹å¦‚ï¼Œå¦‚æžœä½ æŠŠä¸¤ä¸ªè„±ç®¡å¯¹è±¡å®žä¾‹æ”¾è¿›åŒä¸€ä¸ª  <literal>Set</literal> çš„æ—¶å€™ï¼Œå°±å¯èƒ½å‘ç”Ÿã€‚è¿™ä¸¤ä¸ªå¯¹è±¡å®žä¾‹å¯èƒ½æœ‰åŒä¸€ä¸ªæ•°æ®åº“æ ‡è¯†ï¼ˆä¹Ÿå°±æ˜¯è¯´ï¼Œ 他们代表了表的同一行数据），从 JVM æ ‡è¯†çš„å®šä¹‰ä¸Šæ¥è¯´ï¼Œå¯¹è„±ç®¡çš„å¯¹è±¡è€Œè¨€ï¼ŒHibernate æ— æ³•ä¿è¯ä»–ä»¬ çš„çš„ JVM æ ‡è¯†ä¸€è‡´ã€‚å¼€å‘äººå‘˜å¿…é¡»è¦†ç›–æŒä¹…åŒ–ç±»çš„ <literal>equals()</literal> 方法和  <literal>hashCode()</literal> æ–¹æ³•ï¼Œä»Žè€Œå®žçŽ°è‡ªå®šä¹‰çš„å¯¹è±¡ç›¸ç­‰è¯­ä¹‰ã€‚è­¦å‘Šï¼šä¸è¦ä½¿ç”¨æ•°æ®åº“æ ‡è¯†æ¥å®žçŽ°å¯¹è±¡ç›¸ç­‰ï¼Œåº”è¯¥ä½¿ç”¨ä¸šåŠ¡é”®å€¼ï¼Œç”±å”¯ä¸€çš„ï¼Œé€šå¸¸ä¸å˜çš„å±žæ€§ç»„æˆã€‚å½“ä¸€ä¸ªçž¬æ—¶å¯¹è±¡è¢«æŒä¹…åŒ–çš„æ—¶å€™ï¼Œå®ƒçš„æ•°æ®åº“æ ‡è¯†ä¼šå‘ç”Ÿæ”¹å˜ã€‚å¦‚æžœä¸€ä¸ªçž¬æ—¶å¯¹è±¡ï¼ˆé€šå¸¸ä¹ŸåŒ…æ‹¬è„±ç®¡å¯¹è±¡å®žä¾‹ï¼‰è¢«æ”¾å…¥ä!
 ¸€ä¸ª <literal>Set</literal>，改变它的 hashcode 会导致与这个 <literal>Set</literal> 的关系中断。虽 ç„¶ä¸šåŠ¡é”®å€¼çš„å±žæ€§ä¸è±¡æ•°æ®åº“ä¸»é”®é‚£æ ·ç¨³å®šä¸å˜ï¼Œä½†æ˜¯ä½ åªéœ€è¦ä¿è¯åœ¨åŒä¸€ä¸ª <literal>Set</literal> 中的对象属性的稳定性就足够了。请到 Hibernate 网站去寻求这个问题更多的详细的讨论。请注意，这不是一个有关 Hibernate 的问题，而仅仅是一个关于 Java å¯¹è±¡æ ‡è¯†å’Œåˆ¤ç­‰è¡Œä¸ºå¦‚ä½•å®žçŽ°çš„é—®é¢˜ã€‚ "
 
 #. Tag: title
 #: transactions.xml:334
@@ -561,84 +244,27 @@
 
 #. Tag: para
 #: transactions.xml:336
-#, fuzzy, no-c-format
-msgid ""
-"Do not use the anti-patterns <emphasis>session-per-user-session</emphasis> "
-"or <emphasis>session-per-application</emphasis> (there are, however, rare "
-"exceptions to this rule). Some of the following issues might also arise "
-"within the recommended patterns, so ensure that you understand the "
-"implications before making a design decision:"
-msgstr ""
-"决不要使用反模式 <emphasis>session-per-user-session</emphasis> 或者 "
-"<emphasis> session-per-application</emphasis>ï¼ˆå½“ç„¶ï¼Œè¿™ä¸ªè§„å®šå‡ ä¹Žæ²¡æœ‰ä¾‹å¤–ï¼‰ã€‚"
-"è¯·æ³¨æ„ï¼Œä¸‹è¿°ä¸€äº›é—®é¢˜å¯èƒ½ä¹Ÿä¼šå‡ºçŽ°åœ¨æˆ‘ä»¬æŽ¨èçš„æ¨¡å¼ä¸­ï¼Œåœ¨ä½ ä½œå‡ºæŸä¸ªè®¾è®¡å†³å®šä¹‹"
-"前，请务必理解该模式的应用前提。"
+#, no-c-format
+msgid "Do not use the anti-patterns <emphasis>session-per-user-session</emphasis> or <emphasis>session-per-application</emphasis> (there are, however, rare exceptions to this rule). Some of the following issues might also arise within the recommended patterns, so ensure that you understand the implications before making a design decision:"
+msgstr "决不要使用反模式 <emphasis>session-per-user-session</emphasis> 或者 <emphasis> session-per-application</emphasis>ï¼ˆå½“ç„¶ï¼Œè¿™ä¸ªè§„å®šå‡ ä¹Žæ²¡æœ‰ä¾‹å¤–ï¼‰ã€‚è¯·æ³¨æ„ï¼Œä¸‹è¿°ä¸€äº›é—®é¢˜å¯èƒ½ä¹Ÿä¼šå‡ºçŽ°åœ¨æˆ‘ä»¬æŽ¨èçš„æ¨¡å¼ä¸­ï¼Œåœ¨ä½ ä½œå‡ºæŸä¸ªè®¾è®¡å†³å®šä¹‹å‰ï¼Œè¯·åŠ¡å¿…ç†è§£è¯¥æ¨¡å¼çš„åº”ç”¨å‰æã€‚ "
 
 #. Tag: para
 #: transactions.xml:345
-#, fuzzy, no-c-format
-msgid ""
-"A <literal>Session</literal> is not thread-safe. Things that work "
-"concurrently, like HTTP requests, session beans, or Swing workers, will "
-"cause race conditions if a <literal>Session</literal> instance is shared. If "
-"you keep your Hibernate <literal>Session</literal> in your "
-"<literal>HttpSession</literal> (this is discussed later in the chapter), you "
-"should consider synchronizing access to your Http session. Otherwise, a user "
-"that clicks reload fast enough can use the same <literal>Session</literal> "
-"in two concurrently running threads."
-msgstr ""
-"<literal>Session</literal> 对象是非线程安全的。如果一个 <literal>Session</"
-"literal> 实例允许共享的话，那些支持并发运行的东东，例如 HTTP request，"
-"session beans 或者是 Swing workers，将会导致出现资源争用（race condition）。"
-"如果在 <literal>HttpSession</literal> 中有 Hibernate 的 <literal>Session</"
-"literal> çš„è¯ï¼ˆç¨åŽè®¨è®ºï¼‰ï¼Œä½ åº”è¯¥è€ƒè™‘åŒæ­¥è®¿é—®ä½ çš„ Http session。 否则，只要用"
-"户足够快的点击浏览器的“刷新”，就会导致两个并发运行线程使用同一个  "
-"<literal>Session</literal>。"
+#, no-c-format
+msgid "A <literal>Session</literal> is not thread-safe. Things that work concurrently, like HTTP requests, session beans, or Swing workers, will cause race conditions if a <literal>Session</literal> instance is shared. If you keep your Hibernate <literal>Session</literal> in your <literal>HttpSession</literal> (this is discussed later in the chapter), you should consider synchronizing access to your Http session. Otherwise, a user that clicks reload fast enough can use the same <literal>Session</literal> in two concurrently running threads."
+msgstr "<literal>Session</literal> 对象是非线程安全的。如果一个 <literal>Session</literal> 实例允许共享的话，那些支持并发运行的东东，例如 HTTP request，session beans 或者是 Swing workers，将会导致出现资源争用（race condition）。如果在 <literal>HttpSession</literal> 中有 Hibernate çš„ <literal>Session</literal> çš„è¯ï¼ˆç¨åŽè®¨è®ºï¼‰ï¼Œä½ åº”è¯¥è€ƒè™‘åŒæ­¥è®¿é—®ä½ çš„ Http session。 否则，只要用户足够快的点击浏览器的“刷新”，就会导致两个并发运行线程使用同一个  <literal>Session</literal>。 "
 
 #. Tag: para
 #: transactions.xml:356
-#, fuzzy, no-c-format
-msgid ""
-"An exception thrown by Hibernate means you have to rollback your database "
-"transaction and close the <literal>Session</literal> immediately (this is "
-"discussed in more detail later in the chapter). If your <literal>Session</"
-"literal> is bound to the application, you have to stop the application. "
-"Rolling back the database transaction does not put your business objects "
-"back into the state they were at the start of the transaction. This means "
-"that the database state and the business objects will be out of sync. "
-"Usually this is not a problem, because exceptions are not recoverable and "
-"you will have to start over after rollback anyway."
-msgstr ""
-"一个由 Hibernate æŠ›å‡ºçš„å¼‚å¸¸æ„å‘³ç€ä½ å¿…é¡»ç«‹å³å›žæ»šæ•°æ®åº“äº‹åŠ¡ï¼Œå¹¶ç«‹å³å…³é—­ "
-"<literal>Session</literal>ï¼ˆç¨åŽä¼šå±•å¼€è®¨è®ºï¼‰ã€‚å¦‚æžœä½ çš„ <literal>Session</"
-"literal> ç»‘å®šåˆ°ä¸€ä¸ªåº”ç”¨ç¨‹åºä¸Šï¼Œä½ å¿…é¡»åœæ­¢è¯¥åº”ç”¨ç¨‹åºã€‚å›žæ»šæ•°æ®åº“äº‹åŠ¡å¹¶ä¸ä¼šæŠŠä½ "
-"的业务对象退回到事务启动时候的状态。这意味着数据库状态和业务对象状态不同步。"
-"é€šå¸¸æƒ…å†µä¸‹ï¼Œè¿™ä¸æ˜¯ä»€ä¹ˆé—®é¢˜ï¼Œå› ä¸ºå¼‚å¸¸æ˜¯ä¸å¯æ¢å¤çš„ï¼Œä½ å¿…é¡»åœ¨å›žæ»šä¹‹åŽé‡æ–°å¼€å§‹æ‰§"
-"行。"
+#, no-c-format
+msgid "An exception thrown by Hibernate means you have to rollback your database transaction and close the <literal>Session</literal> immediately (this is discussed in more detail later in the chapter). If your <literal>Session</literal> is bound to the application, you have to stop the application. Rolling back the database transaction does not put your business objects back into the state they were at the start of the transaction. This means that the database state and the business objects will be out of sync. Usually this is not a problem, because exceptions are not recoverable and you will have to start over after rollback anyway."
+msgstr "一个由 Hibernate æŠ›å‡ºçš„å¼‚å¸¸æ„å‘³ç€ä½ å¿…é¡»ç«‹å³å›žæ»šæ•°æ®åº“äº‹åŠ¡ï¼Œå¹¶ç«‹å³å…³é—­ <literal>Session</literal>ï¼ˆç¨åŽä¼šå±•å¼€è®¨è®ºï¼‰ã€‚å¦‚æžœä½ çš„ <literal>Session</literal> ç»‘å®šåˆ°ä¸€ä¸ªåº”ç”¨ç¨‹åºä¸Šï¼Œä½ å¿…é¡»åœæ­¢è¯¥åº”ç”¨ç¨‹åºã€‚å›žæ»šæ•°æ®åº“äº‹åŠ¡å¹¶ä¸ä¼šæŠŠä½ çš„ä¸šåŠ¡å¯¹è±¡é€€å›žåˆ°äº‹åŠ¡å¯åŠ¨æ—¶å€™çš„çŠ¶æ€ã€‚è¿™æ„å‘³ç€æ•°æ®åº“çŠ¶æ€å’Œä¸šåŠ¡å¯¹è±¡çŠ¶æ€ä¸åŒæ­¥ã€‚é€šå¸¸æƒ…å†µä¸‹ï¼Œè¿™ä¸æ˜¯ä»€ä¹ˆé—®é¢˜ï¼Œå› ä¸ºå¼‚å¸¸æ˜¯ä¸å¯æ¢å¤çš„ï¼Œä½ å¿…é¡»åœ¨å›žæ»šä¹‹åŽé‡æ–°å¼€å§‹æ‰§è¡Œã€‚ "
 
 #. Tag: para
 #: transactions.xml:368
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>Session</literal> caches every object that is in a persistent "
-"state (watched and checked for dirty state by Hibernate). If you keep it "
-"open for a long time or simply load too much data, it will grow endlessly "
-"until you get an OutOfMemoryException. One solution is to call <literal>clear"
-"()</literal> and <literal>evict()</literal> to manage the <literal>Session</"
-"literal> cache, but you should consider a Stored Procedure if you need mass "
-"data operations. Some solutions are shown in <xref linkend=\"batch\"/>. "
-"Keeping a <literal>Session</literal> open for the duration of a user session "
-"also means a higher probability of stale data."
-msgstr ""
-"<literal>Session</literal> 缓存了处于持久化状态的每个对象（Hibernate 会监视和"
-"检查脏数据）。 è¿™æ„å‘³ç€ï¼Œå¦‚æžœä½ è®© <literal>Session</literal> 打开很长一段时"
-"间，或是仅仅载入了过多的数据， <literal>Session</literal> å ç”¨çš„å†…å­˜ä¼šä¸€ç›´å¢ž"
-"长，直到抛出 OutOfMemoryException 异常。这个 问题的一个解决方法是调用 "
-"<literal>clear()</literal> 和 <literal>evict()</literal> 来管理 "
-"<literal>Session</literal> çš„ç¼“å­˜ï¼Œä½†æ˜¯å¦‚æžœä½ éœ€è¦å¤§æ‰¹é‡æ•°æ®æ“ä½œçš„è¯ï¼Œæœ€å¥½è€ƒè™‘"
-"使用存储过程。在<xref linkend=\"Batch_processing\"/>中有一些解决方案。在用户"
-"会话期间一直保持 <literal>Session</literal> 打开也意味着出现脏数据的可能性很"
-"高。"
+#, no-c-format
+msgid "The <literal>Session</literal> caches every object that is in a persistent state (watched and checked for dirty state by Hibernate). If you keep it open for a long time or simply load too much data, it will grow endlessly until you get an OutOfMemoryException. One solution is to call <literal>clear()</literal> and <literal>evict()</literal> to manage the <literal>Session</literal> cache, but you should consider a Stored Procedure if you need mass data operations. Some solutions are shown in <xref linkend=\"batch\"/>. Keeping a <literal>Session</literal> open for the duration of a user session also means a higher probability of stale data."
+msgstr "<literal>Session</literal> 缓存了处于持久化状态的每个对象（Hibernate 会监视和检查脏数据）。 è¿™æ„å‘³ç€ï¼Œå¦‚æžœä½ è®© <literal>Session</literal> 打开很长一段时间，或是仅仅载入了过多的数据， <literal>Session</literal> å ç”¨çš„å†…å­˜ä¼šä¸€ç›´å¢žé•¿ï¼Œç›´åˆ°æŠ›å‡º OutOfMemoryException 异常。这个 问题的一个解决方法是调用 <literal>clear()</literal> å’Œ <literal>evict()</literal> 来管理 <literal>Session</literal> çš„ç¼“å­˜ï¼Œä½†æ˜¯å¦‚æžœä½ éœ€è¦å¤§æ‰¹é‡æ•°æ®æ“ä½œçš„è¯ï¼Œæœ€å¥½è€ƒè™‘ä½¿ç”¨å­˜å‚¨è¿‡ç¨‹ã€‚åœ¨<xref linkend=\"Batch_processing\"/>中有一些解决方案。在用户会话期间一直保持 <literal>Session</literal> 打开也意味着出现脏数据的可能性很高。 "
 
 #. Tag: title
 #: transactions.xml:386
@@ -648,69 +274,27 @@
 
 #. Tag: para
 #: transactions.xml:388
-#, fuzzy, no-c-format
-msgid ""
-"Database, or system, transaction boundaries are always necessary. No "
-"communication with the database can occur outside of a database transaction "
-"(this seems to confuse many developers who are used to the auto-commit "
-"mode). Always use clear transaction boundaries, even for read-only "
-"operations. Depending on your isolation level and database capabilities this "
-"might not be required, but there is no downside if you always demarcate "
-"transactions explicitly. Certainly, a single database transaction is going "
-"to perform better than many small transactions, even for reading data."
-msgstr ""
-"æ•°æ®åº“ï¼ˆæˆ–è€…ç³»ç»Ÿï¼‰äº‹åŠ¡çš„å£°æ˜Žæ€»æ˜¯å¿…é¡»çš„ã€‚åœ¨æ•°æ®åº“äº‹åŠ¡ä¹‹å¤–ï¼Œå°±æ— æ³•å’Œæ•°æ®åº“é€šè®¯"
-"ï¼ˆè¿™å¯èƒ½ä¼šè®©é‚£äº›ä¹ æƒ¯äºŽè‡ªåŠ¨æäº¤äº‹åŠ¡æ¨¡å¼çš„å¼€å‘äººå‘˜æ„Ÿåˆ°è¿·æƒ‘ï¼‰ã€‚æ°¸è¿œä½¿ç”¨æ¸…æ™°çš„äº‹"
-"务声明，即使只读操作也是如此。进行 æ˜¾å¼çš„äº‹åŠ¡å£°æ˜Žå¹¶ä¸æ€»æ˜¯éœ€è¦çš„ï¼Œè¿™å–å†³äºŽä½ çš„"
-"äº‹åŠ¡éš”ç¦»çº§åˆ«å’Œæ•°æ®åº“çš„èƒ½åŠ›ï¼Œä½†ä¸ç®¡æ€Žä¹ˆè¯´ï¼Œå£°æ˜Žäº‹åŠ¡æ€»å½’æœ‰ç›Šæ— å®³ã€‚å½“ç„¶ï¼Œä¸€ä¸ªå•"
-"ç‹¬çš„æ•°æ®åº“äº‹åŠ¡æ€»æ˜¯æ¯”å¾ˆå¤šçç¢Žçš„äº‹åŠ¡æ€§èƒ½æ›´å¥½ï¼Œå³æ—¶å¯¹è¯»æ•°æ®è€Œè¨€ä¹Ÿæ˜¯ä¸€æ ·ã€‚"
+#, no-c-format
+msgid "Database, or system, transaction boundaries are always necessary. No communication with the database can occur outside of a database transaction (this seems to confuse many developers who are used to the auto-commit mode). Always use clear transaction boundaries, even for read-only operations. Depending on your isolation level and database capabilities this might not be required, but there is no downside if you always demarcate transactions explicitly. Certainly, a single database transaction is going to perform better than many small transactions, even for reading data."
+msgstr "æ•°æ®åº“ï¼ˆæˆ–è€…ç³»ç»Ÿï¼‰äº‹åŠ¡çš„å£°æ˜Žæ€»æ˜¯å¿…é¡»çš„ã€‚åœ¨æ•°æ®åº“äº‹åŠ¡ä¹‹å¤–ï¼Œå°±æ— æ³•å’Œæ•°æ®åº“é€šè®¯ï¼ˆè¿™å¯èƒ½ä¼šè®©é‚£äº›ä¹ æƒ¯äºŽè‡ªåŠ¨æäº¤äº‹åŠ¡æ¨¡å¼çš„å¼€å‘äººå‘˜æ„Ÿåˆ°è¿·æƒ‘ï¼‰ã€‚æ°¸è¿œä½¿ç”¨æ¸…æ™°çš„äº‹åŠ¡å£°æ˜Žï¼Œå³ä½¿åªè¯»æ“ä½œä¹Ÿæ˜¯å¦‚æ­¤ã€‚è¿›è¡Œ æ˜¾å¼çš„äº‹åŠ¡å£°æ˜Žå¹¶ä¸æ€»æ˜¯éœ€è¦çš„ï¼Œè¿™å–å†³äºŽä½ çš„äº‹åŠ¡éš”ç¦»çº§åˆ«å’Œæ•°æ®åº“çš„èƒ½åŠ›ï¼Œä½†ä¸ç®¡æ€Žä¹ˆè¯´ï¼Œå£°æ˜Žäº‹åŠ¡æ€»å½’æœ‰ç›Šæ— å®³ã€‚å½“ç„¶ï¼Œä¸€ä¸ªå•ç‹¬çš„æ•°æ®åº“äº‹åŠ¡æ€»æ˜¯æ¯”å¾ˆå¤šçç¢Žçš„äº‹åŠ¡æ€§èƒ½æ›´å¥½ï¼Œå³æ—¶å¯¹è¯»æ•°æ®è€Œè¨€ä¹Ÿæ˜¯ä¸€æ ·ã€‚ "
 
 #. Tag: para
 #: transactions.xml:398
-#, fuzzy, no-c-format
-msgid ""
-"A Hibernate application can run in non-managed (i.e., standalone, simple "
-"Web- or Swing applications) and managed J2EE environments. In a non-managed "
-"environment, Hibernate is usually responsible for its own database "
-"connection pool. The application developer has to manually set transaction "
-"boundaries (begin, commit, or rollback database transactions) themselves. A "
-"managed environment usually provides container-managed transactions (CMT), "
-"with the transaction assembly defined declaratively (in deployment "
-"descriptors of EJB session beans, for example). Programmatic transaction "
-"demarcation is then no longer necessary."
-msgstr ""
-"一个 Hibernate 应用程序可以运行在非托管环境中（也就是独立运行的应用程序，简"
-"单 Web 应用程序，或者Swing图形桌面应用程序），也可以运行在托管的 J2EE 环境"
-"中。在一个非托管环境中，Hibernate é€šå¸¸è‡ªå·±è´Ÿè´£ç®¡ç†æ•°æ®åº“è¿žæŽ¥æ± ã€‚åº”ç”¨ç¨‹åºå¼€å‘"
-"人员必须手工设置事务声明，换句话说，就是手工启 动，提交，或者回滚数据库事务。"
-"一个托管的环境通常提供了容器管理事务（CMT），例如事务装配通过可声明的方式定义"
-"在 EJB session beans 的部署描述符中。可编程式事务声明不再需要，即使是 "
-"<literal>Session</literal> 的同步也可以自动完成。"
+#, no-c-format
+msgid "A Hibernate application can run in non-managed (i.e., standalone, simple Web- or Swing applications) and managed J2EE environments. In a non-managed environment, Hibernate is usually responsible for its own database connection pool. The application developer has to manually set transaction boundaries (begin, commit, or rollback database transactions) themselves. A managed environment usually provides container-managed transactions (CMT), with the transaction assembly defined declaratively (in deployment descriptors of EJB session beans, for example). Programmatic transaction demarcation is then no longer necessary."
+msgstr "一个 Hibernate 应用程序可以运行在非托管环境中（也就是独立运行的应用程序，简单 Web 应用程序，或者Swing图形桌面应用程序），也可以运行在托管的 J2EE 环境中。在一个非托管环境中，Hibernate é€šå¸¸è‡ªå·±è´Ÿè´£ç®¡ç†æ•°æ®åº“è¿žæŽ¥æ± ã€‚åº”ç”¨ç¨‹åºå¼€å‘äººå‘˜å¿…é¡»æ‰‹å·¥è®¾ç½®äº‹åŠ¡å£°æ˜Žï¼Œæ¢å¥è¯è¯´ï¼Œå°±æ˜¯æ‰‹å·¥å¯ 动，提交，或者回滚数据库事务。一个托管的环境通常提供了容器管理事务（CMT），例如事务装配通过可声明的方式定义在 EJB session beans 的部署描述符中。可编程式事务声明不再需要，即使是 <literal>Session</literal> 的同步也可以自动完成。 "
 
 #. Tag: para
 #: transactions.xml:408
-#, fuzzy, no-c-format
-msgid ""
-"However, it is often desirable to keep your persistence layer portable "
-"between non-managed resource-local environments, and systems that can rely "
-"on JTA but use BMT instead of CMT. In both cases use programmatic "
-"transaction demarcation. Hibernate offers a wrapper API called "
-"<literal>Transaction</literal> that translates into the native transaction "
-"system of your deployment environment. This API is actually optional, but we "
-"strongly encourage its use unless you are in a CMT session bean."
-msgstr ""
-"让持久层具备可移植性是人们的理想,这种移植发生在非托管的本地资源环境，与依赖 "
-"JTA 但是使用 BMT 而非 CMT çš„ç³»ç»Ÿä¹‹é—´ã€‚åœ¨ä¸¤ç§æƒ…å†µä¸‹ä½ éƒ½å¯ä»¥ä½¿ç”¨ç¼–ç¨‹å¼çš„äº‹åŠ¡ç®¡"
-"理。Hibernate 提供了一套称为 <literal>Transaction</literal> 的封装 API， 用来"
-"æŠŠä½ çš„éƒ¨ç½²çŽ¯å¢ƒä¸­çš„æœ¬åœ°äº‹åŠ¡ç®¡ç†ç³»ç»Ÿè½¬æ¢åˆ° Hibernate 事务上。这个 API 是可选"
-"çš„ï¼Œä½†æ˜¯æˆ‘ä»¬å¼ºçƒˆæŽ¨èä½ ä½¿ç”¨ï¼Œé™¤éžä½ ç”¨ CMT session bean。"
+#, no-c-format
+msgid "However, it is often desirable to keep your persistence layer portable between non-managed resource-local environments, and systems that can rely on JTA but use BMT instead of CMT. In both cases use programmatic transaction demarcation. Hibernate offers a wrapper API called <literal>Transaction</literal> that translates into the native transaction system of your deployment environment. This API is actually optional, but we strongly encourage its use unless you are in a CMT session bean."
+msgstr "让持久层具备可移植性是人们的理想,这种移植发生在非托管的本地资源环境，与依赖 JTA 但是使用 BMT 而非 CMT çš„ç³»ç»Ÿä¹‹é—´ã€‚åœ¨ä¸¤ç§æƒ…å†µä¸‹ä½ éƒ½å¯ä»¥ä½¿ç”¨ç¼–ç¨‹å¼çš„äº‹åŠ¡ç®¡ç†ã€‚Hibernate 提供了一套称为 <literal>Transaction</literal> 的封装 API， ç”¨æ¥æŠŠä½ çš„éƒ¨ç½²çŽ¯å¢ƒä¸­çš„æœ¬åœ°äº‹åŠ¡ç®¡ç†ç³»ç»Ÿè½¬æ¢åˆ° Hibernate 事务上。这个 API æ˜¯å¯é€‰çš„ï¼Œä½†æ˜¯æˆ‘ä»¬å¼ºçƒˆæŽ¨èä½ ä½¿ç”¨ï¼Œé™¤éžä½ ç”¨ CMT session bean。 "
 
 #. Tag: para
 #: transactions.xml:417
-#, fuzzy, no-c-format
-msgid ""
-"Ending a <literal>Session</literal> usually involves four distinct phases:"
-msgstr "通常情况下，结束 <literal>Session</literal> 包含了四个不同的阶段："
+#, no-c-format
+msgid "Ending a <literal>Session</literal> usually involves four distinct phases:"
+msgstr "通常情况下，结束 <literal>Session</literal> 包含了四个不同的阶段： "
 
 #. Tag: para
 #: transactions.xml:423
@@ -738,14 +322,9 @@
 
 #. Tag: para
 #: transactions.xml:444
-#, fuzzy, no-c-format
-msgid ""
-"We discussed Flushing the session earlier, so we will now have a closer look "
-"at transaction demarcation and exception handling in both managed and non-"
-"managed environments."
-msgstr ""
-"session 的同步（flush，刷出）前面已经讨论过了，我们现在进一步考察在托管和非托"
-"管环境下的事务声明和异常处理。"
+#, no-c-format
+msgid "We discussed Flushing the session earlier, so we will now have a closer look at transaction demarcation and exception handling in both managed and non-managed environments."
+msgstr "session 的同步（flush，刷出）前面已经讨论过了，我们现在进一步考察在托管和非托管环境下的事务声明和异常处理。 "
 
 #. Tag: title
 #: transactions.xml:451
@@ -755,19 +334,13 @@
 
 #. Tag: para
 #: transactions.xml:453
-#, fuzzy, no-c-format
-msgid ""
-"If a Hibernate persistence layer runs in a non-managed environment, database "
-"connections are usually handled by simple (i.e., non-DataSource) connection "
-"pools from which Hibernate obtains connections as needed. The session/"
-"transaction handling idiom looks like this:"
-msgstr ""
-"如果 Hibernat 持久层运行在一个非托管环境中，数据库连接通常由 Hibernate 的简单"
-"（即非 DataSourceï¼‰è¿žæŽ¥æ± æœºåˆ¶ 来处理。session/transaction 处理方式如下所示："
+#, no-c-format
+msgid "If a Hibernate persistence layer runs in a non-managed environment, database connections are usually handled by simple (i.e., non-DataSource) connection pools from which Hibernate obtains connections as needed. The session/transaction handling idiom looks like this:"
+msgstr "如果 Hibernat 持久层运行在一个非托管环境中，数据库连接通常由 Hibernate 的简单（即非 DataSourceï¼‰è¿žæŽ¥æ± æœºåˆ¶ 来处理。session/transaction 处理方式如下所示： "
 
 #. Tag: programlisting
 #: transactions.xml:460
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[// Non-managed environment idiom\n"
 "Session sess = factory.openSession();\n"
@@ -788,7 +361,7 @@
 "    sess.close();\n"
 "}]]>"
 msgstr ""
-"// Non-managed environment idiom\n"
+"<![CDATA[// Non-managed environment idiom\n"
 "Session sess = factory.openSession();\n"
 "Transaction tx = null;\n"
 "try {\n"
@@ -805,40 +378,23 @@
 "}\n"
 "finally {\n"
 "    sess.close();\n"
-"}"
+"}]]>"
 
 #. Tag: para
 #: transactions.xml:462
-#, fuzzy, no-c-format
-msgid ""
-"You do not have to <literal>flush()</literal> the <literal>Session</literal> "
-"explicitly: the call to <literal>commit()</literal> automatically triggers "
-"the synchronization depending on the <xref linkend=\"objectstate-flushing\"/"
-"> for the session. A call to <literal>close()</literal> marks the end of a "
-"session. The main implication of <literal>close()</literal> is that the JDBC "
-"connection will be relinquished by the session. This Java code is portable "
-"and runs in both non-managed and JTA environments."
-msgstr ""
-"ä½ ä¸éœ€è¦æ˜¾å¼ <literal>flush()</literal> <literal>Session</literal> — 对 "
-"<literal>commit()</literal> 的调用会自动触发 session 的同步（取决于 session "
-"的 <xref linkend=\"objectstate-flushing\">FlushMode</xref>）。调用 "
-"<literal>close()</literal> æ ‡å¿— session 的结束。<literal>close()</literal> æ–¹"
-"法重要的暗示是，<literal>session</literal> 释放了 JDBC 连接。这段 Java ä»£ç åœ¨"
-"非托管环境下和 JTA 环境下都可以运行。"
+#, no-c-format
+msgid "You do not have to <literal>flush()</literal> the <literal>Session</literal> explicitly: the call to <literal>commit()</literal> automatically triggers the synchronization depending on the <xref linkend=\"objectstate-flushing\"/> for the session. A call to <literal>close()</literal> marks the end of a session. The main implication of <literal>close()</literal> is that the JDBC connection will be relinquished by the session. This Java code is portable and runs in both non-managed and JTA environments."
+msgstr "ä½ ä¸éœ€è¦æ˜¾å¼ <literal>flush()</literal> <literal>Session</literal> — 对 <literal>commit()</literal> 的调用会自动触发 session 的同步（取决于 session çš„ <xref linkend=\"objectstate-flushing\">FlushMode</xref>）。调用 <literal>close()</literal> æ ‡å¿— session 的结束。<literal>close()</literal> 方法重要的暗示是，<literal>session</literal> 释放了 JDBC 连接。这段 Java ä»£ç åœ¨éžæ‰˜ç®¡çŽ¯å¢ƒä¸‹å’Œ JTA 环境下都可以运行。 "
 
 #. Tag: para
 #: transactions.xml:471
-#, fuzzy, no-c-format
-msgid ""
-"As outlined earlier, a much more flexible solution is Hibernate's built-in "
-"\"current session\" context management:"
-msgstr ""
-"æ›´åŠ çµæ´»çš„æ–¹æ¡ˆæ˜¯ Hibernate 内置的 \"current session\" 上下文管理，前文已经讲"
-"过："
+#, no-c-format
+msgid "As outlined earlier, a much more flexible solution is Hibernate's built-in \"current session\" context management:"
+msgstr "æ›´åŠ çµæ´»çš„æ–¹æ¡ˆæ˜¯ Hibernate 内置的 \"current session\" 上下文管理，前文已经讲过： "
 
 #. Tag: programlisting
 #: transactions.xml:476
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
 "try {\n"
@@ -854,7 +410,7 @@
 "    throw e; // or display error message\n"
 "}]]>"
 msgstr ""
-"// Non-managed environment idiom with getCurrentSession()\n"
+"<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
 "try {\n"
 "    factory.getCurrentSession().beginTransaction();\n"
 "\n"
@@ -866,41 +422,19 @@
 "catch (RuntimeException e) {\n"
 "    factory.getCurrentSession().getTransaction().rollback();\n"
 "    throw e; // or display error message\n"
-"}"
+"}]]>"
 
 #. Tag: para
 #: transactions.xml:478
-#, fuzzy, no-c-format
-msgid ""
-"You will not see these code snippets in a regular application; fatal "
-"(system) exceptions should always be caught at the \"top\". In other words, "
-"the code that executes Hibernate calls in the persistence layer, and the "
-"code that handles <literal>RuntimeException</literal> (and usually can only "
-"clean up and exit), are in different layers. The current context management "
-"by Hibernate can significantly simplify this design by accessing a "
-"<literal>SessionFactory</literal>. Exception handling is discussed later in "
-"this chapter."
-msgstr ""
-"ä½ å¾ˆå¯èƒ½ä»Žæœªåœ¨ä¸€ä¸ªé€šå¸¸çš„åº”ç”¨ç¨‹åºçš„ä¸šåŠ¡ä»£ç ä¸­è§è¿‡è¿™æ ·çš„ä»£ç ç‰‡æ–­ï¼šè‡´å‘½çš„ï¼ˆç³»"
-"统）异常应该总是 在应用程序“顶层”被捕获。换句话说，执行 Hibernate è°ƒç”¨çš„ä»£ç "
-"（在持久层）和处理 <literal>RuntimeException</literal> å¼‚å¸¸çš„ä»£ç ï¼ˆé€šå¸¸åªèƒ½æ¸…"
-"理和退出应用程序）应该在不同 的应用程序逻辑层。Hibernate 的当前上下文管理可以"
-"æžå¤§åœ°ç®€åŒ–è¿™ä¸€è®¾è®¡ï¼Œä½ æ‰€æœ‰çš„ä¸€åˆ‡å°±æ˜¯ <literal>SessionFactory</literal>。异常"
-"å¤„ç†å°†åœ¨æœ¬ç« ç¨åŽè¿›è¡Œè®¨è®ºã€‚"
+#, no-c-format
+msgid "You will not see these code snippets in a regular application; fatal (system) exceptions should always be caught at the \"top\". In other words, the code that executes Hibernate calls in the persistence layer, and the code that handles <literal>RuntimeException</literal> (and usually can only clean up and exit), are in different layers. The current context management by Hibernate can significantly simplify this design by accessing a <literal>SessionFactory</literal>. Exception handling is discussed later in this chapter."
+msgstr "ä½ å¾ˆå¯èƒ½ä»Žæœªåœ¨ä¸€ä¸ªé€šå¸¸çš„åº”ç”¨ç¨‹åºçš„ä¸šåŠ¡ä»£ç ä¸­è§è¿‡è¿™æ ·çš„ä»£ç ç‰‡æ–­ï¼šè‡´å‘½çš„ï¼ˆç³»ç»Ÿï¼‰å¼‚å¸¸åº”è¯¥æ€»æ˜¯ 在应用程序“顶层”被捕获。换句话说，执行 Hibernate è°ƒç”¨çš„ä»£ç ï¼ˆåœ¨æŒä¹…å±‚ï¼‰å’Œå¤„ç† <literal>RuntimeException</literal> å¼‚å¸¸çš„ä»£ç ï¼ˆé€šå¸¸åªèƒ½æ¸…ç†å’Œé€€å‡ºåº”ç”¨ç¨‹åºï¼‰åº”è¯¥åœ¨ä¸åŒ 的应用程序逻辑层。Hibernate çš„å½“å‰ä¸Šä¸‹æ–‡ç®¡ç†å¯ä»¥æžå¤§åœ°ç®€åŒ–è¿™ä¸€è®¾è®¡ï¼Œä½ æ‰€æœ‰çš„ä¸€åˆ‡å°±æ˜¯ <literal>SessionFactory</literal>ã€‚å¼‚å¸¸å¤„ç†å°†åœ¨æœ¬ç« ç¨åŽè¿›è¡Œè®¨è®ºã€‚ "
 
 #. Tag: para
 #: transactions.xml:488
-#, fuzzy, no-c-format
-msgid ""
-"You should select <literal>org.hibernate.transaction.JDBCTransactionFactory</"
-"literal>, which is the default, and for the second example select <literal>"
-"\"thread\"</literal> as your <literal>hibernate."
-"current_session_context_class</literal>."
-msgstr ""
-"è¯·æ³¨æ„ï¼Œä½ åº”è¯¥é€‰æ‹© <literal>org.hibernate.transaction."
-"JDBCTransactionFactory</literal> （这是默认选项），对第二个例子来说，"
-"<literal>hibernate.current_session_context_class</literal>应该是 <literal>"
-"\"thread\"</literal>"
+#, no-c-format
+msgid "You should select <literal>org.hibernate.transaction.JDBCTransactionFactory</literal>, which is the default, and for the second example select <literal>\"thread\"</literal> as your <literal>hibernate.current_session_context_class</literal>."
+msgstr "è¯·æ³¨æ„ï¼Œä½ åº”è¯¥é€‰æ‹© <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> （这是默认选项），对第二个例子来说，<literal>hibernate.current_session_context_class</literal>应该是 <literal>\"thread\"</literal>。"
 
 #. Tag: title
 #: transactions.xml:497
@@ -910,34 +444,19 @@
 
 #. Tag: para
 #: transactions.xml:499
-#, fuzzy, no-c-format
-msgid ""
-"If your persistence layer runs in an application server (for example, behind "
-"EJB session beans), every datasource connection obtained by Hibernate will "
-"automatically be part of the global JTA transaction. You can also install a "
-"standalone JTA implementation and use it without EJB. Hibernate offers two "
-"strategies for JTA integration."
-msgstr ""
-"å¦‚æžœä½ çš„æŒä¹…å±‚è¿è¡Œåœ¨ä¸€ä¸ªåº”ç”¨æœåŠ¡å™¨ä¸­ï¼ˆä¾‹å¦‚ï¼Œåœ¨ EJB session beans 的后面），"
-"Hibernate 获取的每个数据源连接将自动成为全局 JTA äº‹åŠ¡çš„ä¸€éƒ¨åˆ†ã€‚ä½ å¯ä»¥å®‰è£…ä¸€ä¸ª"
-"独立的 JTA 实现，使用它而不使用 EJB。Hibernate 提供了两种策略进行 JTA 集成。"
+#, no-c-format
+msgid "If your persistence layer runs in an application server (for example, behind EJB session beans), every datasource connection obtained by Hibernate will automatically be part of the global JTA transaction. You can also install a standalone JTA implementation and use it without EJB. Hibernate offers two strategies for JTA integration."
+msgstr "å¦‚æžœä½ çš„æŒä¹…å±‚è¿è¡Œåœ¨ä¸€ä¸ªåº”ç”¨æœåŠ¡å™¨ä¸­ï¼ˆä¾‹å¦‚ï¼Œåœ¨ EJB session beans 的后面），Hibernate 获取的每个数据源连接将自动成为全局 JTA äº‹åŠ¡çš„ä¸€éƒ¨åˆ†ã€‚ä½ å¯ä»¥å®‰è£…ä¸€ä¸ªç‹¬ç«‹çš„ JTA 实现，使用它而不使用 EJB。Hibernate 提供了两种策略进行 JTA 集成。 "
 
 #. Tag: para
 #: transactions.xml:506
-#, fuzzy, no-c-format
-msgid ""
-"If you use bean-managed transactions (BMT), Hibernate will tell the "
-"application server to start and end a BMT transaction if you use the "
-"<literal>Transaction</literal> API. The transaction management code is "
-"identical to the non-managed environment."
-msgstr ""
-"å¦‚æžœä½ ä½¿ç”¨ bean 管理事务（BMT），可以通过使用 Hibernate çš„ "
-"<literal>Transaction</literal> API 来告诉应用服务器启动和结束 BMT äº‹åŠ¡ã€‚å› "
-"æ­¤ï¼Œäº‹åŠ¡ç®¡ç†ä»£ç å’Œåœ¨éžæ‰˜ç®¡çŽ¯å¢ƒä¸‹æ˜¯ä¸€æ ·çš„ã€‚"
+#, no-c-format
+msgid "If you use bean-managed transactions (BMT), Hibernate will tell the application server to start and end a BMT transaction if you use the <literal>Transaction</literal> API. The transaction management code is identical to the non-managed environment."
+msgstr "å¦‚æžœä½ ä½¿ç”¨ bean 管理事务（BMT），可以通过使用 Hibernate çš„ <literal>Transaction</literal> API 来告诉应用服务器启动和结束 BMT äº‹åŠ¡ã€‚å› æ­¤ï¼Œäº‹åŠ¡ç®¡ç†ä»£ç å’Œåœ¨éžæ‰˜ç®¡çŽ¯å¢ƒä¸‹æ˜¯ä¸€æ ·çš„ã€‚ "
 
 #. Tag: programlisting
 #: transactions.xml:512
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[// BMT idiom\n"
 "Session sess = factory.openSession();\n"
@@ -958,7 +477,7 @@
 "    sess.close();\n"
 "}]]>"
 msgstr ""
-"// BMT idiom\n"
+"<![CDATA[// BMT idiom\n"
 "Session sess = factory.openSession();\n"
 "Transaction tx = null;\n"
 "try {\n"
@@ -975,23 +494,17 @@
 "}\n"
 "finally {\n"
 "    sess.close();\n"
-"}"
+"}]]>"
 
 #. Tag: para
 #: transactions.xml:514
-#, fuzzy, no-c-format
-msgid ""
-"If you want to use a transaction-bound <literal>Session</literal>, that is, "
-"the <literal>getCurrentSession()</literal> functionality for easy context "
-"propagation, use the JTA <literal>UserTransaction</literal> API directly:"
-msgstr ""
-"å¦‚æžœä½ å¸Œæœ›ä½¿ç”¨ä¸Žäº‹åŠ¡ç»‘å®šçš„ <literal>Session</literal>，也就是使用 "
-"<literal>getCurrentSession()</literal> æ¥ç®€åŒ–ä¸Šä¸‹æ–‡ç®¡ç†ï¼Œä½ å°†ä¸å¾—ä¸ç›´æŽ¥ä½¿ç”¨ "
-"JTA  <literal>UserTransaction</literal> API。"
+#, no-c-format
+msgid "If you want to use a transaction-bound <literal>Session</literal>, that is, the <literal>getCurrentSession()</literal> functionality for easy context propagation, use the JTA <literal>UserTransaction</literal> API directly:"
+msgstr "å¦‚æžœä½ å¸Œæœ›ä½¿ç”¨ä¸Žäº‹åŠ¡ç»‘å®šçš„ <literal>Session</literal>，也就是使用 <literal>getCurrentSession()</literal> æ¥ç®€åŒ–ä¸Šä¸‹æ–‡ç®¡ç†ï¼Œä½ å°†ä¸å¾—ä¸ç›´æŽ¥ä½¿ç”¨ JTA  <literal>UserTransaction</literal> API。 "
 
 #. Tag: programlisting
 #: transactions.xml:520
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[// BMT idiom with getCurrentSession()\n"
 "try {\n"
@@ -1011,7 +524,7 @@
 "    throw e; // or display error message\n"
 "}]]>"
 msgstr ""
-"// BMT idiom with getCurrentSession()\n"
+"<![CDATA[// BMT idiom with getCurrentSession()\n"
 "try {\n"
 "    UserTransaction tx = (UserTransaction)new InitialContext()\n"
 "                            .lookup(\"java:comp/UserTransaction\");\n"
@@ -1027,21 +540,17 @@
 "catch (RuntimeException e) {\n"
 "    tx.rollback();\n"
 "    throw e; // or display error message\n"
-"}"
+"}]]>"
 
 #. Tag: para
 #: transactions.xml:522
-#, fuzzy, no-c-format
-msgid ""
-"With CMT, transaction demarcation is completed in session bean deployment "
-"descriptors, not programmatically. The code is reduced to:"
-msgstr ""
-"在 CMT 方式下，事务声明是在 session bean çš„éƒ¨ç½²æè¿°ç¬¦ä¸­ï¼Œè€Œä¸éœ€è¦ç¼–ç¨‹ã€‚å› æ­¤ï¼Œ"
-"ä»£ç è¢«ç®€åŒ–ä¸º:"
+#, no-c-format
+msgid "With CMT, transaction demarcation is completed in session bean deployment descriptors, not programmatically. The code is reduced to:"
+msgstr "在 CMT 方式下，事务声明是在 session bean çš„éƒ¨ç½²æè¿°ç¬¦ä¸­ï¼Œè€Œä¸éœ€è¦ç¼–ç¨‹ã€‚å› æ­¤ï¼Œä»£ç è¢«ç®€åŒ–ä¸ºï¼š"
 
 #. Tag: programlisting
 #: transactions.xml:527
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[// CMT idiom\n"
 " Session sess = factory.getCurrentSession();\n"
@@ -1050,76 +559,30 @@
 " ...\n"
 "]]>"
 msgstr ""
-"// CMT idiom\n"
+"<![CDATA[// CMT idiom\n"
 " Session sess = factory.getCurrentSession();\n"
 "\n"
 " // do some work\n"
-" ..."
+" ...\n"
+"]]>"
 
 #. Tag: para
 #: transactions.xml:529
-#, fuzzy, no-c-format
-msgid ""
-"In a CMT/EJB, even rollback happens automatically. An unhandled "
-"<literal>RuntimeException</literal> thrown by a session bean method tells "
-"the container to set the global transaction to rollback. <emphasis>You do "
-"not need to use the Hibernate <literal>Transaction</literal> API at all with "
-"BMT or CMT, and you get automatic propagation of the \"current\" Session "
-"bound to the transaction.</emphasis>"
-msgstr ""
-"在 CMT/EJB 中甚至会自动 rollbackï¼Œå› ä¸ºå‡è‹¥æœ‰æœªæ•èŽ·çš„ "
-"<literal>RuntimeException</literal> 从 session bean 方法中抛出，这就会通知容"
-"器把全局事务回滚。<emphasis>这就意味着，在 BMT 或者 CMT ä¸­ï¼Œä½ æ ¹æœ¬å°±ä¸éœ€è¦ä½¿"
-"用 Hibernate <literal>Transaction</literal> APIï¼Œä½ è‡ªåŠ¨å¾—åˆ°äº†ç»‘å®šåˆ°äº‹åŠ¡çš„â€œå½“"
-"前” Session。 </emphasis>"
+#, no-c-format
+msgid "In a CMT/EJB, even rollback happens automatically. An unhandled <literal>RuntimeException</literal> thrown by a session bean method tells the container to set the global transaction to rollback. <emphasis>You do not need to use the Hibernate <literal>Transaction</literal> API at all with BMT or CMT, and you get automatic propagation of the \"current\" Session bound to the transaction.</emphasis>"
+msgstr "在 CMT/EJB 中甚至会自动 rollbackï¼Œå› ä¸ºå‡è‹¥æœ‰æœªæ•èŽ·çš„ <literal>RuntimeException</literal> 从 session bean 方法中抛出，这就会通知容器把全局事务回滚。<emphasis>这就意味着，在 BMT 或者 CMT ä¸­ï¼Œä½ æ ¹æœ¬å°±ä¸éœ€è¦ä½¿ç”¨ Hibernate <literal>Transaction</literal> APIï¼Œä½ è‡ªåŠ¨å¾—åˆ°äº†ç»‘å®šåˆ°äº‹åŠ¡çš„â€œå½“å‰â€ Session。</emphasis>"
 
 #. Tag: para
 #: transactions.xml:537
-#, fuzzy, no-c-format
-msgid ""
-"When configuring Hibernate's transaction factory, choose <literal>org."
-"hibernate.transaction.JTATransactionFactory</literal> if you use JTA "
-"directly (BMT), and <literal>org.hibernate.transaction."
-"CMTTransactionFactory</literal> in a CMT session bean. Remember to also set "
-"<literal>hibernate.transaction.manager_lookup_class</literal>. Ensure that "
-"your <literal>hibernate.current_session_context_class</literal> is either "
-"unset (backwards compatibility), or is set to <literal>\"jta\"</literal>."
-msgstr ""
-"æ³¨æ„ï¼Œå½“ä½ é…ç½® Hibernate çš„ transaction factory 的时候，在直接使用 JTA 的时候"
-"（BMTï¼‰ï¼Œä½ åº”è¯¥é€‰æ‹© <literal>org.hibernate.transaction."
-"JTATransactionFactory</literal>，在 CMT session bean 中选择 <literal>org."
-"hibernate.transaction.CMTTransactionFactory</literal>。记得也要设置 "
-"<literal>hibernate.transaction.manager_lookup_class</literal>ã€‚è¿˜æœ‰ï¼Œç¡®è®¤ä½ "
-"的 <literal>hibernate.current_session_context_class</literal> 未设置（为了向"
-"下兼容），或者设置为 <literal>\"jta\"</literal>。"
+#, no-c-format
+msgid "When configuring Hibernate's transaction factory, choose <literal>org.hibernate.transaction.JTATransactionFactory</literal> if you use JTA directly (BMT), and <literal>org.hibernate.transaction.CMTTransactionFactory</literal> in a CMT session bean. Remember to also set <literal>hibernate.transaction.manager_lookup_class</literal>. Ensure that your <literal>hibernate.current_session_context_class</literal> is either unset (backwards compatibility), or is set to <literal>\"jta\"</literal>."
+msgstr "æ³¨æ„ï¼Œå½“ä½ é…ç½® Hibernate çš„ transaction factory 的时候，在直接使用 JTA 的时候（BMTï¼‰ï¼Œä½ åº”è¯¥é€‰æ‹© <literal>org.hibernate.transaction.JTATransactionFactory</literal>，在 CMT session bean 中选择 <literal>org.hibernate.transaction.CMTTransactionFactory</literal>。记得也要设置 <literal>hibernate.transaction.manager_lookup_class</literal>ã€‚è¿˜æœ‰ï¼Œç¡®è®¤ä½ çš„ <literal>hibernate.current_session_context_class</literal> 未设置（为了向下兼容），或者设置为 <literal>\"jta\"</literal>。 "
 
 #. Tag: para
 #: transactions.xml:546
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>getCurrentSession()</literal> operation has one downside in a "
-"JTA environment. There is one caveat to the use of <literal>after_statement</"
-"literal> connection release mode, which is then used by default. Due to a "
-"limitation of the JTA spec, it is not possible for Hibernate to "
-"automatically clean up any unclosed <literal>ScrollableResults</literal> or "
-"<literal>Iterator</literal> instances returned by <literal>scroll()</"
-"literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> "
-"release the underlying database cursor by calling <literal>ScrollableResults."
-"close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicitly "
-"from a <literal>finally</literal> block. Most applications can easily avoid "
-"using <literal>scroll()</literal> or <literal>iterate()</literal> from the "
-"JTA or CMT code.)"
-msgstr ""
-"<literal>getCurrentSession()</literal>在 JTA 环境中有一个弊端。对 "
-"<literal>after_statement</literal> 连接释放方式有一个警告，这是被默认使用的。"
-"å› ä¸º JTA è§„èŒƒçš„ä¸€ä¸ªå¾ˆæ„šè ¢çš„é™åˆ¶ï¼ŒHibernate 不可能自动清理任何未关闭的 "
-"<literal>ScrollableResults</literal> 或者<literal>Iterator</literal>，它们是"
-"ç”± <literal>scroll()</literal> 或 <literal>iterate()</literal> äº§ç”Ÿçš„ã€‚ä½  "
-"<emphasis>must</emphasis> 通过在 <literal>finally</literal> 块中，显式调用 "
-"<literal>ScrollableResults.close()</literal> 或者 <literal>Hibernate.close"
-"(Iterator)</literal> æ–¹æ³•æ¥é‡Šæ”¾åº•å±‚æ•°æ®åº“æ¸¸æ ‡ã€‚ï¼ˆå½“ç„¶ï¼Œå¤§éƒ¨åˆ†ç¨‹åºå®Œå…¨å¯ä»¥å¾ˆå®¹"
-"易的避免在 JTA 或 CMT ä»£ç ä¸­å‡ºçŽ° <literal>scroll()</literal> 或 "
-"<literal>iterate()</literal>。）"
+#, no-c-format
+msgid "The <literal>getCurrentSession()</literal> operation has one downside in a JTA environment. There is one caveat to the use of <literal>after_statement</literal> connection release mode, which is then used by default. Due to a limitation of the JTA spec, it is not possible for Hibernate to automatically clean up any unclosed <literal>ScrollableResults</literal> or <literal>Iterator</literal> instances returned by <literal>scroll()</literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> release the underlying database cursor by calling <literal>ScrollableResults.close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicitly from a <literal>finally</literal> block. Most applications can easily avoid using <literal>scroll()</literal> or <literal>iterate()</literal> from the JTA or CMT code.)"
+msgstr "<literal>getCurrentSession()</literal>在 JTA 环境中有一个弊端。对 <literal>after_statement</literal> è¿žæŽ¥é‡Šæ”¾æ–¹å¼æœ‰ä¸€ä¸ªè­¦å‘Šï¼Œè¿™æ˜¯è¢«é»˜è®¤ä½¿ç”¨çš„ã€‚å› ä¸º JTA è§„èŒƒçš„ä¸€ä¸ªå¾ˆæ„šè ¢çš„é™åˆ¶ï¼ŒHibernate 不可能自动清理任何未关闭的 <literal>ScrollableResults</literal> 或者<literal>Iterator</literal>，它们是由 <literal>scroll()</literal> 或 <literal>iterate()</literal> äº§ç”Ÿçš„ã€‚ä½  <emphasis>must</emphasis> 通过在 <literal>finally</literal> 块中，显式调用 <literal>ScrollableResults.close()</literal> 或者 <literal>Hibernate.close(Iterator)</literal> æ–¹æ³•æ¥é‡Šæ”¾åº•å±‚æ•°æ®åº“æ¸¸æ ‡ã€‚ï¼ˆå½“ç„¶ï¼Œå¤§éƒ¨åˆ†ç¨‹åºå®Œå…¨å¯ä»¥å¾ˆå®¹æ˜“çš„é¿å…åœ¨ JTA 或 CMT ä»£ç ä¸­å‡ºçŽ° <literal>scroll()</literal> 或 <literal>iterate()</literal>。） "
 
 #. Tag: title
 #: transactions.xml:562
@@ -1129,124 +592,51 @@
 
 #. Tag: para
 #: transactions.xml:564
-#, fuzzy, no-c-format
-msgid ""
-"If the <literal>Session</literal> throws an exception, including any "
-"<literal>SQLException</literal>, immediately rollback the database "
-"transaction, call <literal>Session.close()</literal> and discard the "
-"<literal>Session</literal> instance. Certain methods of <literal>Session</"
-"literal> will <emphasis>not</emphasis> leave the session in a consistent "
-"state. No exception thrown by Hibernate can be treated as recoverable. "
-"Ensure that the <literal>Session</literal> will be closed by calling "
-"<literal>close()</literal> in a <literal>finally</literal> block."
-msgstr ""
-"如果 <literal>Session</literal> 抛出异常 （包括任何 <literal>SQLException</"
-"literal>ï¼‰ï¼Œä½ åº”è¯¥ç«‹å³å›žæ»šæ•°æ®åº“äº‹åŠ¡ï¼Œè°ƒç”¨ <literal>Session.close()</"
-"literal> ，丢弃该  <literal>Session</literal> 实例。<literal>Session</"
-"literal> 的某些方法可能会导致 session 处于不一致的状态。所有由 Hibernate 抛出"
-"的异常都视为不可以恢复的。确保在  <literal>finally</literal> ä»£ç å—ä¸­è°ƒç”¨ "
-"<literal>close()</literal> 方法，以关闭掉  <literal>Session</literal>。"
+#, no-c-format
+msgid "If the <literal>Session</literal> throws an exception, including any <literal>SQLException</literal>, immediately rollback the database transaction, call <literal>Session.close()</literal> and discard the <literal>Session</literal> instance. Certain methods of <literal>Session</literal> will <emphasis>not</emphasis> leave the session in a consistent state. No exception thrown by Hibernate can be treated as recoverable. Ensure that the <literal>Session</literal> will be closed by calling <literal>close()</literal> in a <literal>finally</literal> block."
+msgstr "如果 <literal>Session</literal> 抛出异常（包括任何 <literal>SQLException</literal>ï¼‰ï¼Œä½ åº”è¯¥ç«‹å³å›žæ»šæ•°æ®åº“äº‹åŠ¡ï¼Œè°ƒç”¨ <literal>Session.close()</literal> ，丢弃该  <literal>Session</literal> 实例。<literal>Session</literal> 的某些方法可能会导致 session 处于不一致的状态。所有由 Hibernate 抛出的异常都视为不可以恢复的。确保在  <literal>finally</literal> ä»£ç å—ä¸­è°ƒç”¨ <literal>close()</literal> 方法，以关闭掉  <literal>Session</literal>。"
 
 #. Tag: para
 #: transactions.xml:575
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>HibernateException</literal>, which wraps most of the errors "
-"that can occur in a Hibernate persistence layer, is an unchecked exception. "
-"It was not in older versions of Hibernate. In our opinion, we should not "
-"force the application developer to catch an unrecoverable exception at a low "
-"layer. In most systems, unchecked and fatal exceptions are handled in one of "
-"the first frames of the method call stack (i.e., in higher layers) and "
-"either an error message is presented to the application user or some other "
-"appropriate action is taken. Note that Hibernate might also throw other "
-"unchecked exceptions that are not a <literal>HibernateException</literal>. "
-"These are not recoverable and appropriate action should be taken."
-msgstr ""
-"<literal>HibernateException</literal> 是一个非检查期异常（这不同于 Hibernate "
-"老的版本）， 它封装了 Hibernate 持久层可能出现的大多数错误。我们的观点是，不"
-"应该强迫应用程序开发人员 åœ¨åº•å±‚æ•èŽ·æ— æ³•æ¢å¤çš„å¼‚å¸¸ã€‚åœ¨å¤§å¤šæ•°è½¯ä»¶ç³»ç»Ÿä¸­ï¼Œéžæ£€æŸ¥"
-"期异常和致命异常都是在相应方法调用 çš„å †æ ˆçš„é¡¶å±‚è¢«å¤„ç†çš„ï¼ˆä¹Ÿå°±æ˜¯è¯´ï¼Œåœ¨è½¯ä»¶ä¸Šé¢"
-"的逻辑层），并且提供一个错误信息给应用软件的用户 （或者采取其他某些相应的操"
-"作）。请注意，Hibernate 也有可能抛出其他并不属于 "
-"<literal>HibernateException</literal> çš„éžæ£€æŸ¥æœŸå¼‚å¸¸ã€‚è¿™äº›å¼‚å¸¸åŒæ ·ä¹Ÿæ˜¯æ— æ³•æ¢"
-"复的，应该 采取某些相应的操作去处理。"
+#, no-c-format
+msgid "The <literal>HibernateException</literal>, which wraps most of the errors that can occur in a Hibernate persistence layer, is an unchecked exception. It was not in older versions of Hibernate. In our opinion, we should not force the application developer to catch an unrecoverable exception at a low layer. In most systems, unchecked and fatal exceptions are handled in one of the first frames of the method call stack (i.e., in higher layers) and either an error message is presented to the application user or some other appropriate action is taken. Note that Hibernate might also throw other unchecked exceptions that are not a <literal>HibernateException</literal>. These are not recoverable and appropriate action should be taken."
+msgstr "<literal>HibernateException</literal> 是一个非检查期异常（这不同于 Hibernate 老的版本），它封装了 Hibernate 持久层可能出现的大多数错误。我们的观点是，不应该强迫应用程序开发人员 åœ¨åº•å±‚æ•èŽ·æ— æ³•æ¢å¤çš„å¼‚å¸¸ã€‚åœ¨å¤§å¤šæ•°è½¯ä»¶ç³»ç»Ÿä¸­ï¼Œéžæ£€æŸ¥æœŸå¼‚å¸¸å’Œè‡´å‘½å¼‚å¸¸éƒ½æ˜¯åœ¨ç›¸åº”æ–¹æ³•è°ƒç”¨ çš„å †æ ˆçš„é¡¶å±‚è¢«å¤„ç†çš„ï¼ˆä¹Ÿå°±æ˜¯è¯´ï¼Œåœ¨è½¯ä»¶ä¸Šé¢çš„é€»è¾‘å±‚ï¼‰ï¼Œå¹¶ä¸”æä¾›ä¸€ä¸ªé”™è¯¯ä¿¡æ¯ç»™åº”ç”¨è½¯ä»¶çš„ç”¨æˆ· （或者采取其他某些相应的操作）。请注意，Hibernate 也有可能抛出其他并不属于 <literal>HibernateException</literal> çš„éžæ£€æŸ¥æœŸå¼‚å¸¸ã€‚è¿™äº›å¼‚å¸¸åŒæ ·ä¹Ÿæ˜¯æ— æ³•æ¢å¤çš„ï¼Œåº”è¯¥ 采取某些相应的操作去处理。"
 
 #. Tag: para
 #: transactions.xml:587
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate wraps <literal>SQLException</literal>s thrown while interacting "
-"with the database in a <literal>JDBCException</literal>. In fact, Hibernate "
-"will attempt to convert the exception into a more meaningful subclass of "
-"<literal>JDBCException</literal>. The underlying <literal>SQLException</"
-"literal> is always available via <literal>JDBCException.getCause()</"
-"literal>. Hibernate converts the <literal>SQLException</literal> into an "
-"appropriate <literal>JDBCException</literal> subclass using the "
-"<literal>SQLExceptionConverter</literal> attached to the "
-"<literal>SessionFactory</literal>. By default, the "
-"<literal>SQLExceptionConverter</literal> is defined by the configured "
-"dialect. However, it is also possible to plug in a custom implementation. "
-"See the javadocs for the <literal>SQLExceptionConverterFactory</literal> "
-"class for details. The standard <literal>JDBCException</literal> subtypes "
-"are:"
-msgstr ""
-"在和数据库进行交互时，Hibernate 把捕获的 <literal>SQLException</literal> 封装"
-"为 Hibernate 的  <literal>JDBCException</literal>。事实上，Hibernate 尝试把异"
-"常转换为更有实际含义的 <literal>JDBCException</literal> 异常的子类。底层的 "
-"<literal>SQLException</literal> 可以通过 <literal>JDBCException.getCause()</"
-"literal> 来得到。Hibernate 通过使用关联到  <literal>SessionFactory</literal> "
-"上的 <literal>SQLExceptionConverter</literal> 来把 <literal>SQLException</"
-"literal> 转换为一个对应的 <literal>JDBCException</literal> 异常的子类。默认情"
-"况下，<literal>SQLExceptionConverter</literal> 可以通过配置 dialect 选项指"
-"定；此外，也可以使用用户自定义的实现类（参考 javadocs "
-"<literal>SQLExceptionConverterFactory</literal> ç±»æ¥äº†è§£è¯¦æƒ…ï¼‰ã€‚æ ‡å‡†çš„ "
-"<literal>JDBCException</literal> 子类型是："
+#, no-c-format
+msgid "Hibernate wraps <literal>SQLException</literal>s thrown while interacting with the database in a <literal>JDBCException</literal>. In fact, Hibernate will attempt to convert the exception into a more meaningful subclass of <literal>JDBCException</literal>. The underlying <literal>SQLException</literal> is always available via <literal>JDBCException.getCause()</literal>. Hibernate converts the <literal>SQLException</literal> into an appropriate <literal>JDBCException</literal> subclass using the <literal>SQLExceptionConverter</literal> attached to the <literal>SessionFactory</literal>. By default, the <literal>SQLExceptionConverter</literal> is defined by the configured dialect. However, it is also possible to plug in a custom implementation. See the javadocs for the <literal>SQLExceptionConverterFactory</literal> class for details. The standard <literal>JDBCException</literal> subtypes are:"
+msgstr "在和数据库进行交互时，Hibernate 把捕获的 <literal>SQLException</literal> 封装为 Hibernate çš„  <literal>JDBCException</literal>。事实上，Hibernate 尝试把异常转换为更有实际含义的 <literal>JDBCException</literal> 异常的子类。底层的 <literal>SQLException</literal> 可以通过 <literal>JDBCException.getCause()</literal> 来得到。Hibernate 通过使用关联到  <literal>SessionFactory</literal> 上的 <literal>SQLExceptionConverter</literal> 来把 <literal>SQLException</literal> 转换为一个对应的 <literal>JDBCException</literal> 异常的子类。默认情况下，<literal>SQLExceptionConverter</literal> 可以通过配置 dialect 选项指定；此外，也可以使用用户自定义的实现类（参考 javadocs <literal>SQLExceptionConverterFactory</literal> ç±»æ¥äº†è§£è¯¦æƒ…ï¼‰ã€‚æ ‡å‡†çš„ <literal>JDBCException</literal> 子类型是： "
 
 #. Tag: para
 #: transactions.xml:603
-#, fuzzy, no-c-format
-msgid ""
-"<literal>JDBCConnectionException</literal>: indicates an error with the "
-"underlying JDBC communication."
-msgstr ""
-"<literal>JDBCConnectionException</literal> — 指明底层的 JDBC 通讯出现错误"
+#, no-c-format
+msgid "<literal>JDBCConnectionException</literal>: indicates an error with the underlying JDBC communication."
+msgstr "<literal>JDBCConnectionException</literal>：指明底层的 JDBC 通讯出现错误。"
 
 #. Tag: para
 #: transactions.xml:609
-#, fuzzy, no-c-format
-msgid ""
-"<literal>SQLGrammarException</literal>: indicates a grammar or syntax "
-"problem with the issued SQL."
-msgstr ""
-"<literal>SQLGrammarException</literal> — 指明发送的 SQL è¯­å¥çš„è¯­æ³•æˆ–è€…æ ¼å¼é”™"
-"误"
+#, no-c-format
+msgid "<literal>SQLGrammarException</literal>: indicates a grammar or syntax problem with the issued SQL."
+msgstr "<literal>SQLGrammarException</literal>：指明发送的 SQL è¯­å¥çš„è¯­æ³•æˆ–è€…æ ¼å¼é”™è¯¯ã€‚"
 
 #. Tag: para
 #: transactions.xml:615
-#, fuzzy, no-c-format
-msgid ""
-"<literal>ConstraintViolationException</literal>: indicates some form of "
-"integrity constraint violation."
-msgstr ""
-"<literal>ConstraintViolationException</literal> — 指明某种类型的约束违例错误"
+#, no-c-format
+msgid "<literal>ConstraintViolationException</literal>: indicates some form of integrity constraint violation."
+msgstr "<literal>ConstraintViolationException</literal>：指明某种类型的约束违例错误"
 
 #. Tag: para
 #: transactions.xml:621
-#, fuzzy, no-c-format
-msgid ""
-"<literal>LockAcquisitionException</literal>: indicates an error acquiring a "
-"lock level necessary to perform the requested operation."
-msgstr ""
-"<literal>LockAcquisitionException</literal> — 指明了在执行请求操作时，获取所"
-"需的锁级别时出现的错误。"
+#, no-c-format
+msgid "<literal>LockAcquisitionException</literal>: indicates an error acquiring a lock level necessary to perform the requested operation."
+msgstr "<literal>LockAcquisitionException</literal>：指明了在执行请求操作时，获取所需的锁级别时出现的错误。"
 
 #. Tag: para
 #: transactions.xml:627
-#, fuzzy, no-c-format
-msgid ""
-"<literal>GenericJDBCException</literal>: a generic exception which did not "
-"fall into any of the other categories."
-msgstr "<literal>GenericJDBCException</literal> — 不属于任何其他种类的原生异常"
+#, no-c-format
+msgid "<literal>GenericJDBCException</literal>: a generic exception which did not fall into any of the other categories."
+msgstr "<literal>GenericJDBCException</literal>：不属于任何其他种类的原生异常。"
 
 #. Tag: title
 #: transactions.xml:637
@@ -1256,29 +646,13 @@
 
 #. Tag: para
 #: transactions.xml:639
-#, fuzzy, no-c-format
-msgid ""
-"An important feature provided by a managed environment like EJB, that is "
-"never provided for non-managed code, is transaction timeout. Transaction "
-"timeouts ensure that no misbehaving transaction can indefinitely tie up "
-"resources while returning no response to the user. Outside a managed (JTA) "
-"environment, Hibernate cannot fully provide this functionality. However, "
-"Hibernate can at least control data access operations, ensuring that "
-"database level deadlocks and queries with huge result sets are limited by a "
-"defined timeout. In a managed environment, Hibernate can delegate "
-"transaction timeout to JTA. This functionality is abstracted by the "
-"Hibernate <literal>Transaction</literal> object."
-msgstr ""
-"EJB è¿™æ ·çš„æ‰˜ç®¡çŽ¯å¢ƒæœ‰ä¸€é¡¹æžä¸ºé‡è¦çš„ç‰¹æ€§ï¼Œè€Œå®ƒä»Žæœªåœ¨éžæ‰˜ç®¡çŽ¯å¢ƒä¸­æä¾›è¿‡ï¼Œé‚£å°±æ˜¯"
-"äº‹åŠ¡è¶…æ—¶ã€‚åœ¨å‡ºçŽ°é”™è¯¯çš„äº‹åŠ¡è¡Œä¸ºçš„æ—¶å€™ï¼Œè¶…æ—¶å¯ä»¥ç¡®ä¿ä¸ä¼šæ— é™æŒ‚èµ·èµ„æºã€å¯¹ç”¨æˆ·æ²¡"
-"有交代。在托管（JTA）环境之外，Hibernate æ— æ³•å®Œå…¨æä¾›è¿™ä¸€åŠŸèƒ½ã€‚ä½†æ˜¯ï¼Œ"
-"Hiberante 至少可以控制数据访问，确保数据库级别的死锁，和返回巨大结果集的查询"
-"被限定在一个规定的时间内。在托管环境中，Hibernate 会把事务超时转交给 JTA。这"
-"一功能通过 Hibernate <literal>Transaction</literal> 对象进行抽象。"
+#, no-c-format
+msgid "An important feature provided by a managed environment like EJB, that is never provided for non-managed code, is transaction timeout. Transaction timeouts ensure that no misbehaving transaction can indefinitely tie up resources while returning no response to the user. Outside a managed (JTA) environment, Hibernate cannot fully provide this functionality. However, Hibernate can at least control data access operations, ensuring that database level deadlocks and queries with huge result sets are limited by a defined timeout. In a managed environment, Hibernate can delegate transaction timeout to JTA. This functionality is abstracted by the Hibernate <literal>Transaction</literal> object."
+msgstr "EJB è¿™æ ·çš„æ‰˜ç®¡çŽ¯å¢ƒæœ‰ä¸€é¡¹æžä¸ºé‡è¦çš„ç‰¹æ€§ï¼Œè€Œå®ƒä»Žæœªåœ¨éžæ‰˜ç®¡çŽ¯å¢ƒä¸­æä¾›è¿‡ï¼Œé‚£å°±æ˜¯äº‹åŠ¡è¶…æ—¶ã€‚åœ¨å‡ºçŽ°é”™è¯¯çš„äº‹åŠ¡è¡Œä¸ºçš„æ—¶å€™ï¼Œè¶…æ—¶å¯ä»¥ç¡®ä¿ä¸ä¼šæ— é™æŒ‚èµ·èµ„æºã€å¯¹ç”¨æˆ·æ²¡æœ‰äº¤ä»£ã€‚åœ¨æ‰˜ç®¡ï¼ˆJTA）环境之外，Hibernate æ— æ³•å®Œå…¨æä¾›è¿™ä¸€åŠŸèƒ½ã€‚ä½†æ˜¯ï¼ŒHiberante 至少可以控制数据访问，确保数据库级别的死锁，和返回巨大结果集的查询被限定在一个规定的时间内。在托管环境中，Hibernate 会把事务超时转交给 JTA。这一功能通过 Hibernate <literal>Transaction</literal> 对象进行抽象。 "
 
 #. Tag: programlisting
 #: transactions.xml:652
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[\n"
 "Session sess = factory.openSession();\n"
@@ -1300,6 +674,7 @@
 "    sess.close();\n"
 "}]]>"
 msgstr ""
+"<![CDATA[\n"
 "Session sess = factory.openSession();\n"
 "try {\n"
 "    //set transaction timeout to 3 seconds\n"
@@ -1317,17 +692,13 @@
 "}\n"
 "finally {\n"
 "    sess.close();\n"
-"}"
+"}]]>"
 
 #. Tag: para
 #: transactions.xml:654
-#, fuzzy, no-c-format
-msgid ""
-"<literal>setTimeout()</literal> cannot be called in a CMT bean, where "
-"transaction timeouts must be defined declaratively."
-msgstr ""
-"注意 <literal>setTimeout()</literal> 不应该在 CMT bean 中调用，此时事务超时值"
-"应该是被声明式定义的。"
+#, no-c-format
+msgid "<literal>setTimeout()</literal> cannot be called in a CMT bean, where transaction timeouts must be defined declaratively."
+msgstr "注意 <literal>setTimeout()</literal> 不应该在 CMT bean 中调用，此时事务超时值应该是被声明式定义的。 "
 
 #. Tag: title
 #: transactions.xml:664
@@ -1337,21 +708,9 @@
 
 #. Tag: para
 #: transactions.xml:666
-#, fuzzy, no-c-format
-msgid ""
-"The only approach that is consistent with high concurrency and high "
-"scalability, is optimistic concurrency control with versioning. Version "
-"checking uses version numbers, or timestamps, to detect conflicting updates "
-"and to prevent lost updates. Hibernate provides three possible approaches to "
-"writing application code that uses optimistic concurrency. The use cases we "
-"discuss are in the context of long conversations, but version checking also "
-"has the benefit of preventing lost updates in single database transactions."
-msgstr ""
-"唯一能够同时保持高并发和高可伸缩性的方法就是使用带版本化的乐观并发控制。版本"
-"检查使用版本号、 或者时间戳来检测更新冲突（并且防止更新丢失）。Hibernate 为使"
-"ç”¨ä¹è§‚å¹¶å‘æŽ§åˆ¶çš„ä»£ç æä¾›äº†ä¸‰ç§å¯ èƒ½çš„æ–¹æ³•ï¼Œåº”ç”¨ç¨‹åºåœ¨ç¼–å†™è¿™äº›ä»£ç æ—¶ï¼Œå¯ä»¥é‡‡ç”¨"
-"它们。我们已经在前面应用程序对话那部分展示了 乐观并发控制的应用场景，此外，在"
-"单个数据库事务范围内，版本检查也提供了防止更新丢失的好处。"
+#, no-c-format
+msgid "The only approach that is consistent with high concurrency and high scalability, is optimistic concurrency control with versioning. Version checking uses version numbers, or timestamps, to detect conflicting updates and to prevent lost updates. Hibernate provides three possible approaches to writing application code that uses optimistic concurrency. The use cases we discuss are in the context of long conversations, but version checking also has the benefit of preventing lost updates in single database transactions."
+msgstr "唯一能够同时保持高并发和高可伸缩性的方法就是使用带版本化的乐观并发控制。版本检查使用版本号、 或者时间戳来检测更新冲突（并且防止更新丢失）。Hibernate ä¸ºä½¿ç”¨ä¹è§‚å¹¶å‘æŽ§åˆ¶çš„ä»£ç æä¾›äº†ä¸‰ç§å¯ èƒ½çš„æ–¹æ³•ï¼Œåº”ç”¨ç¨‹åºåœ¨ç¼–å†™è¿™äº›ä»£ç æ—¶ï¼Œå¯ä»¥é‡‡ç”¨å®ƒä»¬ã€‚æˆ‘ä»¬å·²ç»åœ¨å‰é¢åº”ç”¨ç¨‹åºå¯¹è¯é‚£éƒ¨åˆ†å±•ç¤ºäº† 乐观并发控制的应用场景，此外，在单个数据库事务范围内，版本检查也提供了防止更新丢失的好处。 "
 
 #. Tag: title
 #: transactions.xml:677
@@ -1361,24 +720,13 @@
 
 #. Tag: para
 #: transactions.xml:679
-#, fuzzy, no-c-format
-msgid ""
-"In an implementation without much help from Hibernate, each interaction with "
-"the database occurs in a new <literal>Session</literal> and the developer is "
-"responsible for reloading all persistent instances from the database before "
-"manipulating them. The application is forced to carry out its own version "
-"checking to ensure conversation transaction isolation. This approach is the "
-"least efficient in terms of database access. It is the approach most similar "
-"to entity EJBs."
-msgstr ""
-"未能充分利用 Hibernate åŠŸèƒ½çš„å®žçŽ°ä»£ç ä¸­ï¼Œæ¯æ¬¡å’Œæ•°æ®åº“äº¤äº’éƒ½éœ€è¦ä¸€ä¸ªæ–°çš„  "
-"<literal>Session</literal>，而且开发人员必须在显示数据之前从数据库中重新载入"
-"所有的持久化对象实例。这种方式迫使应用程序自己实现版本检查来确保对话事务的隔"
-"离，从数据访问的角度来说是最低效的。这种使用方式和 entity EJB 最相似。"
+#, no-c-format
+msgid "In an implementation without much help from Hibernate, each interaction with the database occurs in a new <literal>Session</literal> and the developer is responsible for reloading all persistent instances from the database before manipulating them. The application is forced to carry out its own version checking to ensure conversation transaction isolation. This approach is the least efficient in terms of database access. It is the approach most similar to entity EJBs."
+msgstr "未能充分利用 Hibernate åŠŸèƒ½çš„å®žçŽ°ä»£ç ä¸­ï¼Œæ¯æ¬¡å’Œæ•°æ®åº“äº¤äº’éƒ½éœ€è¦ä¸€ä¸ªæ–°çš„  <literal>Session</literal>，而且开发人员必须在显示数据之前从数据库中重新载入所有的持久化对象实例。这种方式迫使应用程序自己实现版本检查来确保对话事务的隔离，从数据访问的角度来说是最低效的。这种使用方式和 entity EJB 最相似。 "
 
 #. Tag: programlisting
 #: transactions.xml:688
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[// foo is an instance loaded by a previous Session\n"
 "session = factory.openSession();\n"
@@ -1386,68 +734,41 @@
 "\n"
 "int oldVersion = foo.getVersion();\n"
 "session.load( foo, foo.getKey() ); // load the current state\n"
-"if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException"
-"();\n"
+"if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
 "foo.setProperty(\"bar\");\n"
 "\n"
 "t.commit();\n"
 "session.close();]]>"
 msgstr ""
-"// foo is an instance loaded by a previous Session\n"
+"<![CDATA[// foo is an instance loaded by a previous Session\n"
 "session = factory.openSession();\n"
 "Transaction t = session.beginTransaction();\n"
 "\n"
 "int oldVersion = foo.getVersion();\n"
 "session.load( foo, foo.getKey() ); // load the current state\n"
-"if ( oldVersion!=foo.getVersion ) throw new StaleObjectStateException();\n"
+"if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
 "foo.setProperty(\"bar\");\n"
 "\n"
 "t.commit();\n"
-"session.close();"
+"session.close();]]>"
 
 #. Tag: para
 #: transactions.xml:690
 #, no-c-format
-msgid ""
-"The <literal>version</literal> property is mapped using <literal>&lt;"
-"version&gt;</literal>, and Hibernate will automatically increment it during "
-"flush if the entity is dirty."
-msgstr ""
-"<literal>version</literal> 属性使用 <literal>&lt;version&gt;</literal> æ¥æ˜ "
-"射，如果对象是脏数据，在同步的时候，Hibernate ä¼šè‡ªåŠ¨å¢žåŠ ç‰ˆæœ¬å·ã€‚"
+msgid "The <literal>version</literal> property is mapped using <literal>&lt;version&gt;</literal>, and Hibernate will automatically increment it during flush if the entity is dirty."
+msgstr "<literal>version</literal> 属性使用 <literal>&lt;version&gt;</literal> æ¥æ˜ å°„ï¼Œå¦‚æžœå¯¹è±¡æ˜¯è„æ•°æ®ï¼Œåœ¨åŒæ­¥çš„æ—¶å€™ï¼ŒHibernate ä¼šè‡ªåŠ¨å¢žåŠ ç‰ˆæœ¬å·ã€‚"
 
 #. Tag: para
 #: transactions.xml:696
-#, fuzzy, no-c-format
-msgid ""
-"If you are operating in a low-data-concurrency environment, and do not "
-"require version checking, you can use this approach and skip the version "
-"check. In this case, <emphasis>last commit wins</emphasis> is the default "
-"strategy for long conversations. Be aware that this might confuse the users "
-"of the application, as they might experience lost updates without error "
-"messages or a chance to merge conflicting changes."
-msgstr ""
-"å½“ç„¶ï¼Œå¦‚æžœä½ çš„åº”ç”¨æ˜¯åœ¨ä¸€ä¸ªä½Žæ•°æ®å¹¶å‘çŽ¯å¢ƒä¸‹ï¼Œå¹¶ä¸éœ€è¦ç‰ˆæœ¬æ£€æŸ¥çš„è¯ï¼Œä½ ç…§æ ·å¯ä»¥"
-"使用这种方式，只不过跳过版本检查就是了。在这种情况下，<emphasis>最晚提交生效"
-"</emphasis> （<emphasis>last commit wins</emphasis>ï¼‰å°±æ˜¯ä½ çš„é•¿å¯¹è¯çš„é»˜è®¤å¤„ç†"
-"ç­–ç•¥ã€‚è¯·è®°ä½è¿™ç§ç­–ç•¥å¯èƒ½ä¼šè®©åº”ç”¨è½¯ä»¶çš„ç”¨æˆ·æ„Ÿåˆ°å›°æƒ‘ï¼Œå› ä¸ºä»–ä»¬æœ‰å¯èƒ½ä¼šç¢°ä¸Šæ›´æ–°"
-"丢失掉却没有出错信息，或者需要合并更改冲突的情况。"
+#, no-c-format
+msgid "If you are operating in a low-data-concurrency environment, and do not require version checking, you can use this approach and skip the version check. In this case, <emphasis>last commit wins</emphasis> is the default strategy for long conversations. Be aware that this might confuse the users of the application, as they might experience lost updates without error messages or a chance to merge conflicting changes."
+msgstr "å½“ç„¶ï¼Œå¦‚æžœä½ çš„åº”ç”¨æ˜¯åœ¨ä¸€ä¸ªä½Žæ•°æ®å¹¶å‘çŽ¯å¢ƒä¸‹ï¼Œå¹¶ä¸éœ€è¦ç‰ˆæœ¬æ£€æŸ¥çš„è¯ï¼Œä½ ç…§æ ·å¯ä»¥ä½¿ç”¨è¿™ç§æ–¹å¼ï¼Œåªä¸è¿‡è·³è¿‡ç‰ˆæœ¬æ£€æŸ¥å°±æ˜¯äº†ã€‚åœ¨è¿™ç§æƒ…å†µä¸‹ï¼Œ<emphasis>最晚提交生效</emphasis> （<emphasis>last commit wins</emphasis>ï¼‰å°±æ˜¯ä½ çš„é•¿å¯¹è¯çš„é»˜è®¤å¤„ç†ç­–ç•¥ã€‚è¯·è®°ä½è¿™ç§ç­–ç•¥å¯èƒ½ä¼šè®©åº”ç”¨è½¯ä»¶çš„ç”¨æˆ·æ„Ÿåˆ°å›°æƒ‘ï¼Œå› ä¸ºä»–ä»¬æœ‰å¯èƒ½ä¼šç¢°ä¸Šæ›´æ–°ä¸¢å¤±æŽ‰å´æ²¡æœ‰å‡ºé”™ä¿¡æ¯ï¼Œæˆ–è€…éœ€è¦åˆå¹¶æ›´æ”¹å†²çªçš„æƒ…å†µã€‚ "
 
 #. Tag: para
 #: transactions.xml:705
-#, fuzzy, no-c-format
-msgid ""
-"Manual version checking is only feasible in trivial circumstances and not "
-"practical for most applications. Often not only single instances, but "
-"complete graphs of modified objects, have to be checked. Hibernate offers "
-"automatic version checking with either an extended <literal>Session</"
-"literal> or detached instances as the design paradigm."
-msgstr ""
-"很明显，手工进行版本检查只适合于某些软件规模非常小的应用场景，对于大多数软件"
-"应用场景来说并不现实。通常情况下，不仅是单个对象实例需要进行版本检查，整个被"
-"ä¿®æ”¹è¿‡çš„å…³è”å¯¹è±¡å›¾ä¹Ÿéƒ½éœ€è¦è¿›è¡Œç‰ˆæœ¬æ£€æŸ¥ã€‚ä½œä¸ºæ ‡å‡†è®¾è®¡èŒƒä¾‹ï¼ŒHibernate 使用扩展"
-"周期的 <literal>Session</literal> 的方式，或者脱管对象实例的方式来提供自动版"
-"本检查。"
+#, no-c-format
+msgid "Manual version checking is only feasible in trivial circumstances and not practical for most applications. Often not only single instances, but complete graphs of modified objects, have to be checked. Hibernate offers automatic version checking with either an extended <literal>Session</literal> or detached instances as the design paradigm."
+msgstr "å¾ˆæ˜Žæ˜¾ï¼Œæ‰‹å·¥è¿›è¡Œç‰ˆæœ¬æ£€æŸ¥åªé€‚åˆäºŽæŸäº›è½¯ä»¶è§„æ¨¡éžå¸¸å°çš„åº”ç”¨åœºæ™¯ï¼Œå¯¹äºŽå¤§å¤šæ•°è½¯ä»¶åº”ç”¨åœºæ™¯æ¥è¯´å¹¶ä¸çŽ°å®žã€‚é€šå¸¸æƒ…å†µä¸‹ï¼Œä¸ä»…æ˜¯å•ä¸ªå¯¹è±¡å®žä¾‹éœ€è¦è¿›è¡Œç‰ˆæœ¬æ£€æŸ¥ï¼Œæ•´ä¸ªè¢«ä¿®æ”¹è¿‡çš„å…³è”å¯¹è±¡å›¾ä¹Ÿéƒ½éœ€è¦è¿›è¡Œç‰ˆæœ¬æ£€æŸ¥ã€‚ä½œä¸ºæ ‡å‡†è®¾è®¡èŒƒä¾‹ï¼ŒHibernate 使用扩展周期的 <literal>Session</literal> 的方式，或者脱管对象实例的方式来提供自动版本检查。 "
 
 #. Tag: title
 #: transactions.xml:716
@@ -1457,43 +778,22 @@
 
 #. Tag: para
 #: transactions.xml:718
-#, fuzzy, no-c-format
-msgid ""
-"A single <literal>Session</literal> instance and its persistent instances "
-"that are used for the whole conversation are known as <emphasis>session-per-"
-"conversation</emphasis>. Hibernate checks instance versions at flush time, "
-"throwing an exception if concurrent modification is detected. It is up to "
-"the developer to catch and handle this exception. Common options are the "
-"opportunity for the user to merge changes or to restart the business "
-"conversation with non-stale data."
-msgstr ""
-"单个 <literal>Session</literal> 实例和它所关联的所有持久化对象实例都被用于整"
-"个对话，这被称为 <emphasis>session-per-conversation</emphasis>。Hibernate 在"
-"同步的时候进行对象实例的版本检查，如果检测到并发修改则抛出异常。由开发人员来"
-"决定是否需要捕获和处理这个异常（通常的抉择是给用户 æä¾›ä¸€ä¸ªåˆå¹¶æ›´æ”¹ï¼Œæˆ–è€…åœ¨æ— "
-"脏数据情况下重新进行业务对话的机会）。"
+#, no-c-format
+msgid "A single <literal>Session</literal> instance and its persistent instances that are used for the whole conversation are known as <emphasis>session-per-conversation</emphasis>. Hibernate checks instance versions at flush time, throwing an exception if concurrent modification is detected. It is up to the developer to catch and handle this exception. Common options are the opportunity for the user to merge changes or to restart the business conversation with non-stale data."
+msgstr "单个 <literal>Session</literal> 实例和它所关联的所有持久化对象实例都被用于整个对话，这被称为 <emphasis>session-per-conversation</emphasis>。Hibernate 在同步的时候进行对象实例的版本检查，如果检测到并发修改则抛出异常。由开发人员来决定是否需要捕获和处理这个异常（通常的抉择是给用户 æä¾›ä¸€ä¸ªåˆå¹¶æ›´æ”¹ï¼Œæˆ–è€…åœ¨æ— è„æ•°æ®æƒ…å†µä¸‹é‡æ–°è¿›è¡Œä¸šåŠ¡å¯¹è¯çš„æœºä¼šï¼‰ã€‚ "
 
 #. Tag: para
 #: transactions.xml:727
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>Session</literal> is disconnected from any underlying JDBC "
-"connection when waiting for user interaction. This approach is the most "
-"efficient in terms of database access. The application does not version "
-"check or reattach detached instances, nor does it have to reload instances "
-"in every database transaction."
-msgstr ""
-"在等待用户交互的时候， <literal>Session</literal> 断开底层的 JDBC 连接。这种"
-"方式以数据库访问的角度来说是最高效的方式。应用程序不需要关心版本检查或脱管对"
-"象实例的重新关联，在每个数据库事务中，应用程序也不需要载入读取对象实例。"
+#, no-c-format
+msgid "The <literal>Session</literal> is disconnected from any underlying JDBC connection when waiting for user interaction. This approach is the most efficient in terms of database access. The application does not version check or reattach detached instances, nor does it have to reload instances in every database transaction."
+msgstr "在等待用户交互的时候， <literal>Session</literal> 断开底层的 JDBC 连接。这种方式以数据库访问的角度来说是最高效的方式。应用程序不需要关心版本检查或脱管对象实例的重新关联，在每个数据库事务中，应用程序也不需要载入读取对象实例。 "
 
 #. Tag: programlisting
 #: transactions.xml:735
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[// foo is an instance loaded earlier by the old session\n"
-"Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, "
-"start transaction\n"
+"Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, start transaction\n"
 "\n"
 "foo.setProperty(\"bar\");\n"
 "\n"
@@ -1501,112 +801,50 @@
 "t.commit();         // Also return JDBC connection\n"
 "session.close();    // Only for last transaction in conversation]]>"
 msgstr ""
-"// foo is an instance loaded earlier by the old session\n"
-"Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, "
-"start transaction\n"
+"<![CDATA[// foo is an instance loaded earlier by the old session\n"
+"Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, start transaction\n"
 "\n"
 "foo.setProperty(\"bar\");\n"
 "\n"
 "session.flush();    // Only for last transaction in conversation\n"
 "t.commit();         // Also return JDBC connection\n"
-"session.close();    // Only for last transaction in conversation"
+"session.close();    // Only for last transaction in conversation]]>"
 
 #. Tag: para
 #: transactions.xml:736
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>foo</literal> object knows which <literal>Session</literal> it "
-"was loaded in. Beginning a new database transaction on an old session "
-"obtains a new connection and resumes the session. Committing a database "
-"transaction disconnects a session from the JDBC connection and returns the "
-"connection to the pool. After reconnection, to force a version check on data "
-"you are not updating, you can call <literal>Session.lock()</literal> with "
-"<literal>LockMode.READ</literal> on any objects that might have been updated "
-"by another transaction. You do not need to lock any data that you "
-"<emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode."
-"MANUAL</literal> on an extended <literal>Session</literal>, so that only the "
-"last database transaction cycle is allowed to actually persist all "
-"modifications made in this conversation. Only this last database transaction "
-"will include the <literal>flush()</literal> operation, and then "
-"<literal>close()</literal> the session to end the conversation."
-msgstr ""
-"<literal>foo</literal> 对象知道它是在哪个 <literal>Session</literal> 中被装入"
-"的。在一个旧 session 中开启一个新的数据库事务，会导致 session 获取一个新的连"
-"接，并恢复 session 的功能。将数据库事务提交，使得 session 从 JDBC 连接断开，"
-"å¹¶å°†æ­¤è¿žæŽ¥äº¤è¿˜ç»™è¿žæŽ¥æ± ã€‚åœ¨é‡æ–°è¿žæŽ¥ä¹‹åŽï¼Œè¦å¼ºåˆ¶å¯¹ä½ æ²¡æœ‰æ›´æ–°çš„æ•°æ®è¿›è¡Œä¸€æ¬¡ç‰ˆæœ¬"
-"æ£€æŸ¥ï¼Œä½ å¯ä»¥å¯¹æ‰€æœ‰å¯èƒ½è¢«å…¶ä»–äº‹åŠ¡ä¿®æ”¹è¿‡çš„å¯¹è±¡ï¼Œä½¿ç”¨å‚æ•° <literal>LockMode."
-"READ</literal> 来调用 <literal>Session.lock()</literal>ã€‚ä½ ä¸ç”¨ lock ä»»ä½•ä½ "
-"<emphasis>正在</emphasis>æ›´æ–°çš„æ•°æ®ã€‚ä¸€èˆ¬ä½ ä¼šåœ¨æ‰©å±•çš„ <literal>Session</"
-"literal> 上设置 <literal>FlushMode.NEVER</literal>ï¼Œå› æ­¤åªæœ‰æœ€åŽä¸€ä¸ªæ•°æ®åº“äº‹"
-"åŠ¡å¾ªçŽ¯æ‰ä¼šçœŸæ­£çš„æŠŠæ•´ä¸ªå¯¹è¯ä¸­å‘ç”Ÿçš„ä¿®æ”¹å‘é€åˆ°æ•°æ®åº“ã€‚å› æ­¤ï¼Œåªæœ‰è¿™æœ€åŽä¸€æ¬¡æ•°æ®"
-"库事务才会包含 <literal>flush()</literal> 操作，然后在整个对话结束后，还要 "
-"<literal>close()</literal> 这个 session。"
+#, no-c-format
+msgid "The <literal>foo</literal> object knows which <literal>Session</literal> it was loaded in. Beginning a new database transaction on an old session obtains a new connection and resumes the session. Committing a database transaction disconnects a session from the JDBC connection and returns the connection to the pool. After reconnection, to force a version check on data you are not updating, you can call <literal>Session.lock()</literal> with <literal>LockMode.READ</literal> on any objects that might have been updated by another transaction. You do not need to lock any data that you <emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode.MANUAL</literal> on an extended <literal>Session</literal>, so that only the last database transaction cycle is allowed to actually persist all modifications made in this conversation. Only this last database transaction will include the <literal>flush()</literal> operation, and then <literal>close()</literal> the se!
 ssion to end the conversation."
+msgstr "<literal>foo</literal> 对象知道它是在哪个 <literal>Session</literal> 中被装入的。在一个旧 session 中开启一个新的数据库事务，会导致 session 获取一个新的连接，并恢复 session 的功能。将数据库事务提交，使得 session 从 JDBC è¿žæŽ¥æ–­å¼€ï¼Œå¹¶å°†æ­¤è¿žæŽ¥äº¤è¿˜ç»™è¿žæŽ¥æ± ã€‚åœ¨é‡æ–°è¿žæŽ¥ä¹‹åŽï¼Œè¦å¼ºåˆ¶å¯¹ä½ æ²¡æœ‰æ›´æ–°çš„æ•°æ®è¿›è¡Œä¸€æ¬¡ç‰ˆæœ¬æ£€æŸ¥ï¼Œä½ å¯ä»¥å¯¹æ‰€æœ‰å¯èƒ½è¢«å…¶ä»–äº‹åŠ¡ä¿®æ”¹è¿‡çš„å¯¹è±¡ï¼Œä½¿ç”¨å‚æ•° <literal>LockMode.READ</literal> 来调用 <literal>Session.lock()</literal>ã€‚ä½ ä¸ç”¨ lock ä»»ä½•ä½ <emphasis>正在</emphasis>æ›´æ–°çš„æ•°æ®ã€‚ä¸€èˆ¬ä½ ä¼šåœ¨æ‰©å±•çš„ <literal>Session</literal> 上设置 <literal>FlushMode.NEVER</literal>ï¼Œå› æ­¤åªæœ‰æœ€åŽä¸€ä¸ªæ•°æ®åº“äº‹åŠ¡å¾ªçŽ¯æ‰ä¼šçœŸæ­£çš„æŠŠæ•´ä¸ªå¯¹è¯ä¸­å‘ç”Ÿçš„ä¿®æ”¹å‘é€åˆ°æ•°æ®åº“ã€‚å› æ­¤ï¼Œåªæœ‰è¿™æœ€åŽä¸€æ¬¡æ•°æ®åº“äº‹åŠ¡æ‰ä¼šåŒ…å« <literal>flush()</literal> 操作，然后在整个对话结束后ï¼!
 Œè¿˜è¦ <literal>close()</literal> 这个 session。 "
 
 #. Tag: para
 #: transactions.xml:751
-#, fuzzy, no-c-format
-msgid ""
-"This pattern is problematic if the <literal>Session</literal> is too big to "
-"be stored during user think time (for example, an <literal>HttpSession</"
-"literal> should be kept as small as possible). As the <literal>Session</"
-"literal> is also the first-level cache and contains all loaded objects, we "
-"can probably use this strategy only for a few request/response cycles. Use a "
-"<literal>Session</literal> only for a single conversation as it will soon "
-"have stale data."
-msgstr ""
-"如果在用户思考的过程中，<literal>Session</literal> å› ä¸ºå¤ªå¤§äº†è€Œä¸èƒ½ä¿å­˜ï¼Œé‚£ä¹ˆ"
-"这种模式是有问题的。举例来说，一个 <literal>HttpSession</literal> 应该尽可能"
-"的小。由于  <literal>Session</literal> 是一级缓存，并且保持了所有被载入过的对"
-"è±¡ï¼Œå› æ­¤æˆ‘ä»¬åªåº”è¯¥åœ¨é‚£äº›å°‘é‡çš„ request/response æƒ…å†µä¸‹ä½¿ç”¨è¿™ç§ç­–ç•¥ã€‚ä½ åº”è¯¥åª"
-"把一个 <literal>Session</literal> ç”¨äºŽå•ä¸ªå¯¹è¯ï¼Œå› ä¸ºå®ƒå¾ˆå¿«å°±ä¼šå‡ºçŽ°è„æ•°æ®ã€‚"
+#, no-c-format
+msgid "This pattern is problematic if the <literal>Session</literal> is too big to be stored during user think time (for example, an <literal>HttpSession</literal> should be kept as small as possible). As the <literal>Session</literal> is also the first-level cache and contains all loaded objects, we can probably use this strategy only for a few request/response cycles. Use a <literal>Session</literal> only for a single conversation as it will soon have stale data."
+msgstr "如果在用户思考的过程中，<literal>Session</literal> å› ä¸ºå¤ªå¤§äº†è€Œä¸èƒ½ä¿å­˜ï¼Œé‚£ä¹ˆè¿™ç§æ¨¡å¼æ˜¯æœ‰é—®é¢˜çš„ã€‚ä¸¾ä¾‹æ¥è¯´ï¼Œä¸€ä¸ª <literal>HttpSession</literal> 应该尽可能的小。由于  <literal>Session</literal> æ˜¯ä¸€çº§ç¼“å­˜ï¼Œå¹¶ä¸”ä¿æŒäº†æ‰€æœ‰è¢«è½½å…¥è¿‡çš„å¯¹è±¡ï¼Œå› æ­¤æˆ‘ä»¬åªåº”è¯¥åœ¨é‚£äº›å°‘é‡çš„ request/response æƒ…å†µä¸‹ä½¿ç”¨è¿™ç§ç­–ç•¥ã€‚ä½ åº”è¯¥åªæŠŠä¸€ä¸ª <literal>Session</literal> ç”¨äºŽå•ä¸ªå¯¹è¯ï¼Œå› ä¸ºå®ƒå¾ˆå¿«å°±ä¼šå‡ºçŽ°è„æ•°æ®ã€‚ "
 
 #. Tag: title
 #: transactions.xml:762
 #, no-c-format
 msgid "Note"
-msgstr ""
+msgstr "注意"
 
 #. Tag: para
 #: transactions.xml:763
-#, fuzzy, no-c-format
-msgid ""
-"Earlier versions of Hibernate required explicit disconnection and "
-"reconnection of a <literal>Session</literal>. These methods are deprecated, "
-"as beginning and ending a transaction has the same effect."
-msgstr ""
-"（注意，早期的 Hibernate 版本需要明确的对 <literal>Session</literal> 进行 "
-"disconnect å’Œ reconnectã€‚è¿™äº›æ–¹æ³•çŽ°åœ¨å·²ç»è¿‡æ—¶äº†ï¼Œæ‰“å¼€äº‹åŠ¡å’Œå…³é—­äº‹åŠ¡ä¼šèµ·åˆ°åŒæ ·"
-"的效果。）"
+#, no-c-format
+msgid "Earlier versions of Hibernate required explicit disconnection and reconnection of a <literal>Session</literal>. These methods are deprecated, as beginning and ending a transaction has the same effect."
+msgstr "注意，早期的 Hibernate 版本需要明确的对 <literal>Session</literal> 进行 disconnect å’Œ reconnectã€‚è¿™äº›æ–¹æ³•çŽ°åœ¨å·²ç»è¿‡æ—¶äº†ï¼Œæ‰“å¼€äº‹åŠ¡å’Œå…³é—­äº‹åŠ¡ä¼šèµ·åˆ°åŒæ ·çš„æ•ˆæžœã€‚"
 
 #. Tag: para
 #: transactions.xml:769
-#, fuzzy, no-c-format
-msgid ""
-"Keep the disconnected <literal>Session</literal> close to the persistence "
-"layer. Use an EJB stateful session bean to hold the <literal>Session</"
-"literal> in a three-tier environment. Do not transfer it to the web layer, "
-"or even serialize it to a separate tier, to store it in the "
-"<literal>HttpSession</literal>."
-msgstr ""
-"æ­¤å¤–ï¼Œä¹Ÿè¯·æ³¨æ„ï¼Œä½ åº”è¯¥è®©ä¸Žæ•°æ®åº“è¿žæŽ¥æ–­å¼€çš„ <literal>Session</literal> 对持久"
-"层保持关闭状态。换句话说，在三层环境中，使用有状态的 EJB session bean 来持 有"
-"<literal>Session</literal>， è€Œä¸è¦æŠŠå®ƒä¼ é€’åˆ° web 层（甚至把它序列化到一个单"
-"独的层），保存在 <literal>HttpSession</literal> 中。"
+#, no-c-format
+msgid "Keep the disconnected <literal>Session</literal> close to the persistence layer. Use an EJB stateful session bean to hold the <literal>Session</literal> in a three-tier environment. Do not transfer it to the web layer, or even serialize it to a separate tier, to store it in the <literal>HttpSession</literal>."
+msgstr "æ­¤å¤–ï¼Œä¹Ÿè¯·æ³¨æ„ï¼Œä½ åº”è¯¥è®©ä¸Žæ•°æ®åº“è¿žæŽ¥æ–­å¼€çš„ <literal>Session</literal> 对持久层保持关闭状态。换句话说，在三层环境中，使用有状态的 EJB session bean 来持 有<literal>Session</literal>， è€Œä¸è¦æŠŠå®ƒä¼ é€’åˆ° web 层（甚至把它序列化到一个单独的层），保存在 <literal>HttpSession</literal> 中。 "
 
 #. Tag: para
 #: transactions.xml:777
-#, fuzzy, no-c-format
-msgid ""
-"The extended session pattern, or <emphasis>session-per-conversation</"
-"emphasis>, is more difficult to implement with automatic current session "
-"context management. You need to supply your own implementation of the "
-"<literal>CurrentSessionContext</literal> for this. See the Hibernate Wiki "
-"for examples."
-msgstr ""
-"扩展 session 模式，或者被称为<emphasis>每次对话一个session（session-per-"
-"conversation）</emphasis>，自动管理当前 session ä¸Šä¸‹æ–‡è”ç”¨çš„æ—¶å€™ä¼šæ›´å›°éš¾ã€‚ä½ "
-"éœ€è¦æä¾›ä½ è‡ªå·±çš„ <literal>CurrentSessionContext</literal> 实现。请参阅 "
-"Hibernate Wiki 以获得示例。"
+#, no-c-format
+msgid "The extended session pattern, or <emphasis>session-per-conversation</emphasis>, is more difficult to implement with automatic current session context management. You need to supply your own implementation of the <literal>CurrentSessionContext</literal> for this. See the Hibernate Wiki for examples."
+msgstr "扩展 session 模式，或者被称为<emphasis>每次对话一个session（session-per-conversation）</emphasis>，自动管理当前 session ä¸Šä¸‹æ–‡è”ç”¨çš„æ—¶å€™ä¼šæ›´å›°éš¾ã€‚ä½ éœ€è¦æä¾›ä½ è‡ªå·±çš„ <literal>CurrentSessionContext</literal> 实现。请参阅 Hibernate Wiki 以获得示例。 "
 
 #. Tag: title
 #: transactions.xml:787
@@ -1617,66 +855,40 @@
 #. Tag: para
 #: transactions.xml:789
 #, no-c-format
-msgid ""
-"Each interaction with the persistent store occurs in a new <literal>Session</"
-"literal>. However, the same persistent instances are reused for each "
-"interaction with the database. The application manipulates the state of "
-"detached instances originally loaded in another <literal>Session</literal> "
-"and then reattaches them using <literal>Session.update()</literal>, "
-"<literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</"
-"literal>."
-msgstr ""
-"这种方式下，与持久化存储的每次交互都发生在一个新的 <literal>Session</"
-"literal> 中。然而，同一持久化对象实例可以在多次与数据库的交互中重用。应用程序"
-"操纵脱管对象实例 的状态，这个脱管对象实例最初是在另一个 <literal>Session</"
-"literal> 中载入的，然后调用 <literal>Session.update()</literal>，"
-"<literal>Session.saveOrUpdate()</literal>，或者  <literal>Session.merge()</"
-"literal> 来重新关联该对象实例。"
+msgid "Each interaction with the persistent store occurs in a new <literal>Session</literal>. However, the same persistent instances are reused for each interaction with the database. The application manipulates the state of detached instances originally loaded in another <literal>Session</literal> and then reattaches them using <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</literal>."
+msgstr "这种方式下，与持久化存储的每次交互都发生在一个新的 <literal>Session</literal> 中。然而，同一持久化对象实例可以在多次与数据库的交互中重用。应用程序操纵脱管对象实例 的状态，这个脱管对象实例最初是在另一个 <literal>Session</literal> 中载入的，然后调用 <literal>Session.update()</literal>，<literal>Session.saveOrUpdate()</literal>，或者  <literal>Session.merge()</literal> 来重新关联该对象实例。"
 
 #. Tag: programlisting
 #: transactions.xml:797
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[// foo is an instance loaded by a previous Session\n"
 "foo.setProperty(\"bar\");\n"
 "session = factory.openSession();\n"
 "Transaction t = session.beginTransaction();\n"
-"session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded "
-"already\n"
+"session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
 "t.commit();\n"
 "session.close();]]>"
 msgstr ""
-"// foo is an instance loaded by a previous Session\n"
+"<![CDATA[// foo is an instance loaded by a previous Session\n"
 "foo.setProperty(\"bar\");\n"
 "session = factory.openSession();\n"
 "Transaction t = session.beginTransaction();\n"
-"session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded "
-"already\n"
+"session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
 "t.commit();\n"
-"session.close();"
+"session.close();]]>"
 
 #. Tag: para
 #: transactions.xml:799
-#, fuzzy, no-c-format
-msgid ""
-"Again, Hibernate will check instance versions during flush, throwing an "
-"exception if conflicting updates occurred."
-msgstr ""
-"Hibernate 会再一次在同步的时候检查对象实例的版本，如果发生更新冲突，就抛出异"
-"常。"
+#, no-c-format
+msgid "Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occurred."
+msgstr "Hibernate 会再一次在同步的时候检查对象实例的版本，如果发生更新冲突，就抛出异常。 "
 
 #. Tag: para
 #: transactions.xml:804
-#, fuzzy, no-c-format
-msgid ""
-"You can also call <literal>lock()</literal> instead of <literal>update()</"
-"literal>, and use <literal>LockMode.READ</literal> (performing a version "
-"check and bypassing all caches) if you are sure that the object has not been "
-"modified."
-msgstr ""
-"å¦‚æžœä½ ç¡®ä¿¡å¯¹è±¡æ²¡æœ‰è¢«ä¿®æ”¹è¿‡ï¼Œä½ ä¹Ÿå¯ä»¥è°ƒç”¨ <literal>lock()</literal> 来设置  "
-"<literal>LockMode.READ</literal>（绕过所有的缓存，执行版本检查），从而取代  "
-"<literal>update()</literal> 操作。"
+#, no-c-format
+msgid "You can also call <literal>lock()</literal> instead of <literal>update()</literal>, and use <literal>LockMode.READ</literal> (performing a version check and bypassing all caches) if you are sure that the object has not been modified."
+msgstr "å¦‚æžœä½ ç¡®ä¿¡å¯¹è±¡æ²¡æœ‰è¢«ä¿®æ”¹è¿‡ï¼Œä½ ä¹Ÿå¯ä»¥è°ƒç”¨ <literal>lock()</literal> 来设置  <literal>LockMode.READ</literal>（绕过所有的缓存，执行版本检查），从而取代  <literal>update()</literal> 操作。 "
 
 #. Tag: title
 #: transactions.xml:813
@@ -1686,197 +898,93 @@
 
 #. Tag: para
 #: transactions.xml:815
-#, fuzzy, no-c-format
-msgid ""
-"You can disable Hibernate's automatic version increment for particular "
-"properties and collections by setting the <literal>optimistic-lock</literal> "
-"mapping attribute to <literal>false</literal>. Hibernate will then no longer "
-"increment versions if the property is dirty."
-msgstr ""
-"å¯¹äºŽç‰¹å®šçš„å±žæ€§å’Œé›†åˆï¼Œé€šè¿‡ä¸ºå®ƒä»¬è®¾ç½®æ˜ å°„å±žæ€§ <literal>optimistic-lock</"
-"literal> 的值为 <literal>false</literal>，来禁止 Hibernate çš„ç‰ˆæœ¬è‡ªåŠ¨å¢žåŠ ã€‚è¿™"
-"æ ·çš„è¯ï¼Œå¦‚æžœè¯¥å±žæ€§è„æ•°æ®ï¼ŒHibernate å°†ä¸å†å¢žåŠ ç‰ˆæœ¬å·ã€‚"
+#, no-c-format
+msgid "You can disable Hibernate's automatic version increment for particular properties and collections by setting the <literal>optimistic-lock</literal> mapping attribute to <literal>false</literal>. Hibernate will then no longer increment versions if the property is dirty."
+msgstr "å¯¹äºŽç‰¹å®šçš„å±žæ€§å’Œé›†åˆï¼Œé€šè¿‡ä¸ºå®ƒä»¬è®¾ç½®æ˜ å°„å±žæ€§ <literal>optimistic-lock</literal> 的值为 <literal>false</literal>，来禁止 Hibernate çš„ç‰ˆæœ¬è‡ªåŠ¨å¢žåŠ ã€‚è¿™æ ·çš„è¯ï¼Œå¦‚æžœè¯¥å±žæ€§è„æ•°æ®ï¼ŒHibernate å°†ä¸å†å¢žåŠ ç‰ˆæœ¬å·ã€‚ "
 
 #. Tag: para
 #: transactions.xml:822
-#, fuzzy, no-c-format
-msgid ""
-"Legacy database schemas are often static and cannot be modified. Or, other "
-"applications might access the same database and will not know how to handle "
-"version numbers or even timestamps. In both cases, versioning cannot rely on "
-"a particular column in a table. To force a version check with a comparison "
-"of the state of all fields in a row but without a version or timestamp "
-"property mapping, turn on <literal>optimistic-lock=\"all\"</literal> in the "
-"<literal>&lt;class&gt;</literal> mapping. This conceptually only works if "
-"Hibernate can compare the old and the new state (i.e., if you use a single "
-"long <literal>Session</literal> and not session-per-request-with-detached-"
-"objects)."
-msgstr ""
-"遗留系统的数据库 Schema 通常是静态的，不可修改的。或者，其他应用程序也可能访"
-"é—®åŒä¸€æ•°æ®åº“ï¼Œæ ¹æœ¬æ— æ³•å¾—çŸ¥å¦‚ä½•å¤„ç†ç‰ˆæœ¬å·ï¼Œç”šè‡³æ—¶é—´æˆ³ã€‚åœ¨ä»¥ä¸Šçš„æ‰€æœ‰åœºæ™¯ä¸­ï¼Œå®ž"
-"çŽ°ç‰ˆæœ¬åŒ–ä¸èƒ½ä¾é æ•°æ®åº“è¡¨çš„æŸä¸ªç‰¹å®šåˆ—ã€‚åœ¨ <literal>&lt;class&gt;</literal> çš„"
-"æ˜ å°„ä¸­è®¾ç½®  <literal>optimistic-lock=\"all\"</literal> 可以在没有版本或者时间"
-"æˆ³å±žæ€§æ˜ å°„çš„æƒ…å†µä¸‹å®žçŽ°ç‰ˆæœ¬æ£€æŸ¥ï¼Œæ­¤æ—¶ Hibernate 将比较一行记录的每个字段的状"
-"态。请注意，只有当 Hibernate 能够比较新旧状态的情况下，这种方式才能生效，也就"
-"æ˜¯è¯´ï¼Œä½ å¿…é¡»ä½¿ç”¨å•ä¸ªé•¿ç”Ÿå‘½å‘¨æœŸ <literal>Session</literal> 模式，而不能使用 "
-"session-per-request-with-detached-objects 模式。"
+#, no-c-format
+msgid "Legacy database schemas are often static and cannot be modified. Or, other applications might access the same database and will not know how to handle version numbers or even timestamps. In both cases, versioning cannot rely on a particular column in a table. To force a version check with a comparison of the state of all fields in a row but without a version or timestamp property mapping, turn on <literal>optimistic-lock=\"all\"</literal> in the <literal>&lt;class&gt;</literal> mapping. This conceptually only works if Hibernate can compare the old and the new state (i.e., if you use a single long <literal>Session</literal> and not session-per-request-with-detached-objects)."
+msgstr "遗留系统的数据库 Schema é€šå¸¸æ˜¯é™æ€çš„ï¼Œä¸å¯ä¿®æ”¹çš„ã€‚æˆ–è€…ï¼Œå…¶ä»–åº”ç”¨ç¨‹åºä¹Ÿå¯èƒ½è®¿é—®åŒä¸€æ•°æ®åº“ï¼Œæ ¹æœ¬æ— æ³•å¾—çŸ¥å¦‚ä½•å¤„ç†ç‰ˆæœ¬å·ï¼Œç”šè‡³æ—¶é—´æˆ³ã€‚åœ¨ä»¥ä¸Šçš„æ‰€æœ‰åœºæ™¯ä¸­ï¼Œå®žçŽ°ç‰ˆæœ¬åŒ–ä¸èƒ½ä¾é æ•°æ®åº“è¡¨çš„æŸä¸ªç‰¹å®šåˆ—ã€‚åœ¨ <literal>&lt;class&gt;</literal> çš„æ˜ å°„ä¸­è®¾ç½®  <literal>optimistic-lock=\"all\"</literal> å¯ä»¥åœ¨æ²¡æœ‰ç‰ˆæœ¬æˆ–è€…æ—¶é—´æˆ³å±žæ€§æ˜ å°„çš„æƒ…å†µä¸‹å®žçŽ°ç‰ˆæœ¬æ£€æŸ¥ï¼Œæ­¤æ—¶ Hibernate 将比较一行记录的每个字段的状态。请注意，只有当 Hibernate èƒ½å¤Ÿæ¯”è¾ƒæ–°æ—§çŠ¶æ€çš„æƒ…å†µä¸‹ï¼Œè¿™ç§æ–¹å¼æ‰èƒ½ç”Ÿæ•ˆï¼Œä¹Ÿå°±æ˜¯è¯´ï¼Œä½ å¿…é¡»ä½¿ç”¨å•ä¸ªé•¿ç”Ÿå‘½å‘¨æœŸ <literal>Session</literal> 模式，而不能使用 session-per-request-with-detached-objects 模式。 "
 
 #. Tag: para
 #: transactions.xml:834
-#, fuzzy, no-c-format
-msgid ""
-"Concurrent modification can be permitted in instances where the changes that "
-"have been made do not overlap. If you set <literal>optimistic-lock=\"dirty"
-"\"</literal> when mapping the <literal>&lt;class&gt;</literal>, Hibernate "
-"will only compare dirty fields during flush."
-msgstr ""
-"æœ‰äº›æƒ…å†µä¸‹ï¼Œåªè¦æ›´æ”¹ä¸å‘ç”Ÿäº¤é”™ï¼Œå¹¶å‘ä¿®æ”¹ä¹Ÿæ˜¯å…è®¸çš„ã€‚å½“ä½ åœ¨ <literal>&lt;"
-"class&gt;</literal> çš„æ˜ å°„ä¸­è®¾ç½® <literal>optimistic-lock=\"dirty\"</"
-"literal>，Hibernate 在同步的时候将只比较有脏数据的字段。"
+#, no-c-format
+msgid "Concurrent modification can be permitted in instances where the changes that have been made do not overlap. If you set <literal>optimistic-lock=\"dirty\"</literal> when mapping the <literal>&lt;class&gt;</literal>, Hibernate will only compare dirty fields during flush."
+msgstr "æœ‰äº›æƒ…å†µä¸‹ï¼Œåªè¦æ›´æ”¹ä¸å‘ç”Ÿäº¤é”™ï¼Œå¹¶å‘ä¿®æ”¹ä¹Ÿæ˜¯å…è®¸çš„ã€‚å½“ä½ åœ¨ <literal>&lt;class&gt;</literal> çš„æ˜ å°„ä¸­è®¾ç½® <literal>optimistic-lock=\"dirty\"</literal>，Hibernate 在同步的时候将只比较有脏数据的字段。 "
 
 #. Tag: para
 #: transactions.xml:840
-#, fuzzy, no-c-format
-msgid ""
-"In both cases, with dedicated version/timestamp columns or with a full/dirty "
-"field comparison, Hibernate uses a single <literal>UPDATE</literal> "
-"statement, with an appropriate <literal>WHERE</literal> clause, per entity "
-"to execute the version check and update the information. If you use "
-"transitive persistence to cascade reattachment to associated entities, "
-"Hibernate may execute unnecessary updates. This is usually not a problem, "
-"but <emphasis>on update</emphasis> triggers in the database might be "
-"executed even when no changes have been made to detached instances. You can "
-"customize this behavior by setting <literal>select-before-update=\"true\"</"
-"literal> in the <literal>&lt;class&gt;</literal> mapping, forcing Hibernate "
-"to <literal>SELECT</literal> the instance to ensure that changes did occur "
-"before updating the row."
-msgstr ""
-"在以上所有场景中，不管是专门设置一个版本/时间戳列，还是进行全部字段/脏数据字"
-"段比较，Hibernate 都会针对每个实体对象发送一条 <literal>UPDATE</literal>（带"
-"有相应的 <literal>WHERE</literal> 语句 ）的 SQL 语句来执行版本检查和数据更"
-"æ–°ã€‚å¦‚æžœä½ å¯¹å…³è”å®žä½“ è®¾ç½®çº§è”å…³ç³»ä½¿ç”¨ä¼ æ’­æ€§æŒä¹…åŒ–ï¼ˆtransitive persistence），"
-"那么 Hibernate 可能会执行不必 要的update语句。这通常不是个问题，但是数据库里"
-"面对 <emphasis>on update</emphasis> 点火 的触发器可能在脱管对象没有任何更改的"
-"æƒ…å†µä¸‹è¢«è§¦å‘ã€‚å› æ­¤ï¼Œä½ å¯ä»¥åœ¨ <literal>&lt;class&gt;</literal> çš„æ˜ å°„ä¸­ï¼Œé€šè¿‡"
-"设置<literal>select-before-update=\"true\"</literal> 来定制这一行为，强制 "
-"Hibernate  <literal>SELECT</literal> 这个对象实例，从而保证，在更新记录之前，"
-"对象的确是被修改过。"
+#, no-c-format
+msgid "In both cases, with dedicated version/timestamp columns or with a full/dirty field comparison, Hibernate uses a single <literal>UPDATE</literal> statement, with an appropriate <literal>WHERE</literal> clause, per entity to execute the version check and update the information. If you use transitive persistence to cascade reattachment to associated entities, Hibernate may execute unnecessary updates. This is usually not a problem, but <emphasis>on update</emphasis> triggers in the database might be executed even when no changes have been made to detached instances. You can customize this behavior by setting <literal>select-before-update=\"true\"</literal> in the <literal>&lt;class&gt;</literal> mapping, forcing Hibernate to <literal>SELECT</literal> the instance to ensure that changes did occur before updating the row."
+msgstr "在以上所有场景中，不管是专门设置一个版本/时间戳列，还是进行全部字段/脏数据字段比较，Hibernate 都会针对每个实体对象发送一条 <literal>UPDATE</literal>（带有相应的 <literal>WHERE</literal> 语句 ）的 SQL è¯­å¥æ¥æ‰§è¡Œç‰ˆæœ¬æ£€æŸ¥å’Œæ•°æ®æ›´æ–°ã€‚å¦‚æžœä½ å¯¹å…³è”å®žä½“ è®¾ç½®çº§è”å…³ç³»ä½¿ç”¨ä¼ æ’­æ€§æŒä¹…åŒ–ï¼ˆtransitive persistence），那么 Hibernate 可能会执行不必 要的update语句。这通常不是个问题，但是数据库里面对 <emphasis>on update</emphasis> 点火 çš„è§¦å‘å™¨å¯èƒ½åœ¨è„±ç®¡å¯¹è±¡æ²¡æœ‰ä»»ä½•æ›´æ”¹çš„æƒ…å†µä¸‹è¢«è§¦å‘ã€‚å› æ­¤ï¼Œä½ å¯ä»¥åœ¨ <literal>&lt;class&gt;</literal> çš„æ˜ å°„ä¸­ï¼Œé€šè¿‡è®¾ç½®<literal>select-before-update=\"true\"</literal> 来定制这一行为，强制 Hibernate  <literal>SELECT</literal> 这个对象实例，从而保证，在更新记录之前，对象的确是被修改过。 "
 
 #. Tag: title
 #: transactions.xml:858
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Pessimistic locking"
-msgstr "悲观锁定（Pessimistic Locking）"
+msgstr "悲观锁定（Pessimistic Locking） "
 
 #. Tag: para
 #: transactions.xml:860
-#, fuzzy, no-c-format
-msgid ""
-"It is not intended that users spend much time worrying about locking "
-"strategies. It is usually enough to specify an isolation level for the JDBC "
-"connections and then simply let the database do all the work. However, "
-"advanced users may wish to obtain exclusive pessimistic locks or re-obtain "
-"locks at the start of a new transaction."
-msgstr ""
-"用户其实并不需要花很多精力去担心锁定策略的问题。通常情况下，只要为 JDBC 连接"
-"指定一下隔离级别，然后让数据库去搞定一切就够了。然而，高级用户有时候希望进行"
-"一个排它的悲观锁定，或者在一个新的事务启动的时候，重新进行锁定。"
+#, no-c-format
+msgid "It is not intended that users spend much time worrying about locking strategies. It is usually enough to specify an isolation level for the JDBC connections and then simply let the database do all the work. However, advanced users may wish to obtain exclusive pessimistic locks or re-obtain locks at the start of a new transaction."
+msgstr "用户其实并不需要花很多精力去担心锁定策略的问题。通常情况下，只要为 JDBC 连接指定一下隔离级别，然后让数据库去搞定一切就够了。然而，高级用户有时候希望进行一个排它的悲观锁定，或者在一个新的事务启动的时候，重新进行锁定。 "
 
 #. Tag: para
 #: transactions.xml:867
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate will always use the locking mechanism of the database; it never "
-"lock objects in memory."
-msgstr "Hibernate 总是使用数据库的锁定机制，从不在内存中锁定对象！"
+#, no-c-format
+msgid "Hibernate will always use the locking mechanism of the database; it never lock objects in memory."
+msgstr "Hibernate 总是使用数据库的锁定机制，从不在内存中锁定对象。"
 
 #. Tag: para
 #: transactions.xml:872
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>LockMode</literal> class defines the different lock levels that "
-"can be acquired by Hibernate. A lock is obtained by the following mechanisms:"
-msgstr ""
-"类 <literal>LockMode</literal> 定义了 Hibernate 所需的不同的锁定级别。一个锁"
-"定可以通过以下的机制来设置:"
+#, no-c-format
+msgid "The <literal>LockMode</literal> class defines the different lock levels that can be acquired by Hibernate. A lock is obtained by the following mechanisms:"
+msgstr "类 <literal>LockMode</literal> 定义了 Hibernate 所需的不同的锁定级别。一个锁定可以通过以下的机制来设置："
 
 #. Tag: para
 #: transactions.xml:879
 #, no-c-format
-msgid ""
-"<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate "
-"updates or inserts a row."
-msgstr ""
-"当 Hibernate 更新或者插入一行记录的时候，锁定级别自动设置为 "
-"<literal>LockMode.WRITE</literal>。"
+msgid "<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate updates or inserts a row."
+msgstr "当 Hibernate 更新或者插入一行记录的时候，锁定级别自动设置为 <literal>LockMode.WRITE</literal>。"
 
 #. Tag: para
 #: transactions.xml:885
-#, fuzzy, no-c-format
-msgid ""
-"<literal>LockMode.UPGRADE</literal> can be acquired upon explicit user "
-"request using <literal>SELECT ... FOR UPDATE</literal> on databases which "
-"support that syntax."
-msgstr ""
-"当用户显式的使用数据库支持的 SQL æ ¼å¼ <literal>SELECT ... FOR UPDATE</"
-"literal> 发送 SQL 的时候，锁定级别设置为 <literal>LockMode.UPGRADE</"
-"literal>。"
+#, no-c-format
+msgid "<literal>LockMode.UPGRADE</literal> can be acquired upon explicit user request using <literal>SELECT ... FOR UPDATE</literal> on databases which support that syntax."
+msgstr "当用户显式的使用数据库支持的 SQL æ ¼å¼ <literal>SELECT ... FOR UPDATE</literal> 发送 SQL 的时候，锁定级别设置为 <literal>LockMode.UPGRADE</literal>。 "
 
 #. Tag: para
 #: transactions.xml:891
-#, fuzzy, no-c-format
-msgid ""
-"<literal>LockMode.UPGRADE_NOWAIT</literal> can be acquired upon explicit "
-"user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under "
-"Oracle."
-msgstr ""
-"当用户显式的使用 Oracle 数据库的 SQL 语句 <literal>SELECT ... FOR UPDATE "
-"NOWAIT</literal> 的时候，锁定级别设置 <literal>LockMode.UPGRADE_NOWAIT</"
-"literal>。"
+#, no-c-format
+msgid "<literal>LockMode.UPGRADE_NOWAIT</literal> can be acquired upon explicit user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under Oracle."
+msgstr "当用户显式的使用 Oracle 数据库的 SQL 语句 <literal>SELECT ... FOR UPDATE NOWAIT</literal> 的时候，锁定级别设置 <literal>LockMode.UPGRADE_NOWAIT</literal>。 "
 
 #. Tag: para
 #: transactions.xml:897
-#, fuzzy, no-c-format
-msgid ""
-"<literal>LockMode.READ</literal> is acquired automatically when Hibernate "
-"reads data under Repeatable Read or Serializable isolation level. It can be "
-"re-acquired by explicit user request."
-msgstr ""
-"当 Hibernate 在“可重复读”或者是“序列化”数据库隔离级别下读取数据的时候，锁定模"
-"式自动设置为 <literal>LockMode.READ</literal>。这种模式也可以通过用户显式指定"
-"进行设置。"
+#, no-c-format
+msgid "<literal>LockMode.READ</literal> is acquired automatically when Hibernate reads data under Repeatable Read or Serializable isolation level. It can be re-acquired by explicit user request."
+msgstr "当 Hibernate 在“可重复读”或者是“序列化”数据库隔离级别下读取数据的时候，锁定模式自动设置为 <literal>LockMode.READ</literal>。这种模式也可以通过用户显式指定进行设置。 "
 
 #. Tag: para
 #: transactions.xml:904
 #, no-c-format
-msgid ""
-"<literal>LockMode.NONE</literal> represents the absence of a lock. All "
-"objects switch to this lock mode at the end of a <literal>Transaction</"
-"literal>. Objects associated with the session via a call to <literal>update()"
-"</literal> or <literal>saveOrUpdate()</literal> also start out in this lock "
-"mode."
-msgstr ""
-"<literal>LockMode.NONE</literal> ä»£è¡¨æ— éœ€é”å®šã€‚åœ¨ <literal>Transaction</"
-"literal> 结束时， 所有的对象都切换到该模式上来。与 session 相关联的对象通过调"
-"用 <literal>update()</literal> 或者 <literal>saveOrUpdate()</literal> 脱离该"
-"模式。"
+msgid "<literal>LockMode.NONE</literal> represents the absence of a lock. All objects switch to this lock mode at the end of a <literal>Transaction</literal>. Objects associated with the session via a call to <literal>update()</literal> or <literal>saveOrUpdate()</literal> also start out in this lock mode."
+msgstr "<literal>LockMode.NONE</literal> ä»£è¡¨æ— éœ€é”å®šã€‚åœ¨ <literal>Transaction</literal> 结束时， 所有的对象都切换到该模式上来。与 session 相关联的对象通过调用 <literal>update()</literal> 或者 <literal>saveOrUpdate()</literal> 脱离该模式。"
 
 #. Tag: para
 #: transactions.xml:913
 #, no-c-format
-msgid ""
-"The \"explicit user request\" is expressed in one of the following ways:"
+msgid "The \"explicit user request\" is expressed in one of the following ways:"
 msgstr "\"显式的用户指定\"å¯ä»¥é€šè¿‡ä»¥ä¸‹å‡ ç§æ–¹å¼ä¹‹ä¸€æ¥è¡¨ç¤ºï¼š"
 
 #. Tag: para
 #: transactions.xml:919
 #, no-c-format
-msgid ""
-"A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</"
-"literal>."
-msgstr ""
-"调用 <literal>Session.load()</literal> 的时候指定<literal>锁定模式"
-"（LockMode）</literal>。"
+msgid "A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</literal>."
+msgstr "调用 <literal>Session.load()</literal> 的时候指定<literal>锁定模式（LockMode）</literal>。"
 
 #. Tag: para
 #: transactions.xml:924
@@ -1893,187 +1001,78 @@
 #. Tag: para
 #: transactions.xml:935
 #, no-c-format
-msgid ""
-"If <literal>Session.load()</literal> is called with <literal>UPGRADE</"
-"literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was "
-"not yet loaded by the session, the object is loaded using "
-"<literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is "
-"called for an object that is already loaded with a less restrictive lock "
-"than the one requested, Hibernate calls <literal>lock()</literal> for that "
-"object."
-msgstr ""
-"如果在 <literal>UPGRADE</literal> 或者 <literal>UPGRADE_NOWAIT</literal> 锁定"
-"模式下调用 <literal>Session.load()</literal>，并且要读取的对象尚未被 session "
-"载入过，那么对象通过 <literal>SELECT ... FOR UPDATE</literal> è¿™æ ·çš„ SQL 语句"
-"被载入。如果为一个对象调用  <literal>load()</literal> 方法时，该对象已经在另"
-"一个较少限制的锁定模式下被载入了，那么  Hibernate 就对该对象调用 "
-"<literal>lock()</literal> 方法。"
+msgid "If <literal>Session.load()</literal> is called with <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was not yet loaded by the session, the object is loaded using <literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is called for an object that is already loaded with a less restrictive lock than the one requested, Hibernate calls <literal>lock()</literal> for that object."
+msgstr "如果在 <literal>UPGRADE</literal> 或者 <literal>UPGRADE_NOWAIT</literal> 锁定模式下调用 <literal>Session.load()</literal>，并且要读取的对象尚未被 session 载入过，那么对象通过 <literal>SELECT ... FOR UPDATE</literal> è¿™æ ·çš„ SQL 语句被载入。如果为一个对象调用  <literal>load()</literal> 方法时，该对象已经在另一个较少限制的锁定模式下被载入了，那么  Hibernate 就对该对象调用 <literal>lock()</literal> 方法。"
 
 #. Tag: para
 #: transactions.xml:944
-#, fuzzy, no-c-format
-msgid ""
-"<literal>Session.lock()</literal> performs a version number check if the "
-"specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> "
-"or <literal>UPGRADE_NOWAIT</literal>. In the case of <literal>UPGRADE</"
-"literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR "
-"UPDATE</literal> is used."
-msgstr ""
-"如果指定的锁定模式是 <literal>READ</literal>，<literal>UPGRADE</literal> 或  "
-"<literal>UPGRADE_NOWAIT</literal>，那么 <literal>Session.lock()</literal> 就"
-"执行版本号检查。（在 <literal>UPGRADE</literal> 或者 "
-"<literal>UPGRADE_NOWAIT</literal> 锁定模式下，执行  <literal>SELECT ... FOR "
-"UPDATE</literal>è¿™æ ·çš„SQL语句。）"
+#, no-c-format
+msgid "<literal>Session.lock()</literal> performs a version number check if the specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>. In the case of <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR UPDATE</literal> is used."
+msgstr "如果指定的锁定模式是 <literal>READ</literal>，<literal>UPGRADE</literal> 或  <literal>UPGRADE_NOWAIT</literal>，那么 <literal>Session.lock()</literal> 就执行版本号检查。（在 <literal>UPGRADE</literal> 或者 <literal>UPGRADE_NOWAIT</literal> 锁定模式下，执行 <literal>SELECT ... FOR UPDATE</literal>è¿™æ ·çš„SQL语句。）"
 
 #. Tag: para
 #: transactions.xml:951
-#, fuzzy, no-c-format
-msgid ""
-"If the requested lock mode is not supported by the database, Hibernate uses "
-"an appropriate alternate mode instead of throwing an exception. This ensures "
-"that applications are portable."
-msgstr ""
-"如果数据库不支持用户设置的锁定模式，Hibernate 将使用适当的替代模式（而不是扔"
-"出异常）。这一点可以确保应用程序的可移植性。"
+#, no-c-format
+msgid "If the requested lock mode is not supported by the database, Hibernate uses an appropriate alternate mode instead of throwing an exception. This ensures that applications are portable."
+msgstr "如果数据库不支持用户设置的锁定模式，Hibernate 将使用适当的替代模式（而不是扔出异常）。这一点可以确保应用程序的可移植性。 "
 
 #. Tag: title
 #: transactions.xml:960
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Connection release modes"
-msgstr "连接释放模式（Connection Release Modes）"
+msgstr "连接释放模式（Connection Release Modes） "
 
 #. Tag: para
 #: transactions.xml:962
-#, fuzzy, no-c-format
-msgid ""
-"One of the legacies of Hibernate 2.x JDBC connection management meant that a "
-"<literal>Session</literal> would obtain a connection when it was first "
-"required and then maintain that connection until the session was closed. "
-"Hibernate 3.x introduced the notion of connection release modes that would "
-"instruct a session how to handle its JDBC connections. The following "
-"discussion is pertinent only to connections provided through a configured "
-"<literal>ConnectionProvider</literal>. User-supplied connections are outside "
-"the breadth of this discussion. The different release modes are identified "
-"by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</"
-"literal>:"
-msgstr ""
-"Hibernate 关于 JDBC 连接管理的旧（2.x）行为是，<literal>Session</literal> 在"
-"第一次需要的时候获取一个连接，在 session 关闭之前一直会持有这个连接。"
-"Hibernate 引入了连接释放的概念，来告诉 session 如何处理它的 JDBC 连接。注意，"
-"下面的讨论只适用于采用配置 <literal>ConnectionProvider</literal> 来提供连接的"
-"æƒ…å†µï¼Œç”¨æˆ·è‡ªå·±æä¾›çš„è¿žæŽ¥ä¸Žè¿™é‡Œçš„è®¨è®ºæ— å…³ã€‚é€šè¿‡ <literal>org.hibernate."
-"ConnectionReleaseMode</literal> 的不同枚举值来使用不用的释放模式:"
+#, no-c-format
+msgid "One of the legacies of Hibernate 2.x JDBC connection management meant that a <literal>Session</literal> would obtain a connection when it was first required and then maintain that connection until the session was closed. Hibernate 3.x introduced the notion of connection release modes that would instruct a session how to handle its JDBC connections. The following discussion is pertinent only to connections provided through a configured <literal>ConnectionProvider</literal>. User-supplied connections are outside the breadth of this discussion. The different release modes are identified by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</literal>:"
+msgstr "Hibernate 关于 JDBC 连接管理的旧（2.x）行为是，<literal>Session</literal> 在第一次需要的时候获取一个连接，在 session 关闭之前一直会持有这个连接。Hibernate 引入了连接释放的概念，来告诉 session 如何处理它的 JDBC 连接。注意，下面的讨论只适用于采用配置 <literal>ConnectionProvider</literal> æ¥æä¾›è¿žæŽ¥çš„æƒ…å†µï¼Œç”¨æˆ·è‡ªå·±æä¾›çš„è¿žæŽ¥ä¸Žè¿™é‡Œçš„è®¨è®ºæ— å…³ã€‚é€šè¿‡ <literal>org.hibernate.ConnectionReleaseMode</literal> 的不同枚举值来使用不用的释放模式："
 
 #. Tag: para
 #: transactions.xml:976
-#, fuzzy, no-c-format
-msgid ""
-"<literal>ON_CLOSE</literal>: is the legacy behavior described above. The "
-"Hibernate session obtains a connection when it first needs to perform some "
-"JDBC access and maintains that connection until the session is closed."
-msgstr ""
-"<literal>ON_CLOSE</literal> — 基本上就是上面提到的老式行为。Hibernate "
-"session 在第一次需要进行 JDBC 操作的时候获取连接，然后持有它，直到 session 关"
-"闭。"
+#, no-c-format
+msgid "<literal>ON_CLOSE</literal>: is the legacy behavior described above. The Hibernate session obtains a connection when it first needs to perform some JDBC access and maintains that connection until the session is closed."
+msgstr "<literal>ON_CLOSE</literal>：基本上就是上面提到的老式行为。Hibernate session 在第一次需要进行 JDBC 操作的时候获取连接，然后持有它，直到 session 关闭。"
 
 #. Tag: para
 #: transactions.xml:983
-#, fuzzy, no-c-format
-msgid ""
-"<literal>AFTER_TRANSACTION</literal>: releases connections after a "
-"<literal>org.hibernate.Transaction</literal> has been completed."
-msgstr ""
-"<literal>AFTER_TRANSACTION</literal> — 在 <literal>org.hibernate."
-"Transaction</literal> 结束后释放连接。"
+#, no-c-format
+msgid "<literal>AFTER_TRANSACTION</literal>: releases connections after a <literal>org.hibernate.Transaction</literal> has been completed."
+msgstr "<literal>AFTER_TRANSACTION</literal>：在 <literal>org.hibernate.Transaction</literal> 结束后释放连接。"
 
 #. Tag: para
 #: transactions.xml:989
-#, fuzzy, no-c-format
-msgid ""
-"<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release): "
-"releases connections after every statement execution. This aggressive "
-"releasing is skipped if that statement leaves open resources associated with "
-"the given session. Currently the only situation where this occurs is through "
-"the use of <literal>org.hibernate.ScrollableResults</literal>."
-msgstr ""
-"<literal>AFTER_STATEMENT</literal>（也被称做积极释放） — 在每一条语句被执行后"
-"就释放连接。但假若语句留下了与 session 相关的资源，那就不会被释放。目前唯一的"
-"这种情形就是使用 <literal>org.hibernate.ScrollableResults</literal>。"
+#, no-c-format
+msgid "<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release): releases connections after every statement execution. This aggressive releasing is skipped if that statement leaves open resources associated with the given session. Currently the only situation where this occurs is through the use of <literal>org.hibernate.ScrollableResults</literal>."
+msgstr "<literal>AFTER_STATEMENT</literal>（也被称做积极释放）：在每一条语句被执行后就释放连接。但假若语句留下了与 session 相关的资源，那就不会被释放。目前唯一的这种情形就是使用 <literal>org.hibernate.ScrollableResults</literal>。"
 
 #. Tag: para
 #: transactions.xml:999
-#, fuzzy, no-c-format
-msgid ""
-"The configuration parameter <literal>hibernate.connection.release_mode</"
-"literal> is used to specify which release mode to use. The possible values "
-"are as follows:"
-msgstr ""
-"<literal>hibernate.connection.release_mode</literal> 配置参数用来指定使用哪一"
-"种释放模式。可能的值有："
+#, no-c-format
+msgid "The configuration parameter <literal>hibernate.connection.release_mode</literal> is used to specify which release mode to use. The possible values are as follows:"
+msgstr "<literal>hibernate.connection.release_mode</literal> 配置参数用来指定使用哪一种释放模式。可能的值有： "
 
 #. Tag: para
 #: transactions.xml:1006
-#, fuzzy, no-c-format
-msgid ""
-"<literal>auto</literal> (the default): this choice delegates to the release "
-"mode returned by the <literal>org.hibernate.transaction.TransactionFactory."
-"getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this "
-"returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, "
-"this returns ConnectionReleaseMode.AFTER_TRANSACTION. Do not change this "
-"default behavior as failures due to the value of this setting tend to "
-"indicate bugs and/or invalid assumptions in user code."
-msgstr ""
-"<literal>auto</literal>（默认） — 这一选择把释放模式委派给 <literal>org."
-"hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> æ–¹"
-"法。对 JTATransactionFactory 来说，它会返回 ConnectionReleaseMode."
-"AFTER_STATEMENT；对　JDBCTransactionFactory　来说，则是　"
-"ConnectionReleaseMode.AFTER_TRANSACTIONã€‚å¾ˆå°‘éœ€è¦ä¿®æ”¹è¿™ä¸€é»˜è®¤è¡Œä¸ºï¼Œå› ä¸ºå‡è‹¥è®¾"
-"置不当，就会带来　bugï¼Œæˆ–è€…ç»™ç”¨æˆ·ä»£ç å¸¦æ¥è¯¯å¯¼ã€‚"
+#, no-c-format
+msgid "<literal>auto</literal> (the default): this choice delegates to the release mode returned by the <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, this returns ConnectionReleaseMode.AFTER_TRANSACTION. Do not change this default behavior as failures due to the value of this setting tend to indicate bugs and/or invalid assumptions in user code."
+msgstr "<literal>auto</literal>（默认）：这一选择把释放模式委派给 <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> 方法。对 JTATransactionFactory 来说，它会返回 ConnectionReleaseMode.AFTER_STATEMENT；对　JDBCTransactionFactory　来说，则是ConnectionReleaseMode.AFTER_TRANSACTIONã€‚å¾ˆå°‘éœ€è¦ä¿®æ”¹è¿™ä¸€é»˜è®¤è¡Œä¸ºï¼Œå› ä¸ºå‡è‹¥è®¾ç½®ä¸å½“ï¼Œå°±ä¼šå¸¦æ¥ bugï¼Œæˆ–è€…ç»™ç”¨æˆ·ä»£ç å¸¦æ¥è¯¯å¯¼ã€‚"
 
 #. Tag: para
 #: transactions.xml:1016
-#, fuzzy, no-c-format
-msgid ""
-"<literal>on_close</literal>: uses ConnectionReleaseMode.ON_CLOSE. This "
-"setting is left for backwards compatibility, but its use is discouraged."
-msgstr ""
-"<literal>on_close</literal> — 使用 ConnectionReleaseMode.ON_CLOSE。这种方式是"
-"为了向下兼容的,但是已经完全不被鼓励使用了。"
+#, no-c-format
+msgid "<literal>on_close</literal>: uses ConnectionReleaseMode.ON_CLOSE. This setting is left for backwards compatibility, but its use is discouraged."
+msgstr "<literal>on_close</literal>：使用 ConnectionReleaseMode.ON_CLOSE。这种方式是为了向下兼容的,但是已经完全不被鼓励使用了。"
 
 #. Tag: para
 #: transactions.xml:1022
-#, fuzzy, no-c-format
-msgid ""
-"<literal>after_transaction</literal>: uses ConnectionReleaseMode."
-"AFTER_TRANSACTION. This setting should not be used in JTA environments. Also "
-"note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is "
-"considered to be in auto-commit mode, connections will be released as if the "
-"release mode were AFTER_STATEMENT."
-msgstr ""
-"<literal>after_transaction</literal> — 使用 ConnectionReleaseMode."
-"AFTER_TRANSACTION。这一设置不应该在 JTA 环境下使用。也要注意，使用 "
-"ConnectionReleaseMode.AFTER_TRANSACTION 的时候，假若session 处于 auto-commit "
-"状态，连接会像 AFTER_STATEMENT é‚£æ ·è¢«é‡Šæ”¾ã€‚"
+#, no-c-format
+msgid "<literal>after_transaction</literal>: uses ConnectionReleaseMode.AFTER_TRANSACTION. This setting should not be used in JTA environments. Also note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is considered to be in auto-commit mode, connections will be released as if the release mode were AFTER_STATEMENT."
+msgstr "<literal>after_transaction</literal>：使用 ConnectionReleaseMode.AFTER_TRANSACTION。这一设置不应该在 JTA 环境下使用。也要注意，使用 ConnectionReleaseMode.AFTER_TRANSACTION 的时候，假若session 处于 auto-commit 状态，连接会像 AFTER_STATEMENT é‚£æ ·è¢«é‡Šæ”¾ã€‚"
 
 #. Tag: para
 #: transactions.xml:1030
-#, fuzzy, no-c-format
-msgid ""
-"<literal>after_statement</literal>: uses ConnectionReleaseMode."
-"AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</"
-"literal> is consulted to see if it supports this setting "
-"(<literal>supportsAggressiveRelease()</literal>). If not, the release mode "
-"is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only "
-"safe in environments where we can either re-acquire the same underlying JDBC "
-"connection each time you make a call into <literal>ConnectionProvider."
-"getConnection()</literal> or in auto-commit environments where it does not "
-"matter if we re-establish the same connection."
-msgstr ""
-"<literal>after_statement</literal> — 使用 ConnectionReleaseMode."
-"AFTER_STATEMENT。除此之外，会查询配置的 <literal>ConnectionProvider</"
-"literal>，是否它支持这一设置（<literal>supportsAggressiveRelease()</"
-"literal>）。假若不支持，释放模式会被设置为  ConnectionReleaseMode."
-"AFTER_TRANSACTIONã€‚åªæœ‰åœ¨ä½ æ¯æ¬¡è°ƒç”¨  <literal>ConnectionProvider."
-"getConnection()</literal> 获取底层 JDBC 连接的时候，都可以确信获得同一个连接"
-"的时候，这一设置才是安全的；或者在 auto-commit çŽ¯å¢ƒä¸­ï¼Œä½ å¯ä»¥ä¸ç®¡æ˜¯å¦æ¯æ¬¡éƒ½èŽ·"
-"得同一个连接的时候，这才是安全的。"
+#, no-c-format
+msgid "<literal>after_statement</literal>: uses ConnectionReleaseMode.AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</literal> is consulted to see if it supports this setting (<literal>supportsAggressiveRelease()</literal>). If not, the release mode is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only safe in environments where we can either re-acquire the same underlying JDBC connection each time you make a call into <literal>ConnectionProvider.getConnection()</literal> or in auto-commit environments where it does not matter if we re-establish the same connection."
+msgstr "<literal>after_statement</literal>：使用 ConnectionReleaseMode.AFTER_STATEMENT。除此之外，会查询配置的 <literal>ConnectionProvider</literal>，是否它支持这一设置（<literal>supportsAggressiveRelease()</literal>）。假若不支持，释放模式会被设置为  ConnectionReleaseMode.AFTER_TRANSACTIONã€‚åªæœ‰åœ¨ä½ æ¯æ¬¡è°ƒç”¨  <literal>ConnectionProvider.getConnection()</literal> 获取底层 JDBC 连接的时候，都可以确信获得同一个连接的时候，这一设置才是安全的；或者在 auto-commit çŽ¯å¢ƒä¸­ï¼Œä½ å¯ä»¥ä¸ç®¡æ˜¯å¦æ¯æ¬¡éƒ½èŽ·å¾—åŒä¸€ä¸ªè¿žæŽ¥çš„æ—¶å€™ï¼Œè¿™æ‰æ˜¯å®‰å…¨çš„ã€‚"
+

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-11-27 03:48:07 UTC (rev 97059)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/xml.po	2009-11-27 04:12:59 UTC (rev 97060)
@@ -6,7 +6,7 @@
 "Project-Id-Version: Collection_Mapping\n"
 "Report-Msgid-Bugs-To: http://bugs.kde.org\n"
 "POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-11-27 13:57+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -22,11 +22,9 @@
 
 #. Tag: emphasis
 #: xml.xml:31
-#, fuzzy, no-c-format
-msgid ""
-"XML Mapping is an experimental feature in Hibernate 3.0 and is currently "
-"under active development."
-msgstr "注意这是 Hibernate 3.0 的一个实验性的特性。这一特性仍在积极开发中。"
+#, no-c-format
+msgid "XML Mapping is an experimental feature in Hibernate 3.0 and is currently under active development."
+msgstr "注意 XML æ˜ å°„åªæ˜¯ Hibernate 3.0 的一个实验性的特性。这一特性仍在积极开发中。"
 
 #. Tag: title
 #: xml.xml:37
@@ -36,55 +34,27 @@
 
 #. Tag: para
 #: xml.xml:39
-#, fuzzy, 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 的另外一种在对象层面上表示关系型数"
-"据的途径."
+#, 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 的另外一种在对象层面上表示关系型数据的途径。"
 
 #. Tag: para
 #: xml.xml:46
 #, 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
 #: xml.xml:56
 #, 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
 #: xml.xml:61
-#, fuzzy, 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 文档。"
+#, 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 文档。 "
 
 #. Tag: title
 #: xml.xml:68
@@ -100,7 +70,7 @@
 
 #. Tag: programlisting
 #: xml.xml:74
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[<class name=\"Account\" \n"
 "        table=\"ACCOUNTS\" \n"
@@ -123,26 +93,26 @@
 "    \n"
 "</class>]]>"
 msgstr ""
-"&lt;class name=\"Account\" \n"
+"<![CDATA[<class name=\"Account\" \n"
 "        table=\"ACCOUNTS\" \n"
-"        node=\"account\"&gt;\n"
+"        node=\"account\">\n"
 "        \n"
-"    &lt;id name=\"accountId\" \n"
+"    <id name=\"accountId\" \n"
 "            column=\"ACCOUNT_ID\" \n"
-"            node=\"@id\"/&gt;\n"
+"            node=\"@id\"/>\n"
 "            \n"
-"    &lt;many-to-one name=\"customer\" \n"
+"    <many-to-one name=\"customer\" \n"
 "            column=\"CUSTOMER_ID\" \n"
 "            node=\"customer/@id\" \n"
-"            embed-xml=\"false\"/&gt;\n"
+"            embed-xml=\"false\"/>\n"
 "            \n"
-"    &lt;property name=\"balance\" \n"
+"    <property name=\"balance\" \n"
 "            column=\"BALANCE\" \n"
-"            node=\"balance\"/&gt;\n"
+"            node=\"balance\"/>\n"
 "            \n"
 "    ...\n"
 "    \n"
-"&lt;/class&gt;"
+"</class>]]>"
 
 #. Tag: title
 #: xml.xml:78
@@ -158,7 +128,7 @@
 
 #. Tag: programlisting
 #: xml.xml:84
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[<class entity-name=\"Account\" \n"
 "        table=\"ACCOUNTS\" \n"
@@ -184,41 +154,35 @@
 "    \n"
 "</class>]]>"
 msgstr ""
-"&lt;class entity-name=\"Account\" \n"
+"<![CDATA[<class entity-name=\"Account\" \n"
 "        table=\"ACCOUNTS\" \n"
-"        node=\"account\"&gt;\n"
+"        node=\"account\">\n"
 "        \n"
-"    &lt;id name=\"id\" \n"
+"    <id name=\"id\" \n"
 "            column=\"ACCOUNT_ID\" \n"
 "            node=\"@id\" \n"
-"            type=\"string\"/&gt;\n"
+"            type=\"string\"/>\n"
 "            \n"
-"    &lt;many-to-one name=\"customerId\" \n"
+"    <many-to-one name=\"customerId\" \n"
 "            column=\"CUSTOMER_ID\" \n"
 "            node=\"customer/@id\" \n"
 "            embed-xml=\"false\" \n"
-"            entity-name=\"Customer\"/&gt;\n"
+"            entity-name=\"Customer\"/>\n"
 "            \n"
-"    &lt;property name=\"balance\" \n"
+"    <property name=\"balance\" \n"
 "            column=\"BALANCE\" \n"
 "            node=\"balance\" \n"
-"            type=\"big_decimal\"/&gt;\n"
+"            type=\"big_decimal\"/>\n"
 "            \n"
 "    ...\n"
 "    \n"
-"&lt;/class&gt;"
+"</class>]]>"
 
 #. Tag: para
 #: xml.xml:86
-#, fuzzy, 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>sï¼‰ç»„æˆçš„å›¾é‚£æ ·è®¿é—®ã€‚å±žæ€§åå­—çº¯ç²¹æ˜¯é€»è¾‘ä¸Šçš„ç»“"
-"æž„ï¼Œä½ å¯ä»¥åœ¨ HQL 查询中引用它。"
+#, 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 查询中引用它。"
 
 #. Tag: title
 #: xml.xml:97
@@ -228,77 +192,49 @@
 
 #. Tag: para
 #: xml.xml:99
-#, fuzzy, 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> 属性必须是下列"
-"æ ¼å¼ä¹‹ä¸€ï¼š"
+#, 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> å±žæ€§å¿…é¡»æ˜¯ä¸‹åˆ—æ ¼å¼ä¹‹ä¸€ï¼š "
 
 #. Tag: para
 #: xml.xml:108
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>\"element-name\"</literal>: map to the named XML element"
-msgstr "<literal>\"element-name\"</literal> — æ˜ å°„ä¸ºæŒ‡å®šçš„ XML å…ƒç´ "
+msgstr "<literal>\"element-name\"</literal>ï¼šæ˜ å°„ä¸ºæŒ‡å®šçš„ XML å…ƒç´ "
 
 #. Tag: para
 #: xml.xml:111
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>\"@attribute-name\"</literal>: map to the named XML attribute"
-msgstr "<literal>\"@attribute-name\"</literal> — æ˜ å°„ä¸ºæŒ‡å®šçš„ XML 属性"
+msgstr "<literal>\"@attribute-name\"</literal>ï¼šæ˜ å°„ä¸ºæŒ‡å®šçš„ XML 属性"
 
 #. Tag: para
 #: xml.xml:114
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>\".\"</literal>: map to the parent element"
-msgstr "<literal>\".\"</literal> — æ˜ å°„ä¸ºçˆ¶å…ƒç´ "
+msgstr "<literal>\".\"</literal>ï¼šæ˜ å°„ä¸ºçˆ¶å…ƒç´ "
 
 #. Tag: para
 #: xml.xml:117
-#, fuzzy, 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> — æ˜ å°„ä¸ºæŒ‡å®šå…ƒç´ çš„æŒ‡å®šå±ž"
-"性"
+#, 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>ï¼šæ˜ å°„ä¸ºæŒ‡å®šå…ƒç´ çš„æŒ‡å®šå±žæ€§"
 
 #. Tag: para
 #: xml.xml:124
-#, fuzzy, 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 æ ‘"
-"ä¸­ï¼ˆè¢«å¼•ç”¨å®žä½“æœ¬èº«ä¸å‡ºçŽ°ï¼‰ï¼Œè€Œé›†åˆåˆ™æ ¹æœ¬ä¸å‡ºçŽ°ã€‚"
+#, 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 æ ‘ä¸­ï¼ˆè¢«å¼•ç”¨å®žä½“æœ¬èº«ä¸å‡ºçŽ°ï¼‰ï¼Œè€Œé›†åˆåˆ™æ ¹æœ¬ä¸å‡ºçŽ°ã€‚"
 
 #. Tag: para
 #: xml.xml:134
-#, fuzzy, 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 不能很好地处理 循环引用！"
+#, 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 不能很好地处理循环引用。"
 
 #. Tag: programlisting
 #: xml.xml:139
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[<class name=\"Customer\" \n"
 "        table=\"CUSTOMER\" \n"
@@ -335,69 +271,62 @@
 "    \n"
 "</class>]]>"
 msgstr ""
-"&lt;class name=\"Customer\" \n"
+"<![CDATA[<class name=\"Customer\" \n"
 "        table=\"CUSTOMER\" \n"
-"        node=\"customer\"&gt;\n"
+"        node=\"customer\">\n"
 "        \n"
-"    &lt;id name=\"id\" \n"
+"    <id name=\"id\" \n"
 "            column=\"CUST_ID\" \n"
-"            node=\"@id\"/&gt;\n"
+"            node=\"@id\"/>\n"
 "            \n"
-"    &lt;map name=\"accounts\" \n"
+"    <map name=\"accounts\" \n"
 "            node=\".\" \n"
-"            embed-xml=\"true\"&gt;\n"
-"        &lt;key column=\"CUSTOMER_ID\" \n"
-"                not-null=\"true\"/&gt;\n"
-"        &lt;map-key column=\"SHORT_DESC\" \n"
+"            embed-xml=\"true\">\n"
+"        <key column=\"CUSTOMER_ID\" \n"
+"                not-null=\"true\"/>\n"
+"        <map-key column=\"SHORT_DESC\" \n"
 "                node=\"@short-desc\" \n"
-"                type=\"string\"/&gt;\n"
-"        &lt;one-to-many entity-name=\"Account\"\n"
+"                type=\"string\"/>\n"
+"        <one-to-many entity-name=\"Account\"\n"
 "                embed-xml=\"false\" \n"
-"                node=\"account\"/&gt;\n"
-"    &lt;/map&gt;\n"
+"                node=\"account\"/>\n"
+"    </map>\n"
 "    \n"
-"    &lt;component name=\"name\" \n"
-"            node=\"name\"&gt;\n"
-"        &lt;property name=\"firstName\" \n"
-"                node=\"first-name\"/&gt;\n"
-"        &lt;property name=\"initial\" \n"
-"                node=\"initial\"/&gt;\n"
-"        &lt;property name=\"lastName\" \n"
-"                node=\"last-name\"/&gt;\n"
-"    &lt;/component&gt;\n"
+"    <component name=\"name\" \n"
+"            node=\"name\">\n"
+"        <property name=\"firstName\" \n"
+"                node=\"first-name\"/>\n"
+"        <property name=\"initial\" \n"
+"                node=\"initial\"/>\n"
+"        <property name=\"lastName\" \n"
+"                node=\"last-name\"/>\n"
+"    </component>\n"
 "    \n"
 "    ...\n"
 "    \n"
-"&lt;/class&gt;"
+"</class>]]>"
 
 #. Tag: para
 #: xml.xml:141
-#, fuzzy, 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 查询："
+#, 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 查询： "
 
 #. Tag: programlisting
 #: xml.xml:146
-#, fuzzy, no-c-format
-msgid ""
-"<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :"
-"lastName]]>"
-msgstr ""
-"from Customer c left join fetch c.accounts where c.lastName like :lastName"
+#, no-c-format
+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]]>"
 
 #. Tag: para
 #: xml.xml:148
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "would return datasets such as this:"
-msgstr "è¿”å›žçš„æ•°æ®é›†å°†æ˜¯è¿™æ ·ï¼š"
+msgstr "è¿”å›žçš„æ•°æ®é›†å°†æ˜¯è¿™æ ·ï¼š "
 
 #. Tag: programlisting
 #: xml.xml:152
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[<customer id=\"123456789\">\n"
 "    <account short-desc=\"Savings\">987632567</account>\n"
@@ -410,30 +339,26 @@
 "    ...\n"
 "</customer>]]>"
 msgstr ""
-"&lt;customer id=\"123456789\"&gt;\n"
-"    &lt;account short-desc=\"Savings\"&gt;987632567&lt;/account&gt;\n"
-"    &lt;account short-desc=\"Credit Card\"&gt;985612323&lt;/account&gt;\n"
-"    &lt;name&gt;\n"
-"        &lt;first-name&gt;Gavin&lt;/first-name&gt;\n"
-"        &lt;initial&gt;A&lt;/initial&gt;\n"
-"        &lt;last-name&gt;King&lt;/last-name&gt;\n"
-"    &lt;/name&gt;\n"
+"<![CDATA[<customer id=\"123456789\">\n"
+"    <account short-desc=\"Savings\">987632567</account>\n"
+"    <account short-desc=\"Credit Card\">985612323</account>\n"
+"    <name>\n"
+"        <first-name>Gavin</first-name>\n"
+"        <initial>A</initial>\n"
+"        <last-name>King</last-name>\n"
+"    </name>\n"
 "    ...\n"
-"&lt;/customer&gt;"
+"</customer>]]>"
 
 #. Tag: para
 #: xml.xml:154
 #, no-c-format
-msgid ""
-"If you set <literal>embed-xml=\"true\"</literal> on the <literal>&lt;one-to-"
-"many&gt;</literal> mapping, the data might look more like this:"
-msgstr ""
-"å¦‚æžœä½ æŠŠä¸€å¯¹å¤šæ˜ å°„ <literal>&lt;one-to-many&gt;</literal> çš„ embed-xml 属性置"
-"为真（<literal>embed-xml=\"true\"</literal>ï¼‰ï¼Œåˆ™æ•°æ®çœ‹ä¸ŠåŽ»å°±åƒè¿™æ ·ï¼š"
+msgid "If you set <literal>embed-xml=\"true\"</literal> on the <literal>&lt;one-to-many&gt;</literal> mapping, the data might look more like this:"
+msgstr "å¦‚æžœä½ æŠŠä¸€å¯¹å¤šæ˜ å°„ <literal>&lt;one-to-many&gt;</literal> çš„ embed-xml 属性置为真（<literal>embed-xml=\"true\"</literal>ï¼‰ï¼Œåˆ™æ•°æ®çœ‹ä¸ŠåŽ»å°±åƒè¿™æ ·ï¼š"
 
 #. Tag: programlisting
 #: xml.xml:159
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[<customer id=\"123456789\">\n"
 "    <account id=\"987632567\" short-desc=\"Savings\">\n"
@@ -452,22 +377,22 @@
 "    ...\n"
 "</customer>]]>"
 msgstr ""
-"&lt;customer id=\"123456789\"&gt;\n"
-"    &lt;account id=\"987632567\" short-desc=\"Savings\"&gt;\n"
-"        &lt;customer id=\"123456789\"/&gt;\n"
-"        &lt;balance&gt;100.29&lt;/balance&gt;\n"
-"    &lt;/account&gt;\n"
-"    &lt;account id=\"985612323\" short-desc=\"Credit Card\"&gt;\n"
-"        &lt;customer id=\"123456789\"/&gt;\n"
-"        &lt;balance&gt;-2370.34&lt;/balance&gt;\n"
-"    &lt;/account&gt;\n"
-"    &lt;name&gt;\n"
-"        &lt;first-name&gt;Gavin&lt;/first-name&gt;\n"
-"        &lt;initial&gt;A&lt;/initial&gt;\n"
-"        &lt;last-name&gt;King&lt;/last-name&gt;\n"
-"    &lt;/name&gt;\n"
+"<![CDATA[<customer id=\"123456789\">\n"
+"    <account id=\"987632567\" short-desc=\"Savings\">\n"
+"        <customer id=\"123456789\"/>\n"
+"        <balance>100.29</balance>\n"
+"    </account>\n"
+"    <account id=\"985612323\" short-desc=\"Credit Card\">\n"
+"        <customer id=\"123456789\"/>\n"
+"        <balance>-2370.34</balance>\n"
+"    </account>\n"
+"    <name>\n"
+"        <first-name>Gavin</first-name>\n"
+"        <initial>A</initial>\n"
+"        <last-name>King</last-name>\n"
+"    </name>\n"
 "    ...\n"
-"&lt;/customer&gt;"
+"</customer>]]>"
 
 #. Tag: title
 #: xml.xml:165
@@ -477,17 +402,13 @@
 
 #. Tag: para
 #: xml.xml:167
-#, fuzzy, 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 会话可以做到这一"
-"点："
+#, 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 会话可以做到这一点："
 
 #. Tag: programlisting
 #: xml.xml:172
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[Document doc = ....;\n"
 "       \n"
@@ -496,8 +417,7 @@
 "Transaction tx = session.beginTransaction();\n"
 "\n"
 "List results = dom4jSession\n"
-"    .createQuery(\"from Customer c left join fetch c.accounts where c."
-"lastName like :lastName\")\n"
+"    .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
 "    .list();\n"
 "for ( int i=0; i<results.size(); i++ ) {\n"
 "    //add the customer data to the XML document\n"
@@ -508,28 +428,27 @@
 "tx.commit();\n"
 "session.close();]]>"
 msgstr ""
-"Document doc = ....;\n"
+"<![CDATA[Document doc = ....;\n"
 "       \n"
 "Session session = factory.openSession();\n"
 "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
 "Transaction tx = session.beginTransaction();\n"
 "\n"
 "List results = dom4jSession\n"
-"    .createQuery(\"from Customer c left join fetch c.accounts where c."
-"lastName like :lastName\")\n"
+"    .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
 "    .list();\n"
-"for ( int i=0; i&lt;results.size(); i++ ) {\n"
+"for ( int i=0; i<results.size(); i++ ) {\n"
 "    //add the customer data to the XML document\n"
 "    Element customer = (Element) results.get(i);\n"
 "    doc.add(customer);\n"
 "}\n"
 "\n"
 "tx.commit();\n"
-"session.close();"
+"session.close();]]>"
 
 #. Tag: programlisting
 #: xml.xml:174
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<![CDATA[Session session = factory.openSession();\n"
 "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
@@ -548,12 +467,12 @@
 "tx.commit();\n"
 "session.close();]]>"
 msgstr ""
-"Session session = factory.openSession();\n"
+"<![CDATA[Session session = factory.openSession();\n"
 "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
 "Transaction tx = session.beginTransaction();\n"
 "\n"
 "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
-"for ( int i=0; i&lt;results.size(); i++ ) {\n"
+"for ( int i=0; i<results.size(); i++ ) {\n"
 "    Element customer = (Element) results.get(i);\n"
 "    //change the customer name in the XML and database\n"
 "    Element name = customer.element(\"name\");\n"
@@ -563,14 +482,11 @@
 "}\n"
 "\n"
 "tx.commit();\n"
-"session.close();"
+"session.close();]]>"
 
 #. Tag: para
 #: xml.xml:176
-#, fuzzy, 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 的数据导入/导出将非常有用."
+#, 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 的数据导入/导出将非常有用。"
+