[jboss-cvs] JBossAS SVN: r73405 - projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Thu May 15 01:26:24 EDT 2008
Author: xhuang at jboss.com
Date: 2008-05-15 01:26:23 -0400 (Thu, 15 May 2008)
New Revision: 73405
Modified:
projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_HTTP.po
Log:
update
Modified: projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_HTTP.po
===================================================================
--- projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_HTTP.po 2008-05-15 01:37:30 UTC (rev 73404)
+++ projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_HTTP.po 2008-05-15 05:26:23 UTC (rev 73405)
@@ -1,18 +1,21 @@
+# translation of Clustering_Guide_HTTP.po to
# Language /tmp/mike/JBEAP420/JBAS translations for JBEAP package.
-# Copyright (C) 2007 Free Software Foundation, Inc.
-# Automatically generated, 2007.
+# Copyright (C) 2007, 2008 Free Software Foundation, Inc.
#
+# Automatically generated, 2007.
+# Xi HUANG <xhuang at redhat.com>, 2008.
msgid ""
msgstr ""
-"Project-Id-Version: JBEAP 420\n"
+"Project-Id-Version: Clustering_Guide_HTTP\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2007-12-09 23:23+0000\n"
-"PO-Revision-Date: 2001-02-09 01:25+0100\n"
-"Last-Translator: Automatically generated\n"
-"Language-Team: none\n"
+"PO-Revision-Date: 2008-05-15 11:35+1000\n"
+"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
+"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
+"X-Generator: KBabel 1.11.4\n"
#. Tag: title
#: Clustering_Guide_HTTP.xml:5
@@ -41,13 +44,13 @@
#. Tag: para
#: Clustering_Guide_HTTP.xml:14
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Load-balancing of incoming invocations"
msgstr "传入调用（incoming invocations）的负载平衡"
#. Tag: para
#: Clustering_Guide_HTTP.xml:17
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"State replication is directly handled by JBoss. When you run JBoss in the "
"<literal>all</literal> configuration, session state replication is enabled "
@@ -55,13 +58,13 @@
"<filename>web.xml</filename> (see below), deploy it, and its session state "
"is automtically replicated across all JBoss instances in the cluster."
msgstr ""
-"状态复制（State replication）由 JBoss 直接处理。当你在 <literal>all</"
-"literal> 配置里运行 JBoss，会话状态复制缺省是启用的。只要部署了你的 web 应用"
-"程序，它的会话状态就已经复制在群集里的所有 JBoss 实例中了。"
+"状态复制（State replication）由 JBoss 直接处理。当你使用 <literal>all</"
+"literal> 配置运行 JBoss，会话状态复制缺省是启用的。通过 <filename>web.xml</filename> 文件（请参考下面的内容）把你的 web 应用"
+"程序配置为分布式的，它的会话状态就会自动在群集里的所有 JBoss 实例中复制了。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:19
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"However, load-balancing is a different story; it is not handled by JBoss "
"itself and requires an external load balancer. aThis function could be "
@@ -70,19 +73,18 @@
"common scenario, we will demonstrate how to set up a software load balancer "
"using Apache httpd and mod_jk."
msgstr ""
-"然而，负载平衡是不一样的。它不是由 JBoss 自己处理的，它需要额外的软件。我们将"
-"演示怎样设立 Apache 和 mod_jk，这是一个很常见的例子。但这需要专门的硬件开关，"
-"路由器（如 Cisco LoadDirector）或其他专门的软件来执行。"
+"然而，负载平衡是不一样的。它不是由 JBoss 自己处理的，它需要额外的软件。专门的硬件开关或路由器（如 Cisco LoadDirector）或其他专门的软件可提供这样的功能。我们将"
+"演示怎样用 Apache 和 mod_jk 设立软件负载平衡系统，这是一个常用的模式。"
#. Tag: title
#: Clustering_Guide_HTTP.xml:22 Clustering_Guide_HTTP.xml:447
#, no-c-format
msgid "Note"
-msgstr ""
+msgstr "请注意"
#. Tag: para
#: Clustering_Guide_HTTP.xml:24
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"A load-balancer tracks HTTP requests and, depending on the session to which "
"the request is linked, it dispatches the request to the appropriate node. "
@@ -101,8 +103,8 @@
msgstr ""
"负载平衡系统跟踪 HTTP 请求，它依据请求所链接的会话把请求分派给合适的节点。一"
"旦会话在节点上被创建，将来的每个请求都被同一节点所处理：这被称作使用 sticky-"
-"sessions 的负载平衡系统。使用支持不复制会话的 sticky-sessions 的负载平衡系统"
-"允许你不付出复制状态的代价就可以很好地扩充：每个查询将总是由同一节点来处理。"
+"session 的负载平衡系统。使用支持 sticky-sessions 但不需配置会话复制的负载平衡系统"
+"允许你不付出复制状态的代价就可以很好地进行扩充：每个查询将总是由同一节点来处理。"
"但是，如果某个节点崩溃了，所有以这个节点为宿主的客户会话状态就将全部丢失（如"
"购物车），客户很有可能需要登录另外一节点来启动新的会话。在大部分情况下，不复"
"制 HTTP 会话是可以接受的，因为所有关键状态都存储在数据库里。在丢失客户会话是"
@@ -110,13 +112,13 @@
#. Tag: title
#: Clustering_Guide_HTTP.xml:26
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Configuring load balancing using Apache and mod_jk"
-msgstr "配置 Apache 来装载 mod_jk"
+msgstr "用 Apache 和 mod_jk 配置负载平衡"
#. Tag: para
#: Clustering_Guide_HTTP.xml:28
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"Apache is a well-known web server which can be extended by plugging in "
"modules. One of these modules, mod_jk has been specifically designed to "
@@ -125,9 +127,8 @@
"containers while maintaining sticky sessions, which is what is most "
"interesting for us in this section."
msgstr ""
-"Apache 是一个很有名的 web 服务器，它可以通过插件来扩展。mod_jk（和最新的 "
-"mod_jk2）已经被特别的设计成可以允许从 Apache 转发请求到 Servlet 容器里。而"
-"且，当维护 sticky sessions 时，它也能够对 Servlet 容器的 HTTP 调用的负载进行"
+"Apache 是一个很有名的 web 服务器，它可以通过插件来扩展。mod_jk 被特别的设计成可以允许从 Apache 转发请求到 Servlet 容器里。而"
+"且，当维护 sticky session 时，它也能够对 Servlet 容器的 HTTP 调用的负载进行"
"平衡，这正是让我们感兴趣的地方。"
#. Tag: title
@@ -187,7 +188,7 @@
#. Tag: programlisting
#: Clustering_Guide_HTTP.xml:49
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"# Include mod_jk's specific configuration file \n"
"Include conf/mod-jk.conf"
@@ -201,8 +202,7 @@
msgid ""
"Next, create a new file named <literal>APACHE_HOME/conf/mod-jk.conf</"
"literal>:"
-msgstr ""
-"然后，建立一个叫 <literal>APACHE_HOME/conf/mod-jk.conf</literal> 的文件。"
+msgstr "然后，建立一个叫 <literal>APACHE_HOME/conf/mod-jk.conf</literal> 的文件。"
#. Tag: programlisting
#: Clustering_Guide_HTTP.xml:51
@@ -402,7 +402,7 @@
#. Tag: para
#: Clustering_Guide_HTTP.xml:82
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"Next, you need to configure mod_jk workers file <literal>conf/workers."
"properties</literal>. This file specifies where the different Servlet "
@@ -414,7 +414,7 @@
"然后，你需要配置 mod_jk 的 workers 文件 <literal>conf/workers.properties</"
"literal>。这个文件指定不同的 Servlet 容器的存放位置和怎样对它们之间的调用进行"
"负载平衡。这个配置文件包含了一个全局设置部分以及针对每个目标 Servlet 容器的设"
-"置部分。对于两个节点的设立，这个文件如下所示："
+"置部分。对于两个节点的设立，这个文件将类似于："
#. Tag: programlisting
#: Clustering_Guide_HTTP.xml:87
@@ -492,7 +492,7 @@
#. Tag: para
#: Clustering_Guide_HTTP.xml:91
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"In the <literal>works.properties</literal> file, each node is defined using "
"the <literal>worker.XXX</literal> naming convention where <literal>XXX</"
@@ -508,7 +508,7 @@
#. Tag: para
#: Clustering_Guide_HTTP.xml:96
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"The <literal>lbfactor</literal> attribute is the load-balancing factor for "
"this specific worker. It is used to define the priority (or weight) a node "
@@ -519,7 +519,7 @@
msgstr ""
"<literal>lbfactor</literal> 属性是对于特定的 worker 的负载平衡因子。它用来定"
"义一个节点对于其他节点的优先级（或权重）。这个数字越大，就要接收越多的 HTTP "
-"请求。这个设置可以用来调节不同服务器的处理能力。"
+"请求。这个设置可以用来区分具有不同处理能力的服务器。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:98
@@ -556,7 +556,7 @@
#. Tag: para
#: Clustering_Guide_HTTP.xml:108
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"The <literal>sticky_session</literal> property specifies the cluster "
"behavior for HTTP sessions. If you specify <literal>worker.loadbalancer."
@@ -571,28 +571,25 @@
msgstr ""
"<literal>sticky_session</literal> 属性指定 HTTP 会话的群集系统行为。如果你指"
"定 <literal>worker.loadbalancer.sticky_session=0</literal>，每个请求会在节点 "
-"1 和节点 2 之间进行负载平衡。但是当用户在服务器上开始一个会话，把这个的用户的"
-"请求转发到同一服务器会是个好主意。这被称作 \"sticky session\"，因为客户总是使"
-"用处理他第一个请求的服务器。否则用户的会话数据就必须在两个服务器之间同步（即"
-"会话复制，请参考 <xref linkend=\"clustering-http-state\"/>）。为了启用 "
+"1 和节点 2 之间进行负载平衡；也就是说，对于相同会话的不同请求将交由不同的服务器来处理。但是当用户在服务器上开始一个会话，只要这个服务器可用，这个用户的"
+"请求就转发给它。这被称作 \"sticky session\"，因为客户总是使"
+"用处理他第一个请求的服务器。为了启用 "
"session stickiness，你需要把 <literal>worker.loadbalancer.sticky_session</"
"literal> 设置为 1。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:113
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"A non-loadbalanced setup with a single node requires a <literal>worker."
"list=node1</literal> entry."
-msgstr ""
-"单节点的非负载平衡的设立需要设置 <literal>worker.list=node1</literal> 条目，"
-"才能使 mod_jk 正常工作。"
+msgstr "单节点的非负载平衡的设立需要设置 <literal>worker.list=node1</literal> 条目。"
#. Tag: title
#: Clustering_Guide_HTTP.xml:118
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Configuring JBoss to work with mod_jk"
-msgstr "配置 mod_jk 里的 worker 节点"
+msgstr "在 JBoss 里配置 mod_jk"
#. Tag: para
#: Clustering_Guide_HTTP.xml:119
@@ -606,7 +603,7 @@
#. Tag: para
#: Clustering_Guide_HTTP.xml:121
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"On each clustered JBoss node, we have to name the node according to the name "
"specified in <literal>workers.properties</literal>. For instance, on JBoss "
@@ -616,8 +613,8 @@
"literal> element and add an attribute <literal>jvmRoute</literal>:"
msgstr ""
"在每个群集节点上，我们得按 <literal>workers.properties</literal> 里指定的名字"
-"来命名节点名。例如，在 JBoss 实例节点1上，编辑 <literal>JBOSS_HOME/server/"
-"all/deploy/jbossweb-tomcat50.sar/server.xml</literal> 文件（有必要的话用你自"
+"来命名节点名。例如，在 JBoss 实例节点 1 上，编辑 <literal>JBOSS_HOME/server/all/deploy/jboss-web."
+"deployer/server.xml</literal> 文件（有必要的话用你自"
"己的服务器名代替<literal>/all</literal>）。定位 <literal><Engine></"
"literal> 元素并加入一个 <literal>jvmRoute</literal> 属性："
@@ -641,7 +638,7 @@
msgid ""
"You also need to be sure the AJP connector in server.xml is enabled (i.e., "
"uncommented). It is enabled by default."
-msgstr ""
+msgstr "你也需要确保 server.xml 里的 AJP 连接器被启用（也就是取消注释）。它缺省是启用的。"
#. Tag: programlisting
#: Clustering_Guide_HTTP.xml:129
@@ -654,10 +651,16 @@
"emptySessionPath=\"true\" enableLookups=\"false\" redirectPort=\"8443\" /> ]]"
">"
msgstr ""
+"<![CDATA[ \n"
+"<!-- Define an AJP 1.3 Connector on port 8009 --> \n"
+"<Connector port=\"8009\" address=\"${jboss.bind.address}\" protocol=\"AJP/1.3"
+"\" \n"
+"emptySessionPath=\"true\" enableLookups=\"false\" redirectPort=\"8443\" /> ]]"
+">"
#. Tag: para
#: Clustering_Guide_HTTP.xml:131
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"Then, for each JBoss Tomcat instance in the cluster, we need to tell it that "
"mod_jk is in use, so it can properly manage the <literal>jvmRoute</literal> "
@@ -668,10 +671,9 @@
"literal> element with a name of <literal>UseJK</literal>, and set its value "
"to <literal>true</literal>:"
msgstr ""
-"然后，对群集里的每个 JBoss Tomcat 实例，我们需要使它们在它们的会话 cookies 里"
-"加入 <literal>jvmRoute</literal> 值，这样 mod_jk 才能指引进来的请求。编辑 "
-"<literal>JBOSS_HOME/server/all/deploy/jbossweb-tomcat50.sar/META-INF/jboss-"
-"service.xml</literal> 文件（有必要的话用你自己的服务器名代替 <literal>/all</"
+"然后，对群集里的每个 JBoss Tomcat 实例，我们需要告知正在使用 mod_jk，让它正确地管理附加在会话 cookies 里的 <literal>jvmRoute</literal> 值，让 mod_jk 可以正确地指引转入的请求。编辑 "
+"<literal>JBOSS_HOME/server/all/deploy/jbossweb-tomcat50."
+"sar/META-INF/jboss-service.xml</literal> 文件（有必要的话用你自己的服务器名代替 <literal>/all</"
"literal>）。用 <literal>UseJK</literal>名来定位<literal><attribute></"
"literal> 元素，把它的值设置为 <literal>true</literal>："
@@ -708,9 +710,9 @@
#. Tag: title
#: Clustering_Guide_HTTP.xml:149
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Configuring HTTP session state replication"
-msgstr "配置 HTTP 会话状态复制（session state replication）"
+msgstr "配置 HTTP 会话状态复制"
#. Tag: para
#: Clustering_Guide_HTTP.xml:150
@@ -719,11 +721,11 @@
"The preceding discussion has been focused on using mod_jk as a load "
"balancer. The content of the remainder our discussion of clustering HTTP "
"services in JBoss AS applies no matter what load balancer is used."
-msgstr ""
+msgstr "前面的讨论着重于把 mod_jk 用作负载平衡系统。余下的内容将讨论 JBoss AS 里的群集 HTTP 服务而不管使用什么负载平衡系统。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:153
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"In <xref linkend=\"clustering-http-nodes\"/>, we covered how to use sticky "
"sessions to make sure that a client in a session always hits the same server "
@@ -734,14 +736,13 @@
"server node and obtain the same session state."
msgstr ""
"在 <xref linkend=\"clustering-http-nodes\"/> 里，我们涉及了怎样使用 sticky "
-"sessions 来确保会话里的客户总是利用相同的服务器来维护会话状态。然而，这并非一"
-"个理想的解决方案。如果某一节点崩溃了并丢失了所有的会话数据，负载就有可能没有"
-"均衡分布在节点上。一个更好的和可靠的办法就是在群集里的所有节点上复制会话数"
+"session 来确保会话里的客户总是利用相同的服务器来维护会话状态。然而，sticky session 本身并非一"
+"个理想的解决方案。如果某一节点崩溃了，那所有的会话数据都会丢失。一个更好的和可靠的办法就是在群集里的所有节点上复制会话数"
"据。这样的话，客户可以访问任何节点而获得相同的会话数据。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:155
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"The <literal>jboss.cache:service=TomcatClusteringCache</literal> MBean makes "
"use of JBoss Cache to provide HTTP session replication services to the JBoss "
@@ -750,37 +751,39 @@
msgstr ""
"<literal>jboss.cache:service=TomcatClusteringCache</literal> MBean 利用 "
"JBoss Cache 来为 JBoss Tomcat 群集里的 HTTP 负载平衡系统提供 HTTP 会话复制服"
-"务。<literal>deploy/tc5-cluster.sar/META-INF/jboss-service.xml</literal> 文件"
+"务。<literal>deploy/jboss-web-"
+"cluster.sar/META-INF/jboss-service.xml</literal> 文件"
"里定义了这个 MBean。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:158
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"Before AS 4.2.0, the location of the HTTP session cache configuration file "
"was <literal>deploy/tc5-cluster.sar/META-INF/jboss-service.xml</literal>. "
"Prior to AS 4.0.4 CR2, the file was named <literal>deploy/tc5-cluster-"
"service.xml</literal>."
msgstr ""
-"在 AS 4.0.4 CR2 之前， HTTP 会话缓存配置文件是 <literal>deploy/tc5-cluster-"
-"service.xml</literal>。请参考 AS 4.0.3 文档来获得更多细节。"
+"在 AS 4.2.0 之前， HTTP 会话缓存配置文件是 <literal>deploy/tc5-cluster.sar/META-INF/jboss-service.xml</literal>。而在 AS 4.0.4 CR2 之前，这个文件是 <literal>deploy/tc5-cluster-"
+"service.xml</literal>。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:160
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"Below is a typical <literal>deploy/jbossweb-cluster.sar/META-INF/jboss-"
"service.xml</literal> file. The configuration attributes in the "
"<literal>TomcatClusteringCache</literal> MBean are very similar to those in "
"the JBoss AS cache configuration."
msgstr ""
-"下面是一个典型的 <literal>deploy/tc5-cluster.sar/META-INF/jboss-service.xml</"
+"下面是一个典型的 <literal>deploy/jbossweb-cluster.sar/META-INF/jboss-"
+"service.xml</"
"literal> 文件。<literal>TomcatClusteringCache</literal> MBean 里的配置属性和 "
-"<xref linkend=\"jbosscache-cache\"/> 里的非常相似。"
+" JBoss AS Cache 配置里的非常相似。"
#. Tag: programlisting
#: Clustering_Guide_HTTP.xml:163
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<mbean code=\"org.jboss.cache.aop.TreeCacheAop\"\n"
" name=\"jboss.cache:service=TomcatClusteringCache\">\n"
@@ -844,8 +847,10 @@
" ... ...\n"
" </attribute>\n"
" \n"
+" \n"
" <attribute name=\"LockAcquisitionTimeout\">15000</"
"attribute>\n"
+" <attribute name=\"SyncReplTimeout\">20000</attribute>\n"
"</mbean>"
#. Tag: para
@@ -858,23 +863,23 @@
"(covered below) needs the added features of the <literal>TreeCacheAop</"
"literal> (a.k.a. <literal>PojoCache</literal>) class."
msgstr ""
+"请注意，mbean 元素的 code 属性值是 org.jboss.cache."
+"aop.TreeCacheAop，这和 JBoss AS 里的其他 JBoss Cache Mbean 不同。这是因为 FIELD 颗粒度的 HTTP 会话复制需要额外的 <literal>TreeCacheAop</"
+"literal>（也就是 <literal>PojoCache</literal>）类。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:168
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"The details of all the configuration options for a TreeCache MBean are "
"covered in the JBoss Cache documentation. Below, we will just discuss "
"several attributes that are most relevant to the HTTP cluster session "
"replication."
-msgstr ""
-"<xref linkend=\"jbosscache-cache\"/> 里包括了 <literal>TreeCache</literal> "
-"MBean 的详细配置。下面，我们将讨论和 HTTP 群集会话复制（cluster session "
-"replication）最为相关的几个属性。"
+msgstr "JBoss Cache 文档介绍了 TreeCache MBean 的详细配置。下面，我们将讨论和 HTTP 群集会话复制最为相关的几个属性。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:171
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<emphasis role=\"bold\">TransactionManagerLookupClass</emphasis> sets the "
"transaction manager factory. The default value is <literal>org.jboss.cache."
@@ -882,14 +887,15 @@
"participate in JTA-specific transactions. Instead, the cache manages its own "
"transactions. Please do not change this."
msgstr ""
-"<emphasis role=\"bold\">TransactionManagerLookupClass</emphasis> 设置 "
-"transaction manager factory。它的缺省值是 <literal>org.jboss.cache."
+"<emphasis role=\"bold\">TransactionManagerLookupClass</emphasis> 设置事务管理者工厂（"
+"transaction manager factory）。它的缺省值是 <literal>org.jboss.cache."
"BatchModeTransactionManagerLookup</literal>。它告诉缓存不要参与 JTA 相关的事"
-"务。作为替代，缓存管理自己的事务来支持细颗粒度的复制。"
+"务。相反，缓存管理自己的事务。请不要修改它的值。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:178
#, no-c-format
+#, fuzzy
msgid ""
"<emphasis role=\"bold\">CacheMode</emphasis> controls how the cache is "
"replicated. The valid values are <literal>REPL_SYNC</literal> and "
@@ -904,6 +910,8 @@
"cluster before the web request completes. However, synchronous replication "
"is much slower."
msgstr ""
+"<emphasis role=\"bold\">CacheMode</emphasis> 控制缓存的复制模式。其有效值是 <literal>REPL_SYNC</literal> 和 "
+"<literal>REPL_ASYNC</literal>。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:182
@@ -941,18 +949,18 @@
"<emphasis role=\"bold\">ClusterConfig</emphasis> configures the underlying "
"JGroups stack. Please refer to <xref linkend=\"jbosscache-jgroups\"/> for "
"more information."
-msgstr ""
+msgstr "<emphasis role=\"bold\">ClusterConfig</emphasis> 配置底层的 JGroups 栈。更多信息请参考 <xref linkend=\"jbosscache-jgroups\"/>。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:195
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<emphasis role=\"bold\">LockAcquisitionTimeout</emphasis> sets the maximum "
"number of milliseconds to wait for a lock acquisition when trying to lock a "
"cache node. The default value is 15000."
msgstr ""
"<emphasis role=\"bold\">LockAcquisitionTimeout</emphasis> 设置以毫秒为单位的"
-"等待所锁定捕获（lock acquisition）的最长时间。它的缺省值是 15000。"
+"锁定缓存节点时等待所锁定捕获（lock acquisition）的最长时间。它的缺省值是 15000。"
#. Tag: para
#: Clustering_Guide_HTTP.xml:199
@@ -974,18 +982,18 @@
#. Tag: para
#: Clustering_Guide_HTTP.xml:208
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"To enable clustering of your web application you must tag it as "
"distributable in the <literal>web.xml</literal> descriptor. Here's an "
"example:"
msgstr ""
"为了启用 web 应用程序的群集，你必须在 <literal>web.xml</literal> 描述符里把它"
-"标记为 distributable。下面是一个例子："
+"标记为 distributable。下面是一个例子： "
#. Tag: programlisting
#: Clustering_Guide_HTTP.xml:210
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<?xml version=\"1.0\"?> \n"
"<web-app xmlns=\"http://java.sun.com/xml/ns/j2ee\"\n"
@@ -1243,7 +1251,7 @@
#. Tag: programlisting
#: Clustering_Guide_HTTP.xml:266
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[\n"
"@org.jboss.cache.aop.AopMarker\n"
@@ -1252,14 +1260,12 @@
"...\n"
"}]]>"
msgstr ""
-"/*\n"
-" *\n"
-" * @@org.jboss.web.tomcat.tc5.session.InstanceOfAopMarker\n"
-" */\n"
-"public class Person \n"
+"<![CDATA[\n"
+"@org.jboss.cache.aop.AopMarker\n"
+"public class Address \n"
"{\n"
"...\n"
-"}"
+"}]]>"
#. Tag: para
#: Clustering_Guide_HTTP.xml:268
@@ -1288,6 +1294,18 @@
"}\n"
"]]>"
msgstr ""
+"<![CDATA[\n"
+"@org.jboss.cache.aop.InstanceOfAopMarker\n"
+"public class Person \n"
+"{\n"
+"...\n"
+"}\n"
+"then when you have a sub-class like\n"
+"public class Student extends Person\n"
+"{\n"
+"...\n"
+"}\n"
+"]]>"
#. Tag: para
#: Clustering_Guide_HTTP.xml:273
@@ -1330,7 +1348,7 @@
#. Tag: programlisting
#: Clustering_Guide_HTTP.xml:283
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"/*\n"
" *\n"
@@ -1342,10 +1360,10 @@
"}"
msgstr ""
"/*\n"
-" * My usual comments here first.\n"
-" * @@org.jboss.web.tomcat.tc5.session.AopMarker\n"
+" *\n"
+" * @@org.jboss.web.tomcat.tc5.session.InstanceOfAopMarker\n"
" */\n"
-"public class Address \n"
+"public class Person \n"
"{\n"
"...\n"
"}"
@@ -1456,7 +1474,7 @@
#. Tag: programlisting
#: Clustering_Guide_HTTP.xml:318
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"// Do this only once. So this can be in init(), e.g.\n"
"if(firstTime)\n"
@@ -1529,7 +1547,7 @@
#. Tag: programlisting
#: Clustering_Guide_HTTP.xml:328
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"/JSESSION\n"
"\n"
@@ -1548,6 +1566,8 @@
msgstr ""
"/JSESSION\n"
"\n"
+"/localhost\n"
+"\n"
"/quote\n"
"\n"
"/FB04767C454BAB3B2E462A27CB571330\n"
@@ -1717,8 +1737,7 @@
#. Tag: para
#: Clustering_Guide_HTTP.xml:372
#, no-c-format
-msgid ""
-"Using deploy-hasingleton is very simple, but it does have two drawbacks:"
+msgid "Using deploy-hasingleton is very simple, but it does have two drawbacks:"
msgstr ""
#. Tag: para
@@ -1795,6 +1814,24 @@
" } \n"
"} ]]>"
msgstr ""
+"<![CDATA[ \n"
+"public class HASingletonExample\n"
+"implements HASingletonExampleMBean { \n"
+" \n"
+"private boolean isMasterNode = false; \n"
+" \n"
+"public void startSingleton() { \n"
+"isMasterNode = true; \n"
+"} \n"
+". \n"
+"public boolean isMasterNode() { \n"
+"return isMasterNode; \n"
+" } \n"
+" \n"
+" public void stopSingleton() { \n"
+" isMasterNode = false; \n"
+" } \n"
+"} ]]>"
#. Tag: para
#: Clustering_Guide_HTTP.xml:402
@@ -1846,6 +1883,34 @@
" </mbean> \n"
"</server> ]]>"
msgstr ""
+"<![CDATA[\n"
+" <server> \n"
+" <!-- This MBean is an example of a clustered singleton --> \n"
+" <mbean code=\"org.jboss.ha.examples.HASingletonExample\" \n"
+" name=“jboss:service=HASingletonExample\"/> \n"
+" \n"
+" <!-- This HASingletonController manages the cluster Singleton --> \n"
+" <mbean code=\"org.jboss.ha.singleton.HASingletonController\" \n"
+" name=\"jboss:service=ExampleHASingletonController\"> \n"
+" \n"
+" <!-- Inject a ref to the HAPartition -->\n"
+" <depends optional-attribute-name=\"ClusterPartition\" proxy-"
+"type=\"attribute\">\n"
+" jboss:service=${jboss.partition.name:"
+"DefaultPartition}\n"
+" </depends> \n"
+" <!-- Inject a ref to the service being controlled -->\n"
+" <depends optional-attribute-name=\"TargetName\">\n"
+" jboss:service=HASingletonExample\n"
+" </depends>\n"
+" <!-- Methods to invoke when become master / stop being "
+"master -->\n"
+" <attribute name=\"TargetStartMethod\">startSingleton</"
+"attribute> \n"
+" <attribute name=\"TargetStopMethod\">stopSingleton</"
+"attribute> \n"
+" </mbean> \n"
+"</server> ]]>"
#. Tag: para
#: Clustering_Guide_HTTP.xml:410
@@ -1902,6 +1967,25 @@
" </attribute> \n"
"</mbean> ]]>"
msgstr ""
+"<![CDATA[ \n"
+"<mbean code=\"org.jboss.ha.singleton.HASingletonController\" \n"
+"name=\"jboss.ha:service=HASingletonDeployer\"> \n"
+" <depends optional-attribute-name=\"ClusterPartition\" proxy-type=\"attribute"
+"\">\n"
+" jboss:service=${jboss.partition.name:DefaultPartition}\n"
+" </depends> \n"
+" <depends optional-attributeame=\"TargetName\">\n"
+" jboss.system:service=MainDeployer\n"
+" </depends> \n"
+" <attribute name=\"TargetStartMethod\">deploy</attribute> \n"
+" <attribute name=\"TargetStartMethodArgument\">\n"
+" ${jboss.server.home.url}/deploy-hasingleton\n"
+" </attribute> \n"
+" <attribute name=\"TargetStopMethod\">undeploy</attribute> \n"
+" <attribute name=\"TargetStopMethodArgument\">\n"
+" ${jboss.server.home.url}/deploy-hasingleton\n"
+" </attribute> \n"
+"</mbean> ]]>"
#. Tag: para
#: Clustering_Guide_HTTP.xml:420
@@ -2084,2991 +2168,3 @@
"to become the master again just because it was before."
msgstr ""
-#~ msgid "Clustering"
-#~ msgstr "群集"
-
-#~ msgid "High Availability Enterprise Services via JBoss Clusters"
-#~ msgstr "用 JBoss 群集实现高可用性企业服务"
-
-#~ msgid "Introduction"
-#~ msgstr "简介"
-
-#~ msgid ""
-#~ "Clustering allows us to run an applications on several parallel servers "
-#~ "(a.k.a cluster nodes). The load is distributed across different servers, "
-#~ "and even if any of the servers fails, the application is still accessible "
-#~ "via other cluster nodes. Clustering is crucial for scalable enterprise "
-#~ "applications, as you can improve performance by simply adding more nodes "
-#~ "to the cluster."
-#~ msgstr ""
-#~ "群集系统（Clustering）允许我们在多台平行的服务器（群集节点）上运行一个应用"
-#~ "程序。负载分布在不同的服务器上，即使其中任何一台崩溃，应用程序还是可以在其"
-#~ "他群集节点（cluster nodes）上运行。群集对于可扩展性企业级应用程序是很关键"
-#~ "的，因为你简单地把更多节点加入到群集系统里就可以提高性能。"
-
-#~ msgid ""
-#~ "The JBoss Application Server (AS) comes with clustering support out of "
-#~ "the box. The simplest way to start a JBoss server cluster is to start "
-#~ "several JBoss instances on the same local network, using the <literal>run "
-#~ "-c all</literal> command for each instance. Those server instances, all "
-#~ "started in the <literal>all</literal> configuration, detect each other "
-#~ "and automatically form a cluster."
-#~ msgstr ""
-#~ "JBoss 应用服务器（AS）缺省支持群集系统。最简单的启动 JBoss 服务器群集的方"
-#~ "法就是在同一本地网络里启动多个 JBoss 实例，每个实例都可以用 <literal>run -"
-#~ "c all</literal> 命令来运行。这些按照 <literal>all</literal> 配置文件启动的"
-#~ "实例，可以检测到对方而自动组成一个群集系统。"
-
-#, fuzzy
-#~ msgid ""
-#~ "In the first section of this chapter, I discuss basic concepts behind "
-#~ "JBoss's clustering services. It is important that you understand "
-#~ "those concepts before reading the rest of the chapter. Clustering "
-#~ "configurations for specific types of applications are covered after this "
-#~ "section."
-#~ msgstr ""
-#~ "在本章的第一部分，我们将讨论 JBoss 群集服务的基本概念。在阅读本章后面的内"
-#~ "容之前，先理解这些概念是很重要的。在这部分内容之后，我们将介绍怎样为特定类"
-#~ "型的应用程序配置群集系统。"
-
-#~ msgid "Cluster Definition"
-#~ msgstr "群集系统的定义"
-
-#~ msgid ""
-#~ "A cluster is a set of nodes. In a JBoss cluster, a node is a JBoss server "
-#~ "instance. Thus, to build a cluster, several JBoss instances have to be "
-#~ "grouped together (known as a \"partition\"). On a same network, we may "
-#~ "have different clusters. In order to differentiate them, each cluster "
-#~ "must have an individual name."
-#~ msgstr ""
-#~ "群集系统是节点（node）的集合。在 JBoss 群集系统里，节点是一个 JBoss 服务器"
-#~ "实例。因此，为了建立一个群集，JBoss 实例必须组合在一起（通称\"partition"
-#~ "\"）。在同一个网络里，我们可能有不同的群集。为了区分，每个群集都必须有一个"
-#~ "唯一的名字。"
-
-#~ msgid ""
-#~ "shows an example network of JBoss server instances divided into three "
-#~ "clusters, with each cluster only having one node. Nodes can be added to "
-#~ "or removed from clusters at any time."
-#~ msgstr ""
-#~ "展示了网络里的 JBoss 服务器实例被分到三个群集系统里，有的群集系统只有一个"
-#~ "节点。在任何时候，你都可以在群集里加入或删除节点。"
-
-#~ msgid "Clusters and server nodes"
-#~ msgstr "Clusters and server nodes"
-
-#~ msgid ""
-#~ "While it is technically possible to put a JBoss server instance into "
-#~ "multiple clusters at the same time, this practice is generally not "
-#~ "recommended, as it increases the management complexity."
-#~ msgstr ""
-#~ "从技术上来讲，我们可以在同一时间把 JBoss 服务器实例放到多个群集里，但我们"
-#~ "通常不推荐这么做，因为这增加了管理的复杂性。"
-
-#~ msgid ""
-#~ "Each JBoss server instance (node) specifies which cluster (i.e., "
-#~ "partition) it joins in the <literal>ClusterPartition</literal> MBean in "
-#~ "the <literal>deploy/cluster-service.xml</literal> file. All nodes that "
-#~ "have the same <literal>ClusterPartition</literal> MBean configuration "
-#~ "join the same cluster. Hence, if you want to divide JBoss nodes in a "
-#~ "network into two clusters, you can just come up with two different "
-#~ "<literal>ClusterPartition</literal> MBean configurations, and each node "
-#~ "would have one of the two configurations depending on which cluster it "
-#~ "needs to join. If the designated cluster does not exist when the node is "
-#~ "started, the cluster would be created. Likewise, a cluster is removed "
-#~ "when all its nodes are removed."
-#~ msgstr ""
-#~ "每个 JBoss 服务器实例（节点）在 <literal>deploy/cluster-service.xml</"
-#~ "literal> 文件的 <literal>ClusterPartition</literal> MBean 里指定了它所加入"
-#~ "的群集（也就是 partition）。所有具有相同 <literal>ClusterPartition</"
-#~ "literal> MBean 配置的节点加入到同一个群集系统里。因此，如果你想把同一个网"
-#~ "络里的 JBoss 节点分开到两个群集里，你可以使用两个不同的 "
-#~ "<literal>ClusterPartition</literal> MBean 配置，每个节点可以根据它所需要加"
-#~ "入的群集来选择其中一个配置。如果节点启动的时候，它指定的群集不存在，这个群"
-#~ "集将被创建。相同地，当群集系统的所有节点都被删除后，这个群集也将被删除。"
-
-#~ msgid ""
-#~ "The following example shows the MBean definition packaged with the "
-#~ "standard JBoss AS distribution. So, if you simply start JBoss servers "
-#~ "with their default clustering settings on a local network, you would get "
-#~ "a default cluster named <literal>DefaultPartition</literal> that includes "
-#~ "all server instances as its nodes."
-#~ msgstr ""
-#~ "下例展示了标准 JBoss AS 发行版本里的 MBean 的定义。如果你在本地网络里用缺"
-#~ "省的群集设定来启动 JBoss 服务器，你将得到一个叫 "
-#~ "<literal>DefaultPartition</literal> 的缺省群集，它包括了所有作为节点的服务"
-#~ "器实例。"
-
-#~ msgid ""
-#~ "<mbean code=\"org.jboss.ha.framework.server.ClusterPartition\"\n"
-#~ " name=\"jboss:service=DefaultPartition\">\n"
-#~ " \n"
-#~ " <! -- Name of the partition being built -->\n"
-#~ " <attribute name=\"PartitionName\">\n"
-#~ " ${jboss.partition.name:DefaultPartition}\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <! -- The address used to determine the node name -->\n"
-#~ " <attribute name=\"NodeAddress\">${jboss.bind.address}</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <! -- Determine if deadlock detection is enabled -->\n"
-#~ " <attribute name=\"DeadlockDetection\">False</attribute>\n"
-#~ " \n"
-#~ " <! -- Max time (in ms) to wait for state transfer to complete. \n"
-#~ " Increase for large states -->\n"
-#~ " <attribute name=\"StateTransferTimeout\">30000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <! -- The JGroups protocol configuration -->\n"
-#~ " <attribute name=\"PartitionConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ "</mbean>"
-#~ msgstr ""
-#~ "<mbean code=\"org.jboss.ha.framework.server.ClusterPartition\"\n"
-#~ " name=\"jboss:service=DefaultPartition\">\n"
-#~ " \n"
-#~ " <! -- Name of the partition being built -->\n"
-#~ " <attribute name=\"PartitionName\">\n"
-#~ " ${jboss.partition.name:DefaultPartition}\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <! -- The address used to determine the node name -->\n"
-#~ " <attribute name=\"NodeAddress\">${jboss.bind.address}</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <! -- Determine if deadlock detection is enabled -->\n"
-#~ " <attribute name=\"DeadlockDetection\">False</attribute>\n"
-#~ " \n"
-#~ " <! -- Max time (in ms) to wait for state transfer to complete. \n"
-#~ " Increase for large states -->\n"
-#~ " <attribute name=\"StateTransferTimeout\">30000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <! -- The JGroups protocol configuration -->\n"
-#~ " <attribute name=\"PartitionConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ "</mbean>"
-
-#, fuzzy
-#~ msgid ""
-#~ "Here, we omitted the detailed JGroups protocol configuration for this "
-#~ "cluster. JGroups handles the underlying peer-to-peer communication "
-#~ "between nodes, and its configuration is discussed in <xref linkend="
-#~ "\"JBossCache_and_JGroups_Services-JGroups_Configuration\"/>. The "
-#~ "following list shows the available configuration attributes in the "
-#~ "<literal>ClusterPartition</literal> MBean."
-#~ msgstr ""
-#~ "在这里，我们忽略了这个群集的详细的 JGroups 协议配置（protocal "
-#~ "configuration）。JGroups 处理节点之间底层的点到点通信，我们将在 <xref "
-#~ "linkend=\"jbosscache-jgroups\"/> 里讨论它的配置。下面的列表展示了 "
-#~ "<literal>ClusterPartition</literal> MBean 里可用的配置属性。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> is an optional attribute "
-#~ "to specify the name of the cluster. Its default value is "
-#~ "<literal>DefaultPartition</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> 是用来指定节点名称的可选"
-#~ "属性。它的缺省值是 <literal>DefaultPartition</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">NodeAddress</emphasis> is an optional attribute "
-#~ "to specify the binding IP address of this node."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">NodeAddress</emphasis> 是用来指定节点所绑定的 IP "
-#~ "地址的可选属性。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">DeadlockDetection</emphasis> is an optional "
-#~ "boolean attribute that tells JGroups to run message deadlock detection "
-#~ "algorithms with every request. Its default value is <literal>false</"
-#~ "literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">DeadlockDetection</emphasis> 是用来通知 JGroups 为"
-#~ "每个请求运行消息死锁检测算法（message deadlock detection algorithms）的可"
-#~ "选布尔值属性。它的缺省值是 <literal>false</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">StateTransferTimeout</emphasis> is an optional "
-#~ "attribute to specify the timeout for state replication across the cluster "
-#~ "(in milliseconds). Its default value is <literal>30000</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">StateTransferTimeout</emphasis> 是用来指定跨群集的"
-#~ "状态复制（state replication）的超时时间（以毫秒为单位）的可选属性。它的缺"
-#~ "省值是 <literal>30000</literal>。"
-
-#, fuzzy
-#~ msgid ""
-#~ "<emphasis role=\"bold\">PartitionConfig</emphasis> is an element to "
-#~ "specify JGroup configuration options for this cluster (see <xref linkend="
-#~ "\"JBossCache_and_JGroups_Services-JGroups_Configuration\"/>)."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">PartitionConfig</emphasis> 是一个用来为这个群集"
-#~ "（参看 <xref linkend=\"jbosscache-jgroups\"/>）指定 JGroup 配置选项的元素"
-#~ "（element）。"
-
-#, fuzzy
-#~ msgid ""
-#~ "In order for nodes to form a cluster, they must have the exact same "
-#~ "<literal>PartitionName</literal> and the <literal>ParitionConfig</"
-#~ "literal> elements. Changes in either element on some but not all nodes "
-#~ "would cause the cluster to split. It is generally easier to change the "
-#~ "<literal>ParitionConfig</literal> (i.e., the address/port) to run "
-#~ "multiple cluster rather than changing the <literal>PartitionName</"
-#~ "literal> due to the mulititude of places the former needs to be changed "
-#~ "in other configuration files. However, changing the "
-#~ "<literal>PartitionName</literal> is made easier in 4.2 due to the use of "
-#~ "the <literal>${jboss.partition.name}</literal> property which allows the "
-#~ "name to be change via a single <literal>jboss.partition.name</literal> "
-#~ "system property"
-#~ msgstr ""
-#~ "为了组成一个群集系统，它们必须有刚好一样的 <literal>PartitionName</"
-#~ "literal> 和 <literal>ParitionConfig</literal> 元素。只改变其中一些而不是"
-#~ "全部节点会导致群集的分离。通常来说，修改 <literal>ParitionConfig</literal>"
-#~ "（即：地址/端口）而不是 <literal>PartitionName</literal> 来运行多个群集系"
-#~ "统会比较容易，因为后者需要在其他配置文件里的多个地方修改。然而，在 4.0.2+ "
-#~ "以后的版本里，修改 <literal>PartitionName</literal> 反而更方便了。因为使用"
-#~ "了 <literal>${jboss.partition.name}</literal> 属性，它允许通过单个的 "
-#~ "<literal>jboss.partition.name</literal> 系统属性来修改群集系统的名字。"
-
-#, fuzzy
-#~ msgid ""
-#~ "You can view the current cluster information by pointing your browser to "
-#~ "the JMX console of any JBoss instance in the cluster (i.e., <ulink url="
-#~ "\"http://hostname:8080/jmx-console/\">http://hostname:8080/jmx-console/</"
-#~ "ulink>) and then clicking on the <literal>jboss:service=DefaultPartition</"
-#~ "literal> MBean (change the MBean name to reflect your cluster name if "
-#~ "this node does not join <literal>DefaultPartition</literal>). A list of "
-#~ "IP addresses for the current cluster members is shown in the "
-#~ "<literal>CurrentView</literal> field."
-#~ msgstr ""
-#~ "你可以用浏览器访问群集系统里的任何 JBoss 实例的 JMX 控制台来查看当前的群集"
-#~ "信息（如，<literal>http://hostname:8080/jmx-console/</literal>），点击 "
-#~ "<literal>jboss:service=DefaultPartition</literal> MBean（如果这个节点没有"
-#~ "加入 <literal>DefaultPartition</literal>，你可以改变 MBean 名来反映群集"
-#~ "名）。<literal>CurrentView</literal> 字段会显示当前群集的 IP 地址的列表。"
-
-#, fuzzy
-#~ msgid ""
-#~ "A cluster (partition) contains a set of nodes that work toward a same "
-#~ "goal. Some clustering features require to sub-partition the cluster to "
-#~ "achieve a better scalability. For example, let's imagine that we have "
-#~ "a 10-node cluster and we want to replicate in memory the state of "
-#~ "stateful session beans on all 10 different nodes to provide for fault-"
-#~ "tolerant behaviour. It would mean that each node has to store a backup of "
-#~ "the 9 other nodes. This would not scale at all (each node would need to "
-#~ "carry the whole state cluster load). It is probably much better to have "
-#~ "some kind of sub-partitions inside a cluster and have beans state "
-#~ "exchanged only between nodes that are part of the same sub-partition. The "
-#~ "future JBoss clustering implementation will support sub-partitions and it "
-#~ "will allow the cluster administrator to determine the optimal size of a "
-#~ "sub-partition. The sub-partition topology computation will be done "
-#~ "dynamically by the cluster."
-#~ msgstr ""
-#~ "群集系统（partition）包含了实现同一目标的节点。某些群集特征需要用群集的子"
-#~ "分区（sub-partition）来实现更好的扩展性。例如，假设有一个 10 个节点的群"
-#~ "集，我们想把所有 10 个不同的节点上的 stateful session beans 的状态复制在内"
-#~ "存里来提供容错行为。这意味着每个节点都存有其他 9 个节点的备份。其实这根本"
-#~ "就不能扩展（因为每个节点都承担了整个群集负载）。在这个情况下，使用群集里的"
-#~ "某种子分区（sub-partition），只在同一子分区内的节点之间交换 beans 状态可能"
-#~ "会更好。以后的 JBoss 群集实现将支持子分区，允许群集管理者来决定子分区的最"
-#~ "佳规模。子分区的拓扑计算将由群集系统动态地完成。"
-
-#~ msgid "Service Architectures"
-#~ msgstr "服务架构"
-
-#, fuzzy
-#~ msgid ""
-#~ "The clustering topography defined by the <literal>ClusterPartition</"
-#~ "literal> MBean on each node is of great importance to system "
-#~ "administrators. But for most application developers, you are probably "
-#~ "more concerned about the cluster architecture from a client "
-#~ "application's point of view. JBoss AS supports two types of "
-#~ "clustering architectures: client-side interceptors (a.k.a proxies or "
-#~ "stubs) and load balancers."
-#~ msgstr ""
-#~ "每个节点上的 <literal>ClusterPartition</literal> MBean 定义的群集拓扑结构"
-#~ "（clustering topography）对系统管理员很重要。但是对于大部分的应用程序开发"
-#~ "者来说，你可能更关心从客户应用程序的角度来看的群集架构。JBoss AS 支持两种"
-#~ "群集架构：客户端拦截器（client-side interceptors）（proxies 或 stubs）和负"
-#~ "载平衡系统（load balancers）。"
-
-#~ msgid "Client-side interceptor"
-#~ msgstr "客户端拦截器"
-
-#~ msgid ""
-#~ "Most remote services provided by the JBoss application server, including "
-#~ "JNDI, EJB, RMI and JBoss Remoting, require the client to obtain (e.g., to "
-#~ "look up and download) a stub (or proxy) object. The stub object is "
-#~ "generated by the server and it implements the business interface of the "
-#~ "service. The client then makes local method calls against the stub "
-#~ "object. The call is automatically routed across the network and invoked "
-#~ "against service objects managed in the server. In a clustering "
-#~ "environment, the server-generated stub object is also an interceptor that "
-#~ "understand how to route calls to nodes in the cluster. The stub object "
-#~ "figures out how to find the appropriate server node, marshal call "
-#~ "parameters, un-marshall call results, return the results to the caller "
-#~ "client."
-#~ msgstr ""
-#~ "JBoss 应用服务器提供的大部分远程服务，包括 JNDI、EJB、RMI 和 JBoss "
-#~ "Remoting，都要求客户端获得（如，查找和下载）一个 stub（或 proxy）对象。占"
-#~ "位对象（stub object）由服务器生成，它实现服务的商业接口。客户可对占位对象"
-#~ "调用本地方法。这个调用会自动寻找路由，并被服务器管理的服务对象引用。在群集"
-#~ "环境里，服务器生成的占位对象也是一个懂得怎样把调用指引向不同节点的拦截器。"
-#~ "占位对象寻找合适的服务器节点、配置调用参数、解释调用结果，并把结果返回给调"
-#~ "用程序。"
-
-#, fuzzy
-#~ msgid ""
-#~ "The stub interceptors have updated knowledge about the cluster. For "
-#~ "instance, they know the IP addresses of all available server nodes, the "
-#~ "algorithm to distribute load across nodes (see next section), and how to "
-#~ "failover the request if the target node not available. With every service "
-#~ "request, the server node updates the stub interceptor with the latest "
-#~ "changes in the cluster. For instance, if a node drops out of the cluster, "
-#~ "each of the client stub interceptor is updated with the new configuration "
-#~ "the next time it connects to any active node in the cluster. All the "
-#~ "manipulations on the service stub are transparent to the client "
-#~ "application. The client-side interceptor clustering architecture is "
-#~ "illustrated in <xref linkend=\"Client_side_interceptor-"
-#~ "The_client_side_interceptor_proxy_architecture_for_clustering\"/>."
-#~ msgstr ""
-#~ "stub interceptors 拥有群集系统的更新信息。例如，它们知道所有可用网络节点"
-#~ "的 IP 地址，怎样在节点上分摊负载的算法（请参考下一部分内容），和如果目标节"
-#~ "点不可用时对请求进行失效切换（failover）。对于每个服务请求，服务器节点都用"
-#~ "群集里最新的信息来更新 stub interceptor。例如，如果一个节点退出群集系统"
-#~ "后，每个客户 stub interceptor 在下一次连接活动的节点时，都会用新的配置来更"
-#~ "新。在 service stub 上的所有操作对于客户应用程序都是透明的。<xref linkend="
-#~ "\"clustering-InterceptorArch.fig\"/> 里说明了客户端拦截器群集架构。"
-
-#~ msgid "The client-side interceptor (proxy) architecture for clustering"
-#~ msgstr "The client-side interceptor (proxy) architecture for clustering"
-
-#~ msgid ""
-#~ "describes how to enable the client proxy to handle the entire cluster "
-#~ "restart."
-#~ msgstr "描述怎样用客户代理（client proxy）来处理整个群集系统的重启。"
-
-#~ msgid "Load balancer"
-#~ msgstr "负载平衡系统"
-
-#, fuzzy
-#~ msgid ""
-#~ "Other JBoss services, in particular the HTTP web services, do not require "
-#~ "the client to download anything. The client (e.g., a web browser) sends "
-#~ "in requests and receives responses directly over the wire according to "
-#~ "certain communication protocols (e.g., the HTTP protocol). In this case, "
-#~ "a load balancer is required to process all requests and dispatch them to "
-#~ "server nodes in the cluster. The load balancer is typically part of the "
-#~ "cluster. It understands the cluster configuration as well as failover "
-#~ "policies. The client only needs to know about the load balancer. The load "
-#~ "balancer clustering architecture is illustrated in <xref linkend="
-#~ "\"Load_balancer-The_load_balancer_architecture_for_clustering\"/>."
-#~ msgstr ""
-#~ "其他的 JBoss 服务，特别是 HTTP web 服务，不要求客户下载任何东西。客户端"
-#~ "（如，web 浏览器）按照某种通信协议（如 HTTP 协议）直接发送请求和接收回复。"
-#~ "在这种情况下，负载平衡系统需要处理所有的请求并把它们分配给群集里的服务器节"
-#~ "点。负载平衡系统是群集里的一个典型概念。它理解群集配置和失效切换策略"
-#~ "（failover policies）。客户只需要知道它的存在。<xref linkend=\"clustering-"
-#~ "BalancerArch.fig\"/> 说明了负载平衡系统的群集架构。"
-
-#~ msgid "The load balancer architecture for clustering"
-#~ msgstr "The load balancer architecture for clustering"
-
-#~ msgid ""
-#~ "A potential problem with the load balancer solution is that the load "
-#~ "balancer itself is a single point of failure. It needs to be monitored "
-#~ "closely to ensure high availability of the entire cluster services."
-#~ msgstr ""
-#~ "负载平衡系统的一个潜在问题就是它本身就是单一的故障点。它需要被很好地监控来"
-#~ "确保整个群集服务的高可用性。"
-
-#~ msgid "Load-Balancing Policies"
-#~ msgstr "负载平衡策略"
-
-#, fuzzy
-#~ msgid ""
-#~ "Both the JBoss client-side interceptor (stub) and load balancer use load "
-#~ "balancing policies to determine which server node to send a new request "
-#~ "to. In this section, let's go over the load balancing policies "
-#~ "available in JBoss AS."
-#~ msgstr ""
-#~ "JBoss 客户端拦截器（stub）和负载平衡系统都使用了负载平衡策略来决定把新请求"
-#~ "发送给哪个节点。让我们来看看 JBoss AS 里的负载平衡策略。"
-
-#~ msgid "JBoss AS 3.0.x"
-#~ msgstr "JBoss AS 3.0.x"
-
-#~ msgid ""
-#~ "In JBoss 3.0.x, the following two load balancing options are available."
-#~ msgstr "在 JBoss 3.0.x 里，有下面两种可用的负载平衡选项。"
-
-#~ msgid ""
-#~ "Round-Robin (<literal>org.jboss.ha.framework.interfaces.RoundRobin</"
-#~ "literal>): each call is dispatched to a new node. The first target node "
-#~ "is randomly selected from the list."
-#~ msgstr ""
-#~ "Round-Robin (<literal>org.jboss.ha.framework.interfaces.RoundRobin</"
-#~ "literal>)：每次调用都分派给新节点。第一个目标节点从列表里随机选择。"
-
-#~ msgid ""
-#~ "First Available (<literal>org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable</literal>): one of the available target nodes is elected "
-#~ "as the main target and is used for every call: this elected member is "
-#~ "randomly chosen from the list of members in the cluster. When the list of "
-#~ "target nodes changes (because a node starts or dies), the policy will re-"
-#~ "elect a target node unless the currently elected node is still available. "
-#~ "Each client-side interceptor or load balancer elects its own target node "
-#~ "independently of the other proxies."
-#~ msgstr ""
-#~ "First Available (<literal>org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable</literal>)：选择其中一个可用目标节点作为主目标节点，用于每"
-#~ "次调用：这个节点是在群集里的节点列表里随机选取的。当目标节点的列表改变时"
-#~ "（因为有节点启动或退出），除非当前选用的节点仍然可用，这个策略会重新选择一"
-#~ "个目标节点。每个客户端拦截器或者负载平衡系统都会根据自己的策略独立地选择目"
-#~ "标节点。"
-
-#~ msgid "JBoss AS 3.2+"
-#~ msgstr "JBoss AS 3.2+"
-
-#~ msgid ""
-#~ "In JBoss 3.2+, three load balancing options are available. The Round-"
-#~ "Robin and First Available options have the same meaning as the ones in "
-#~ "JBoss AS 3.0.x."
-#~ msgstr ""
-#~ "在 JBoss 3.2+ 里，有三个负载平衡策略可用。其中 Round-Robin 和 First "
-#~ "Available 选项和 JBoss AS 3.0.x 里的一样。"
-
-#~ msgid ""
-#~ "The new load balancing option in JBoss 3.2 is \"First "
-#~ "AvailableIdenticalAllProxies\" (<literal>org.jboss.ha.framework."
-#~ "interfaces.FirstAvailableIdenticalAllProxies</literal>). It has the same "
-#~ "behaviour as the \"First Available\" policy but the elected target node "
-#~ "is shared by all client-side interceptors of the same \"family\"."
-#~ msgstr ""
-#~ "JBoss 3.2 里的新的负载平衡选项是 \"First AvailableIdenticalAllProxies"
-#~ "\" (<literal>org.jboss.ha.framework.interfaces."
-#~ "FirstAvailableIdenticalAllProxies</literal>)。它与 \"First Available\" 有"
-#~ "相同的行为，但选取的目标节点由所有同一 \"family\" 的客户端拦截器共享。"
-
-#, fuzzy
-#~ msgid ""
-#~ "In JBoss 3.2 (and later), the notion of \"Proxy Family\" is defined. A "
-#~ "Proxy Family is a set of stub interceptors that all make invocations "
-#~ "against the same replicated target. For EJBs for example, all stubs "
-#~ "targeting the same EJB in a given cluster belong to the same proxy "
-#~ "family. All interceptors of a given family share the same list of target "
-#~ "nodes. Each interceptor also has the ability to share arbitrary "
-#~ "information with other interceptors of the same family. A use case for "
-#~ "the proxy family is give in <xref linkend=\"Clustered_Session_EJBs-"
-#~ "Stateless_Session_Bean_in_EJB_2.x\"/>."
-#~ msgstr ""
-#~ "在 JBoss 3.2（或更新的版本）里定义了 \"Proxy Family\" 标识。代理族（Proxy "
-#~ "Family）是所有对同一被复制目标调用的 stub interceptors 的集合。拿 EJB 来"
-#~ "说，在给定群集里所有以同一 EJB 为目标的 stubs 属于同一代理族。给定族里拦截"
-#~ "器共享相同的目标节点的列表。每个拦截器也能够与同一族里的其他拦截器共享任何"
-#~ "信息。<xref linkend=\"clustering-session-slsb21\"/> 里给出了代理族的一个用"
-#~ "例。"
-
-#~ msgid "Farming Deployment"
-#~ msgstr "Farming 部署"
-
-#, fuzzy
-#~ msgid ""
-#~ "The easiest way to deploy an application into the cluster is to use the "
-#~ "farming service. That is to hot-deploy the application archive file (e."
-#~ "g., the EAR, WAR or SAR file) in the<code>all/farm/</code>directory of "
-#~ "any of the cluster member and the application is automatically duplicated "
-#~ "across all nodes in the same cluster. If node joins the cluster later, it "
-#~ "will pull in all farm deployed applications in the cluster and deploy "
-#~ "them locally at start-up time. If you delete the application from one of "
-#~ "the running cluster server node's <literal>farm/</literal> folder, "
-#~ "the application will be undeployed locally and then removed from all "
-#~ "other cluster server nodes farm folder (triggers undeployment.) You "
-#~ "should manually delete the application from the farm folder of any server "
-#~ "node not currently connected to the cluster."
-#~ msgstr ""
-#~ "把应用程序部署到群集里最简单的方法就是使用 farming 服务。那就是在任何群集"
-#~ "节点的 <code>all/farm/</code> 目录下热部署（hot-deploy）应用程序档案文件"
-#~ "（如 EAR，WAR 或 SAR 文件），而且应用程序自动地在同一群集里的节点间复制。"
-#~ "如果节点后来才加入到群集里，它会引入群集里所有用 farm 部署的应用程序并在启"
-#~ "动时把它们部署在本地。如果你从某一正运行的群集节点的 <literal>farm/</"
-#~ "literal> 文件夹里把应用程序删除，这个应用程序将从本地移除并从所有其他群集"
-#~ "服务器节点 farm 文件夹移走（触发移除）。对于当前未与群集系统相连的服务器节"
-#~ "点，你应该手工地从 farm 文件夹里把应用程序删除。"
-
-#~ msgid ""
-#~ "You can only put archive files, not exploded directories, in the "
-#~ "<literal>farm</literal> directory. This way, the application on a remote "
-#~ "node is only deployed when the entire archive file is copied over. "
-#~ "Otherwise, the application might be deployed (and failed) when the "
-#~ "directory is only partially copied."
-#~ msgstr ""
-#~ "你只能把档案文件而不是展开的目录，放到 <literal>farm</literal> 目录里。因"
-#~ "为这样，远程节点的应用程序只有当整个档案文件被拷贝时才会被部署。否则，当目"
-#~ "录只是部分地被复制时，这个应用程序不能被部署。"
-
-#~ msgid ""
-#~ "Farming is enabled by default in the <literal>all</literal> configuration "
-#~ "in JBoss AS distributions, so you will not have to set it up yourself. "
-#~ "The configuration file is located in the <literal>deploy/deploy.last</"
-#~ "literal> directory. If you want to enable farming in your custom "
-#~ "configuration, simply create the XML file shown below (named it "
-#~ "<literal>farm-service.xml</literal>) and copy it to the JBoss deploy "
-#~ "directory <literal>$JBOSS_HOME/server/your_own_config/deploy</literal>. "
-#~ "Make sure that you custom configuration has clustering enabled."
-#~ msgstr ""
-#~ "在 JBoss AS 发行版本里，Farming 在 <literal>all</literal> 配置里是缺省被启"
-#~ "用的，所以你不需要自己来设置它。配置文件放在 <literal>deploy/deploy.last</"
-#~ "literal> 目录下。如果你想在自定义的配置文件里启用 farming，只需要建立如下"
-#~ "所示的 XML 文件（<literal>farm-service.xml</literal>）并把它拷贝到 JBoss "
-#~ "的 <literal>$JBOSS_HOME/server/your_own_config/deploy</literal> 目录下。请"
-#~ "确保你的自定义配置文件启用了群集系统。"
-
-#~ msgid ""
-#~ "<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n"
-#~ "<server> \n"
-#~ " \n"
-#~ " <mbean code=\"org.jboss.ha.framework.server.FarmMemberService"
-#~ "\" \n"
-#~ " name=\"jboss:service=FarmMember,partition=DefaultPartition"
-#~ "\"> \n"
-#~ " ... \n"
-#~ " <attribute name=\"PartitionName\">DefaultPartition</"
-#~ "attribute> \n"
-#~ " <attribute name=\"ScanPeriod\">5000</"
-#~ "attribute> \n"
-#~ " <attribute name=\"URLs\">farm/</attribute> \n"
-#~ " </mbean> \n"
-#~ "</server>"
-#~ msgstr ""
-#~ "<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n"
-#~ "<server> \n"
-#~ " \n"
-#~ " <mbean code=\"org.jboss.ha.framework.server.FarmMemberService"
-#~ "\" \n"
-#~ " name=\"jboss:service=FarmMember,partition=DefaultPartition"
-#~ "\"> \n"
-#~ " ... \n"
-#~ " <attribute name=\"PartitionName\">DefaultPartition</"
-#~ "attribute> \n"
-#~ " <attribute name=\"ScanPeriod\">5000</"
-#~ "attribute> \n"
-#~ " <attribute name=\"URLs\">farm/</attribute> \n"
-#~ " </mbean> \n"
-#~ "</server>"
-
-#~ msgid ""
-#~ "After deploying <literal>farm-service.xml</literal> you are ready to "
-#~ "rumble. The required <literal>FarmMemberService</literal> MBean "
-#~ "attributes for configuring a farm are listed below."
-#~ msgstr ""
-#~ "在部署了 <literal>farm-service.xml</literal> 之后，下面所列是配置 farm 所"
-#~ "需的 <literal>FarmMemberService</literal> MBean 属性。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> specifies the name of "
-#~ "the cluster for this deployed farm. Its default value is "
-#~ "<literal>DefaultPartition</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> 指定了部署这个 farm 的群"
-#~ "集的名字。它的缺省值是 <literal>DefaultPartition</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">URLs</emphasis> points to the directory where "
-#~ "deployer watches for files to be deployed. This MBean will create this "
-#~ "directory is if does not already exist. Also, \".\" pertains to the "
-#~ "configuration directory (i.e., <literal>$JBOSS_HOME/server/all/</"
-#~ "literal>)."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">URLs</emphasis> 指向部署者（deployer）用来观察文件"
-#~ "部署的目录。如果这个目录不存在，MBean 将创建它。而且，\".\" 指向配置目录"
-#~ "（也就是：<literal>$JBOSS_HOME/server/all/</literal>）。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">ScanPeriod</emphasis> specifies the interval at "
-#~ "which the folder must be scanned for changes.. Its default value is "
-#~ "<literal>5000</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">ScanPeriod</emphasis> 指定了扫描文件夹变化的时间间"
-#~ "隔。它的缺省值是 <literal>5000</literal>。"
-
-#~ msgid ""
-#~ "The Farming service is an extension of the <literal>URLDeploymentScanner</"
-#~ "literal>, which scans for hot deployments in <literal>deploy/</literal> "
-#~ "directory. So, you can use all the attributes defined in the "
-#~ "<literal>URLDeploymentScanner</literal> MBean in the "
-#~ "<literal>FarmMemberService</literal> MBean. In fact, the <literal>URLs</"
-#~ "literal> and <literal>ScanPeriod</literal> attributes listed above are "
-#~ "inherited from the <literal>URLDeploymentScanner</literal> MBean."
-#~ msgstr ""
-#~ "Farming 服务是 <literal>URLDeploymentScanner</literal> 的扩展，它扫描 "
-#~ "<literal>deploy/</literal> 目录下的热部署（hot deployment）。所以，你能够"
-#~ "使用 <literal>FarmMemberService</literal> MBean 里的 "
-#~ "<literal>URLDeploymentScanner</literal> MBean 定义的所有属性。实际上，上"
-#~ "列 <literal>URLs</literal> 和 <literal>ScanPeriod</literal> 属性都是从 "
-#~ "<literal>URLDeploymentScanner</literal> MBean 继承过来的。"
-
-#~ msgid "Distributed state replication services"
-#~ msgstr "分布式状态复制服务"
-
-#~ msgid ""
-#~ "In a clustered server environment, distributed state management is a key "
-#~ "service the cluster must provide. For instance, in a stateful session "
-#~ "bean application, the session state must be synchronized among all bean "
-#~ "instances across all nodes, so that the client application reaches the "
-#~ "same session state no matter which node serves the request. In an entity "
-#~ "bean application, the bean object sometimes needs to be cached across the "
-#~ "cluster to reduce the database load. Currently, the state replication and "
-#~ "distributed cache services in JBoss AS are provided via two ways: the "
-#~ "<literal>HASessionState</literal> MBean and the JBoss Cache framework."
-#~ msgstr ""
-#~ "在群集服务器环境里，分布式状态管理（distributed state management）是群集系"
-#~ "统必须提供的一个关键服务。例如，在 stateful session bean 应用程序里，会话"
-#~ "状态（session state）必须在所有节点的 bean 实例中同步，这可以使客户应用程"
-#~ "序获得相同的会话状态，而不用管是哪个节点处理请求。在 entity bean 应用程序"
-#~ "里，bean 对象有时候需要跨群集地缓存来减少数据库负载。目前，JBoss AS 里的状"
-#~ "态复制（state replication）和分布式缓存服务（distributed cache service）由"
-#~ "两个途径提供：<literal>HASessionState</literal> MBean 和 JBoss Cache "
-#~ "framework。"
-
-#~ msgid ""
-#~ "The <literal>HASessionState</literal> MBean provides session replication "
-#~ "and distributed cache services for EJB 2.x stateful session beans and "
-#~ "HTTP load balancers in JBoss 3.x and 4.x. The MBean is defined in the "
-#~ "<literal>all/deploy/cluster-service.xml</literal> file. We will show its "
-#~ "configuration options in the EJB 2.x stateful session bean section later."
-#~ msgstr ""
-#~ "<literal>HASessionState</literal> MBean 为 EJB 2.x 的 stateful session "
-#~ "beans 和 JBoss 3.x 和 4.x 里的 HTTP 负载平衡提供会话复制（session "
-#~ "replication）和分布式缓存服务（distributed cache service）。<literal>all/"
-#~ "deploy/cluster-service.xml</literal> 文件里定义了这个 MBean。我们会在后面"
-#~ "的 EJB 2.x stateful session bean 部分展示它的配置选项。"
-
-#~ msgid ""
-#~ "JBoss Cache is a fully featured distributed cache framework that can be "
-#~ "used in any application server environment and standalone. It gradually "
-#~ "replaces the <literal>HASessionState</literal> service. JBoss AS "
-#~ "integrates JBoss Cache to provide cache services for HTTP sessions, EJB "
-#~ "3.0 session and entity beans, as well as Hibernate persistence objects. "
-#~ "Each of these cache services is defined in a separate MBean. We will "
-#~ "cover those MBeans when we discuss specific services in the next several "
-#~ "sections."
-#~ msgstr ""
-#~ "JBoss Cache 是个一个能用在任何应用程序和独立服务器环境里的分布式缓存框架。"
-#~ "它逐渐地代替了 <literal>HASessionState</literal> 服务。JBoss AS 集成了 "
-#~ "JBoss Cache 来为 HTTP 会话，EJB 3.0，entity beans 和 Hibernate 持久化对象 "
-#~ "（persistence objects） 提供缓存服务，每个缓存服务都在不同的 MBean 里定"
-#~ "义。我们将在后面讨论特定服务时介绍这些 MBean。"
-
-#~ msgid "Clustered JNDI Services"
-#~ msgstr "群集的 JNDI 服务"
-
-#~ msgid ""
-#~ "JNDI is one of the most important services provided by the application "
-#~ "server. The JBoss clustered JNDI service is based on the client-side "
-#~ "interceptor architecture. The client must obtain a JNDI stub object (via "
-#~ "the <literal>InitialContext</literal> object) and invoke JNDI lookup "
-#~ "services on the remote server through the stub. Furthermore, JNDI is the "
-#~ "basis for many other interceptor-based clustering services: those "
-#~ "services register themselves with the JNDI so that the client can lookup "
-#~ "their stubs and make use of their services."
-#~ msgstr ""
-#~ "JNDI 是应用服务器提供的最重要的服务之一。JBoss 的群集 JNDI 服务基于客户端"
-#~ "拦截器架构。客户必须获得一个 JNDI 占位对象（stub object）（通过"
-#~ "<literal>InitialContext</literal>对象）和通过 stub 在远程服务器上调用 "
-#~ "JNDI 查找服务。而且，JNDI 是许多其他基于拦截器的群集服务的基础：这些服务"
-#~ "在 JNDI 上注册，客户就可以查找它们的 stubs 并使用它们的服务。"
-
-#~ msgid "How it works"
-#~ msgstr "它怎样工作"
-
-#~ msgid ""
-#~ "The JBoss HA-JNDI (High Availability JNDI) service maintains a cluster-"
-#~ "wide context tree. The cluster wide tree is always available as long as "
-#~ "there is one node left in the cluster. Each JNDI node in the cluster also "
-#~ "maintains its own local JNDI context. The server side application can "
-#~ "bind its objects to either trees. In this section, you will learn the "
-#~ "distinctions of the two trees and the best practices in application "
-#~ "development. The design rational of this architecture is as follows."
-#~ msgstr ""
-#~ "JBoss HA-JNDI （高可用性 JNDI）服务维护了一个跨群集的上下文树（context "
-#~ "tree）。只要群集里有一个节点，这个树就会存在。群集里的每个 JNDI 节点也维护"
-#~ "子集的本地 JNDI 上下文。服务器端的应用程序可以把它的对象绑定在两者中的任意"
-#~ "一个上。在本部分内容里，你将学习怎样区分这两种树和在应用部署时的最佳做法。"
-#~ "这个架构的合理设计如下："
-
-#, fuzzy
-#~ msgid ""
-#~ "We didn't want any migration issues with applications already "
-#~ "assuming that their JNDI implementation was local. We wanted clustering "
-#~ "to work out-of-the-box with just a few tweaks of configuration files."
-#~ msgstr ""
-#~ "我们不希望在本地实现 JNDI 的应用程序有任何的移植问题。我们希望通过简单的配"
-#~ "置群集系统就可以正常工作。"
-
-#~ msgid ""
-#~ "We needed a clean distinction between locally bound objects and cluster-"
-#~ "wide objects."
-#~ msgstr "我们需要清晰地区分本地绑定的对象和跨群集的对象。"
-
-#~ msgid ""
-#~ "In a homogeneous cluster, this configuration actually cuts down on the "
-#~ "amount of network traffic."
-#~ msgstr "在同样的群集里，这个配置实际上降低了网络的负载。"
-
-#~ msgid ""
-#~ "Designing it in this way makes the HA-JNDI service an optional service "
-#~ "since all underlying cluster code uses a straight new "
-#~ "<literal>InitialContext()</literal> to lookup or create bindings."
-#~ msgstr ""
-#~ "既然所有下面的群集节点都使用一个新的 <literal>InitialContext()</literal> "
-#~ "来查找或创建绑定，用这个方法来设计可以使 HA-JNDI 服务成为一种可选的服务。"
-
-#~ msgid ""
-#~ "On the server side, <literal>new InitialContext()</literal>, will be "
-#~ "bound to a local-only, non-cluster-wide JNDI Context (this is actually "
-#~ "basic JNDI). So, all EJB homes and such will not be bound to the cluster-"
-#~ "wide JNDI Context, but rather, each home will be bound into the local "
-#~ "JNDI. When a remote client does a lookup through HA-JNDI, HA-JNDI will "
-#~ "delegate to the local JNDI Context when it cannot find the object within "
-#~ "the global cluster-wide Context. The detailed lookup rule is as follows."
-#~ msgstr ""
-#~ "在服务器端，<literal>new InitialContext()</literal> 将会绑定到一个仅用于本"
-#~ "地的，非跨群集的 JNDI 上下文（实际上是基本 JNDI）。因此，所有 EJB 主接口"
-#~ "（homes）都不会绑定到跨群集的 JNDI 上下文。但是，每个主接口都会绑定到本地 "
-#~ "JNDI 上。当远程的客户通过 HA-JNDI 发起一个查找，HA-JNDI 在全局跨群集上下文"
-#~ "找不到这个对象时会委托给本地 JNDI 上下文。详细的查找规则如下所示。"
-
-#~ msgid ""
-#~ "If the binding is available in the cluster-wide JNDI tree and it returns "
-#~ "it."
-#~ msgstr "如果这个绑定在跨群集的 JNDI 树（JNDI tree）里可用。"
-
-#~ msgid ""
-#~ "If the binding is not in the cluster-wide tree, it delegates the lookup "
-#~ "query to the local JNDI service and returns the received answer if "
-#~ "available."
-#~ msgstr ""
-#~ "如果这个绑定不在跨群集的树里，它会把查找请求委托给本地 JNDI 服务并返回可用"
-#~ "的结果。"
-
-#~ msgid ""
-#~ "If not available, the HA-JNDI services asks all other nodes in the "
-#~ "cluster if their local JNDI service owns such a binding and returns the "
-#~ "an answer from the set it receives."
-#~ msgstr ""
-#~ "如果没有可用的结果，HA-JNDI 服务会查找其他群集里的节点，如果它们的本地 "
-#~ "JNDI 服务拥有这样的绑定，就会返回相应的结果。"
-
-#~ msgid ""
-#~ "If no local JNDI service owns such a binding, a "
-#~ "<literal>NameNotFoundException</literal> is finally raised."
-#~ msgstr ""
-#~ "如果没有任何本地 JNDI 服务有这样的一个绑定，最后会产生 "
-#~ "<literal>NameNotFoundException</literal> 异常。"
-
-#~ msgid ""
-#~ "So, an EJB home lookup through HA-JNDI, will always be delegated to the "
-#~ "local JNDI instance. If different beans (even of the same type, but "
-#~ "participating in different clusters) use the same JNDI name, it means "
-#~ "that each JNDI server will have a different \"target\" bound (JNDI on "
-#~ "node 1 will have a binding for bean A and JNDI on node 2 will have a "
-#~ "binding, under the same name, for bean B). Consequently, if a client "
-#~ "performs a HA-JNDI query for this name, the query will be invoked on any "
-#~ "JNDI server of the cluster and will return the locally bound stub. "
-#~ "Nevertheless, it may not be the correct stub that the client is expecting "
-#~ "to receive!"
-#~ msgstr ""
-#~ "所以，当 EJB home 通过 HA-JNDI 查找，总会委托给本地 JNDI 实例。如果不同的 "
-#~ "beans（即使是相同的类型,但在不同的群集里）使用同一个 JNDI 名称，这意味着每"
-#~ "个 JNDI 服务器将会有一个不同的 \"target\" 绑定（节点 1 上的 JNDI 将有一个"
-#~ "用于 bean A 的绑定,节点 2 会有一个用于 bean B 的相同名字的绑定）。因此，如"
-#~ "果客户为这个名字执行 HA-JNDI 查询，这个查询会在群集里的任何 JNDI 服务器上"
-#~ "调用并返回本地绑定的 stub。而且，它未必是客户所希望的正确的 stub!"
-
-#~ msgid ""
-#~ "You cannot currently use a non-JNP JNDI implementation (i.e. LDAP) for "
-#~ "your local JNDI implementation if you want to use HA-JNDI. However, you "
-#~ "can use JNDI federation using the <literal>ExternalContext</literal> "
-#~ "MBean to bind non-JBoss JNDI trees into the JBoss JNDI namespace. "
-#~ "Furthermore, nothing prevents you though of using one centralized JNDI "
-#~ "server for your whole cluster and scrapping HA-JNDI and JNP."
-#~ msgstr ""
-#~ "如果你想使用 HA-JNDI，你不能有一个用于本地 JNDI 实现的 non-JNP JNDI 实现"
-#~ "（如：LDAP）。然而，你可以用 <literal>ExternalContext</literal> MBean 来运"
-#~ "用 JNDI 联合把非 JBoss JNDI trees 绑定到 JBoss JNDI 命名空间里。而且，你也"
-#~ "可以对整个群集使用集中式的 JNDI 服务器，而不用 HA-JNDI 和 JNP。"
-
-#~ msgid ""
-#~ "If a binding is only made available on a few nodes in the cluster (for "
-#~ "example because a bean is only deployed on a small subset of nodes in the "
-#~ "cluster), the probability to lookup a HA-JNDI server that does not own "
-#~ "this binding is higher and the lookup will need to be forwarded to all "
-#~ "nodes in the cluster. Consequently, the query time will be longer than if "
-#~ "the binding would have been available locally. Moral of the story: as "
-#~ "much as possible, cache the result of your JNDI queries in your client."
-#~ msgstr ""
-#~ "如果绑定只在群集（例如，bean 只在群集里某一小的子集里部署）里的一些节点上"
-#~ "可用，查找没有这个绑定 HA-JNDI 服务器的可能性就增高了，而且需要将查找转发"
-#~ "给群集里的所有节点。因此，查询时间会比这个绑定在本地可用的情况更长。这就告"
-#~ "诉我们：尽可能地在客户端缓存你的 JNDI 查询结果。"
-
-#~ msgid ""
-#~ "If you want to access HA-JNDI from the server side, you must explicitly "
-#~ "get an <literal>InitialContext</literal> by passing in JNDI properties. "
-#~ "The following code shows how to access the HA-JNDI."
-#~ msgstr ""
-#~ "如果你要从服务器端访问 HA-JNDI，你必须传入 JNDI 属性来显性地得到 "
-#~ "<literal>InitialContext</literal>。下面的代码展示了怎样访问 HA-JNDI。"
-
-#~ msgid ""
-#~ "Properties p = new Properties(); \n"
-#~ "p.put(Context.INITIAL_CONTEXT_FACTORY, \n"
-#~ " \"org.jnp.interfaces.NamingContextFactory\"); \n"
-#~ "p.put(Context.URL_PKG_PREFIXES, \"jboss.naming:org.jnp.interfaces\"); \n"
-#~ "p.put(Context.PROVIDER_URL, \"localhost:1100\"); // HA-JNDI port. \n"
-#~ "return new InitialContext(p);"
-#~ msgstr ""
-#~ "Properties p = new Properties(); \n"
-#~ "p.put(Context.INITIAL_CONTEXT_FACTORY, \n"
-#~ " \"org.jnp.interfaces.NamingContextFactory\"); \n"
-#~ "p.put(Context.URL_PKG_PREFIXES, \"jboss.naming:org.jnp.interfaces\"); \n"
-#~ "p.put(Context.PROVIDER_URL, \"localhost:1100\"); // HA-JNDI port. \n"
-#~ "return new InitialContext(p);"
-
-#, fuzzy
-#~ msgid ""
-#~ "The <literal>Context.PROVIDER_URL</literal> property points to the HA-"
-#~ "JNDI service configured in the <literal>HANamingService</literal> MBean "
-#~ "(see <xref linkend=\"Clustered_JNDI_Services-JBoss_configuration\"/>)."
-#~ msgstr ""
-#~ "<literal>Context.PROVIDER_URL</literal> 属性指向 "
-#~ "<literal>HANamingService</literal> MBean （参看 <xref linkend="
-#~ "\"clustering-jndi-jboss\"/>）里配置的 HA-JNDI 服务。"
-
-#~ msgid "Client configuration"
-#~ msgstr "客户端配置"
-
-#, fuzzy
-#~ msgid ""
-#~ "The JNDI client needs to be aware of the HA-JNDI cluster. You can pass a "
-#~ "list of JNDI servers (i.e., the nodes in the HA-JNDI cluster) to the "
-#~ "<literal>java.naming.provider.url</literal> JNDI setting in the "
-#~ "<literal>jndi.properties</literal> file. Each server node is identified "
-#~ "by its IP address and the JNDI port number. The server nodes are "
-#~ "separated by commas (see <xref linkend=\"Clustered_JNDI_Services-"
-#~ "JBoss_configuration\"/> on how to configure the servers and ports)."
-#~ msgstr ""
-#~ "JNDI 客户需要意识到 HA-JNDI 的群集方式。你可以把 JNDI 服务器的列表（HA-"
-#~ "JNDI群集里的节点）写入到 <literal>jndi.properties</literal> 文件里的 "
-#~ "<literal>java.naming.provider.url</literal> 设置里。每个服务器节点都用它"
-#~ "的 IP 地址和 JNDI 端口号码来识别。服务器节点用逗号来隔开（关于怎么配置服务"
-#~ "器和端口，请参看 <xref linkend=\"clustering-jndi-jboss\"/> ）。"
-
-#~ msgid ""
-#~ "java.naming.provier.url=server1:1100,server2:1100,server3:1100,"
-#~ "server4:1100"
-#~ msgstr ""
-#~ "java.naming.provier.url=server1:1100,server2:1100,server3:1100,"
-#~ "server4:1100"
-
-#~ msgid ""
-#~ "When initialising, the JNP client code will try to get in touch with each "
-#~ "server node from the list, one after the other, stopping as soon as one "
-#~ "server has been reached. It will then download the HA-JNDI stub from this "
-#~ "node."
-#~ msgstr ""
-#~ "初始化时，JNP 客户代码会试图连接列表里的每个服务器，一个接一个，只要连接到"
-#~ "一个服务器它就会停止尝试。然后它将从这个节点下载 HA-JNDI stub。"
-
-#~ msgid ""
-#~ "There is no load balancing behavior in the JNP client lookup process. It "
-#~ "just goes through the provider list and use the first available server. "
-#~ "The HA-JNDI provider list only needs to contain a subset of HA-JNDI nodes "
-#~ "in the cluster."
-#~ msgstr ""
-#~ "JNP 客户的查找过程中没有用到负载平衡。它只是遍历这个列表来使用第一个可用的"
-#~ "服务器。HA-JNDI 提供者列表只需要包含群集里的 HA-JNDI 节点的一个子集。"
-
-#~ msgid ""
-#~ "The downloaded smart stub contains the logic to fail-over to another node "
-#~ "if necessary and the updated list of currently running nodes. "
-#~ "Furthermore, each time a JNDI invocation is made to the server, the list "
-#~ "of targets in the stub interceptor is updated (only if the list has "
-#~ "changed since the last call)."
-#~ msgstr ""
-#~ "下载的 smart stub 包含了必要时失效切换（fail-over）至另一节点的逻辑和更新"
-#~ "的当前运行节点的列表。而且，每次对服务器执行 JNDI 调用后，stub "
-#~ "interceptor 里的目标节点列表都会被更新（只有在上次调用后又有修改的情况下）"
-
-#, fuzzy
-#~ msgid ""
-#~ "If the property string <literal>java.naming.provider.url</literal> is "
-#~ "empty or if all servers it mentions are not reachable, the JNP client "
-#~ "will try to discover a bootstrap HA-JNDI server through a multicast call "
-#~ "on the network (auto-discovery). See <xref linkend="
-#~ "\"Clustered_JNDI_Services-JBoss_configuration\"/> on how to configure "
-#~ "auto-discovery on the JNDI server nodes. Through auto-discovery, the "
-#~ "client might be able to get a valid HA-JNDI server node without any "
-#~ "configuration. Of course, for the auto-discovery to work, the client must "
-#~ "reside in the same LAN as the server cluster (e.g., the web servlets "
-#~ "using the EJB servers). The LAN or WAN must also be configured to "
-#~ "propagate such multicast datagrams."
-#~ msgstr ""
-#~ "如果属性字符串 <literal>java.naming.provider.url</literal> 是空或者它标明"
-#~ "的所有服务器是不可到达的，JNP client 会试图通过网络上的多点传送"
-#~ "（multicast）调用来恢复 HA-JNDI 服务器。请参考 <xref linkend=\"clustering-"
-#~ "jndi-jboss\"/>关于怎样在 JNDI 服务器节点上配置自动恢复（auto-discovery）的"
-#~ "内容。通过自动恢复，客户端不需要任何配置就可以获得一个有效的 HA-JNDI 服务"
-#~ "器节点。当然，为了自动恢复能够工作，客户应用程序必须和服务器节点（使用 "
-#~ "EJB 服务器的 web servlets）在同一局域网里。局域网和广域网也必须配置成可以"
-#~ "传送这样的多点传送数据包。"
-
-#~ msgid ""
-#~ "The auto-discovery feature uses multicast group address 230.0.0.4:1102."
-#~ msgstr "自动恢复（auto-discovery）特征使用多点传送组地址 230.0.0.4:1102。"
-
-#~ msgid ""
-#~ "In addition to the <literal>java.naming.provier.url</literal> property, "
-#~ "you can specify a set of other properties. The following list shows all "
-#~ "client side properties you can specify, when creating a new "
-#~ "<literal>InitialContext</literal>."
-#~ msgstr ""
-#~ "除 <literal>java.naming.provier.url</literal> 属性以外，你还可以指定一系列"
-#~ "其他属性。下面的列表展示了当建立一个新的 <literal>InitialContext</"
-#~ "literal> 时，你可以指定的所有客户端属性。"
-
-#~ msgid ""
-#~ "<literal>java.naming.provier.url</literal>: Provides a list of IP "
-#~ "addresses and port numbers for HA-JNDI provider nodes in the cluster. The "
-#~ "client tries those providers one by one and uses the first one that "
-#~ "responds."
-#~ msgstr ""
-#~ "<literal>java.naming.provier.url</literal>：提供群集里 HA-JNDI 提供者节点"
-#~ "的 IP 地址和端口号的列表。客户端会尝试这些提供者并使用第一个响应的服务器。"
-
-#~ msgid ""
-#~ "<literal>jnp.disableDiscovery</literal>: When set to <literal>true</"
-#~ "literal>, this property disables the automatic discovery feature. Default "
-#~ "is <literal>false</literal>."
-#~ msgstr ""
-#~ "<literal>jnp.disableDiscovery</literal>：当设置为 <literal>true</literal> "
-#~ "时，这个属性关闭了自动恢复（automatic discovery）特征。它的缺省值是 "
-#~ "<literal>false</literal>。"
-
-#~ msgid ""
-#~ "<literal>jnp.partitionName</literal>: In an environment where multiple HA-"
-#~ "JNDI services, which are bound to distinct clusters (i.e., partitions), "
-#~ "are started, this property allows you to configure which cluster you "
-#~ "broadcast to when the automatic discovery feature is used. If you do not "
-#~ "use the automatic discovery feature (e.g., you could explicitly provide a "
-#~ "list of valid JNDI nodes in <literal>java.naming.provider.url</literal>), "
-#~ "this property is not used. By default, this property is not set and the "
-#~ "automatic discovery select the first HA-JNDI server that responds, "
-#~ "independently of the cluster partition name."
-#~ msgstr ""
-#~ "<literal>jnp.partitionName</literal>：在有多个绑定在不同的群集系统的 HA-"
-#~ "JNDI 服务的环境里，这个属性允许你配置当使用自动恢复（automatic discovery）"
-#~ "特征时广播至哪个群集。如果你没有使用自动恢复特征（就是说你可在以在 "
-#~ "<literal>java.naming.provider.url</literal> 里显性地提供有效的 JNDI 节点的"
-#~ "列表），这个属性就不会被使用。在缺省情况下，这个属性不会被设置，自动恢复选"
-#~ "择第一个响应的 HA-JNDI 服务器，而不管在哪个群集系统里。"
-
-#~ msgid ""
-#~ "<literal>jnp.discoveryTimeout</literal>: Determines how much time the "
-#~ "context will wait for a response to its automatic discovery packet. "
-#~ "Default is 5000 ms."
-#~ msgstr ""
-#~ "<literal>jnp.discoveryTimeout</literal>：决定上下文（context）等待对它的自"
-#~ "动恢复数据包应答的的时间，它的缺省值是 5000 毫秒。"
-
-#~ msgid ""
-#~ "<literal>jnp.discoveryGroup</literal>: Determines which multicast group "
-#~ "address is used for the automatic discovery. Default is "
-#~ "<literal>230.0.0.4</literal>."
-#~ msgstr ""
-#~ "<literal>jnp.discoveryGroup</literal>：决定用于自动恢复的多点传送组地址。"
-#~ "它的缺省值是 <literal>230.0.0.4</literal>。"
-
-#~ msgid ""
-#~ "<literal>jnp.discoveryPort</literal>: Determines which multicast group "
-#~ "port is used for the automatic discovery. Default is <literal>1102</"
-#~ "literal>."
-#~ msgstr ""
-#~ "<literal>jnp.discoveryPort</literal>：决定用于自动恢复的多点传送组端口。它"
-#~ "的缺省值是 <literal>1102</literal>。"
-
-#~ msgid "JBoss configuration"
-#~ msgstr "JBoss 配置"
-
-#~ msgid ""
-#~ "The <literal>cluster-service.xml</literal> file in the <literal>all/"
-#~ "deploy</literal> directory includes the following MBean to enable HA-JNDI "
-#~ "services."
-#~ msgstr ""
-#~ "<literal>all/deploy</literal> 目录下的 <literal>cluster-service.xml</"
-#~ "literal> 文件包括了下列启用 HA-JNDI 服务的 MBean。"
-
-#~ msgid ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>jboss:service=DefaultPartition</depends> \n"
-#~ "</mbean>"
-#~ msgstr ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>jboss:service=DefaultPartition</depends> \n"
-#~ "</mbean>"
-
-#~ msgid ""
-#~ "You can see that this MBean depends on the <literal>DefaultPartition</"
-#~ "literal> MBean defined above it (discussed in an earlier section in this "
-#~ "chapter). In other configurations, you can put that element in the "
-#~ "<literal>jboss-services.xml</literal> file or any other JBoss "
-#~ "configuration files in the <literal>/deploy</literal> directory to enable "
-#~ "HA-JNDI services. The available attributes for this MBean are listed "
-#~ "below."
-#~ msgstr ""
-#~ "你可以看到这个 MBean 依赖于在它之上定义的 <literal>DefaultPartition</"
-#~ "literal> MBean（在本章之前的部分曾讨论过）。在其他配置里，你可以把那个元素"
-#~ "（element）放在 <literal>jboss-services.xml</literal> 或者 <literal>/"
-#~ "deploy</literal> 目录下的其他 JBoss 配置文件里来启用 HA-JNDI 服务。这个 "
-#~ "MBean 的可用属性如下所示。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> is an optional attribute "
-#~ "to specify the name of the cluster for the different nodes of the HA-JNDI "
-#~ "service to communicate. The default value is <literal>DefaultPartition</"
-#~ "literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> 是一个可选的属性，它指定"
-#~ "与 HA-JNDI 服务通讯的不同节点的群集的名字。它的缺省值是 "
-#~ "<literal>DefaultPartition</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">BindAddress</emphasis> is an optional attribute "
-#~ "to specify the address to which the HA-JNDI server will bind waiting for "
-#~ "JNP clients. Only useful for multi-homed computers."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">BindAddress</emphasis> 是一个可选属性，它指定 HA-"
-#~ "JNDI 服务器绑定的等待 JNP 客户连接的地址。它只对多宿主主机（multi-homed "
-#~ "computers）有用。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">Port</emphasis> is an optional attribute to "
-#~ "specify the port to which the HA-JNDI server will bind waiting for JNP "
-#~ "clients. The default value is <literal>1100</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">Port</emphasis> 是一个可选属性，它指定 HA-JNDI 服"
-#~ "务器等待 JNP 客户连接所绑定的端口。它的缺省值是 <literal>1100</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">Backlog</emphasis> is an optional attribute to "
-#~ "specify the backlog value used for the TCP server socket waiting for JNP "
-#~ "clients. The default value is <literal>50</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">Backlog</emphasis> 是一个可选属性，它指定 TCP 服务"
-#~ "器套接字等待 JNP 客户所使用的 backlog 值。它的缺省值是 <literal>50</"
-#~ "literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">RmiPort</emphasis> determines which port the "
-#~ "server should use to communicate with the downloaded stub. This attribute "
-#~ "is optional. If it is missing, the server automatically assigns a RMI "
-#~ "port."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">RmiPort</emphasis> 决定服务器应与下载的 stub 通信"
-#~ "所用的端口。这个属性是可选的。如果它没有设置，服务器会自动分配一个 RMI 端"
-#~ "口。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryAddress</emphasis> is an optional "
-#~ "attribute to specify the multicast address to listen to for JNDI "
-#~ "automatic discovery. The default value is <literal>230.0.0.4</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryAddress</emphasis> 是一个可选属性，它"
-#~ "指定侦听的用于 JNDI 自动恢复的多点传送地址。它的缺省值是 "
-#~ "<literal>230.0.0.4</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryGroup</emphasis> is an optional "
-#~ "attribute to specify the multicast group to listen to for JNDI automatic "
-#~ "discovery.. The default value is <literal>1102</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryGroup</emphasis> 是一个可选属性，它指"
-#~ "定侦听的用于 JNDI 自动恢复的多点传送组。它的缺省值是 <literal>1102</"
-#~ "literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">LookupPool</emphasis> specifies the thread pool "
-#~ "service used to control the bootstrap and auto discovery lookups."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">LookupPool</emphasis> 指定用于控制引导程序和自动恢"
-#~ "复查找的线程池服务。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">DiscoveryDisabled</emphasis> is a boolean flag "
-#~ "that disables configuration of the auto discovery multicast listener."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">DiscoveryDisabled</emphasis> 是一个布尔值标记，它"
-#~ "可用来取消自动恢复多点传送侦听者（multicast listener）的配置。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryBindAddress</emphasis> sets the auto-"
-#~ "discovery bootstrap multicast bind address. If this attribute is not "
-#~ "specified and a <literal>BindAddress</literal> is specified, the "
-#~ "<literal>BindAddress</literal> will be used.."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryBindAddress</emphasis> 设置自动恢复引"
-#~ "导程序绑定的地址。如果这个属性没有指定而设置了 <literal>BindAddress</"
-#~ "literal>，<literal>BindAddress</literal> 将被使用。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryTTL</emphasis> specifies the TTL "
-#~ "(time-to-live) for autodiscovery IP multicast packets."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryTTL</emphasis> 为用于自动恢复的 IP 多"
-#~ "点传送数据包指定 TTL （time-to-live）。"
-
-#~ msgid ""
-#~ "The full default configuration of the <literal>HANamingService</literal> "
-#~ "MBean is as follows."
-#~ msgstr "<literal>HANamingService</literal> MBean 的完整缺省配置如下所示。"
-
-#~ msgid ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>\n"
-#~ " jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ " </depends> \n"
-#~ " <! -- Name of the partition to which the service is linked --"
-#~ "> \n"
-#~ " <attribute name=\"PartitionName\">\n"
-#~ " ${jboss.partition.name:DefaultPartition}\n"
-#~ " </attribute> \n"
-#~ " <! -- Bind address of bootstrap and HA-JNDI RMI endpoints --> \n"
-#~ " <attribute name=\"BindAddress\">${jboss.bind.address}</"
-#~ "attribute> \n"
-#~ " <! -- Port on which the HA-JNDI stub is made available --> \n"
-#~ " <attribute name=\"Port\">1100</attribute> \n"
-#~ " <! -- RmiPort to be used by the HA-JNDI service once bound. \n"
-#~ " 0 is for auto. --> \n"
-#~ " <attribute name=\"RmiPort\">1101</attribute> \n"
-#~ " <! -- Accept backlog of the bootstrap socket --> \n"
-#~ " <attribute name=\"Backlog\">50</attribute> \n"
-#~ " <! -- The thread pool service used to control the bootstrap and \n"
-#~ " auto discovery lookups --> \n"
-#~ " <depends optional-attribute-name=\"LookupPool\" \n"
-#~ " proxy-type=\"attribute\">jboss.system:service=ThreadPool</"
-#~ "depends>\n"
-#~ "\n"
-#~ " <! -- A flag to disable the auto discovery via multicast --> \n"
-#~ " <attribute name=\"DiscoveryDisabled\">false</attribute> \n"
-#~ " <! -- Set the auto-discovery bootstrap multicast bind address. --"
-#~ "> \n"
-#~ " <attribute name=\"AutoDiscoveryBindAddress\">\n"
-#~ " ${jboss.bind.address}\n"
-#~ " </attribute> \n"
-#~ " \n"
-#~ " <! -- Multicast Address and group port used for auto-discovery --"
-#~ "> \n"
-#~ " <attribute name=\"AutoDiscoveryAddress\">\n"
-#~ " ${jboss.partition.udpGroup:230.0.0.4}\n"
-#~ " </attribute> \n"
-#~ " <attribute name=\"AutoDiscoveryGroup\">1102</attribute> \n"
-#~ " <! -- The TTL (time-to-live) for autodiscovery IP multicast "
-#~ "packets --> \n"
-#~ " <attribute name=\"AutoDiscoveryTTL\">16</attribute>\n"
-#~ "\n"
-#~ " <! -- Client socket factory to be used for client-server \n"
-#~ " RMI invocations during JNDI queries \n"
-#~ " <attribute name=\"ClientSocketFactory\">custom</"
-#~ "attribute> \n"
-#~ " --> \n"
-#~ " <! -- Server socket factory to be used for client-server \n"
-#~ " RMI invocations during JNDI queries \n"
-#~ " <attribute name=\"ServerSocketFactory\">custom</"
-#~ "attribute> \n"
-#~ " --> \n"
-#~ "</mbean>"
-#~ msgstr ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>\n"
-#~ " jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ " </depends> \n"
-#~ " <! -- Name of the partition to which the service is linked --"
-#~ "> \n"
-#~ " <attribute name=\"PartitionName\">\n"
-#~ " ${jboss.partition.name:DefaultPartition}\n"
-#~ " </attribute> \n"
-#~ " <! -- Bind address of bootstrap and HA-JNDI RMI endpoints --> \n"
-#~ " <attribute name=\"BindAddress\">${jboss.bind.address}</"
-#~ "attribute> \n"
-#~ " <! -- Port on which the HA-JNDI stub is made available --> \n"
-#~ " <attribute name=\"Port\">1100</attribute> \n"
-#~ " <! -- RmiPort to be used by the HA-JNDI service once bound. \n"
-#~ " 0 is for auto. --> \n"
-#~ " <attribute name=\"RmiPort\">1101</attribute> \n"
-#~ " <! -- Accept backlog of the bootstrap socket --> \n"
-#~ " <attribute name=\"Backlog\">50</attribute> \n"
-#~ " <! -- The thread pool service used to control the bootstrap and \n"
-#~ " auto discovery lookups --> \n"
-#~ " <depends optional-attribute-name=\"LookupPool\" \n"
-#~ " proxy-type=\"attribute\">jboss.system:service=ThreadPool</"
-#~ "depends>\n"
-#~ "\n"
-#~ " <! -- A flag to disable the auto discovery via multicast --> \n"
-#~ " <attribute name=\"DiscoveryDisabled\">false</attribute> \n"
-#~ " <! -- Set the auto-discovery bootstrap multicast bind address. --"
-#~ "> \n"
-#~ " <attribute name=\"AutoDiscoveryBindAddress\">\n"
-#~ " ${jboss.bind.address}\n"
-#~ " </attribute> \n"
-#~ " \n"
-#~ " <! -- Multicast Address and group port used for auto-discovery --"
-#~ "> \n"
-#~ " <attribute name=\"AutoDiscoveryAddress\">\n"
-#~ " ${jboss.partition.udpGroup:230.0.0.4}\n"
-#~ " </attribute> \n"
-#~ " <attribute name=\"AutoDiscoveryGroup\">1102</attribute> \n"
-#~ " <! -- The TTL (time-to-live））for autodiscovery IP multicast "
-#~ "packets --> \n"
-#~ " <attribute name=\"AutoDiscoveryTTL\">16</attribute>\n"
-#~ "\n"
-#~ " <! -- Client socket factory to be used for client-server \n"
-#~ " RMI invocations during JNDI queries \n"
-#~ " <attribute name=\"ClientSocketFactory\">custom</"
-#~ "attribute> \n"
-#~ " --> \n"
-#~ " <! -- Server socket factory to be used for client-server \n"
-#~ " RMI invocations during JNDI queries \n"
-#~ " <attribute name=\"ServerSocketFactory\">custom</"
-#~ "attribute> \n"
-#~ " --> \n"
-#~ "</mbean>"
-
-#~ msgid ""
-#~ "It is possible to start several HA-JNDI services that use different "
-#~ "clusters. This can be used, for example, if a node is part of many "
-#~ "clusters. In this case, make sure that you set a different port or IP "
-#~ "address for both services. For instance, if you wanted to hook up HA-JNDI "
-#~ "to the example cluster you set up and change the binding port, the Mbean "
-#~ "descriptor would look as follows."
-#~ msgstr ""
-#~ "你可以启动几个使用不同群集的 HA-JNDI 服务。例如，这可以用在如果某一节点是"
-#~ "属于多个群集系统的情况下。这个时候，你要确保给不同服务设置了不同的端口号"
-#~ "或 IP 地址。例如，如果你想把 HA-JNDI 与 example 群集挂钩并改变绑定的端口，"
-#~ "Mbean 描述会象下面的样子。"
-
-#~ msgid ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>jboss:service=MySpecialPartition</depends> \n"
-#~ " <attribute name=\"PartitionName\">MySpecialPartition</"
-#~ "attribute> \n"
-#~ " <attribute name=\"Port\">56789</attribute> \n"
-#~ "</mbean>"
-#~ msgstr ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>jboss:service=MySpecialPartition</depends> \n"
-#~ " <attribute name=\"PartitionName\">MySpecialPartition</"
-#~ "attribute> \n"
-#~ " <attribute name=\"Port\">56789</attribute> \n"
-#~ "</mbean>"
-
-#~ msgid "Clustered Session EJBs"
-#~ msgstr "群集的 Session EJBs"
-
-#, fuzzy
-#~ msgid ""
-#~ "Session EJBs provide remote invocation services. They are clustered based "
-#~ "on the client-side interceptor architecture. The client application for a "
-#~ "clustered session bean is exactly the same as the client for the non-"
-#~ "clustered version of the session bean, except for a minor change to the "
-#~ "<literal>java.naming.provier.url</literal> system property to enable HA-"
-#~ "JNDI lookup (see previous section). No code change or re-compilation is "
-#~ "needed on the client side. Now, let's check out how to configure "
-#~ "clustered session beans in EJB 2.x and EJB 3.0 server applications "
-#~ "respectively."
-#~ msgstr ""
-#~ "Session EJBs 提供远程的调用服务。它们按照客户端拦截器架构（client-side "
-#~ "interceptor architecture）组成群集系统。群集的 session bean 的客户应用程序"
-#~ "和非群集的版本是一模一样的，除了对启用 HA-JNDI 查找的 <literal>java."
-#~ "naming.provier.url</literal> 系统属性的少许改动。对于客户端来说，不需要任"
-#~ "何的源码改动或重新编译。现在，让我们看看怎么分别在 EJB 2.x 和 EJB 3.0 服务"
-#~ "器应用程序里配置群集的 session beans。"
-
-#~ msgid "Stateless Session Bean in EJB 2.x"
-#~ msgstr "EJB 2.x 里的 Stateless Session Bean"
-
-#~ msgid ""
-#~ "Clustering stateless session beans is most probably the easiest case: as "
-#~ "no state is involved, calls can be load-balanced on any participating "
-#~ "node (i.e. any node that has this specific bean deployed) of the cluster. "
-#~ "To make a bean clustered, you need to modify its <literal>jboss.xml</"
-#~ "literal> descriptor to contain a <literal><clustered></literal> tag."
-#~ msgstr ""
-#~ "群集的 stateless session beans 有可能是最简单的：因为不涉及到状态，调用可"
-#~ "以在群集里的任何节点（部署有这个 bean 的节点）上进行负载平衡。要群集一个 "
-#~ "bean，你需要修改它的 <literal>jboss.xml</literal> 描述符，使它包含一个 "
-#~ "<literal><clustered></literal> 标签。"
-
-#~ msgid ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans> \n"
-#~ " <session> \n"
-#~ " <ejb-name>nextgen.StatelessSession</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.StatelessSession</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name> \n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces.RoundRobin\n"
-#~ " </bean-load-balance-policy>\n"
-#~ " </cluster-config>\n"
-#~ " </session>\n"
-#~ " </enterprise-beans>\n"
-#~ "</jboss>"
-#~ msgstr ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans> \n"
-#~ " <session> \n"
-#~ " <ejb-name>nextgen.StatelessSession</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.StatelessSession</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name> \n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces.RoundRobin\n"
-#~ " </bean-load-balance-policy>\n"
-#~ " </cluster-config>\n"
-#~ " </session>\n"
-#~ " </enterprise-beans>\n"
-#~ "</jboss>"
-
-#~ msgid ""
-#~ "The <literal><clustered>True</clustered></literal> element is "
-#~ "really just an alias for the <literal><configuration-name>Clustered "
-#~ "Stateless SessionBean</configuration-name></literal> element."
-#~ msgstr ""
-#~ "<literal><clustered>True</clustered></literal> 元素实际上是 "
-#~ "<literal><configuration-name>Clustered Stateless SessionBean</"
-#~ "configuration-name></literal> 元素的一个别名。"
-
-#~ msgid ""
-#~ "In the bean configuration, only the <literal><clustered></literal> "
-#~ "element is mandatory. It indicates that the bean works in a cluster. The "
-#~ "<literal><cluster-config></literal> element is optional and the "
-#~ "default values of its attributes are indicated in the sample "
-#~ "configuration above. Below is a description of the attributes in the "
-#~ "<literal><cluster-config></literal> element."
-#~ msgstr ""
-#~ "在 bean 配置里，只有 <literal><clustered></literal> 元素是强制的。它"
-#~ "指出这个 bean 在群集里运行。<literal><cluster-config></literal> 元素"
-#~ "是可选的，我们在上面的配置样本里指出了它的缺省值。下面是关于 <literal><"
-#~ "cluster-config></literal> 元素里属性的描述。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">partition-name</emphasis> specifies the name of "
-#~ "the cluster the bean participates in. The default value is "
-#~ "<literal>DefaultPartition</literal>. The default partition name can also "
-#~ "be set system-wide using the <literal>jboss.partition.name</literal> "
-#~ "system property."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">partition-name</emphasis> 指定 bean 所参与的群集"
-#~ "名。它的缺省值是 <literal>DefaultPartition</literal>。缺省的分区名也可以"
-#~ "用 <literal>jboss.partition.name</literal> 系统属性跨系统地被指定。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">home-load-balance-policy</emphasis> indicates the "
-#~ "class to be used by the home stub to balance calls made on the nodes of "
-#~ "the cluster. By default, the proxy will load-balance calls in a "
-#~ "<literal>RoundRobin</literal> fashion. You can also implement your own "
-#~ "load-balance policy class or use the class <literal>FirstAvailable</"
-#~ "literal> that persists to use the first node available that it meets "
-#~ "until it fails."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">home-load-balance-policy</emphasis> 指出 home "
-#~ "stub 所用来平衡节点上的调用的类。在缺省情况下，代理（proxy）会用 "
-#~ "<literal>RoundRobin</literal> 方式平衡调用负载。你也可以实现自己的负载平衡"
-#~ "策略类或持续使用所遇到的第一个可用节点直至其消亡的 "
-#~ "<literal>FirstAvailable</literal> 类。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">bean-load-balance-policy</emphasis> Indicates the "
-#~ "class to be used by the bean stub to balance calls made on the nodes of "
-#~ "the cluster. Comments made for the <literal>home-load-balance-policy</"
-#~ "literal> attribute also apply."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">bean-load-balance-policy</emphasis>指出 home stub "
-#~ "所使用的平衡节点上的调用的类。对于 <literal>home-load-balance-policy</"
-#~ "literal> 属性的注释也同样适用。"
-
-#, fuzzy
-#~ msgid ""
-#~ "In JBoss 3.0.x, each client-side stub has its own list of available "
-#~ "target nodes. Consequently, some side-effects can occur. For example, if "
-#~ "you cache your home stub and re-create a remote stub for a stateless "
-#~ "session bean (with the Round-Robin policy) each time you need to make an "
-#~ "invocation, a new remote stub, containing the list of available targets, "
-#~ "will be downloaded for each invocation. Consequently, as the first target "
-#~ "node is always the first in the list, calls will not seemed to be load-"
-#~ "balanced because there is no usage-history between different stubs. In "
-#~ "JBoss 3.2+, the proxy families (i.e., the \"First "
-#~ "AvailableIdenticalAllProxies\" load balancing policy, see <xref linkend="
-#~ "\"Load_Balancing_Policies-JBoss_AS_3.2\"/>) remove this side effect as "
-#~ "the home and remote stubs of a given EJB are in two different families."
-#~ msgstr ""
-#~ "在 JBoss 3.0.x 里，每个客户端 stub 都有自己的可用目标节点的列表。由此会产"
-#~ "生某些副作用。例如，每次你需要进行一次调用时，你都为 stateless session "
-#~ "bean（应用 Round-Robin 策略） 缓存你的 home stub 并重新创建一个远程 stub，"
-#~ "每次调用都会下载包含可用节点列表的新的远程 stub。因此，由于第一个目标节点"
-#~ "总是列表里的第一项，而且不同的 stubs 之间并没有一个节点的使用记录，调用负"
-#~ "载看起来并没有被平衡。在 JBoss 3.2+ 里，proxy families（也就是 \"First "
-#~ "AvailableIdenticalAllProxies\" 负载平衡策略，请参考 <xref linkend="
-#~ "\"clustering-intro-balancepolicy-32\"/>） 消除了这个副作用，因为给定 EJB "
-#~ "的 home 和 remote stubs 分别在两个不同的族（familiy）里。"
-
-#~ msgid "Handle Cluster Restart"
-#~ msgstr "处理群集系统重启"
-
-#, fuzzy
-#~ msgid ""
-#~ "We have covered the HA smart client architecture in <xref linkend="
-#~ "\"Service_Architectures-Client_side_interceptor\"/>. The default HA smart "
-#~ "proxy client can only failover as long as one node in the cluster exists. "
-#~ "If there is a complete cluster shutdown, the proxy becomes orphanned and "
-#~ "looses knowledge of the available nodes in the cluster. There is no way "
-#~ "for the proxy to recover from this. The proxy needs to be looked up out "
-#~ "of JNDI/HAJNDI when the nodes are restarted."
-#~ msgstr ""
-#~ "我们已经在 <xref linkend=\"clustering-intro-arch-proxy\"/> 介绍了 HA "
-#~ "smart client architecture。缺省的 HA smart proxy client 只能在群集里一个节"
-#~ "点故障时进行失效切换（failover）。如果整个群集都关闭了，代理（proxy）将失"
-#~ "去所有群集里可用节点的信息。在这种情况下，代理没有什么办法来恢复系统。当节"
-#~ "点重启时，需要在 JNDI/HAJNDI 之外查找代理。"
-
-#, fuzzy
-#~ msgid ""
-#~ "The 3.2.7+/4.2+ releases contain a <literal>RetryInterceptor</literal> "
-#~ "that can be added to the proxy client side interceptor stack to allow for "
-#~ "a transparent recovery from such a restart failure. To enable it for an "
-#~ "EJB, setup an <literal>invoker-proxy-binding</literal> that includes the "
-#~ "<literal>RetryInterceptor</literal>. Below is an example <literal>jboss."
-#~ "xml</literal> configuration."
-#~ msgstr ""
-#~ "3.2.7+/4.0.2+ 版本包含了 <literal>RetryInterceptor</literal>，它可以加入到"
-#~ "代理客户端拦截器栈里，允许在这样的重启故障后进行透明恢复（transparent "
-#~ "recovery）。为了启用这个机制，你可以设立包含 <literal>RetryInterceptor</"
-#~ "literal> 的 <literal>invoker-proxy-binding</literal>。下面是 "
-#~ "<literal>jboss.xml</literal> 配置的一个示例。"
-
-#~ msgid ""
-#~ "<jboss>\n"
-#~ " <session>\n"
-#~ " <ejb-name>nextgen_RetryInterceptorStatelessSession</ejb-"
-#~ "name>\n"
-#~ " <invoker-bindings>\n"
-#~ " <invoker>\n"
-#~ " <invoker-proxy-binding-name>\n"
-#~ " clustered-retry-stateless-rmi-invoker\n"
-#~ " </invoker-proxy-binding-name>\n"
-#~ " <jndi-name>\n"
-#~ " nextgen_RetryInterceptorStatelessSession\n"
-#~ " </jndi-name>\n"
-#~ " </invoker>\n"
-#~ " </invoker-bindings>\n"
-#~ " <clustered>true</clustered>\n"
-#~ " </session>\n"
-#~ "\n"
-#~ " <invoker-proxy-binding>\n"
-#~ " <name>clustered-retry-stateless-rmi-invoker</name>\n"
-#~ " <invoker-mbean>jboss:service=invoker,type=jrmpha</"
-#~ "invoker-mbean>\n"
-#~ " <proxy-factory>org.jboss.proxy.ejb.ProxyFactoryHA</proxy-"
-#~ "factory>\n"
-#~ " <proxy-factory-config>\n"
-#~ " <client-interceptors>\n"
-#~ " <home>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.HomeInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.SecurityInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.TransactionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.invocation.InvokerInterceptor\n"
-#~ " </interceptor>\n"
-#~ " </home>\n"
-#~ " <bean>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.StatelessSessionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.SecurityInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.TransactionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.invocation.InvokerInterceptor\n"
-#~ " </interceptor>\n"
-#~ " </bean>\n"
-#~ " </client-interceptors>\n"
-#~ " </proxy-factory-config>\n"
-#~ " </invoker-proxy-binding>"
-#~ msgstr ""
-#~ "<jboss>\n"
-#~ " <session>\n"
-#~ " <ejb-name>nextgen_RetryInterceptorStatelessSession</ejb-"
-#~ "name>\n"
-#~ " <invoker-bindings>\n"
-#~ " <invoker>\n"
-#~ " <invoker-proxy-binding-name>\n"
-#~ " clustered-retry-stateless-rmi-invoker\n"
-#~ " </invoker-proxy-binding-name>\n"
-#~ " <jndi-name>\n"
-#~ " nextgen_RetryInterceptorStatelessSession\n"
-#~ " </jndi-name>\n"
-#~ " </invoker>\n"
-#~ " </invoker-bindings>\n"
-#~ " <clustered>true</clustered>\n"
-#~ " </session>\n"
-#~ "\n"
-#~ " <invoker-proxy-binding>\n"
-#~ " <name>clustered-retry-stateless-rmi-invoker</name>\n"
-#~ " <invoker-mbean>jboss:service=invoker,type=jrmpha</"
-#~ "invoker-mbean>\n"
-#~ " <proxy-factory>org.jboss.proxy.ejb.ProxyFactoryHA</proxy-"
-#~ "factory>\n"
-#~ " <proxy-factory-config>\n"
-#~ " <client-interceptors>\n"
-#~ " <home>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.HomeInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.SecurityInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.TransactionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.invocation.InvokerInterceptor\n"
-#~ " </interceptor>\n"
-#~ " </home>\n"
-#~ " <bean>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.StatelessSessionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.SecurityInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.TransactionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.invocation.InvokerInterceptor\n"
-#~ " </interceptor>\n"
-#~ " </bean>\n"
-#~ " </client-interceptors>\n"
-#~ " </proxy-factory-config>\n"
-#~ " </invoker-proxy-binding>"
-
-#~ msgid "Stateful Session Bean in EJB 2.x"
-#~ msgstr "EJB 2.x 里的 Stateful Session Bean"
-
-#~ msgid ""
-#~ "Clustering stateful session beans is more complex than clustering their "
-#~ "stateless counterparts since JBoss needs to manage the state information. "
-#~ "The state of all stateful session beans are replicated and synchronized "
-#~ "across the cluster each time the state of a bean changes. The JBoss AS "
-#~ "uses the <literal>HASessionState</literal> MBean to manage distributed "
-#~ "session states for clustered EJB 2.x stateful session beans. In this "
-#~ "section, we cover both the session bean configuration and the "
-#~ "<literal>HASessionState</literal> MBean configuration."
-#~ msgstr ""
-#~ "既然 JBoss 需要管理状态信息，群集 stateful session beans 就比群集 "
-#~ "stateles ssession beans 更为复杂。当 stateful session beans 的状态改变时，"
-#~ "所有状态在群集中复制和同步。JBoss AS 使用 <literal>HASessionState</"
-#~ "literal> MBean 来为群集的 EJB 2.x stateful session beans 管理分布式的会话"
-#~ "状态。在这部分内容里，我们将介绍 session bean 的配置和 "
-#~ "<literal>HASessionState</literal> MBean 的配置。"
-
-#~ msgid "The EJB application configuration"
-#~ msgstr "EJB 应用程序配置"
-
-#~ msgid ""
-#~ "In the EJB application, you need to modify the <literal>jboss.xml</"
-#~ "literal> descriptor file for each stateful session bean and add the "
-#~ "<literal><clustered></literal> tag."
-#~ msgstr ""
-#~ "在 EJB 应用程序里，你需要为每个 stateful session bean 修改 <literal>jboss."
-#~ "xml</literal> 描述符文件并加入 <literal><clustered></literal> 标签。"
-
-#~ msgid ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans>\n"
-#~ " <session> \n"
-#~ " <ejb-name>nextgen.StatefulSession</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.StatefulSession</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name>\n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable \n"
-#~ " </bean-load-balance-policy> \n"
-#~ " <session-state-manager-jndi-name> \n"
-#~ " /HASessionState/Default \n"
-#~ " </session-state-manager-jndi-name> \n"
-#~ " </cluster-config> \n"
-#~ " </session> \n"
-#~ " </enterprise-beans>\n"
-#~ "</jboss>"
-#~ msgstr ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans>\n"
-#~ " <session> \n"
-#~ " <ejb-name>nextgen.StatefulSession</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.StatefulSession</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name>\n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable \n"
-#~ " </bean-load-balance-policy> \n"
-#~ " <session-state-manager-jndi-name> \n"
-#~ " /HASessionState/Default \n"
-#~ " </session-state-manager-jndi-name> \n"
-#~ " </cluster-config> \n"
-#~ " </session> \n"
-#~ " </enterprise-beans>\n"
-#~ "</jboss>"
-
-#~ msgid ""
-#~ "In the bean configuration, only the <literal><clustered></literal> "
-#~ "tag is mandatory to indicate that the bean works in a cluster. The "
-#~ "<literal><cluster-config></literal> element is optional and its "
-#~ "default attribute values are indicated in the sample configuration above."
-#~ msgstr ""
-#~ "在 bean 的配置文件里，只有 <literal><clustered></literal> 标签是强制"
-#~ "的，它指出 bean 处在群集系统里。<literal><cluster-config></literal> "
-#~ "元素是可选的，我们在上面的配置文件样本里指出了它的缺省属性值。"
-
-#~ msgid ""
-#~ "The <literal><session-state-manager-jndi-name></literal> tag is "
-#~ "used to give the JNDI name of the <literal>HASessionState</literal> "
-#~ "service to be used by this bean."
-#~ msgstr ""
-#~ "<literal><session-state-manager-jndi-name></literal> 标签用来说明这"
-#~ "个 bean 所用的 <literal>HASessionState</literal> 服务的名字。"
-
-#, fuzzy
-#~ msgid ""
-#~ "The description of the remaining tags is identical to the one for "
-#~ "stateless session bean. Actions on the clustered stateful session "
-#~ "bean's home interface are by default load-balanced, round-robin. Once "
-#~ "the bean's remote stub is available to the client, calls will not be "
-#~ "load-balanced round-robin any more and will stay \"sticky\" to the first "
-#~ "node in the list."
-#~ msgstr ""
-#~ "余下的标签的描述和 stateless session bean 的描述是一样的。群集的 stateful "
-#~ "session bean 的主接口上的动作缺省是基于 round-robin 负载平衡策略的。一旦 "
-#~ "bean 的 remote stub 对于客户可用时，调用将不会再进行负载平衡而\"粘"
-#~ "\"（sticky）在列表里的第一个节点上。"
-
-#~ msgid "Optimize state replication"
-#~ msgstr "优化状态复制"
-
-#~ msgid ""
-#~ "As the replication process is a costly operation, you can optimise this "
-#~ "behaviour by optionally implementing in your bean class a method with the "
-#~ "following signature:"
-#~ msgstr ""
-#~ "因为复制过程是很消耗资源的，为了优化这个过程，你可以选择性地在你的 bean 类"
-#~ "里实现有下面的签名的方法："
-
-#~ msgid "public boolean isModified ();"
-#~ msgstr "public boolean isModified ();"
-
-#~ msgid ""
-#~ "Before replicating your bean, the container will detect if your bean "
-#~ "implements this method. If your bean does, the container calls the "
-#~ "<literal>isModified()</literal> method and it only replicates the bean "
-#~ "when the method returns <literal>true</literal>. If the bean has not been "
-#~ "modified (or not enough to require replication, depending on your own "
-#~ "preferences), you can return <literal>false</literal> and the replication "
-#~ "would not occur. This feature is available on JBoss AS 3.0.1+ only."
-#~ msgstr ""
-#~ "在复制你的 bean 之前，容器（container）将检测 bean 是否实现了这个方法。如"
-#~ "果是，容器会调用 <literal>isModified()</literal> 方法并只在方法返回 "
-#~ "<literal>true</literal> 时复制这个 bean。如果 bean 还没被更改(或者还不够来"
-#~ "请求复制，这取决于你的喜好，你可以返回 <literal>false</literal>，这样复制"
-#~ "就不会发生。"
-
-#~ msgid "The HASessionState service configuration"
-#~ msgstr "HASessionState 服务配置"
-
-#, fuzzy
-#~ msgid ""
-#~ "The <literal>HASessionState</literal> service MBean is defined in "
-#~ "the<code>all/deploy/cluster-service.xml</code>file."
-#~ msgstr ""
-#~ "<code>all/deploy/cluster-service.xml</code> 文件里定义了 "
-#~ "<literal>HASessionState</literal> 服务 MBean。"
-
-#~ msgid ""
-#~ "<mbean code=\"org.jboss.ha.hasessionstate.server.HASessionStateService"
-#~ "\"\n"
-#~ " name=\"jboss:service=HASessionState\">\n"
-#~ " <depends>\n"
-#~ " jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ " </depends>\n"
-#~ " <!-- Name of the partition to which the service is linked -->\n"
-#~ " <attribute name=\"PartitionName\">\n"
-#~ " ${jboss.partition.name:DefaultPartition}\n"
-#~ " </attribute>\n"
-#~ " <!-- JNDI name under which the service is bound -->\n"
-#~ " <attribute name=\"JndiName\">/HASessionState/Default</"
-#~ "attribute>\n"
-#~ " <!-- Max delay before cleaning unreclaimed state.\n"
-#~ " Defaults to 30*60*1000 => 30 minutes -->\n"
-#~ " <attribute name=\"BeanCleaningDelay\">0</attribute>\n"
-#~ "</mbean>"
-#~ msgstr ""
-#~ "<mbean code=\"org.jboss.ha.hasessionstate.server.HASessionStateService"
-#~ "\"\n"
-#~ " name=\"jboss:service=HASessionState\">\n"
-#~ " <depends>\n"
-#~ " jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ " </depends>\n"
-#~ " <!-- Name of the partition to which the service is linked -->\n"
-#~ " <attribute name=\"PartitionName\">\n"
-#~ " ${jboss.partition.name:DefaultPartition}\n"
-#~ " </attribute>\n"
-#~ " <!-- JNDI name under which the service is bound -->\n"
-#~ " <attribute name=\"JndiName\">/HASessionState/Default</"
-#~ "attribute>\n"
-#~ " <!-- Max delay before cleaning unreclaimed state.\n"
-#~ " Defaults to 30*60*1000 => 30 minutes -->\n"
-#~ " <attribute name=\"BeanCleaningDelay\">0</attribute>\n"
-#~ "</mbean>"
-
-#~ msgid ""
-#~ "The configuration attributes in the <literal>HASessionState</literal> "
-#~ "MBean are listed below."
-#~ msgstr "<literal>HASessionState</literal> MBean 里的配置属性如下所示："
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">JndiName</emphasis> is an optional attribute to "
-#~ "specify the JNDI name under which this <literal>HASessionState</literal> "
-#~ "service is bound. The default value is <literal>/HAPartition/Default</"
-#~ "literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">JndiName</emphasis> 是一个可选属性，它指定这个 "
-#~ "<literal>HASessionState</literal> 服务被绑定的 JNDI 名。它的缺省值是 "
-#~ "<literal>/HAPartition/Default</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> is an optional attribute "
-#~ "to specify the name of the cluster in which the current "
-#~ "<literal>HASessionState</literal> protocol will work. The default value "
-#~ "is <literal>DefaultPartition</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> 是一个可选属性，它指定了"
-#~ "当前 <literal>HASessionState</literal> 协议所服务的群集名称。它的缺省值是 "
-#~ "<literal>DefaultPartition</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">BeanCleaningDelay</emphasis> is an optional "
-#~ "attribute to specify the number of miliseconds after which the "
-#~ "<literal>HASessionState</literal> service can clean a state that has not "
-#~ "been modified. If a node, owning a bean, crashes, its brother node will "
-#~ "take ownership of this bean. Nevertheless, the container cache of the "
-#~ "brother node will not know about it (because it has never seen it before) "
-#~ "and will never delete according to the cleaning settings of the bean. "
-#~ "That is why the <literal>HASessionState</literal> service needs to do "
-#~ "this cleanup sometimes. The default value is <literal>30*60*1000</"
-#~ "literal> milliseconds (i.e., 30 minutes)."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">BeanCleaningDelay</emphasis> 是一个可选属性，它指"
-#~ "定了一个状态在多久没有变化后 <literal>HASessionState</literal> 服务就可以"
-#~ "清除它，它的单位是毫秒。例如，如果拥有某一 bean 的节点崩溃了，它的兄弟节点"
-#~ "将接管这个 bean。但是，这个兄弟节点的容器缓存并不会知道这个信息（因为之前"
-#~ "并没有这个信息），也永远不会按照这个 bean 的清除设置来删除它。这就是为什"
-#~ "么 <literal>HASessionState</literal> 服务需要来做这个清除工作。它的缺省值"
-#~ "是 <literal>30*60*1000</literal> 毫秒（也就是 30 分钟）。"
-
-#~ msgid "Stateless Session Bean in EJB 3.0"
-#~ msgstr "EJB 3.0 里的 Stateless Session Bean"
-
-#~ msgid ""
-#~ "To cluster a stateless session bean in EJB 3.0, all you need to do is to "
-#~ "annotate the bean class withe the <literal>@Cluster</literal> annotation. "
-#~ "You can pass in the load balance policy and cluster partition as "
-#~ "parameters to the annotation. The default load balance policy is "
-#~ "<literal>org.jboss.ha.framework.interfaces.RandomRobin</literal> and the "
-#~ "default cluster is <literal>DefaultPartition</literal>. Below is the "
-#~ "definition of the <literal>@Cluster</literal> annotation."
-#~ msgstr ""
-#~ "要在 EJB 3.0 内群集一个 stateless session bean，你所需要做的就是用 "
-#~ "<literal>@Cluster</literal> 注解来注解（annotate）bean 类。你可以把负载平"
-#~ "衡策略（load balance policy）和群集分区名当作参数传入这个注解。缺省的负载"
-#~ "平衡策略是 <literal>org.jboss.ha.framework.interfaces.RandomRobin</"
-#~ "literal>，缺省的群集是 <literal>DefaultPartition</literal>。下面是 "
-#~ "<literal>@Cluster</literal> 注解的定义。"
-
-#~ msgid ""
-#~ "public @interface Clustered {\n"
-#~ " Class loadBalancePolicy() default LoadBalancePolicy.class;\n"
-#~ " String partition() default \"DefaultPartition\";\n"
-#~ "}"
-#~ msgstr ""
-#~ "public @interface Clustered {\n"
-#~ " Class loadBalancePolicy() default LoadBalancePolicy.class;\n"
-#~ " String partition() default \"DefaultPartition\";\n"
-#~ "}"
-
-#~ msgid ""
-#~ "Here is an example of a clustered EJB 3.0 stateless session bean "
-#~ "implementation."
-#~ msgstr "这里是一个群集的 EJB 3.0 stateless session bean 实现的例子。"
-
-#~ msgid ""
-#~ "@Stateless\n"
-#~ "@Clustered\n"
-#~ "public class MyBean implements MySessionInt {\n"
-#~ " \n"
-#~ " public void test() {\n"
-#~ " // Do something cool\n"
-#~ " }\n"
-#~ "}"
-#~ msgstr ""
-#~ "@Stateless\n"
-#~ "@Clustered\n"
-#~ "public class MyBean implements MySessionInt {\n"
-#~ " \n"
-#~ " public void test() {\n"
-#~ " // Do something cool\n"
-#~ " }\n"
-#~ "}"
-
-#~ msgid "Stateful Session Bean in EJB 3.0"
-#~ msgstr "EJB 3.0 里的 Stateful Session Bean"
-
-#~ msgid ""
-#~ "To cluster stateful session beans in EJB 3.0, you need to tag the bean "
-#~ "implementation class with the <literal>@Cluster</literal> annotation, "
-#~ "just as we did with the EJB 3.0 stateless session bean earlier."
-#~ msgstr ""
-#~ "为了在 EJB 3.0 里群集 stateful session beans，你需要用 <literal>@Cluster</"
-#~ "literal> 注解来标记 bean 实现类，就和我们之前对 EJB 3.0 stateless session "
-#~ "bean 做的一样。"
-
-#~ msgid ""
-#~ "@Stateful\n"
-#~ "@Clustered\n"
-#~ "public class MyBean implements MySessionInt {\n"
-#~ " \n"
-#~ " private int state = 0;\n"
-#~ "\n"
-#~ " public void increment() {\n"
-#~ " System.out.println(\"counter: \" + (state++));\n"
-#~ " }\n"
-#~ "}"
-#~ msgstr ""
-#~ "@Stateful\n"
-#~ "@Clustered\n"
-#~ "public class MyBean implements MySessionInt {\n"
-#~ " \n"
-#~ " private int state = 0;\n"
-#~ "\n"
-#~ " public void increment() {\n"
-#~ " System.out.println(\"counter: \" + (state++));\n"
-#~ " }\n"
-#~ "}"
-
-#~ msgid ""
-#~ "JBoss Cache provides the session state replication service for EJB 3.0 "
-#~ "stateful session beans. The related MBean service is defined in the "
-#~ "<literal>ejb3-clustered-sfsbcache-service.xml</literal> file in the "
-#~ "<literal>deploy</literal> directory. The contents of the file are as "
-#~ "follows."
-#~ msgstr ""
-#~ "JBoss Cache 为 EJB 3.0 stateful session beans 提供会话状态复制服务"
-#~ "（session state replication service）。<literal>deploy</literal> 目录下 "
-#~ "<literal>ejb3-clustered-sfsbcache-service.xml</literal> 文件定义了相关的 "
-#~ "MBean 服务。文件的内容如下："
-
-#~ msgid ""
-#~ "<server>\n"
-#~ " <mbean code=\"org.jboss.ejb3.cache.tree.PassivationTreeCache\"\n"
-#~ " name=\"jboss.cache:service=EJB3SFSBClusteredCache\">\n"
-#~ " \n"
-#~ " <attribute name=\"IsolationLevel\">READ_UNCOMMITTED</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheMode\">REPL_SYNC</attribute>\n"
-#~ " <attribute name=\"ClusterName\">SFSB-Cache</"
-#~ "attribute>\n"
-#~ " <attribute name=\"ClusterConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Number of milliseconds to wait until all responses for "
-#~ "a\n"
-#~ " synchronous call have been received.\n"
-#~ " -->\n"
-#~ " <attribute name=\"SyncReplTimeout\">10000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <!-- Max number of milliseconds to wait for a lock "
-#~ "acquisition -->\n"
-#~ " <attribute name=\"LockAcquisitionTimeout\">15000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <!-- Name of the eviction policy class. -->\n"
-#~ " <attribute name=\"EvictionPolicyClass\">\n"
-#~ " org.jboss.ejb3.cache.tree.StatefulEvictionPolicy\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Specific eviction policy configurations. This is LRU --"
-#~ ">\n"
-#~ " <attribute name=\"EvictionPolicyConfig\">\n"
-#~ " <config>\n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">1</"
-#~ "attribute>\n"
-#~ " <name>statefulClustered</name>\n"
-#~ " <region name=\"/_default_\">\n"
-#~ " <attribute name=\"maxNodes\">1000000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"timeToIdleSeconds\">300</"
-#~ "attribute>\n"
-#~ " </region>\n"
-#~ " </config>\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"CacheLoaderFetchPersistentState\">"
-#~ "false</attribute>\n"
-#~ " <attribute name=\"CacheLoaderFetchTransientState\">true</"
-#~ "attribute>\n"
-#~ " <attribute name=\"FetchStateOnStartup\">true</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheLoaderClass\">\n"
-#~ " org.jboss.ejb3.cache.tree.StatefulCacheLoader\n"
-#~ " </attribute>\n"
-#~ " <attribute name=\"CacheLoaderConfig\">\n"
-#~ " location=statefulClustered\n"
-#~ " </attribute>\n"
-#~ " </mbean>\n"
-#~ "</server>"
-#~ msgstr ""
-#~ "<server>\n"
-#~ " <mbean code=\"org.jboss.ejb3.cache.tree.PassivationTreeCache\"\n"
-#~ " name=\"jboss.cache:service=EJB3SFSBClusteredCache\">\n"
-#~ " \n"
-#~ " <attribute name=\"IsolationLevel\">READ_UNCOMMITTED</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheMode\">REPL_SYNC</attribute>\n"
-#~ " <attribute name=\"ClusterName\">SFSB-Cache</"
-#~ "attribute>\n"
-#~ " <attribute name=\"ClusterConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Number of milliseconds to wait until all responses for "
-#~ "a\n"
-#~ " synchronous call have been received.\n"
-#~ " -->\n"
-#~ " <attribute name=\"SyncReplTimeout\">10000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <!-- Max number of milliseconds to wait for a lock "
-#~ "acquisition -->\n"
-#~ " <attribute name=\"LockAcquisitionTimeout\">15000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <!-- Name of the eviction policy class. -->\n"
-#~ " <attribute name=\"EvictionPolicyClass\">\n"
-#~ " org.jboss.ejb3.cache.tree.StatefulEvictionPolicy\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Specific eviction policy configurations. This is LRU --"
-#~ ">\n"
-#~ " <attribute name=\"EvictionPolicyConfig\">\n"
-#~ " <config>\n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">1</"
-#~ "attribute>\n"
-#~ " <name>statefulClustered</name>\n"
-#~ " <region name=\"/_default_\">\n"
-#~ " <attribute name=\"maxNodes\">1000000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"timeToIdleSeconds\">300</"
-#~ "attribute>\n"
-#~ " </region>\n"
-#~ " </config>\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"CacheLoaderFetchPersistentState\">"
-#~ "false</attribute>\n"
-#~ " <attribute name=\"CacheLoaderFetchTransientState\">true</"
-#~ "attribute>\n"
-#~ " <attribute name=\"FetchStateOnStartup\">true</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheLoaderClass\">\n"
-#~ " org.jboss.ejb3.cache.tree.StatefulCacheLoader\n"
-#~ " </attribute>\n"
-#~ " <attribute name=\"CacheLoaderConfig\">\n"
-#~ " location=statefulClustered\n"
-#~ " </attribute>\n"
-#~ " </mbean>\n"
-#~ "</server>"
-
-#, fuzzy
-#~ msgid ""
-#~ "The configuration attributes in the <literal>PassivationTreeCache</"
-#~ "literal> MBean are essentially the same as the attributes in the standard "
-#~ "JBoss Cache <literal>TreeCache</literal> MBean discussed in <xref linkend="
-#~ "\"JBossCache_and_JGroups_Services\"/>. Again, we omitted the JGroups "
-#~ "configurations in the <literal>ClusterConfig</literal> attribute (see "
-#~ "more in <xref linkend=\"JBossCache_and_JGroups_Services-"
-#~ "JGroups_Configuration\"/>)."
-#~ msgstr ""
-#~ "<literal>PassivationTreeCache</literal> MBean 里的配置属性基本上和在 "
-#~ "<xref linkend=\"jbosscache.chapt\"/> 里讨论的标准 JBoss Cache "
-#~ "<literal>TreeCache</literal> MBean 一样。我们再一次忽略了 "
-#~ "<literal>ClusterConfig</literal> 属性（详情请参考 <xref linkend="
-#~ "\"jbosscache-jgroups\"/>）的 JGroups 配置。"
-
-#~ msgid "Clustered Entity EJBs"
-#~ msgstr "群集的 Entity EJBs"
-
-#~ msgid ""
-#~ "In a JBoss AS cluster, the entity bean instances need to replicated "
-#~ "across all nodes. If an entity bean provides remote services, the service "
-#~ "methods need to be load balanced as well."
-#~ msgstr ""
-#~ "在 JBoss AS 群集系统里，entity bean 实例需要跨节点的复制。如果某个 entity "
-#~ "bean 提供远程服务，那么服务方法（service methods）也需要进行负载平衡。"
-
-#~ msgid ""
-#~ "To use a clustered entity bean, the application does not need to do "
-#~ "anything special, except for looking up bean references from the "
-#~ "clustered HA-JNDI."
-#~ msgstr ""
-#~ "为了使用群集的 entity bean，应用程序不需要做任何特殊的事情，除了从群集的 "
-#~ "HA-JNDI 里查找 bean 的引用。"
-
-#~ msgid "Entity Bean in EJB 2.x"
-#~ msgstr "EJB 2.x 里的 Entity Bean"
-
-#~ msgid ""
-#~ "First of all, it is worth to note that clustering 2.x entity beans is a "
-#~ "bad thing to do. Its exposes elements that generally are too fine grained "
-#~ "for use as remote objects to clustered remote objects and introduces data "
-#~ "synchronization problems that are non-trivial. Do NOT use EJB 2.x entity "
-#~ "bean clustering unless you fit into the sepecial case situation of read-"
-#~ "only, or one read-write node with read-only nodes synched with the cache "
-#~ "invalidation services."
-#~ msgstr ""
-#~ "首先，值得注意的是群集 2.x 的 entity beans 不是件好事。它向群集的远程对象"
-#~ "开放（exposes）通常过于细颗粒度的元素（elements），导致了严重的数据同步问"
-#~ "题。除非你遇到特殊的情况，如只读或者只写的节点和使用缓存失效服务（cache "
-#~ "invalidation services）的只读节点同步，否则不要使用 EJB 2.x entity bean 的"
-#~ "群集。"
-
-#, fuzzy
-#~ msgid ""
-#~ "To cluster EJB 2.x entity beans, you need to add the <literal><"
-#~ "clustered></literal> element to the application's <literal>jboss."
-#~ "xml</literal> descriptor file. Below is a typical <literal>jboss.xml</"
-#~ "literal> file."
-#~ msgstr ""
-#~ "要群集 EJB 2.x entity beans，你需要把 <literal><clustered></"
-#~ "literal> 元素加入到应用程序的 <literal>jboss.xml</literal> 描述符文件里。"
-#~ "下面是一个典型的 <literal>jboss.xml</literal> 文件。"
-
-#~ msgid ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans> \n"
-#~ " <entity> \n"
-#~ " <ejb-name>nextgen.EnterpriseEntity</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.EnterpriseEntity</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name> \n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable \n"
-#~ " </bean-load-balance-policy> \n"
-#~ " </cluster-config> \n"
-#~ " </entity> \n"
-#~ " </enterprise-beans> \n"
-#~ "</jboss>"
-#~ msgstr ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans> \n"
-#~ " <entity> \n"
-#~ " <ejb-name>nextgen.EnterpriseEntity</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.EnterpriseEntity</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name> \n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable \n"
-#~ " </bean-load-balance-policy> \n"
-#~ " </cluster-config> \n"
-#~ " </entity> \n"
-#~ " </enterprise-beans> \n"
-#~ "</jboss>"
-
-#~ msgid ""
-#~ "The EJB 2.x entity beans are clustered for load balanced remote "
-#~ "invocations. All the bean instances are synchronized to have the same "
-#~ "contents on all nodes."
-#~ msgstr ""
-#~ "为了平衡远程调用的负载，我们群集 EJB 2.x entity beans。所有的 bean 实例都"
-#~ "实现同步，具有所有节点上的相同内容。"
-
-#~ msgid ""
-#~ "However, clustered EJB 2.x Entity Beans do not have a distributed locking "
-#~ "mechanism or a distributed cache. They can only be synchronized by using "
-#~ "row-level locking at the database level (see <literal><row-lock></"
-#~ "literal> in the CMP specification) or by setting the Transaction "
-#~ "Isolation Level of your JDBC driver to be "
-#~ "<literal>TRANSACTION_SERIALIZABLE</literal>. Because there is no "
-#~ "supported distributed locking mechanism or distributed cache Entity Beans "
-#~ "use Commit Option \"B\" by default (See <literal>standardjboss.xml</"
-#~ "literal> and the container configurations Clustered CMP 2.x EntityBean, "
-#~ "Clustered CMP EntityBean, or Clustered BMP EntityBean). It is not "
-#~ "recommended that you use Commit Option \"A\" unless your Entity Bean is "
-#~ "read-only. (There are some design patterns that allow you to use Commit "
-#~ "Option \"A\" with read-mostly beans. You can also take a look at the "
-#~ "Seppuku pattern <ulink url=\"http://dima.dhs.org/misc/readOnlyUpdates.html"
-#~ "\"></ulink>. JBoss may incorporate this pattern into later versions.)"
-#~ msgstr ""
-#~ "然而，群集的 EJB 2.x Entity Beans 没有分布式的锁定机制或是缓存。它们只能用"
-#~ "数据库层面的行级锁定（请参考 CMP 规范的<literal><row-lock></"
-#~ "literal>）或是把 JDBC 驱动的事务隔离（Transaction Isolation）级别设为 "
-#~ "<literal>TRANSACTION_SERIALIZABLE</literal> 来实现同步。因为缺乏分布式的锁"
-#~ "定机制或是缓存支持，Entity Beans 缺省使用提交选项 \"B\"（请参考 "
-#~ "<literal>standardjboss.xml</literal> 和 the container configurations "
-#~ "Clustered CMP 2.x EntityBean，Clustered CMP EntityBean，或 Clustered BMP "
-#~ "EntityBean）。我们不推荐你使用提交选项 \"A\"，除非你的 Entity Bean 是只读"
-#~ "的。（有些设计模式允许你把提交选项\"A\" 用于 read-mostly beans。你也可以看"
-#~ "看 Seppuku 模式：<ulink url=\"http://dima.dhs.org/misc/readOnlyUpdates."
-#~ "html\"></ulink>。JBoss 有可能把这个模式集成到以后的版本里。）"
-
-#~ msgid ""
-#~ "If you are using Bean Managed Persistence (BMP), you are going to have to "
-#~ "implement synchronization on your own. The MVCSoft CMP 2.0 persistence "
-#~ "engine (see <ulink url=\"http://www.jboss.org/jbossgroup/partners.jsp\"></"
-#~ "ulink>) provides different kinds of optimistic locking strategies that "
-#~ "can work in a JBoss cluster."
-#~ msgstr ""
-#~ "如果你正在使用 Bean Managed Persistence (BMP），你将不得不实现自己的同步机"
-#~ "制。MVCSoft CMP 2.0 持久化引擎（persistence engine）(请参考 <ulink url="
-#~ "\"http://www.jboss.org/jbossgroup/partners.jsp\"></ulink>）提供可以在 "
-#~ "JBoss 群集里使用的各种优化锁定策略。"
-
-#~ msgid "Entity Bean in EJB 3.0"
-#~ msgstr "EJB 3.0 里的 Entity Bean"
-
-#~ msgid ""
-#~ "In EJB 3.0, the entity beans primarily serve as a persistence data model. "
-#~ "They do not provide remote services. Hence, the entity bean clustering "
-#~ "service in EJB 3.0 primarily deals with distributed caching and "
-#~ "replication, instead of load balancing."
-#~ msgstr ""
-#~ "在 EJB 3.0 里，entity beans 主要以持久化数据模型出现。它们不提供远程服务。"
-#~ "因此，EJB 3.0 里的 entity bean 群集服务主要处理分布式缓存和复制，而不是负"
-#~ "载平衡。"
-
-#~ msgid "Configure the distributed cache"
-#~ msgstr "配置分布式缓存"
-
-#~ msgid ""
-#~ "To avoid round trips to the database, you can use a cache for your "
-#~ "entities. JBoss EJB 3.0 is implemented by Hibernate, which has support "
-#~ "for a second-level cache. The Hibernate setup used for the JBoss EJB 3.0 "
-#~ "implementation uses JBoss Cache as its underlying cache implementation. "
-#~ "The cache provides the following functionalities."
-#~ msgstr ""
-#~ "为了避免多次访问数据库，你可以为你的 entities 使用缓存。JBoss EJB 3.0 是"
-#~ "用 Hibernate 实现的，它支持两级缓存。用于 JBoss EJB 3.0 实现的 Hibernate "
-#~ "setup 把 JBoss Cache 当作底层缓存实现使用。这个缓存提供了下面的功能："
-
-#~ msgid ""
-#~ "If you persist a cache enabled entity bean instance to the database via "
-#~ "the entity manager the entity will inserted into the cache."
-#~ msgstr ""
-#~ "如果你通过 entity manager 来使应用缓存的 entity bean 的实例持久化，这个 "
-#~ "entity 会被储存到缓存里。"
-
-#~ msgid ""
-#~ "If you update an entity bean instance and save the changes to the "
-#~ "database via the entity manager the entity will updated in the cache."
-#~ msgstr ""
-#~ "如果你通过 entity manager 更新 entity bean 实例并把更改保存到数据库里，缓"
-#~ "存里的这个 entity 将被更新。"
-
-#~ msgid ""
-#~ "If you remove an entity bean instance from the database via the entity "
-#~ "manager the entity will removed from the cache."
-#~ msgstr ""
-#~ "如果你通过 entity manager 把 entity bean 实例从数据库里删除，这个 entity "
-#~ "也将从缓存里删除。"
-
-#~ msgid ""
-#~ "If loading a cached entity from the database via the entity manager, and "
-#~ "that entity does not exist in the database, it will be inserted into the "
-#~ "cache."
-#~ msgstr ""
-#~ "如果你通过 entity manager 从数据库里载入缓存的 entity，而这个这个 entity "
-#~ "并不在缓存里，这个 entity 会被插入到缓存里。"
-
-#, fuzzy
-#~ msgid ""
-#~ "JBoss Cache service for EJB 3.0 entity beans is configured in a "
-#~ "<literal>TreeCache</literal> MBean (see <xref linkend="
-#~ "\"JBossCache_and_JGroups_Services-JBossCache_Configuration\"/>) in the "
-#~ "<literal>deploy/ejb3-entity-cache-service.xml</literal> file. The name of "
-#~ "the cache MBean service is <literal>jboss.cache:"
-#~ "service=EJB3EntityTreeCache</literal>. Below is the contents of the "
-#~ "<literal>ejb3-entity-cache-service.xml</literal> file in the standard "
-#~ "JBoss distribution. Again, we omitted the JGroups configuration element "
-#~ "<literal>ClusterConfig</literal>."
-#~ msgstr ""
-#~ "JEJB 3.0 entity beans 采用的 Boss Cache 服务在 <literal>deploy/ejb3-"
-#~ "entity-cache-service.xml</literal> 文件里的 <literal>TreeCache</literal> "
-#~ "MBean（请参考<xref linkend=\"jbosscache-cache\"/>） 里被配置。缓存 MBean "
-#~ "服务名是<literal>jboss.cache:service=EJB3EntityTreeCache</literal>。下面是"
-#~ "标准 JBoss 发行版本里的 <literal>ejb3-entity-cache-service.xml</literal> "
-#~ "文件的内容。我们再次忽略了 JGroups 的配置元素 <literal>ClusterConfig</"
-#~ "literal>。"
-
-#~ msgid ""
-#~ "<server>\n"
-#~ " <mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ " name=\"jboss.cache:service=EJB3EntityTreeCache\">\n"
-#~ " \n"
-#~ " <depends>jboss:service=Naming</depends>\n"
-#~ " <depends>jboss:service=TransactionManager</depends>\n"
-#~ "\n"
-#~ " <!-- Configure the TransactionManager -->\n"
-#~ " <attribute name=\"TransactionManagerLookupClass\">\n"
-#~ " org.jboss.cache.JBossTransactionManagerLookup\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"IsolationLevel\">REPEATABLE_READ</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheMode\">REPL_SYNC</attribute>\n"
-#~ "\n"
-#~ " <!--Name of cluster. Needs to be the same for all clusters, \n"
-#~ " in order to find each other -->\n"
-#~ " <attribute name=\"ClusterName\">EJB3-entity-cache</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"ClusterConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"InitialStateRetrievalTimeout\">5000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"SyncReplTimeout\">10000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"LockAcquisitionTimeout\">15000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"EvictionPolicyClass\">\n"
-#~ " org.jboss.cache.eviction.LRUPolicy\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Specific eviction policy configurations. This is LRU --"
-#~ ">\n"
-#~ " <attribute name=\"EvictionPolicyConfig\">\n"
-#~ " <config>\n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">5</"
-#~ "attribute>\n"
-#~ " <!-- Cache wide default -->\n"
-#~ " <region name=\"/_default_\">\n"
-#~ " <attribute name=\"maxNodes\">5000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"timeToLiveSeconds\">1000</"
-#~ "attribute>\n"
-#~ " </region>\n"
-#~ " </config>\n"
-#~ " </attribute>\n"
-#~ " </mbean>\n"
-#~ "</server>"
-#~ msgstr ""
-#~ "<server>\n"
-#~ " <mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ " name=\"jboss.cache:service=EJB3EntityTreeCache\">\n"
-#~ " \n"
-#~ " <depends>jboss:service=Naming</depends>\n"
-#~ " <depends>jboss:service=TransactionManager</depends>\n"
-#~ "\n"
-#~ " <!-- Configure the TransactionManager -->\n"
-#~ " <attribute name=\"TransactionManagerLookupClass\">\n"
-#~ " org.jboss.cache.JBossTransactionManagerLookup\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"IsolationLevel\">REPEATABLE_READ</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheMode\">REPL_SYNC</attribute>\n"
-#~ "\n"
-#~ " <!--Name of cluster. Needs to be the same for all clusters, \n"
-#~ " in order to find each other -->\n"
-#~ " <attribute name=\"ClusterName\">EJB3-entity-cache</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"ClusterConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"InitialStateRetrievalTimeout\">5000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"SyncReplTimeout\">10000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"LockAcquisitionTimeout\">15000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"EvictionPolicyClass\">\n"
-#~ " org.jboss.cache.eviction.LRUPolicy\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Specific eviction policy configurations. This is LRU --"
-#~ ">\n"
-#~ " <attribute name=\"EvictionPolicyConfig\">\n"
-#~ " <config>\n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">5</"
-#~ "attribute>\n"
-#~ " <!-- Cache wide default -->\n"
-#~ " <region name=\"/_default_\">\n"
-#~ " <attribute name=\"maxNodes\">5000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"timeToLiveSeconds\">1000</"
-#~ "attribute>\n"
-#~ " </region>\n"
-#~ " </config>\n"
-#~ " </attribute>\n"
-#~ " </mbean>\n"
-#~ "</server>"
-
-#, fuzzy
-#~ msgid ""
-#~ "As we discussed in <xref linkend=\"JBossCache_and_JGroups_Services-"
-#~ "JBossCache_Configuration\"/>, JBoss Cache allows you to specify timeouts "
-#~ "to cached entities. Entities not accessed within a certain amount of time "
-#~ "are dropped from the cache in order to save memory. If running within a "
-#~ "cluster, and the cache is updated, changes to the entries in one node "
-#~ "will be replicated to the corresponding entries in the other nodes in the "
-#~ "cluster."
-#~ msgstr ""
-#~ "正如我们在 <xref linkend=\"jbosscache-cache\"/> 所讨论的，JBoss Cache 允许"
-#~ "你指定缓存的 entities 的超时时间。在某个时段内没有被访问的 entities 将从缓"
-#~ "存里删除，这样可以节省内存。如果这个缓存是在群集里运行，那么它会被更新。对"
-#~ "某个节点的 entries 的改动都会复制到群集里其他节点的相应条目里。"
-
-#~ msgid ""
-#~ "Now, we have JBoss Cache configured to support distributed caching of EJB "
-#~ "3.0 entity beans. We still have to configure individual entity beans to "
-#~ "use the cache service."
-#~ msgstr ""
-#~ "现在，我们配置了 JBoss Cache 来支持 EJB 3.0 entity beans 的分布式缓存。我"
-#~ "们仍不得不配置单个的 entity bean 来使用这个缓存服务。"
-
-#~ msgid "Configure the entity beans for cache"
-#~ msgstr "配置 entity beans 的缓存"
-
-#~ msgid ""
-#~ "You define your entity bean classes the normal way. Future versions of "
-#~ "JBoss EJB 3.0 will support annotating entities and their relationship "
-#~ "collections as cached, but for now you have to configure the underlying "
-#~ "hibernate engine directly. Take a look at the <literal>persistence.xml</"
-#~ "literal> file, which configures the caching options for hibernate via its "
-#~ "optional <literal>property</literal> elements. The following element in "
-#~ "<literal>persistence.xml</literal> defines that caching should be enabled:"
-#~ msgstr ""
-#~ "你用正常方式定义你的 entity bean 类。JBoss EJB 3.0 将来的版本将支持 "
-#~ "annotating entities 和所缓存的它们的关系的集合，但是现在你不得不直接配置底"
-#~ "层的 hibernate 引擎。让我们看看通过可选的 <literal>property</literal> 元素"
-#~ "配置 hibernate 缓存选项的 <literal>persistence.xml</literal> 文件。下面 "
-#~ "<literal>persistence.xml</literal> 里的定义缓存的元素应该被启用："
-
-#~ msgid ""
-#~ "<!-- Clustered cache with TreeCache -->\n"
-#~ "<property name=\"cache.provider_class\">\n"
-#~ " org.jboss.ejb3.entity.TreeCacheProviderHook\n"
-#~ "</property>"
-#~ msgstr ""
-#~ "<!-- Clustered cache with TreeCache -->\n"
-#~ "<property name=\"cache.provider_class\">\n"
-#~ " org.jboss.ejb3.entity.TreeCacheProviderHook\n"
-#~ "</property>"
-
-#~ msgid ""
-#~ "The following property element defines the object name of the cache to be "
-#~ "used, and the MBean name."
-#~ msgstr "下面的属性元素定义了所使用的缓存对象名和 MBean 名。"
-
-#~ msgid ""
-#~ "<property name=\"treecache.mbean.object_name\">\n"
-#~ " jboss.cache:service=EJB3EntityTreeCache\n"
-#~ "</property>"
-#~ msgstr ""
-#~ "<property name=\"treecache.mbean.object_name\">\n"
-#~ " jboss.cache:service=EJB3EntityTreeCache\n"
-#~ "</property>"
-
-#~ msgid ""
-#~ "Next we need to configure what entities be cached. The default is to not "
-#~ "cache anything, even with the settings shown above. We use the "
-#~ "<literal>@Cache</literal> annotation to tag entity beans that needs to be "
-#~ "cached."
-#~ msgstr ""
-#~ "下一步我们需要配置 entities 被缓存的内容。就像上面所展示的样，缺省是什么都"
-#~ "不缓存。我们使用 <literal>@Cache</literal> 注解来标记需要缓存的 entity "
-#~ "beans。"
-
-#~ msgid ""
-#~ "@Entity \n"
-#~ "@Cache(usage=CacheConcurrencyStrategy.TRANSACTIONAL) \n"
-#~ "public class Customer implements Serializable { \n"
-#~ " // ... ... \n"
-#~ "}"
-#~ msgstr ""
-#~ "@Entity \n"
-#~ "@Cache(usage=CacheConcurrencyStrategy.TRANSACTIONAL） \n"
-#~ "public class Customer implements Serializable { \n"
-#~ " // ... ... \n"
-#~ "}"
-
-#~ msgid ""
-#~ "A very simplified rule of thumb is that you will typically want to do "
-#~ "caching for objects that rarely change, and which are frequently read. "
-#~ "You can fine tune the cache for each entity bean in the <literal>ejb3-"
-#~ "entity-cache-service.xml</literal> configuration file. For instance, you "
-#~ "can specify the size of the cache. If there are too many objects in the "
-#~ "cache, the cache could evict oldest objects (or least used objects, "
-#~ "depending on configuration) to make room for new objects. The cache for "
-#~ "the <literal>mycompany.Customer</literal> entity bean is <literal>/"
-#~ "mycompany/Customer</literal> cache region."
-#~ msgstr ""
-#~ "一个简单的原则就是，你应该对很少变动和频繁使用的对象进行缓存.你可以在 "
-#~ "<literal>ejb3-entity-cache-service.xml</literal> 配置文件里为每个 entity "
-#~ "bean 微调缓存设置。例如，你可以指定缓存的大小。如果缓存里的对象太多，缓存"
-#~ "有可能挤掉最老的对象（或者最少用的对象，依你的配置而定）来给新对象留出空"
-#~ "间。<literal>mycompany.Customer</literal> entity bean 的缓存区（cache "
-#~ "region）是 <literal>/mycompany/Customer</literal>。"
-
-#~ msgid ""
-#~ "<server> \n"
-#~ " <mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ " name=\"jboss.cache:service=EJB3EntityTreeCache\"> \n"
-#~ " <depends>jboss:service=Naming \n"
-#~ " <depends>jboss:service=TransactionManager \n"
-#~ " ... ... \n"
-#~ " <attribute name=\"EvictionPolicyConfig\"> \n"
-#~ " <config> \n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">5</"
-#~ "attribute> \n"
-#~ " <region name=\"/_default_\"> \n"
-#~ " <attribute name=\"maxNodes\">5000</attribute> \n"
-#~ " <attribute name=\"timeToLiveSeconds\">1000</"
-#~ "attribute> \n"
-#~ " </region> \n"
-#~ " <region name=\"/mycompany/Customer\"> \n"
-#~ " <attribute name=\"maxNodes\">10</attribute> \n"
-#~ " <attribute name=\"timeToLiveSeconds\">5000</"
-#~ "attribute> \n"
-#~ " </region> \n"
-#~ " ... ... \n"
-#~ " </config> \n"
-#~ " </attribute> \n"
-#~ " </mbean> \n"
-#~ "</server>"
-#~ msgstr ""
-#~ "<server> \n"
-#~ " <mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ " name=\"jboss.cache:service=EJB3EntityTreeCache\"> \n"
-#~ " <depends>jboss:service=Naming \n"
-#~ " <depends>jboss:service=TransactionManager \n"
-#~ " ... ... \n"
-#~ " <attribute name=\"EvictionPolicyConfig\"> \n"
-#~ " <config> \n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">5</"
-#~ "attribute> \n"
-#~ " <region name=\"/_default_\"> \n"
-#~ " <attribute name=\"maxNodes\">5000</attribute> \n"
-#~ " <attribute name=\"timeToLiveSeconds\">1000</"
-#~ "attribute> \n"
-#~ " </region> \n"
-#~ " <region name=\"/mycompany/Customer\"> \n"
-#~ " <attribute name=\"maxNodes\">10</attribute> \n"
-#~ " <attribute name=\"timeToLiveSeconds\">5000</"
-#~ "attribute> \n"
-#~ " </region> \n"
-#~ " ... ... \n"
-#~ " </config> \n"
-#~ " </attribute> \n"
-#~ " </mbean> \n"
-#~ "</server>"
-
-#~ msgid ""
-#~ "If you do not specify a cache region for an entity bean class, all "
-#~ "instances of this class will be cached in the <literal>/_default</"
-#~ "literal> region as defined above. The EJB3 <literal>Query</literal> API "
-#~ "provides means for you to save to load query results (i.e., collections "
-#~ "of entity beans) from specified cache regions."
-#~ msgstr ""
-#~ "如果你没有为 entity bean 类指定缓存区（cache region），这个类的所有实例将"
-#~ "象上面定义的一样缓存在 <literal>/_default</literal> 区里。EJB3 "
-#~ "<literal>Query</literal> API 提供了让你在指定的缓存区里保存或载入查询结果"
-#~ "（就是 entity beans 的集合）的方法。"
-
-#~ msgid "Configure JBoss"
-#~ msgstr "配置 JBoss"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">IsolationLevel</emphasis> sets the isolation "
-#~ "level for updates to the transactional distributed cache. The valid "
-#~ "values are <literal>SERIALIZABLE</literal>, <literal>REPEATABLE_READ</"
-#~ "literal>, <literal>READ_COMMITTED</literal>, <literal>READ_UNCOMMITTED</"
-#~ "literal>, and <literal>NONE</literal>. These isolation levels mean the "
-#~ "same thing as isolation levels on the database. The default isolation of "
-#~ "<literal>REPEATABLE_READ</literal> makes sense for most web applications."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">IsolationLevel</emphasis> 为事务的分布式缓存的更新"
-#~ "设置隔离级别（isolation level）。它的有效值是 <literal>SERIALIZABLE</"
-#~ "literal>，<literal>REPEATABLE_READ</literal>，<literal>READ_COMMITTED</"
-#~ "literal>，<literal>READ_UNCOMMITTED</literal>，和 <literal>NONE</"
-#~ "literal>。这些隔离级别和数据库里的概念是一样的。缺省的 "
-#~ "<literal>REPEATABLE_READ</literal> 级别用于大部分 web 应用程序。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">CacheMode</emphasis> controls how the cache is "
-#~ "replicated. The valid values are <literal>REPL_SYNC</literal> and "
-#~ "<literal>REPL_ASYNC</literal>, which determine whether changes are made "
-#~ "synchronously or asynchronously. Using synchronous replication makes sure "
-#~ "changes propagated to the cluster before the web request completes. "
-#~ "However, synchronous replication is much slower. For asyncrhonous access, "
-#~ "you will want to enable and tune the replication queue."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">CacheMode</emphasis> 控制缓存被复制的方式。它的有"
-#~ "效值是 <literal>REPL_SYNC</literal> 和 <literal>REPL_ASYNC</literal>，用来"
-#~ "决定同步还是异步复制所做的修改。使用同步复制可以确保在 web 请求完成之前把"
-#~ "修改在群集里传播。然而，同步复制比较慢。对于异步方式，你会要启用和调整复制"
-#~ "队列。"
-
-#, fuzzy
-#~ msgid ""
-#~ "<emphasis role=\"bold\">ClusterConfig</emphasis> configures the "
-#~ "underlying JGroups stack. The most import configuration elements are the "
-#~ "muliticast adress and port, <literal>mcast_addr</literal> and "
-#~ "<literal>mcast_port</literal> respectively, to use for clustered "
-#~ "communication. These values should make sense for your network. Please "
-#~ "refer to <xref linkend=\"JBossCache_and_JGroups_Services-"
-#~ "JGroups_Configuration\"/> for more information."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">ClusterConfig</emphasis> 配置底层的 JGroups 栈。最"
-#~ "重要的配置元素是用于群集通讯的多点传送地址和端口，分别是 "
-#~ "<literal>mcast_addr</literal> 和 <literal>mcast_port</literal>。这些值对你"
-#~ "的网络该很有用。请参考 <xref linkend=\"jbosscache-jgroups\"/> 来获得更多信"
-#~ "息。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">UseReplQueue</emphasis> determines whether to "
-#~ "enable the replication queue when using asynchronous replication. This "
-#~ "allows multiple cache updates to be bundled together to improve "
-#~ "performance. The replication queue properties are controlled by the "
-#~ "<literal>ReplQueueInterval</literal> and <literal>ReplQueueMaxElements</"
-#~ "literal> properties."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">UseReplQueue</emphasis> 决定当使用异步复制时是否启"
-#~ "用复制队列。它允许多个缓存更新捆绑在一起来提高性能。复制队列属性由 "
-#~ "<literal>ReplQueueInterval</literal> 和 <literal>ReplQueueMaxElements</"
-#~ "literal> 控制。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">ReplQueueInterval</emphasis> specifies the time "
-#~ "in milliseconds JBoss Cache will wait before sending items in the "
-#~ "replication queue."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">ReplQueueInterval</emphasis> 指定以毫秒为单位的 "
-#~ "JBoss Cache 在发送请求到复制队列之前的等待时间。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">ReplQueueMaxElements</emphasis>: specifies the "
-#~ "maximum number of elements allowed in the replication queue before JBoss "
-#~ "Cache will send an update."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">ReplQueueMaxElements</emphasis>：指定 JBoss Cache "
-#~ "在发送更新之前，复制队列里所允许的最大元素数目。"
-
-#, fuzzy
-#~ msgid ""
-#~ "<emphasis role=\"bold\">SET_AND_NON_PRIMITIVE_GET</emphasis>: This policy "
-#~ "is similar to the SET_AND_GET policy except that only non-primitive get "
-#~ "operations are considered dirty. For example, the http session request "
-#~ "may retrieve a non-primitive object instance from the attribute and then "
-#~ "modify the instance. If we don't specify that non-primitive get is "
-#~ "considered dirty, then the modification will not be replication properly. "
-#~ "This is the default value."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">SET_AND_NON_PRIMITIVE_GET</emphasis>：这个策略和 "
-#~ "SET_AND_GET 相似，除了只有非基本（non-primitive）get 操作被当作 dirty。例"
-#~ "如，http 会话请求可能从属性里取出一个非基本对象实例，然后修改了这个实例。"
-#~ "如果我们没有指定非基本 get 应该考虑为 dirty，这个修改就不会正确地被复制。"
-#~ "这个选项是缺省值。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">SESSION</emphasis>: Replication is per session "
-#~ "instance. As long as it is considered modified when the snapshot manager "
-#~ "is called, the whole session object will be serialized."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">SESSION</emphasis>：复制基于每一会话实例。只要当调"
-#~ "用 snapshot manager 时它被认为有修改，整个会话对象都将串行化。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">ATTRIBUTE</emphasis>: Replication is only for the "
-#~ "dirty attributes in the session plus some session data, like, "
-#~ "lastAccessTime. For session that carries large amount of data, this "
-#~ "option can increase replication performance."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">ATTRIBUTE</emphasis>：复制仅针对于会话里的 ditry "
-#~ "属性加上某些会话数据，如 lastAccessTime。对于承载大量数据的会话，这个选项"
-#~ "可以提高复制性能。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">FIELD</emphasis>: Replication is only for data "
-#~ "fields inside session attribute objects (see more later)."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">FIELD</emphasis>：复制仅针对于会话属性对象里的数据"
-#~ "字段（后面会有更多内容）。"
-
-#, fuzzy
-#~ msgid ""
-#~ "When you annotate your class with <literal>@org.jboss.cache.aop."
-#~ "annotation.PojoCacheable</literal>, you indicate that instances of this "
-#~ "class will be used in FIELD-level replication. For exmaple,"
-#~ msgstr ""
-#~ "为了注解（annotate）你的 POJO，我们提供两个注解方式：<literal>@@org.jboss."
-#~ "web.tomcat.tc5.session.AopMarker</literal> 和 <literal>@@org.jboss.web."
-#~ "tomcat.tc5.session.InstanceAopMarker</literal>。当你用 "
-#~ "<literal>AopMarker</literal> 注解你的类时，你可以指出这个类的实例字段级复"
-#~ "制。例如："
-
-#, fuzzy
-#~ msgid ""
-#~ "If you annotate it with <literal>@org.jboss.cache.aop.annotation."
-#~ "InstanceOfPojoCacheable</literal> instead, then all of its sub-class will "
-#~ "be automatically annotated as well. For example,"
-#~ msgstr ""
-#~ "如果你用 <literal>InstanceAopMarker</literal> 注解类时，它所有的子类都将自"
-#~ "动被注解。例如,"
-
-#~ msgid "then when you have a sub-class like"
-#~ msgstr "当你有一个子类，如："
-
-#~ msgid ""
-#~ "public class Student extends Person\n"
-#~ "{\n"
-#~ "...\n"
-#~ "}"
-#~ msgstr ""
-#~ "public class Student extends Person\n"
-#~ "{\n"
-#~ "...\n"
-#~ "}"
-
-#~ msgid ""
-#~ "there will be no need to annotate <literal>Student</literal>. It will be "
-#~ "annotated automatically because it is a sub-class of <literal>Person</"
-#~ "literal>."
-#~ msgstr ""
-#~ "你不需要注解 <literal>Student</literal>。因为它是 <literal>Person</"
-#~ "literal> 的子类，所以它将自动被注解。"
-
-#~ msgid ""
-#~ "JBoss AS 3.2.4 and above support high availability JMS (HA-JMS) services "
-#~ "in the <literal>all</literal> server configuration. In the current "
-#~ "production release of JBoss AS, the HA-JMS service is implemented as a "
-#~ "clustered singleton fail-over service."
-#~ msgstr ""
-#~ "JBoss AS 3.2.4 和更高的版本支持高可用性的 <literal>all</literal> 服务器配"
-#~ "置里的 JMS（HA-JMS）服务。在 JBoss AS 当前的发布版本里，HA-JMS 服务用一个"
-#~ "群集的 singleton fail-over 服务来实现。"
-
-#~ msgid ""
-#~ "If you are willing to configure HA-JMS yourself, you can get it to work "
-#~ "with earlier versions of JBoss AS. We have a customer who uses HA-JMS "
-#~ "successfully in JBoss AS 3.0.7. Please contact JBoss support for more "
-#~ "questions."
-#~ msgstr ""
-#~ "如果你希望自己来配置 HA-JMS，你可以在以前的 JBoss AS 版本里让它运行。我们"
-#~ "有一个客户成功地在 JBoss AS 3.0.7 里使用 HA-JMS。如果你有更多问题的话，请"
-#~ "联系 JBoss 支持部门。"
-
-#~ msgid "High Availability Singleton Fail-over"
-#~ msgstr "高可用性的 Singleton Fail-over"
-
-#~ msgid ""
-#~ "The JBoss HA-JMS service (i.e., message queues and topics) only runs on a "
-#~ "single node (i.e., the master node) in the cluster at any given time. If "
-#~ "that node fails, the cluster simply elects another node to run the JMS "
-#~ "service (fail-over). This setup provides redundancy against server "
-#~ "failures but does not reduce the work load on the JMS server node."
-#~ msgstr ""
-#~ "JBoss HA-JMS 服务（也就是消息队列和主题）任何给定时间都只在群集里的单节点"
-#~ "运行（主节点）。如果这个节点崩溃了，群集系统简单地选取另外一节点来运行 "
-#~ "JMS 服务（fail-over）。这种设置提供了针对服务器瘫痪的冗余措施，但并没有降"
-#~ "低 JMS 服务器节点的负载。"
-
-#, fuzzy
-#~ msgid ""
-#~ "While you cannot load balance HA-JMS queues (there is only one master "
-#~ "node that runs the queues), you can load balance the MDBs that process "
-#~ "messages from those queues (see <xref linkend="
-#~ "\"High_Availability_Singleton_Fail_over-Load_Balanced_HA_JMS_MDBs\"/>)."
-#~ msgstr ""
-#~ "虽然你不能够对 HA-JMS 队列进行负载平衡（只有一个运行这个队列的主节点），但"
-#~ "是你可以平衡处理队列里信息的 MDBs 的负载（请参考 <xref linkend="
-#~ "\"clustering-jms-loadbalanced\"/>）。"
-
-#~ msgid "Server Side Configuration"
-#~ msgstr "服务端配置"
-
-#~ msgid ""
-#~ "To use the singleton fail-over HA-JMS service, you must configure JMS "
-#~ "services identically on all nodes in the cluster. That includes all JMS "
-#~ "related service MBeans and all deployed JMS applications."
-#~ msgstr ""
-#~ "为了使用 singleton fail-over HA-JMS 服务，你必须在群集里的所有节点上配置相"
-#~ "同的 JMS 服务。这包括所有和 JMS 相关的 MBeans 以及部署的 JMS 应用程序。"
-
-#~ msgid ""
-#~ "The JMS server is configured to persist its data in the "
-#~ "<literal>DefaultDS</literal>. By default, that is the embedded HSQLDB. In "
-#~ "most cluster environments, however, all nodes need to persist data "
-#~ "against a shared database. So, the first thing to do before you start "
-#~ "clustered JMS is to setup a shared database for JMS. You need to do the "
-#~ "following:"
-#~ msgstr ""
-#~ "JMS 服务器被设置成在 <literal>DefaultDS</literal> 里持久化它的数据。在缺省"
-#~ "的情况下，那就是内含的 HSQLDB。然而，在大部分群集环境里，所有节点都需要把"
-#~ "数据持久化到一个共享数据库里。因此，在你启动群集 JMS 之前要做的第一件事就"
-#~ "是建立一个共享数据库。你需要做如下的事情："
-
-#, fuzzy
-#~ msgid ""
-#~ "Configure <literal>DefaultDS</literal> to point to the database server of "
-#~ "your choice. That is to replace the <literal>deploy/hsqlsb-ds.xml</"
-#~ "literal> file with the <literal>xxx-ds.xml</literal> file in the "
-#~ "<literal>docs/examples/jca</literal> directory, where <literal>xxx</"
-#~ "literal> is the name of the target shared database (e.g., <literal>mysql-"
-#~ "ds.xml</literal>, see <xref linkend=\"Connectors_on_JBoss-"
-#~ "Configuring_JDBC_DataSources\"/>)."
-#~ msgstr ""
-#~ "配置 <literal>DefaultDS</literal> 来指向你选择的数据库服务器。就是用 "
-#~ "<literal>docs/examples/jca</literal> 目录下的 <literal>xxx-ds.xml</"
-#~ "literal> 文件代替 <literal>deploy/hsqlsb-ds.xml</literal> 文件，其中 "
-#~ "<literal>xxx</literal> 是目标共享数据库的名字（例如，<literal>mysql-ds."
-#~ "xml</literal> ）"
-
-#~ msgid ""
-#~ "Replace the <literal>hsqldb-jdbc2-service.xml</literal> file under the "
-#~ "<literal>server/all/deploy-hasingleton/jms</literal> directory with one "
-#~ "tuned to the specific database. For example if you use MySQL the file is "
-#~ "<literal>mysql-jdbc2-service.xml</literal>. Configuration files for a "
-#~ "number of RDBMS are bundled with the JBoss AS distribution. They can be "
-#~ "found under <literal>docs/examples/jms</literal>."
-#~ msgstr ""
-#~ "把 <literal>server/all/deploy-hasingleton/jms</literal> 目录下的 "
-#~ "<literal>hsqldb-jdbc2-service.xml</literal>文件用特定数据库的文件代替。例"
-#~ "如，MySQL 的文件就是 <literal>mysql-jdbc2-service.xml</literal>。JBoss AS "
-#~ "发行版本捆绑了一些 RDBMS 的配置文件。它们可以在 <literal>docs/examples/"
-#~ "jms</literal> 下找到。"
-
-#~ msgid ""
-#~ "There is no need to replace the <literal>hsqldb-jdbc-state-service.xml</"
-#~ "literal> file under the <literal>server/all/deploy-hasingleton/jms</"
-#~ "literal> directory. Despite the <literal>hsql</literal> in its name, it "
-#~ "works with all SQL92 compliant databases, including HSQL, MySQL, SQL "
-#~ "Server, and more. It automatically uses the <literal>DefaultDS</literal> "
-#~ "for storage, as we configured above."
-#~ msgstr ""
-#~ "你不需要替换 <literal>server/all/deploy-hasingleton/jms</literal> 目录下"
-#~ "的 <literal>hsqldb-jdbc-state-service.xml</literal> 文件。尽管它的名字里包"
-#~ "含 <literal>hsql</literal>，它适用于所有兼容 SQL92 的数据库，包括 HSQL，"
-#~ "MySQL，SQL Server 和更多数据库。象我们上面配置的那样，它自动使用 "
-#~ "<literal>DefaultDS</literal> 来存放数据。"
-
-#~ msgid "HA-JMS Client"
-#~ msgstr "HA-JMS 客户"
-
-#~ msgid ""
-#~ "The HA-JMS client is different from regular JMS clients in two important "
-#~ "aspects."
-#~ msgstr "HA-JMS 客户和常规的 JMS 客户在两个方面有所不同。"
-
-#~ msgid ""
-#~ "The HA-JMS client must obtain JMS connection factories from the HA-JNDI "
-#~ "(the default port is 1100)."
-#~ msgstr ""
-#~ "HA-JMS 客户必须获得 HA-JNDI 里的 JMS connection factories（缺省端口是"
-#~ "1100）。"
-
-#~ msgid ""
-#~ "The client connection must listens for server exceptions. When the "
-#~ "cluster fail-over to a different master node, all client operations on "
-#~ "the current connection fails with exceptions. The client must know to re-"
-#~ "connect."
-#~ msgstr ""
-#~ "客户连接必须监控服务器异常（exceptions）。当群集系统 fail-over 到另外一个"
-#~ "主节点时，所有在当前连接上的的客户端操作都会失败并产生异常（exceptions）。"
-#~ "客户端必须知道该重新连接。"
-
-#~ msgid ""
-#~ "While the HA-JMS connection factory knows the current master node that "
-#~ "runs JMS services, there is no smart client side interceptor. The client "
-#~ "stub only knows the fixed master node and cannot adjust to server "
-#~ "topography changes."
-#~ msgstr ""
-#~ "虽然 HA-JMS 连接工厂（connection factory）知道运行 JMS 服务的当前主节点，"
-#~ "但并不存在智能的客户端拦截器（client side interceptor）。客户端 stub 只知"
-#~ "道固定的主节点，它不能够依服务器拓扑结构的变化而调整。"
-
-#~ msgid "Load Balanced HA-JMS MDBs"
-#~ msgstr "负载平衡的 HA-JMS MDBs "
-
-#~ msgid ""
-#~ "While the HA-JMS queues and topics only run on a single node at a time, "
-#~ "MDBs on multiple nodes can receive and process messages from the HA-JMS "
-#~ "master node. The contested queues and topics result in load balancing "
-#~ "behavior for MDBs. To enable loading balancing for MDBs, you can specify "
-#~ "a receiver for the queue. The receiver records which node is waiting for "
-#~ "a message and in which order the messages should be processed. JBoss "
-#~ "provides three receiver implementations."
-#~ msgstr ""
-#~ "虽然 HA-JMS 队列（queues）和主题（topics）在同一时间只在单节点上运行，但其"
-#~ "他节点上的 MDBs 也能够接收和处理 HA-JMS 主节点上的信息。这种竞争的情况导"
-#~ "致 MDBs 的平衡负载行为。为了启用 MDBs 的平衡负载，你可以指定队列的 "
-#~ "receiver。这个 receiver 记录哪个节点正在等待信息和信息该按什么样的顺序来处"
-#~ "理。JBoss 提供三个 receiver 的实现（implementations）。"
-
-#~ msgid ""
-#~ "The <literal>org.jboss.mq.server.ReceiversImpl</literal> is the default "
-#~ "implementation using a <literal>HashSet</literal>."
-#~ msgstr ""
-#~ "<literal>org.jboss.mq.server.ReceiversImpl</literal> 是 <literal>HashSet</"
-#~ "literal> 的缺省实现（implementation）。"
-
-#~ msgid ""
-#~ "The <literal>org.jboss.mq.server.ReceiversImplArrayList</literal> is "
-#~ "theimplementation using an <literal>ArrayList</literal>."
-#~ msgstr ""
-#~ "<literal>org.jboss.mq.server.ReceiversImplArrayList</literal> 是 "
-#~ "<literal>ArrayList</literal> 的实现。"
-
-#~ msgid ""
-#~ "The <literal>org.jboss.mq.server.ReceiversImplLinkedList</literal> is the "
-#~ "implementation using a <literal>LinkedList</literal>."
-#~ msgstr ""
-#~ "<literal>org.jboss.mq.server.ReceiversImplLinkedList</literal> 是 "
-#~ "<literal>LinkedList</literal> 的实现。"
-
-#, fuzzy
-#~ msgid ""
-#~ "You can specify the receiver implementation class name as an attribute in "
-#~ "the MBean that defines the permanent JMS <literal>Queue</literal> or "
-#~ "<literal>DestinationManager</literal> on each node (see <xref linkend="
-#~ "\"Messaging_on_JBoss\"/>). For best load balancing performance, we "
-#~ "suggest you to use the <literal>ReceiversImplArrayList</literal> or "
-#~ "<literal>ReceiversImplArrayList</literal> implementations due to an "
-#~ "undesirable implementation detail of <literal>HashSet</literal> in the "
-#~ "JVM."
-#~ msgstr ""
-#~ "你可以指定 receiver 实现的类名作为在每个节点上定义永久 JMS "
-#~ "<literal>Queue</literal> 或 <literal>DestinationManager</literal> 的 "
-#~ "MBean 的一个属性。为了获得最好的负载平衡性能，我们建议你使用 "
-#~ "<literal>ReceiversImplArrayList</literal> 或 "
-#~ "<literal>ReceiversImplArrayList</literal> 实现，因为 JVM 里的 "
-#~ "<literal>HashSet</literal> 的实现不是很好。"
-
-#~ msgid ""
-#~ "Currently, due to an implementation bug, the farm deployment service only "
-#~ "works for hot-deployed archives. If you put an application in the "
-#~ "<literal>farm/</literal> directory first and then start the server, the "
-#~ "application would not be detected and pushed across the cluster. We are "
-#~ "working to resolve this issue."
-#~ msgstr ""
-#~ "目前，由于一个实现的程序缺陷， farm 部署服务只能用于热部署（hot-deployed）"
-#~ "档案文件。如果你先把一个应用程序放在 <literal>farm/</literal> 目录里然后启"
-#~ "动服务器，这个应用不会被检测到且运用到群集里。我们正在努力解决这个问题。"
More information about the jboss-cvs-commits
mailing list