[jboss-cvs] JBossAS SVN: r73096 - projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN.

jboss-cvs-commits at lists.jboss.org jboss-cvs-commits at lists.jboss.org
Wed May 7 00:16:06 EDT 2008 

Author: xhuang at jboss.com
Date: 2008-05-07 00:16:06 -0400 (Wed, 07 May 2008)
New Revision: 73096

Modified:
   projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_Intro.po
   projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_JMS.po
Log:
update

Modified: projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_Intro.po
===================================================================
--- projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_Intro.po	2008-05-07 00:35:51 UTC (rev 73095)
+++ projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_Intro.po	2008-05-07 04:16:06 UTC (rev 73096)
@@ -9,7 +9,7 @@
 "Project-Id-Version: Clustering_Guide_Intro\n"
 "Report-Msgid-Bugs-To: http://bugs.kde.org\n"
 "POT-Creation-Date: 2007-12-09 23:23+0000\n"
-"PO-Revision-Date: 2008-05-06 17:09+1000\n"
+"PO-Revision-Date: 2008-05-07 13:29+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -91,7 +91,6 @@
 #. Tag: para
 #: Clustering_Guide_Intro.xml:24
 #, no-c-format
-#, fuzzy
 msgid ""
 "A cluster is a set of nodes that communicate with each other and work toward "
 "a common goal. In a JBoss Application Server cluster (also known as a "
@@ -109,7 +108,7 @@
 "and name that matches the other cluster members. In summary, a JBoss cluster "
 "is a set of AS server instances each of which is running an identically "
 "configured and named JGroups Channel."
-msgstr "群集由一系列节点组成，它们相互通信并实现一个共同的目标。在 JBoss 应用服务器群集（也称为“partition”）里，节点是一个 JBoss 应用服务器实例。节点之间的通信由 JGroups 组通信库进行处理，而 JGroups Channel 提供核心功能"
+msgstr "群集由一系列节点组成，它们相互通信并实现一个共同的目标。在 JBoss 应用服务器群集（也称为“partition”）里，节点是一个 JBoss 应用服务器实例。节点之间的通信由 JGroups 组通信库进行处理，而 JGroups 频道（Channel）提供记录群集成员并在成员间传递消息的核心功能。具有相同配置和名称的 JGroups 频道能够动态地彼此发现并形成一组。这就是为什么在相同网络里的两个 AS 实例上简单地执行“run -c all”就足够组成一个群集系统了 － 每个 AS 实例都启动一个具有相同缺省配置的频道（实际上是几个），它们可以动态地彼此发现并形成群集系统。在任何时候都可以动态地在群集里添加或删除节点，你只需简单地启动或停止具有映射其他群集成员的配置和名称的频道。总的来说，JBoss 群集是一组 AS 服务器实例，它们都运行具有相同配置å’!
 Œåç§°çš„ JGroups 频道。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:29
@@ -122,7 +121,7 @@
 "as HAPartition. In order to differentiate these channels, each must have a "
 "unique name, and its configuration must match its peers yet differ from the "
 "other channels."
-msgstr ""
+msgstr "在相同的 AS 实例上，不同的服务可以创建各自的频道。在缺省的 4.2.x AS 里，有 4 个不同的服务创建了频道 － web 会话复制服务、EJB3 SFSB 复制服务、EJB3 Entity 缓存服务和核心的通用群集服务，也就是 HAPartition。为了区分，这些频道都必须具有唯一的名字，且必须匹配对应配置而又和其他频道不同。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:32
@@ -134,6 +133,8 @@
 "cluster, but it's important to understand that you really have 4 channels, "
 "and hence 4 two node clusters."
 msgstr ""
+"所以，如果你有两个 AS 4.2.x 实例并执行 <literal>run -c all</"
+"literal>，这些频道将彼此发现，你将拥有一个概念性的<literal>群集</literal>。你很容易把将其考虑为一个具有两个节点的群集，但重要的是要理解实际上这里有 4 个频道，因此是 4 个具有两个节点的群集。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:36
@@ -146,7 +147,7 @@
 "simply by configuring the AS instances such that within a set of nodes meant "
 "to form a cluster the Channel configurations and names match while they "
 "differ from any other channels on the same network."
-msgstr ""
+msgstr "在同一个网络里，即使是相同的服务，我们也可能组成不同的群集。<xref linkend=\"clustering-Partition.fig\"/> 展示了一个网络，里面的 JBoss 服务器实例分成 3 个群集，第三个群集里只有一个节点。这种拓扑结构可以通过简单地配置 AS 实例、使组成群集的节点的频道配置和名称和相同网络里的其他节点彼此不同来实现。"
 
 #. Tag: title
 #: Clustering_Guide_Intro.xml:38
@@ -165,13 +166,13 @@
 "categories: the Channel used by the general purpose HAPartition service, and "
 "three Channels created by JBoss Cache for special purpose caching and "
 "cluster wide state replication."
-msgstr ""
+msgstr "“JGroups 配置”和“隔离 JGroups 频道”章节详细介绍了怎样配置频道，使其相互寻找所需频道而忽略不需要的频道。如上面所提到的，JBoss AS 缺省使用 4 个独立的 JGroups 频道。它们可以分成两个广泛的类别：通用的 HAPartition 服务使用的频道、以及 JBoss Cache 所创建的用于特殊目的的缓存和群集状态复制的 3 个频道。"
 
 #. Tag: title
 #: Clustering_Guide_Intro.xml:50
 #, no-c-format
 msgid "HAPartition"
-msgstr ""
+msgstr "HAPartition"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:52
@@ -189,10 +190,13 @@
 "SFSB replication and entity cache management, farming, HA-JNDI and HA "
 "singletons."
 msgstr ""
+"HAPartition 是一个在 AS 群集里完成不同任务的通用服务。它的核心是建立在 JGroups "
+"Channel 顶层的抽象层，提供对在/从一个或多个群集成员里制造/接收 RPC 调用的支持。HAPartition 也支持分布式的注册表，管理群集服务运行在哪个群集成员上。当群集成员资格或群集注册表有变动时，它为感兴趣的侦听者提供通知。HAPartition 是我们将在后面讨论的许多群集服务的核心，包括智能客户端群集代理、EJB 2 "
+"SFSB 复制和 entity 缓存管理、farming、HA-JNDI 和 HA 单点登录（singleton）。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:57
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "The following example shows the <literal>HAPartition</literal> MBean "
 "definition packaged with the standard JBoss AS distribution. So, if you "
@@ -200,8 +204,7 @@
 "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</"
+"下面的例子展示了标准 JBoss AS 发行版本里的 <literal>HAPartition</literal> MBean 的定义。如果你在本地网络里用缺省的群集设定来启动  JBoss 服务器，你将得到一个名为 <literal>DefaultPartition</"
 "literal> 的缺省群集，它包括了所有作为节点的服务器实例。"
 
 #. Tag: programlisting
@@ -260,7 +263,7 @@
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:62
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "Here, we omitted the detailed JGroups protocol configuration for this "
 "channel. JGroups handles the underlying peer-to-peer communication between "
@@ -271,11 +274,11 @@
 "在这里，我们忽略了这个群集的详细的 JGroups 协议配置（protocal "
 "configuration）。JGroups 处理节点之间底层的点到点通信，我们将在 <xref "
 "linkend=\"jbosscache-jgroups\"/> 里讨论它的配置。下面的列表展示了 "
-"<literal>ClusterPartition</literal> MBean 里可用的配置属性。"
+"<literal>HAPartition</literal> MBean 里可用的配置属性。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:67
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<emphasis role=\"bold\">PartitionName</emphasis> is an optional attribute to "
 "specify the name of the cluster. Its default value is "
@@ -283,17 +286,16 @@
 "--partition) command line switch to set this value at JBoss startup."
 msgstr ""
 "<emphasis role=\"bold\">PartitionName</emphasis> 是用来指定节点名称的可选属"
-"性。它的缺省值是 <literal>DefaultPartition</literal>。"
+"性。它的缺省值是 <literal>DefaultPartition</literal>。你可以使用 <literal>-g </literal> (a.k.a. "
+"--partition) 命令行选项在 JBoss 启动时设置这个值。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:71
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<emphasis role=\"bold\">NodeAddress</emphasis> is an optional attribute used "
 "to help generate a unique name for this node."
-msgstr ""
-"<emphasis role=\"bold\">NodeAddress</emphasis> 是用来指定节点所绑定的 IP 地址"
-"的可选属性。"
+msgstr "<emphasis role=\"bold\">NodeAddress</emphasis> 是用来帮助给节点产生唯一名称的可选属性。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:74
@@ -309,7 +311,7 @@
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:79
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<emphasis role=\"bold\">StateTransferTimeout</emphasis> is an optional "
 "attribute to specify the timeout for state replication across the cluster "
@@ -318,20 +320,19 @@
 "service startup. Its default value is <literal>30000</literal>."
 msgstr ""
 "<emphasis role=\"bold\">StateTransferTimeout</emphasis> 是用来指定跨群集的状"
-"态复制（state replication）的超时时间（以毫秒为单位）的可选属性。它的缺省值"
+"态复制（state replication）的超时时间（以毫秒为单位）的可选属性。状态复制指的是在服务启动时获取其他已经运行的群集成员的初始应用程序状态的过程。它的缺省值"
 "是 <literal>30000</literal>。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:82
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<emphasis role=\"bold\">PartitionConfig</emphasis> is an element to specify "
 "JGroup configuration options for this cluster (see <xref linkend="
 "\"jbosscache-jgroups\"/>)."
 msgstr ""
 "<emphasis role=\"bold\">PartitionConfig</emphasis> 是一个用来为这个群集（参"
-"看 <xref linkend=\"jbosscache-jgroups\"/>）指定 JGroup 配置选项的元素"
-"（element）。"
+"看 <xref linkend=\"jbosscache-jgroups\"/>）指定 JGroup 配置选项的元素（element）。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:86
@@ -341,11 +342,11 @@
 "<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."
-msgstr ""
+msgstr "为了组成一个群集，它们必须具有完全相同的 <literal>PartitionName</literal> 和  <literal>ParitionConfig</literal> 元素。改变一些而不是全部节点里的其中任何一个元素都会导致群集的分离。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:89
-#, fuzzy, no-c-format
+#, no-c-format
 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., <literal>http://"
@@ -357,36 +358,34 @@
 msgstr ""
 "你可以用浏览器访问群集系统里的任何 JBoss 实例的 JMX 控制台来查看当前的群集信"
 "息（如，<literal>http://hostname:8080/jmx-console/</literal>），点击 "
-"<literal>jboss:service=DefaultPartition</literal> MBean（如果这个节点没有加"
-"入 <literal>DefaultPartition</literal>，你可以改变 MBean 名来反映群集名）。"
-"<literal>CurrentView</literal> 字段会显示当前群集的 IP 地址的列表。"
+"<literal>jboss:service=DefaultPartition</literal> MBean（如果使用了 -g 启动选项，你可以改变 MBean 名来反映群集名）。CurrentView 字段会显示当前群集成员的 IP 地址的列表。"
 
 #. Tag: title
 #: Clustering_Guide_Intro.xml:93
 #, no-c-format
 msgid "Note"
-msgstr ""
+msgstr "注意"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:94
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "While it is technically possible to put a JBoss server instance into "
 "multiple HAPartitions at the same time, this practice is generally not "
 "recommended, as it increases management complexity."
 msgstr ""
-"从技术上来讲，我们可以在同一时间把 JBoss 服务器实例放到多个群集里，但我们通常"
+"从技术上来讲，我们可以在同一时间把 JBoss 服务器实例放到多个 HAPartition 里，但我们通常"
 "不推荐这么做，因为这增加了管理的复杂性。"
 
 #. Tag: title
 #: Clustering_Guide_Intro.xml:100
 #, no-c-format
 msgid "JBoss Cache channels"
-msgstr ""
+msgstr "JBoss Cache 频道"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:101
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "JBoss Cache is a fully featured distributed cache framework that can be used "
 "in any application server environment or standalone. JBoss AS integrates "
@@ -396,10 +395,8 @@
 "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 里定义。我"
+"JBoss Cache 是个一个能用在任何应用程序和独立服务器环境里的分布式缓存框架。JBoss AS 集成了 JBoss "
+"Cache 来为 HTTP 会话，EJB 3.0 session bean 和 EJB 3.0 entity beans 提供缓存服务。每个缓存服务都在单独的 MBean 里定义且都创建自己的 JGroups Channel。我"
 "们将在后面讨论特定服务时介绍这些 MBean。"
 
 #. Tag: title
@@ -410,7 +407,7 @@
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:107
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "The clustering topography defined by the <literal>HAPartition</literal> "
 "MBean on each node is of great importance to system administrators. But for "
@@ -420,21 +417,21 @@
 "k.a smart proxies or stubs) and external load balancers. Which architecture "
 "your application will use will depend on what type of client you have."
 msgstr ""
-"每个节点上的 <literal>ClusterPartition</literal> MBean 定义的群集拓扑结构"
+"每个节点上的 <literal>HAPartition</literal> MBean 定义的群集拓扑结构"
 "（clustering topography）对系统管理员很重要。但是对于大部分的应用程序开发者来"
 "说，你可能更关心从客户应用程序的角度来看的群集架构。JBoss AS 支持两种群集架"
-"构：客户端拦截器（client-side interceptors）（proxies 或 stubs）和负载平衡系"
-"统（load balancers）。"
+"构：客户端拦截器（client-side interceptors）（智能 proxies 或 stubs）和外部负载平衡系"
+"统（external load balancers）。采用哪个架构将取决于你的客户端类型。"
 
 #. Tag: title
 #: Clustering_Guide_Intro.xml:113 Clustering_Guide_Intro.xml:159
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Client-side interceptor architecture"
-msgstr "客户端拦截器"
+msgstr "客户端拦截器架构"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:114
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "Most remote services provided by the JBoss application server, including "
 "JNDI, EJB, JMS, RMI and JBoss Remoting, require the client to obtain (e.g., "
@@ -450,15 +447,14 @@
 "client."
 msgstr ""
 "JBoss 应用服务器提供的大部分远程服务，包括 JNDI、EJB、RMI 和 JBoss Remoting，"
-"都要求客户端获得（如，查找和下载）一个 stub（或 proxy）对象。占位对象（stub "
-"object）由服务器生成，它实现服务的商业接口。客户可对占位对象调用本地方法。这"
+"都要求客户端获得（如，查找和下载）一个 stub（或 proxy）对象。Stub 对象由服务器生成，它实现服务的商业接口。客户可对 stub 对象调用本地方法。这"
 "个调用会自动寻找路由，并被服务器管理的服务对象引用。在群集环境里，服务器生成"
-"的占位对象也是一个懂得怎样把调用指引向不同节点的拦截器。占位对象寻找合适的服"
+"的 stub 对象也是一个懂得怎样把调用指引向不同节点的拦截器。Stub 对象寻找合适的服"
 "务器节点、配置调用参数、解释调用结果，并把结果返回给调用程序。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:119
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "The stub interceptors maintain up-to-date knowledge about the cluster. For "
 "instance, they know the IP addresses of all available server nodes, the "
@@ -473,11 +469,11 @@
 "clustering architecture is illustrated in <xref linkend=\"clustering-"
 "InterceptorArch.fig\"/>."
 msgstr ""
-"stub interceptors 拥有群集系统的更新信息。例如，它们知道所有可用网络节点的 "
+"Stub 拦截器拥有群集系统的更新信息。例如，它们知道所有可用网络节点的 "
 "IP 地址，怎样在节点上分摊负载的算法（请参考下一部分内容），和如果目标节点不可"
-"用时对请求进行失效切换（failover）。对于每个服务请求，服务器节点都用群集里最"
-"新的信息来更新 stub interceptor。例如，如果一个节点退出群集系统后，每个客户 "
-"stub interceptor 在下一次连接活动的节点时，都会用新的配置来更新。在 service "
+"用时对请求进行失效切换（failover）。作为处理每个服务请求的一部分，服务器节点都用群集里最"
+"新的信息来更新 stub 拦截器。例如，如果一个节点退出群集系统后，每个客户 "
+"stub 拦截器在下一次连接活动的节点时，都会用新的配置来更新。在 service "
 "stub 上的所有操作对于客户应用程序都是透明的。<xref linkend=\"clustering-"
 "InterceptorArch.fig\"/> 里说明了客户端拦截器群集架构。"
 
@@ -485,7 +481,7 @@
 #: Clustering_Guide_Intro.xml:122
 #, no-c-format
 msgid "The client-side interceptor (proxy) architecture for clustering"
-msgstr "The client-side interceptor (proxy) architecture for clustering"
+msgstr "用于群集的客户端拦截器（代理）架构"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:130
@@ -523,23 +519,25 @@
 "architecture is illustrated in <xref linkend=\"clustering-BalancerArch.fig\"/"
 ">."
 msgstr ""
+"其他 JBoss 服务，特别是基于 HTTP 的服务，并不要求客户下载任何东西。客户端（如浏览器）发送请求并按照某种通信协议（如 HTTP）直接接收响应。在这种情况下，我们需要外部的负载平衡系统来处理所有的请求并分发至群集里的服务器节点。客户端只需要懂得如何联系负载平衡系统，它不需要了解负载平衡系统后面的 JBoss AS 实例。从逻辑上来说，负载平衡系统是群集的一部分，但我们之所以称之为“外部的”，是因为它并未运行在和客户或任何 JBoss AS 实例相同的进程里。它既可以通过硬件也可以通过软件来实现。许多硬件供应商提供负载平衡系统；mod_jk Apache 模块则是一个优秀的软件负载平衡系统。外部负载平衡系统根据群集配置实现它自己的机制并提供负责平衡和失效切换策略。<xref linkend=\"clustering-BalancerArch.fig\"/"
+"> 演示了外部负载平衡系统的群集架构。"
 
 #. Tag: title
 #: Clustering_Guide_Intro.xml:140
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "The external load balancer architecture for clustering"
-msgstr "The load balancer architecture for clustering"
+msgstr "用于群集的外部负载平衡系统的架构"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:147
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "A potential problem with an external load balancer architecture is that the "
 "load balancer itself may be a single point of failure. It needs to be "
 "monitored closely to ensure high availability of the entire cluster's "
 "services."
 msgstr ""
-"负载平衡系统的一个潜在问题就是它本身就是单一的故障点。它需要被很好地监控来确"
+"外部负载平衡系统的一个潜在问题就是它本身就是单一的故障点。它需要被很好地监控来确"
 "保整个群集服务的高可用性。"
 
 #. Tag: title
@@ -550,7 +548,7 @@
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:155
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "Both the JBoss client-side interceptor (stub) and load balancer use load "
 "balancing policies to determine which server node to which node a new "
@@ -558,7 +556,7 @@
 "policies available in JBoss AS."
 msgstr ""
 "JBoss 客户端拦截器（stub）和负载平衡系统都使用了负载平衡策略来决定把新请求发"
-"送给哪个节点。让我们来看看 JBoss AS 里的负载平衡策略。"
+"送给哪个节点。在本节，让我们来看看 JBoss AS 里的负载平衡策略。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:160
@@ -568,11 +566,11 @@
 "client-side interceptor architecture is used. The client-side stub maintains "
 "a list of all nodes providing the target service; the job of the load "
 "balance policy is to pick a node from this list for each request."
-msgstr ""
+msgstr "在 JBoss 4.2.2 里，当使用客户端拦截器时，你可以使用下面的负载平衡选项。客户端 stub 维护了一个包含所有提供目标服务的节点的列表；负载平衡策略的任务是为每个请求从这个列表里选取一个节点。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:165
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "Round-Robin (<literal>org.jboss.ha.framework.interfaces.RoundRobin</"
 "literal>): each call is dispatched to a new node, proceeding sequentially "
@@ -580,21 +578,21 @@
 "the list."
 msgstr ""
 "Round-Robin (<literal>org.jboss.ha.framework.interfaces.RoundRobin</"
-"literal>)：每次调用都分派给新节点。第一个目标节点从列表里随机选择。"
+"literal>)：每次调用都分派给新节点，之后再选取列表里的其他节点。第一个目标节点从列表里随机选择。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:171
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "Random-Robin (<literal>org.jboss.ha.framework.interfaces.RandomRobin</"
 "literal>): for each call the target node is randomly selected from the list."
 msgstr ""
-"Round-Robin (<literal>org.jboss.ha.framework.interfaces.RoundRobin</"
-"literal>)：每次调用都分派给新节点。第一个目标节点从列表里随机选择。"
+"Random-Robin (<literal>org.jboss.ha.framework.interfaces.RandomRobin</"
+"literal>)：对于每次调用，都随机从列表里选择一个目标节点。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:176
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "First Available (<literal>org.jboss.ha.framework.interfaces.FirstAvailable</"
 "literal>): one of the available target nodes is elected as the main target "
@@ -612,11 +610,12 @@
 "literal>)：选择其中一个可用目标节点作为主目标节点，用于每次调用：这个节点是在"
 "群集里的节点列表里随机选取的。当目标节点的列表改变时（因为有节点启动或退"
 "出），除非当前选用的节点仍然可用，这个策略会重新选择一个目标节点。每个客户端"
-"拦截器或者负载平衡系统都会根据自己的策略独立地选择目标节点。"
+"拦截器或者负载平衡系统都会根据自己的策略独立地选择目标节点，所以如果特定的客户端为相同的目标服务（如 EJB）下载了两个 stub，每个 stub 都将独立地选取自己的目标。既然目标节点一旦选取就不能改变，这是一个提供 “session affinity”或“sticky "
+"sessions”的例子。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:183
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "First Available Identical All Proxies (<literal>org.jboss.ha.framework."
 "interfaces.FirstAvailableIdenticalAllProxies</literal>): has the same "
@@ -625,10 +624,9 @@
 "same target service. So if a particular client downloads two stubs for the "
 "same target service (e.g. an EJB), each stub will use the same target."
 msgstr ""
-"JBoss 3.2 里的新的负载平衡选项是 \"First AvailableIdenticalAllProxies"
-"\"  (<literal>org.jboss.ha.framework.interfaces."
-"FirstAvailableIdenticalAllProxies</literal>)。它与 \"First Available\" 有相同"
-"的行为，但选取的目标节点由所有同一 \"family\" 的客户端拦截器共享。"
+"First AvailableIdenticalAllProxies (<literal>org.jboss.ha.framework.interfaces."
+"FirstAvailableIdenticalAllProxies</literal>)：它与 \"First Available\" 有相同"
+"的行为，但选取的目标节点由所有在相同客户端 VM 里的和相同目标服务关联的 stub 共享。所以，如果某个客户为相同的目标服务（如 EJB）下载了了两个 stub，每个 stub 都将使用相同的目标节点。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:189
@@ -640,12 +638,14 @@
 "In later sections we'll see how to configure the load balance policies used "
 "by different services."
 msgstr ""
+"以上都是对 org.jboss.ha.framework."
+"interfaces.LoadBalancePolicy 接口的实现；如需实现特殊行为，用户可以自由地编写对这个简单接口的实现。在后续章节里，我们将看到如何配置不同服务使用的负载平衡策略。"
 
 #. Tag: title
 #: Clustering_Guide_Intro.xml:193
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "External load balancer architecture"
-msgstr "The load balancer architecture for clustering"
+msgstr "外部负载平衡系统的架构"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:195
@@ -658,7 +658,7 @@
 "enabled, once the load balancer routes a request from a client to node A and "
 "the server initiates a session, all future requests associated with that "
 "session must be routed to node A, so long as node A is available."
-msgstr ""
+msgstr "如上所述，外部的负载平衡系统提供自己的负载平衡能力。支持何种能力取决于负载平衡系统提供者。JBoss 唯一的要求是负载平衡系统必须支持“session affinitiy”（亦即“sticky sessions”）。如启用了 session affinitiy，一旦负载平衡系统把请求从客户端导向至节点 A 且服务器初始化了一个 session，只要节点 A 可用，和这个 session 相关的所有未来的请求都必须指向这个节点。"
 
 #. Tag: title
 #: Clustering_Guide_Intro.xml:205
@@ -668,7 +668,7 @@
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:206
-#, fuzzy, no-c-format
+#, no-c-format
 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., "
@@ -689,7 +689,7 @@
 "后来才加入到群集里，它会引入群集里所有用 farm 部署的应用程序并在启动时把它们"
 "部署在本地。如果你从某一正运行的群集节点的 <literal>farm/</literal> 文件夹里"
 "把应用程序删除，这个应用程序将从本地移除并从所有其他群集服务器节点 farm 文件"
-"夹移走（触发移除）。对于当前未与群集系统相连的服务器节点，你应该手工地从 "
+"夹移走（触发卸载）。对于当前未与群集系统相连的服务器节点，你应该手工地从 "
 "farm 文件夹里把应用程序删除。"
 
 #. Tag: para
@@ -705,7 +705,7 @@
 "the application really represents a new deployment or represents an old "
 "deployment that was removed from the rest of the cluster while the newly "
 "starting node was off-line. We are working to resolve this issue."
-msgstr ""
+msgstr "目前由于实施方面的问题，farm 部署服务还只能用于 1) 第一个加入群集的节点下的 farm 目录里的归档文件 2) 热部署归档文件。如果你首先在 farm 目录下放入一个新的应用程序，然后启动服务器来使其加入已经运行的群集，这个应用程序将不能跨群集进行部署。这是因为 farm 服务不知道这个应用程序是否真正代表新的部署还是代表最新启动的节点脱机时从其他群集节点删除的旧的部署。我们正在努力解决这个问题。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:219
@@ -716,7 +716,7 @@
 "will be replicated around the cluster piecemeal, and it is very likely that "
 "remote nodes will begin trying to deploy things before all the pieces have "
 "arrived, leading to deployment failure."
-msgstr ""
+msgstr "你可以在 farm 目录下只放入压缩的归档文件而不是展开的目录。如果使用展开的目录，其内容将在群集逐个地进行复制，远程节点就很可能在所有信息到达之前试图进行部署，这就会导致部署失败。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:222
@@ -729,11 +729,11 @@
 "quite likely, for example, that a redeployment will happen on all nodes in "
 "the cluster simultaneously, briefly leaving no nodes in the cluster "
 "providing service."
-msgstr ""
+msgstr "Farmed 部署不是原子的。在某个节点上部署、卸载或重部署应用程序发生问题时，并不会阻止其他节点上的部署、卸载或重部署。它不具备回滚能力。部署也是不交错的，例如，重部署很可能同时发生在群集里的所有接点上，这就使得没有哪个节点可以提供服务。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:226
-#, fuzzy, no-c-format
+#, no-c-format
 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 "
@@ -745,25 +745,23 @@
 "clustering enabled."
 msgstr ""
 "在 JBoss AS 发行版本里，Farming 在 <literal>all</literal> 配置里是缺省被启用"
-"的，所以你不需要自己来设置它。配置文件放在 <literal>deploy/deploy.last</"
-"literal> 目录下。如果你想在自定义的配置文件里启用 farming，只需要建立如下所示"
-"的 XML 文件（<literal>farm-service.xml</literal>）并把它拷贝到 JBoss 的 "
+"的，所以你不需要自己来设置它。配置文件 <literal>farm-service.xml</literal> 放在 deploy/deploy.last 目录下。如果你想在自定义的配置文件里启用 farming，只需要建立一个 <literal>farm-service.xml</literal> 并把它拷贝到 JBoss 的"
 "<literal>$JBOSS_HOME/server/your_own_config/deploy</literal> 目录下。请确保你"
 "的自定义配置文件启用了群集系统。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:228
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "After deploying farm-service.xml you are ready to rumble. The required "
 "FarmMemberService MBean attributes for configuring a farm are listed below."
 msgstr ""
-"在部署了 <literal>farm-service.xml</literal> 之后，下面所列是配置 farm 所需"
-"的 <literal>FarmMemberService</literal> MBean 属性。"
+"在部署了 farm-service.xml 之后你就可以使用了。下面所列是配置 farm 所需"
+"的 FarmMemberService MBean 属性。"
 
 #. Tag: programlisting
 #: Clustering_Guide_Intro.xml:231
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "&lt;?xml version=\"1.0\" encoding=\"UTF-8\"?&gt;    \n"
 "&lt;server&gt;        \n"
@@ -791,27 +789,30 @@
 "            name=\"jboss:service=FarmMember,partition=DefaultPartition"
 "\"&gt;     \n"
 "        ...      \n"
-"        &lt;attribute name=\"PartitionName\"&gt;DefaultPartition&lt;/"
+"        \n"
+"        &lt;depends optional-attribute-name=\"ClusterPartition\" \n"
+"        proxy-type=\"attribute\"&gt;\n"
+"                jboss:service=${jboss.partition.name:DefaultPartition}\n"
+"                &lt;/depends&gt;     \n"
+"                &lt;attribute name=\"ScanPeriod\"&gt;5000&lt;/"
 "attribute&gt;      \n"
-"        &lt;attribute name=\"ScanPeriod\"&gt;5000&lt;/attribute&gt;      \n"
-"        &lt;attribute name=\"URLs\"&gt;farm/&lt;/attribute&gt;     \n"
-"    &lt;/mbean&gt;       \n"
+"                &lt;attribute name=\"URLs\"&gt;farm/&lt;/attribute&gt;     \n"
+"        ...\n"
+"        &lt;/mbean&gt;       \n"
 "&lt;/server&gt;"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:236
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<emphasis role=\"bold\">ClusterPartition</emphasis> is a required attribute "
 "to inject the HAPartition service that the farm service uses for intra-"
 "cluster communication."
-msgstr ""
-"<emphasis role=\"bold\">PartitionName</emphasis> 是用来指定节点名称的可选属"
-"性。它的缺省值是 <literal>DefaultPartition</literal>。"
+msgstr "<emphasis role=\"bold\">ClusterPartition</emphasis> 是用来注入 HAPartition 的必需属性，Farm 服务把它用于群集内的通信。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:239
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "<emphasis role=\"bold\">URLs</emphasis> points to the directory where "
 "deployer watches for files to be deployed. This MBean will create this "
@@ -820,8 +821,7 @@
 "directory (e.g. <literal>$JBOSS_HOME/server/all/</literal>)."
 msgstr ""
 "<emphasis role=\"bold\">URLs</emphasis> 指向部署者（deployer）用来观察文件部"
-"署的目录。如果这个目录不存在，MBean 将创建它。而且，\".\" 指向配置目录（也就"
-"是：<literal>$JBOSS_HOME/server/all/</literal>）。"
+"署的目录。如果这个目录不存在，这个 MBean 将创建它。如果没有提供完整的 URL，则假定其值为相对于配置目录的路径（如 <literal>$JBOSS_HOME/server/all/</literal>）。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:244
@@ -836,7 +836,7 @@
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:248
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "The farming service is an extension of the <literal>URLDeploymentScanner</"
 "literal>, which scans for hot deployments in the <literal>deploy/</literal> "
@@ -861,7 +861,7 @@
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:258
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "In a clustered server environment, distributed state management is a key "
 "service the cluster must provide. For instance, in a stateful session bean "
@@ -879,12 +879,13 @@
 "（session state）必须在所有节点的 bean 实例中同步，这可以使客户应用程序获得相"
 "同的会话状态，而不用管是哪个节点处理请求。在 entity bean 应用程序里，bean 对"
 "象有时候需要跨群集地缓存来减少数据库负载。目前，JBoss AS 里的状态复制（state "
-"replication）和分布式缓存服务（distributed cache service）由两个途径提供："
-"<literal>HASessionState</literal> MBean 和 JBoss Cache framework。"
+"replication）和分布式缓存服务（distributed cache service）由 3 个途径提供："
+"<literal>HASessionState</literal> MBean、<literal>DistributedState</"
+"literal> MBean 和 JBoss Cache 框架。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:265
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "The <literal>HASessionState</literal> MBean is a legacy service that "
 "provides session replication and distributed cache services for EJB 2.x "
@@ -892,9 +893,7 @@
 "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-"
+"<literal>HASessionState</literal> MBean 为 EJB 2.x 的 stateful session bean提供会话复制（session replication）和分布式缓存服务（distributed cache service）。<literal>all/deploy/cluster-"
 "service.xml</literal> 文件里定义了这个 MBean。我们会在后面的 EJB 2.x "
 "stateful session bean 部分展示它的配置选项。"
 
@@ -906,7 +905,7 @@
 "the HAPartition service. It is supported for backwards compatibility "
 "reasons, but new applications should not use it; they should use the much "
 "more sophisticated JBoss Cache instead."
-msgstr ""
+msgstr "<literal>DistributedState</literal> Mbean 是一个基于 HAPartition 的遗留服务。它用于向后的兼容性，但新的应用程序不应该使用它而应该使用更为复杂的 JBoss Cache。"
 
 #. Tag: para
 #: Clustering_Guide_Intro.xml:274
@@ -918,5 +917,5 @@
 "for any custom caching requirements your applications may have. We will "
 "cover JBoss Cache in more detail when we discuss specific services in the "
 "next several sections.."
-msgstr ""
+msgstr "如上所述，JBoss Cache 为 HTTP 会话、EJB 3.0 session bean 和 EJB 3.0 entity bean 提供缓存服务。它是 JBoss AS 里主要的分布式状态管理工具，如果你的应用程序需要自定义的缓存方案，这是一个不错的选择。在后面讨论特定服务时，我们将更详细地介绍 JBoss Cache。"
 

Modified: projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_JMS.po
===================================================================
--- projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_JMS.po	2008-05-07 00:35:51 UTC (rev 73095)
+++ projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_JMS.po	2008-05-07 04:16:06 UTC (rev 73096)
@@ -1,18 +1,21 @@
+# translation of Clustering_Guide_JMS.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_JMS\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-07 14:15+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_JMS.xml:5
@@ -55,7 +58,7 @@
 "JBoss Messaging project. JBoss Messaging's clustering implementation is "
 "considerably different from HA-JMS based on JBoss MQ; most notably it is not "
 "based on a singleton service only running on one node in the cluster."
-msgstr ""
+msgstr "JBoss AS 4.2.2 和早期版本里的 HA-JMS 都是基于 JBoss MQ messaging 产品的。在后来的 AS 发行版本里，JBoss MQ 被新的 JBoss Messaging 项目所替代。JBoss Messaging 的群集实现和基于 JBoss MQ 的 HA-JMS 有很大的不同；最值得注意的是，它不基于单点登录服务而只运行在群集里的一个节点上。"
 
 #. Tag: title
 #: Clustering_Guide_JMS.xml:25
@@ -65,7 +68,7 @@
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:26
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "The JBoss HA-JMS service (i.e., message queues topics and supporting "
 "services) only runs on a single node (i.e., the master node) in the cluster "
@@ -75,21 +78,20 @@
 "against server failures but does not reduce the work load on the JMS server "
 "node."
 msgstr ""
-"JBoss HA-JMS 服务（也就是消息队列和主题）任何给定时间都只在群集里的单节点运行"
-"（主节点）。如果这个节点崩溃了，群集系统简单地选取另外一节点来运行 JMS 服务"
-"（fail-over）。这种设置提供了针对服务器瘫痪的冗余措施，但并没有降低 JMS 服务"
+"JBoss HA-JMS 服务（也就是消息队列主题和支持服务）任何给定时间都只在群集里的单节点运行"
+"（主节点）。如果这个节点崩溃了，群集系统简单地选取另外一节点来运行 JMS 服务、队列、主题和支持服务（fail-over）。这种设置提供了针对服务器瘫痪的冗余措施，但并没有降低 JMS 服务"
 "器节点的负载。"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:28
-#, fuzzy, no-c-format
+#, no-c-format
 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=\"clustering-jms-loadbalanced\"/>)."
 msgstr ""
-"虽然你不能够对 HA-JMS 队列进行负载平衡（只有一个运行这个队列的主节点），但是"
-"你可以平衡处理队列里信息的 MDBs 的负载（请参考 <xref linkend=\"clustering-"
+"虽然你不能够平衡 HA-JMS 队列的负载时（只有一个运行这个队列的主节点），但是"
+"你可以平衡处理队列里信息的 MDB 的负载（请参考 <xref linkend=\"clustering-"
 "jms-loadbalanced\"/>）。"
 
 #. Tag: title
@@ -112,10 +114,12 @@
 "hasingleton. They should only be deployed there if you only want them "
 "running on one node in the cluster at a time."
 msgstr ""
+"all 配置里的 HA-JMS 和 default 配置里的非 HA 版本的配置的最大区别是大多数配置文件的位置。对于 HA-JMS 而言，大多数配置文件都位于 deploy-hasingleton/jms 目录，而不是 deploy/jms 目录下。你的队列和主题必须部署在 deploy-hasingleton（或其子目录如 deploy-hasingleton/jms）下。充当 HA-JMS 的客户的应用程序组件（如 MDB 和其他 JMS 客户端）不需要部署在 deploy-"
+"hasingleton 下。只有你需要它们每次运行在一个节点上时，它们才应该部署在那里。"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:38
-#, fuzzy, no-c-format
+#, no-c-format
 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 "
@@ -124,11 +128,11 @@
 "be deployed identically across the cluster."
 msgstr ""
 "为了使用 singleton fail-over HA-JMS 服务，你必须在群集里的所有节点上配置相同"
-"的 JMS 服务。这包括所有和 JMS 相关的 MBeans 以及部署的 JMS 应用程序。"
+"的 JMS 服务。这包括所有和 JMS 相关的 MBeans 以及部署的队列和主题。然而，使用 JMS 的应用程序（例如 MDB 和其他 JMS 客户端）并不需要跨群集地进行同样的部署。"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:44
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "The JMS server is configured to persist its data in the <literal>DefaultDS</"
 "literal>. By default, that is the embedded HSQLDB. However, for the HA-JMS "
@@ -140,13 +144,13 @@
 "setup a shared database for JMS. You need to do the following:"
 msgstr ""
 "JMS 服务器被设置成在 <literal>DefaultDS</literal> 里持久化它的数据。在缺省的"
-"情况下，那就是内含的 HSQLDB。然而，在大部分群集环境里，所有节点都需要把数据持"
+"情况下，那就是内含的 HSQLDB。然而，如果 HA-JMS 服务发生了失效切换，新启动的 HA-JMS 服务器需要能够通过旧服务器找到已存储的数据。而如果数据持久化在旧服务器的 HSQLDB 写入的文件里的话，这是不太可能会发生的。在任何群集环境里，所有节点都需要把数据持"
 "久化到一个共享数据库里。因此，在你启动群集 JMS 之前要做的第一件事就是建立一个"
 "共享数据库。你需要做如下的事情："
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:50
-#, fuzzy, no-c-format
+#, no-c-format
 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> "
@@ -157,7 +161,7 @@
 "配置 <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> ）"
+"literal> 是目标共享数据库的名字（例如，<literal>mysql-ds.xml</literal> ）。"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:57
@@ -178,7 +182,7 @@
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:66
-#, fuzzy, no-c-format
+#, no-c-format
 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> "
@@ -190,14 +194,13 @@
 "你不需要替换 <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> 来存放数据。"
+"SQL Server 和更多数据库。象我们上面配置的那样，它自动使用 <literal>DefaultDS</literal> 来存放数据。"
 
 #. Tag: title
 #: Clustering_Guide_JMS.xml:77
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Non-MDB HA-JMS Clients"
-msgstr "HA-JMS 客户"
+msgstr "非 MDB 的 HA-JMS 客户端"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:79
@@ -215,7 +218,7 @@
 "and topicsusing HA-JNDI (the default port is 1100). This ensures the factory/"
 "queue/topic can be found no matter which cluster node is running the HA-JMS "
 "server."
-msgstr ""
+msgstr "HA-JMS 客户端必须用 HA-JNDI（缺省端口是 1100）查找 JMS 连接工厂以及队列和主题。这确保了不论哪个群集节点在运行 HA-JMS 服务器，你都可以找到连接工厂以及队列和主题。"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:91
@@ -225,7 +228,7 @@
 "inside the AS, the lookup via HA-JNDI can be configured using the "
 "component's deployment descriptors: In the standard deployment descriptor "
 "(ejb-jar.xml or web.xml):"
-msgstr ""
+msgstr "如果客户端是一个运行在 AS 内部的 J2EE 应用程序（session bean 或 web 应用程序），你可以用组件的部署描述符来配置基于 HA-JNDI 的查找；在标准的部署描述符（ejb-jar.xml 或 web.xml）里："
 
 #. Tag: programlisting
 #: Clustering_Guide_JMS.xml:99
@@ -245,12 +248,25 @@
 "</resource-ref>\n"
 "]]>"
 msgstr ""
+"<![CDATA[\n"
+"<resource-ref>\n"
+"         <res-ref-name>jms/ConnectionFactory</res-ref-name>\n"
+"         <res-type>javax.jms.QueueConnectionFactory</res-type>\n"
+"         <res-auth>Container</res-auth>\n"
+"</resource-ref>\n"
+"         \n"
+"<resource-ref>\n"
+"         <res-ref-name>jms/Queue</res-ref-name>\n"
+"         <res-type>javax.jms.Queue</res-type>\n"
+"         <res-auth>Container</res-auth>\n"
+"</resource-ref>\n"
+"]]>"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:101
 #, no-c-format
 msgid "And in the JBoss-specific descriptor (jboss.xml or jboss-web.xml):"
-msgstr ""
+msgstr "在 JBoss 专有的描述符（jboss.xml 或 jboss-web.xml）里："
 
 #. Tag: programlisting
 #: Clustering_Guide_JMS.xml:105
@@ -270,6 +286,19 @@
 "         <jndi-name>jnp://localhost:1100/queue/A</jndi-name>\n"
 "</resource-ref>]]>"
 msgstr ""
+"<![CDATA[ \n"
+"<resource-ref>\n"
+"         <res-ref-name>jms/ConnectionFactory</res-ref-name>\n"
+"        <!-- Use the JMS Resource Adapter, let it deal\n"
+"         with knowing where the JMS server is -->\n"
+"        <jndi-name>java:/JmsXA</jndi-name>\n"
+" </resource-ref>\n"
+" \n"
+"<resource-ref>\n"
+"         <res-ref-name>jms/Queue</res-ref-name>\n"
+"         <!-- Use HA-JNDI so we can find the queue on any node -->\n"
+"         <jndi-name>jnp://localhost:1100/queue/A</jndi-name>\n"
+"</resource-ref>]]>"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:110
@@ -281,7 +310,7 @@
 "logic. If the HA-JMS service fails over to a different master node, all "
 "client operations on the current connection will fail with a JMSException. "
 "To deal with this:"
-msgstr ""
+msgstr "如果服务器发生失效切换时，HA-JMS 客户端必须处理发生在 JMS 连接上的异常。例如，不象群集 EJB 代理，JMS 连接对象不包含自动的失效切换逻辑。如果 HA-JMS 服务切换至一个不同的主节点，当前连接上的所有的客户操作都将失败并产生 JMSException。你可以这样处理："
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:118
@@ -292,7 +321,7 @@
 "find the JBoss JMS Resource Adapter; the resource adapter will handle the "
 "task of detecting server failover and reconnecting to the new server when it "
 "starts."
-msgstr ""
+msgstr "如果客户端运行在应用服务器内部，客户端应该通过 JNDI java:/JmsXA 来获取 ConnectionFactory。这将找到到 JBoss JMS 资源适配器；资源适配器将检测失效的服务器并在启动时重新连接新的服务器。"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:122
@@ -304,7 +333,7 @@
 "the task of closing the old connection and reconnecting. Following is a "
 "example application that continuously sends messages to a queue, handling "
 "any exceptions that occur:"
-msgstr ""
+msgstr "对于应用服务器外部的客户端，最好的办法是为连接注册一个 ExceptionListener；如果连接发生异常，这个 listener 将获得回调。相应的回调方法应该关闭旧的连接并进行重新连接。下面的例程持续地往队列发送消息并处理产生的任何异常："
 
 #. Tag: programlisting
 #: Clustering_Guide_JMS.xml:128
@@ -471,12 +500,172 @@
 "}\n"
 "]]>"
 msgstr ""
+"<![CDATA[\n"
+"package com.test.hajms.client;\n"
+"\n"
+"import javax.naming.InitialContext;\n"
+"import javax.jms.ConnectionFactory;\n"
+"import javax.jms.Destination;\n"
+"import javax.jms.Connection;\n"
+"import javax.jms.Session;\n"
+"import javax.jms.MessageProducer;\n"
+"import javax.jms.Message;\n"
+"import javax.jms.ExceptionListener;\n"
+"import javax.jms.JMSException;\n"
+"import javax.jms.DeliveryMode;\n"
+"\n"
+"import org.apache.commons.logging.Log;\n"
+"import org.apache.commons.logging.LogFactory;\n"
+" \n"
+"public class FailoverJMSClient\n"
+"{\n"
+"private static final Log log = LogFactory.getLog(FailoverJMSClient.class);\n"
+"\n"
+"public static final int NUM_RETRIES = 3;\n"
+"\n"
+"volatile boolean doSend = true;\n"
+"ConnectionFactory connectionFactory;\n"
+"Destination queue;\n"
+"Connection connection;\n"
+"Session session;\n"
+"MessageProducer producer;\n"
+"\n"
+"\n"
+"public static void main(String[] args) throws Exception\n"
+"{\n"
+"FailoverJMSClient jmsClient = new FailoverJMSClient();\n"
+"jmsClient.setUpJMS();\n"
+"jmsClient.sendMessages();\n"
+"}\n"
+"\n"
+"\n"
+"public boolean setUpJMS()\n"
+"{\n"
+"InitialContext ic;\n"
+"try\n"
+"{\n"
+"// assume jndi.properties is configured for HA-JNDI\n"
+"ic = new InitialContext();\n"
+"connectionFactory = (ConnectionFactory)ic.lookup(\"ConnectionFactory\");\n"
+"queue = (Destination)ic.lookup(\"queue/FailoverTestQueue\");\n"
+"connection = connectionFactory.createConnection();\n"
+"try\n"
+"{\n"
+"log.debug(\"Connection created ...\");\n"
+"\n"
+"// KEY - register for exception callbacks\n"
+"connection.setExceptionListener(new ExceptionListenerImpl());\n"
+"\n"
+"session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);\n"
+"log.debug(\"Session created ...\");\n"
+"producer = session.createProducer(queue);\n"
+"\n"
+"producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);\n"
+"log.debug(\"Producer created ...\");\n"
+"\n"
+"return true;\n"
+"}\n"
+"catch (Exception e)\n"
+"{\n"
+"// We failed so close the connection\n"
+"try\n"
+"{\n"
+"connection.close();\n"
+"}\n"
+"catch (JMSException ignored)\n"
+"{\n"
+"// Pointless\n"
+"}\n"
+"// Rethrow the initial problem to where we will log it\n"
+"throw e;\n"
+"} \n"
+"finally\n"
+"{\n"
+"// And close the initial context\n"
+"// We don't want to wait for the garbage collector to close it\n"
+"// otherwise we'll have useless hanging network connections\n"
+"ic.close();\n"
+"}\n"
+"}\n"
+"catch (Exception e)\n"
+"{\n"
+"log.error(\"Error setting up JMS\", e);\n"
+"return false;\n"
+"}\n"
+"}\n"
+"\n"
+"public void sendMessages()\n"
+"{\n"
+"int cnt = 0;\n"
+"while(doSend)\n"
+"{\n"
+"try\n"
+"{\n"
+"Thread.sleep(100);\n"
+"\n"
+"Message m = session.createObjectMessage(new Integer(cnt++));\n"
+"producer.send(m);\n"
+"\n"
+"log.trace(\"message \" + cnt + \" sent\");\n"
+"\n"
+"}\n"
+"catch(Exception e)\n"
+"{\n"
+"cnt--;\n"
+"log.error(e.getMessage());\n"
+"}\n"
+"}\n"
+"}\n"
+"\n"
+"\n"
+"\n"
+"private class ExceptionListenerImpl implements ExceptionListener\n"
+"{\n"
+"public void onException(JMSException e)\n"
+"{\n"
+"                         \n"
+"for(int i = 0; i < NUM_RETRIES; i++)\n"
+"            {\n"
+"            log.warn(\"Connection has problems, trying to re-create it, "
+"attempt \" +\n"
+"            (i + 1) + \" ...\");\n"
+"            \n"
+"            try \n"
+"            {\n"
+"            connection.close();  // unregisters the ExceptionListener\n"
+"            }\n"
+"            catch(Exception e2) {\n"
+"            // I will get an Exception anyway, since the connection to "
+"the                     \n"
+"            //server is broken, but close() frees up resources associated \n"
+"            // with the connection\n"
+"            }\n"
+"            \n"
+"            boolean setupOK = setUpJMS();\n"
+"            \n"
+"            if (setupOK)\n"
+"            {\n"
+"            log.info(\"Connection re-established\");\n"
+"            return;\n"
+"            }\n"
+"            else\n"
+"            {\n"
+"            log.warn(\"Re-creating connection failed, retrying ...\");\n"
+"           }\n"
+"            }\n"
+"            \n"
+"            log.error(\"Cannot re-establish connection, giving up ...\");\n"
+"            doSend = false;\n"
+"            }\n"
+"            }\n"
+"}\n"
+"]]>"
 
 #. Tag: title
 #: Clustering_Guide_JMS.xml:132
 #, no-c-format
 msgid "MDBs and HA-JMS Failover"
-msgstr ""
+msgstr "MDB 和 HA-JMS 失效切换"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:133
@@ -485,7 +674,7 @@
 "When you deploy an MDB in JBoss, JBoss' MDB container handles for you all "
 "issues associated with finding the cluster singleton HA-JMS server and with "
 "reconnecting to it if it fails over."
-msgstr ""
+msgstr "当你在 JBoss 里部署 MDB 时，JBoss 的 MDB 容器处理所有和寻找群集单点登录 HA-JMS 和在失效切换时切重新连接相关的问题。"
 
 #. Tag: title
 #: Clustering_Guide_JMS.xml:143
@@ -523,13 +712,11 @@
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:155
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "The <literal>org.jboss.mq.server.ReceiversImplArrayList</literal> is the "
 "implementation using an <literal>ArrayList</literal>."
-msgstr ""
-"<literal>org.jboss.mq.server.ReceiversImplArrayList</literal> 是 "
-"<literal>ArrayList</literal> 的实现。"
+msgstr "<literal>org.jboss.mq.server.ReceiversImplArrayList</literal> 是使用 <literal>ArrayList</literal> 的实现。"
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:159
@@ -543,7 +730,7 @@
 
 #. Tag: para
 #: Clustering_Guide_JMS.xml:163
-#, fuzzy, no-c-format
+#, no-c-format
 msgid ""
 "You can specify the receiver implementation class name as an attribute in "
 "the MBean that defines the permanent JMS <literal>Queue</literal> or "
@@ -557,3976 +744,5 @@
 "literal> 或 <literal>DestinationManager</literal> 的 MBean 的一个属性。为了获"
 "得最好的负载平衡性能，我们建议你使用 <literal>ReceiversImplArrayList</"
 "literal> 或 <literal>ReceiversImplArrayList</literal> 实现，因为 JVM 里的 "
-"<literal>HashSet</literal> 的实现不是很好。"
+"<literal>HashSet</literal> 的实现并不理想。"
 
-#~ 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&#39;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 ""
-#~ "&lt;mbean code=\"org.jboss.ha.framework.server.ClusterPartition\"\n"
-#~ "    name=\"jboss:service=DefaultPartition\"&gt;\n"
-#~ "         \n"
-#~ "    &lt;! -- Name of the partition being built --&gt;\n"
-#~ "    &lt;attribute name=\"PartitionName\"&gt;\n"
-#~ "        ${jboss.partition.name:DefaultPartition}\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "    &lt;! -- The address used to determine the node name --&gt;\n"
-#~ "    &lt;attribute name=\"NodeAddress\"&gt;${jboss.bind.address}&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "    &lt;! -- Determine if deadlock detection is enabled --&gt;\n"
-#~ "    &lt;attribute name=\"DeadlockDetection\"&gt;False&lt;/attribute&gt;\n"
-#~ "     \n"
-#~ "    &lt;! -- Max time (in ms) to wait for state transfer to complete. \n"
-#~ "        Increase for large states --&gt;\n"
-#~ "    &lt;attribute name=\"StateTransferTimeout\"&gt;30000&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "    &lt;! -- The JGroups protocol configuration --&gt;\n"
-#~ "    &lt;attribute name=\"PartitionConfig\"&gt;\n"
-#~ "        ... ...\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "&lt;/mbean&gt;"
-#~ msgstr ""
-#~ "&lt;mbean code=\"org.jboss.ha.framework.server.ClusterPartition\"\n"
-#~ "    name=\"jboss:service=DefaultPartition\"&gt;\n"
-#~ "         \n"
-#~ "    &lt;! -- Name of the partition being built --&gt;\n"
-#~ "    &lt;attribute name=\"PartitionName\"&gt;\n"
-#~ "        ${jboss.partition.name:DefaultPartition}\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "    &lt;! -- The address used to determine the node name --&gt;\n"
-#~ "    &lt;attribute name=\"NodeAddress\"&gt;${jboss.bind.address}&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "    &lt;! -- Determine if deadlock detection is enabled --&gt;\n"
-#~ "    &lt;attribute name=\"DeadlockDetection\"&gt;False&lt;/attribute&gt;\n"
-#~ "     \n"
-#~ "    &lt;! -- Max time (in ms) to wait for state transfer to complete. \n"
-#~ "        Increase for large states --&gt;\n"
-#~ "    &lt;attribute name=\"StateTransferTimeout\"&gt;30000&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "    &lt;! -- The JGroups protocol configuration --&gt;\n"
-#~ "    &lt;attribute name=\"PartitionConfig\"&gt;\n"
-#~ "        ... ...\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "&lt;/mbean&gt;"
-
-#, 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&#39;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&#39;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&#39;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&#39;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 ""
-#~ "&lt;?xml version=\"1.0\" encoding=\"UTF-8\"?&gt;    \n"
-#~ "&lt;server&gt;        \n"
-#~ "        \n"
-#~ "    &lt;mbean code=\"org.jboss.ha.framework.server.FarmMemberService"
-#~ "\"     \n"
-#~ "            name=\"jboss:service=FarmMember,partition=DefaultPartition"
-#~ "\"&gt;     \n"
-#~ "        ...      \n"
-#~ "        &lt;attribute name=\"PartitionName\"&gt;DefaultPartition&lt;/"
-#~ "attribute&gt;      \n"
-#~ "        &lt;attribute name=\"ScanPeriod\"&gt;5000&lt;/"
-#~ "attribute&gt;      \n"
-#~ "        &lt;attribute name=\"URLs\"&gt;farm/&lt;/attribute&gt;     \n"
-#~ "    &lt;/mbean&gt;       \n"
-#~ "&lt;/server&gt;"
-#~ msgstr ""
-#~ "&lt;?xml version=\"1.0\" encoding=\"UTF-8\"?&gt;    \n"
-#~ "&lt;server&gt;        \n"
-#~ "        \n"
-#~ "    &lt;mbean code=\"org.jboss.ha.framework.server.FarmMemberService"
-#~ "\"     \n"
-#~ "            name=\"jboss:service=FarmMember,partition=DefaultPartition"
-#~ "\"&gt;     \n"
-#~ "        ...      \n"
-#~ "        &lt;attribute name=\"PartitionName\"&gt;DefaultPartition&lt;/"
-#~ "attribute&gt;      \n"
-#~ "        &lt;attribute name=\"ScanPeriod\"&gt;5000&lt;/"
-#~ "attribute&gt;      \n"
-#~ "        &lt;attribute name=\"URLs\"&gt;farm/&lt;/attribute&gt;     \n"
-#~ "    &lt;/mbean&gt;       \n"
-#~ "&lt;/server&gt;"
-
-#~ 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&#39;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 ""
-#~ "&lt;mbean code=\"org.jboss.ha.jndi.HANamingService\"            \n"
-#~ "       name=\"jboss:service=HAJNDI\"&gt;       \n"
-#~ "    &lt;depends&gt;jboss:service=DefaultPartition&lt;/depends&gt;    \n"
-#~ "&lt;/mbean&gt;"
-#~ msgstr ""
-#~ "&lt;mbean code=\"org.jboss.ha.jndi.HANamingService\"            \n"
-#~ "       name=\"jboss:service=HAJNDI\"&gt;       \n"
-#~ "    &lt;depends&gt;jboss:service=DefaultPartition&lt;/depends&gt;    \n"
-#~ "&lt;/mbean&gt;"
-
-#~ 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 ""
-#~ "&lt;mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ "      name=\"jboss:service=HAJNDI\"&gt; \n"
-#~ "    &lt;depends&gt;\n"
-#~ "        jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ "    &lt;/depends&gt; \n"
-#~ "    &lt;! -- Name of the partition to which the service is linked --"
-#~ "&gt; \n"
-#~ "    &lt;attribute name=\"PartitionName\"&gt;\n"
-#~ "        ${jboss.partition.name:DefaultPartition}\n"
-#~ "    &lt;/attribute&gt; \n"
-#~ "    &lt;! -- Bind address of bootstrap and HA-JNDI RMI endpoints --&gt; \n"
-#~ "    &lt;attribute name=\"BindAddress\"&gt;${jboss.bind.address}&lt;/"
-#~ "attribute&gt; \n"
-#~ "    &lt;! -- Port on which the HA-JNDI stub is made available --&gt; \n"
-#~ "    &lt;attribute name=\"Port\"&gt;1100&lt;/attribute&gt; \n"
-#~ "    &lt;! -- RmiPort to be used by the HA-JNDI service once bound. \n"
-#~ "        0 is for auto. --&gt; \n"
-#~ "    &lt;attribute name=\"RmiPort\"&gt;1101&lt;/attribute&gt; \n"
-#~ "    &lt;! -- Accept backlog of the bootstrap socket --&gt; \n"
-#~ "    &lt;attribute name=\"Backlog\"&gt;50&lt;/attribute&gt; \n"
-#~ "    &lt;! -- The thread pool service used to control the bootstrap and \n"
-#~ "      auto discovery lookups --&gt; \n"
-#~ "    &lt;depends optional-attribute-name=\"LookupPool\" \n"
-#~ "        proxy-type=\"attribute\"&gt;jboss.system:service=ThreadPool&lt;/"
-#~ "depends&gt;\n"
-#~ "\n"
-#~ "    &lt;! -- A flag to disable the auto discovery via multicast --&gt; \n"
-#~ "    &lt;attribute name=\"DiscoveryDisabled\"&gt;false&lt;/attribute&gt; \n"
-#~ "    &lt;! -- Set the auto-discovery bootstrap multicast bind address. --"
-#~ "&gt; \n"
-#~ "    &lt;attribute name=\"AutoDiscoveryBindAddress\"&gt;\n"
-#~ "        ${jboss.bind.address}\n"
-#~ "    &lt;/attribute&gt; \n"
-#~ "    \n"
-#~ "    &lt;! -- Multicast Address and group port used for auto-discovery --"
-#~ "&gt; \n"
-#~ "    &lt;attribute name=\"AutoDiscoveryAddress\"&gt;\n"
-#~ "        ${jboss.partition.udpGroup:230.0.0.4}\n"
-#~ "    &lt;/attribute&gt; \n"
-#~ "    &lt;attribute name=\"AutoDiscoveryGroup\"&gt;1102&lt;/attribute&gt; \n"
-#~ "    &lt;! -- The TTL (time-to-live) for autodiscovery IP multicast "
-#~ "packets --&gt; \n"
-#~ "    &lt;attribute name=\"AutoDiscoveryTTL\"&gt;16&lt;/attribute&gt;\n"
-#~ "\n"
-#~ "    &lt;! -- Client socket factory to be used for client-server \n"
-#~ "           RMI invocations during JNDI queries \n"
-#~ "    &lt;attribute name=\"ClientSocketFactory\"&gt;custom&lt;/"
-#~ "attribute&gt; \n"
-#~ "    --&gt; \n"
-#~ "    &lt;! -- Server socket factory to be used for client-server \n"
-#~ "           RMI invocations during JNDI queries \n"
-#~ "    &lt;attribute name=\"ServerSocketFactory\"&gt;custom&lt;/"
-#~ "attribute&gt; \n"
-#~ "    --&gt; \n"
-#~ "&lt;/mbean&gt;"
-#~ msgstr ""
-#~ "&lt;mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ "      name=\"jboss:service=HAJNDI\"&gt; \n"
-#~ "    &lt;depends&gt;\n"
-#~ "        jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ "    &lt;/depends&gt; \n"
-#~ "    &lt;! -- Name of the partition to which the service is linked --"
-#~ "&gt; \n"
-#~ "    &lt;attribute name=\"PartitionName\"&gt;\n"
-#~ "        ${jboss.partition.name:DefaultPartition}\n"
-#~ "    &lt;/attribute&gt; \n"
-#~ "    &lt;! -- Bind address of bootstrap and HA-JNDI RMI endpoints --&gt; \n"
-#~ "    &lt;attribute name=\"BindAddress\"&gt;${jboss.bind.address}&lt;/"
-#~ "attribute&gt; \n"
-#~ "    &lt;! -- Port on which the HA-JNDI stub is made available --&gt; \n"
-#~ "    &lt;attribute name=\"Port\"&gt;1100&lt;/attribute&gt; \n"
-#~ "    &lt;! -- RmiPort to be used by the HA-JNDI service once bound. \n"
-#~ "        0 is for auto. --&gt; \n"
-#~ "    &lt;attribute name=\"RmiPort\"&gt;1101&lt;/attribute&gt; \n"
-#~ "    &lt;! -- Accept backlog of the bootstrap socket --&gt; \n"
-#~ "    &lt;attribute name=\"Backlog\"&gt;50&lt;/attribute&gt; \n"
-#~ "    &lt;! -- The thread pool service used to control the bootstrap and \n"
-#~ "      auto discovery lookups --&gt; \n"
-#~ "    &lt;depends optional-attribute-name=\"LookupPool\" \n"
-#~ "        proxy-type=\"attribute\"&gt;jboss.system:service=ThreadPool&lt;/"
-#~ "depends&gt;\n"
-#~ "\n"
-#~ "    &lt;! -- A flag to disable the auto discovery via multicast --&gt; \n"
-#~ "    &lt;attribute name=\"DiscoveryDisabled\"&gt;false&lt;/attribute&gt; \n"
-#~ "    &lt;! -- Set the auto-discovery bootstrap multicast bind address. --"
-#~ "&gt; \n"
-#~ "    &lt;attribute name=\"AutoDiscoveryBindAddress\"&gt;\n"
-#~ "        ${jboss.bind.address}\n"
-#~ "    &lt;/attribute&gt; \n"
-#~ "    \n"
-#~ "    &lt;! -- Multicast Address and group port used for auto-discovery --"
-#~ "&gt; \n"
-#~ "    &lt;attribute name=\"AutoDiscoveryAddress\"&gt;\n"
-#~ "        ${jboss.partition.udpGroup:230.0.0.4}\n"
-#~ "    &lt;/attribute&gt; \n"
-#~ "    &lt;attribute name=\"AutoDiscoveryGroup\"&gt;1102&lt;/attribute&gt; \n"
-#~ "    &lt;! -- The TTL (time-to-live））for autodiscovery IP multicast "
-#~ "packets --&gt; \n"
-#~ "    &lt;attribute name=\"AutoDiscoveryTTL\"&gt;16&lt;/attribute&gt;\n"
-#~ "\n"
-#~ "    &lt;! -- Client socket factory to be used for client-server \n"
-#~ "           RMI invocations during JNDI queries \n"
-#~ "    &lt;attribute name=\"ClientSocketFactory\"&gt;custom&lt;/"
-#~ "attribute&gt; \n"
-#~ "    --&gt; \n"
-#~ "    &lt;! -- Server socket factory to be used for client-server \n"
-#~ "           RMI invocations during JNDI queries \n"
-#~ "    &lt;attribute name=\"ServerSocketFactory\"&gt;custom&lt;/"
-#~ "attribute&gt; \n"
-#~ "    --&gt; \n"
-#~ "&lt;/mbean&gt;"
-
-#~ 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 ""
-#~ "&lt;mbean code=\"org.jboss.ha.jndi.HANamingService\"    \n"
-#~ "       name=\"jboss:service=HAJNDI\"&gt;    \n"
-#~ "    &lt;depends&gt;jboss:service=MySpecialPartition&lt;/depends&gt;    \n"
-#~ "    &lt;attribute name=\"PartitionName\"&gt;MySpecialPartition&lt;/"
-#~ "attribute&gt;    \n"
-#~ "    &lt;attribute name=\"Port\"&gt;56789&lt;/attribute&gt;  \n"
-#~ "&lt;/mbean&gt;"
-#~ msgstr ""
-#~ "&lt;mbean code=\"org.jboss.ha.jndi.HANamingService\"    \n"
-#~ "       name=\"jboss:service=HAJNDI\"&gt;    \n"
-#~ "    &lt;depends&gt;jboss:service=MySpecialPartition&lt;/depends&gt;    \n"
-#~ "    &lt;attribute name=\"PartitionName\"&gt;MySpecialPartition&lt;/"
-#~ "attribute&gt;    \n"
-#~ "    &lt;attribute name=\"Port\"&gt;56789&lt;/attribute&gt;  \n"
-#~ "&lt;/mbean&gt;"
-
-#~ 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&#39;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>&lt;clustered&gt;</literal> tag."
-#~ msgstr ""
-#~ "群集的 stateless session beans 有可能是最简单的：因为不涉及到状态，调用可"
-#~ "以在群集里的任何节点（部署有这个 bean 的节点）上进行负载平衡。要群集一个 "
-#~ "bean，你需要修改它的 <literal>jboss.xml</literal> 描述符，使它包含一个 "
-#~ "<literal>&lt;clustered&gt;</literal> 标签。"
-
-#~ msgid ""
-#~ "&lt;jboss&gt;    \n"
-#~ "    &lt;enterprise-beans&gt;      \n"
-#~ "        &lt;session&gt;        \n"
-#~ "            &lt;ejb-name&gt;nextgen.StatelessSession&lt;/ejb-"
-#~ "name&gt;        \n"
-#~ "            &lt;jndi-name&gt;nextgen.StatelessSession&lt;/jndi-"
-#~ "name&gt;        \n"
-#~ "            &lt;clustered&gt;True&lt;/clustered&gt;        \n"
-#~ "            &lt;cluster-config&gt;          \n"
-#~ "                &lt;partition-name&gt;DefaultPartition&lt;/partition-"
-#~ "name&gt;          \n"
-#~ "                &lt;home-load-balance-policy&gt;                 \n"
-#~ "                    org.jboss.ha.framework.interfaces."
-#~ "RoundRobin          \n"
-#~ "                &lt;/home-load-balance-policy&gt;          \n"
-#~ "                &lt;bean-load-balance-policy&gt;  \n"
-#~ "                    org.jboss.ha.framework.interfaces.RoundRobin\n"
-#~ "                &lt;/bean-load-balance-policy&gt;\n"
-#~ "            &lt;/cluster-config&gt;\n"
-#~ "        &lt;/session&gt;\n"
-#~ "    &lt;/enterprise-beans&gt;\n"
-#~ "&lt;/jboss&gt;"
-#~ msgstr ""
-#~ "&lt;jboss&gt;    \n"
-#~ "    &lt;enterprise-beans&gt;      \n"
-#~ "        &lt;session&gt;        \n"
-#~ "            &lt;ejb-name&gt;nextgen.StatelessSession&lt;/ejb-"
-#~ "name&gt;        \n"
-#~ "            &lt;jndi-name&gt;nextgen.StatelessSession&lt;/jndi-"
-#~ "name&gt;        \n"
-#~ "            &lt;clustered&gt;True&lt;/clustered&gt;        \n"
-#~ "            &lt;cluster-config&gt;          \n"
-#~ "                &lt;partition-name&gt;DefaultPartition&lt;/partition-"
-#~ "name&gt;          \n"
-#~ "                &lt;home-load-balance-policy&gt;                 \n"
-#~ "                    org.jboss.ha.framework.interfaces."
-#~ "RoundRobin          \n"
-#~ "                &lt;/home-load-balance-policy&gt;          \n"
-#~ "                &lt;bean-load-balance-policy&gt;  \n"
-#~ "                    org.jboss.ha.framework.interfaces.RoundRobin\n"
-#~ "                &lt;/bean-load-balance-policy&gt;\n"
-#~ "            &lt;/cluster-config&gt;\n"
-#~ "        &lt;/session&gt;\n"
-#~ "    &lt;/enterprise-beans&gt;\n"
-#~ "&lt;/jboss&gt;"
-
-#~ msgid ""
-#~ "The <literal>&lt;clustered&gt;True&lt;/clustered&gt;</literal> element is "
-#~ "really just an alias for the <literal>&lt;configuration-name&gt;Clustered "
-#~ "Stateless SessionBean&lt;/configuration-name&gt;</literal> element."
-#~ msgstr ""
-#~ "<literal>&lt;clustered&gt;True&lt;/clustered&gt;</literal> 元素实际上是 "
-#~ "<literal>&lt;configuration-name&gt;Clustered Stateless SessionBean&lt;/"
-#~ "configuration-name&gt;</literal> 元素的一个别名。"
-
-#~ msgid ""
-#~ "In the bean configuration, only the <literal>&lt;clustered&gt;</literal> "
-#~ "element is mandatory. It indicates that the bean works in a cluster. The "
-#~ "<literal>&lt;cluster-config&gt;</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>&lt;cluster-config&gt;</literal> element."
-#~ msgstr ""
-#~ "在 bean 配置里，只有 <literal>&lt;clustered&gt;</literal> 元素是强制的。它"
-#~ "指出这个 bean 在群集里运行。<literal>&lt;cluster-config&gt;</literal> 元素"
-#~ "是可选的，我们在上面的配置样本里指出了它的缺省值。下面是关于 <literal>&lt;"
-#~ "cluster-config&gt;</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 ""
-#~ "&lt;jboss&gt;\n"
-#~ "    &lt;session&gt;\n"
-#~ "        &lt;ejb-name&gt;nextgen_RetryInterceptorStatelessSession&lt;/ejb-"
-#~ "name&gt;\n"
-#~ "        &lt;invoker-bindings&gt;\n"
-#~ "            &lt;invoker&gt;\n"
-#~ "                &lt;invoker-proxy-binding-name&gt;\n"
-#~ "                    clustered-retry-stateless-rmi-invoker\n"
-#~ "                &lt;/invoker-proxy-binding-name&gt;\n"
-#~ "                &lt;jndi-name&gt;\n"
-#~ "                    nextgen_RetryInterceptorStatelessSession\n"
-#~ "                &lt;/jndi-name&gt;\n"
-#~ "            &lt;/invoker&gt;\n"
-#~ "        &lt;/invoker-bindings&gt;\n"
-#~ "        &lt;clustered&gt;true&lt;/clustered&gt;\n"
-#~ "    &lt;/session&gt;\n"
-#~ "\n"
-#~ "    &lt;invoker-proxy-binding&gt;\n"
-#~ "        &lt;name&gt;clustered-retry-stateless-rmi-invoker&lt;/name&gt;\n"
-#~ "        &lt;invoker-mbean&gt;jboss:service=invoker,type=jrmpha&lt;/"
-#~ "invoker-mbean&gt;\n"
-#~ "        &lt;proxy-factory&gt;org.jboss.proxy.ejb.ProxyFactoryHA&lt;/proxy-"
-#~ "factory&gt;\n"
-#~ "        &lt;proxy-factory-config&gt;\n"
-#~ "            &lt;client-interceptors&gt;\n"
-#~ "                &lt;home&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.ejb.HomeInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.SecurityInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.TransactionInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.invocation.InvokerInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                &lt;/home&gt;\n"
-#~ "                &lt;bean&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.ejb.StatelessSessionInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.SecurityInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.TransactionInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.invocation.InvokerInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                &lt;/bean&gt;\n"
-#~ "            &lt;/client-interceptors&gt;\n"
-#~ "        &lt;/proxy-factory-config&gt;\n"
-#~ "    &lt;/invoker-proxy-binding&gt;"
-#~ msgstr ""
-#~ "&lt;jboss&gt;\n"
-#~ "    &lt;session&gt;\n"
-#~ "        &lt;ejb-name&gt;nextgen_RetryInterceptorStatelessSession&lt;/ejb-"
-#~ "name&gt;\n"
-#~ "        &lt;invoker-bindings&gt;\n"
-#~ "            &lt;invoker&gt;\n"
-#~ "                &lt;invoker-proxy-binding-name&gt;\n"
-#~ "                    clustered-retry-stateless-rmi-invoker\n"
-#~ "                &lt;/invoker-proxy-binding-name&gt;\n"
-#~ "                &lt;jndi-name&gt;\n"
-#~ "                    nextgen_RetryInterceptorStatelessSession\n"
-#~ "                &lt;/jndi-name&gt;\n"
-#~ "            &lt;/invoker&gt;\n"
-#~ "        &lt;/invoker-bindings&gt;\n"
-#~ "        &lt;clustered&gt;true&lt;/clustered&gt;\n"
-#~ "    &lt;/session&gt;\n"
-#~ "\n"
-#~ "    &lt;invoker-proxy-binding&gt;\n"
-#~ "        &lt;name&gt;clustered-retry-stateless-rmi-invoker&lt;/name&gt;\n"
-#~ "        &lt;invoker-mbean&gt;jboss:service=invoker,type=jrmpha&lt;/"
-#~ "invoker-mbean&gt;\n"
-#~ "        &lt;proxy-factory&gt;org.jboss.proxy.ejb.ProxyFactoryHA&lt;/proxy-"
-#~ "factory&gt;\n"
-#~ "        &lt;proxy-factory-config&gt;\n"
-#~ "            &lt;client-interceptors&gt;\n"
-#~ "                &lt;home&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.ejb.HomeInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.SecurityInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.TransactionInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.invocation.InvokerInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                &lt;/home&gt;\n"
-#~ "                &lt;bean&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.ejb.StatelessSessionInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.SecurityInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.TransactionInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                    &lt;interceptor&gt;\n"
-#~ "                        org.jboss.invocation.InvokerInterceptor\n"
-#~ "                    &lt;/interceptor&gt;\n"
-#~ "                &lt;/bean&gt;\n"
-#~ "            &lt;/client-interceptors&gt;\n"
-#~ "        &lt;/proxy-factory-config&gt;\n"
-#~ "    &lt;/invoker-proxy-binding&gt;"
-
-#~ 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>&lt;clustered&gt;</literal> tag."
-#~ msgstr ""
-#~ "在 EJB 应用程序里，你需要为每个 stateful session bean 修改 <literal>jboss."
-#~ "xml</literal> 描述符文件并加入 <literal>&lt;clustered&gt;</literal> 标签。"
-
-#~ msgid ""
-#~ "&lt;jboss&gt;    \n"
-#~ "    &lt;enterprise-beans&gt;\n"
-#~ "        &lt;session&gt;        \n"
-#~ "            &lt;ejb-name&gt;nextgen.StatefulSession&lt;/ejb-"
-#~ "name&gt;        \n"
-#~ "            &lt;jndi-name&gt;nextgen.StatefulSession&lt;/jndi-"
-#~ "name&gt;        \n"
-#~ "            &lt;clustered&gt;True&lt;/clustered&gt;        \n"
-#~ "            &lt;cluster-config&gt;          \n"
-#~ "                &lt;partition-name&gt;DefaultPartition&lt;/partition-"
-#~ "name&gt;\n"
-#~ "                &lt;home-load-balance-policy&gt;               \n"
-#~ "                    org.jboss.ha.framework.interfaces."
-#~ "RoundRobin          \n"
-#~ "                &lt;/home-load-balance-policy&gt;          \n"
-#~ "                &lt;bean-load-balance-policy&gt;               \n"
-#~ "                    org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable          \n"
-#~ "                &lt;/bean-load-balance-policy&gt;          \n"
-#~ "                &lt;session-state-manager-jndi-name&gt;              \n"
-#~ "                    /HASessionState/Default          \n"
-#~ "                &lt;/session-state-manager-jndi-name&gt;        \n"
-#~ "            &lt;/cluster-config&gt;      \n"
-#~ "        &lt;/session&gt;    \n"
-#~ "    &lt;/enterprise-beans&gt;\n"
-#~ "&lt;/jboss&gt;"
-#~ msgstr ""
-#~ "&lt;jboss&gt;    \n"
-#~ "    &lt;enterprise-beans&gt;\n"
-#~ "        &lt;session&gt;        \n"
-#~ "            &lt;ejb-name&gt;nextgen.StatefulSession&lt;/ejb-"
-#~ "name&gt;        \n"
-#~ "            &lt;jndi-name&gt;nextgen.StatefulSession&lt;/jndi-"
-#~ "name&gt;        \n"
-#~ "            &lt;clustered&gt;True&lt;/clustered&gt;        \n"
-#~ "            &lt;cluster-config&gt;          \n"
-#~ "                &lt;partition-name&gt;DefaultPartition&lt;/partition-"
-#~ "name&gt;\n"
-#~ "                &lt;home-load-balance-policy&gt;               \n"
-#~ "                    org.jboss.ha.framework.interfaces."
-#~ "RoundRobin          \n"
-#~ "                &lt;/home-load-balance-policy&gt;          \n"
-#~ "                &lt;bean-load-balance-policy&gt;               \n"
-#~ "                    org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable          \n"
-#~ "                &lt;/bean-load-balance-policy&gt;          \n"
-#~ "                &lt;session-state-manager-jndi-name&gt;              \n"
-#~ "                    /HASessionState/Default          \n"
-#~ "                &lt;/session-state-manager-jndi-name&gt;        \n"
-#~ "            &lt;/cluster-config&gt;      \n"
-#~ "        &lt;/session&gt;    \n"
-#~ "    &lt;/enterprise-beans&gt;\n"
-#~ "&lt;/jboss&gt;"
-
-#~ msgid ""
-#~ "In the bean configuration, only the <literal>&lt;clustered&gt;</literal> "
-#~ "tag is mandatory to indicate that the bean works in a cluster. The "
-#~ "<literal>&lt;cluster-config&gt;</literal> element is optional and its "
-#~ "default attribute values are indicated in the sample configuration above."
-#~ msgstr ""
-#~ "在 bean 的配置文件里，只有 <literal>&lt;clustered&gt;</literal> 标签是强制"
-#~ "的，它指出 bean 处在群集系统里。<literal>&lt;cluster-config&gt;</literal> "
-#~ "元素是可选的，我们在上面的配置文件样本里指出了它的缺省属性值。"
-
-#~ msgid ""
-#~ "The <literal>&lt;session-state-manager-jndi-name&gt;</literal> tag is "
-#~ "used to give the JNDI name of the <literal>HASessionState</literal> "
-#~ "service to be used by this bean."
-#~ msgstr ""
-#~ "<literal>&lt;session-state-manager-jndi-name&gt;</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&#39;s home interface are by default load-balanced, round-robin. Once "
-#~ "the bean&#39;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 ""
-#~ "&lt;mbean code=\"org.jboss.ha.hasessionstate.server.HASessionStateService"
-#~ "\"\n"
-#~ "      name=\"jboss:service=HASessionState\"&gt;\n"
-#~ "    &lt;depends&gt;\n"
-#~ "        jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ "    &lt;/depends&gt;\n"
-#~ "    &lt;!-- Name of the partition to which the service is linked --&gt;\n"
-#~ "    &lt;attribute name=\"PartitionName\"&gt;\n"
-#~ "        ${jboss.partition.name:DefaultPartition}\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "    &lt;!-- JNDI name under which the service is bound --&gt;\n"
-#~ "    &lt;attribute name=\"JndiName\"&gt;/HASessionState/Default&lt;/"
-#~ "attribute&gt;\n"
-#~ "    &lt;!-- Max delay before cleaning unreclaimed state.\n"
-#~ "           Defaults to 30*60*1000 =&gt; 30 minutes --&gt;\n"
-#~ "    &lt;attribute name=\"BeanCleaningDelay\"&gt;0&lt;/attribute&gt;\n"
-#~ "&lt;/mbean&gt;"
-#~ msgstr ""
-#~ "&lt;mbean code=\"org.jboss.ha.hasessionstate.server.HASessionStateService"
-#~ "\"\n"
-#~ "      name=\"jboss:service=HASessionState\"&gt;\n"
-#~ "    &lt;depends&gt;\n"
-#~ "        jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ "    &lt;/depends&gt;\n"
-#~ "    &lt;!-- Name of the partition to which the service is linked --&gt;\n"
-#~ "    &lt;attribute name=\"PartitionName\"&gt;\n"
-#~ "        ${jboss.partition.name:DefaultPartition}\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "    &lt;!-- JNDI name under which the service is bound --&gt;\n"
-#~ "    &lt;attribute name=\"JndiName\"&gt;/HASessionState/Default&lt;/"
-#~ "attribute&gt;\n"
-#~ "    &lt;!-- Max delay before cleaning unreclaimed state.\n"
-#~ "           Defaults to 30*60*1000 =&gt; 30 minutes --&gt;\n"
-#~ "    &lt;attribute name=\"BeanCleaningDelay\"&gt;0&lt;/attribute&gt;\n"
-#~ "&lt;/mbean&gt;"
-
-#~ 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 ""
-#~ "&lt;server&gt;\n"
-#~ "   &lt;mbean code=\"org.jboss.ejb3.cache.tree.PassivationTreeCache\"\n"
-#~ "       name=\"jboss.cache:service=EJB3SFSBClusteredCache\"&gt;\n"
-#~ "      \n"
-#~ "        &lt;attribute name=\"IsolationLevel\"&gt;READ_UNCOMMITTED&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"CacheMode\"&gt;REPL_SYNC&lt;/attribute&gt;\n"
-#~ "        &lt;attribute name=\"ClusterName\"&gt;SFSB-Cache&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"ClusterConfig\"&gt;\n"
-#~ "            ... ...\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--  Number of milliseconds to wait until all responses for "
-#~ "a\n"
-#~ "              synchronous call have been received.\n"
-#~ "        --&gt;\n"
-#~ "        &lt;attribute name=\"SyncReplTimeout\"&gt;10000&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--  Max number of milliseconds to wait for a lock "
-#~ "acquisition --&gt;\n"
-#~ "        &lt;attribute name=\"LockAcquisitionTimeout\"&gt;15000&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--  Name of the eviction policy class. --&gt;\n"
-#~ "        &lt;attribute name=\"EvictionPolicyClass\"&gt;\n"
-#~ "            org.jboss.ejb3.cache.tree.StatefulEvictionPolicy\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--  Specific eviction policy configurations. This is LRU --"
-#~ "&gt;\n"
-#~ "        &lt;attribute name=\"EvictionPolicyConfig\"&gt;\n"
-#~ "            &lt;config&gt;\n"
-#~ "                &lt;attribute name=\"wakeUpIntervalSeconds\"&gt;1&lt;/"
-#~ "attribute&gt;\n"
-#~ "                &lt;name&gt;statefulClustered&lt;/name&gt;\n"
-#~ "                &lt;region name=\"/_default_\"&gt;\n"
-#~ "                    &lt;attribute name=\"maxNodes\"&gt;1000000&lt;/"
-#~ "attribute&gt;\n"
-#~ "                    &lt;attribute name=\"timeToIdleSeconds\"&gt;300&lt;/"
-#~ "attribute&gt;\n"
-#~ "                &lt;/region&gt;\n"
-#~ "            &lt;/config&gt;\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;attribute name=\"CacheLoaderFetchPersistentState\"&gt;"
-#~ "false&lt;/attribute&gt;\n"
-#~ "        &lt;attribute name=\"CacheLoaderFetchTransientState\"&gt;true&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"FetchStateOnStartup\"&gt;true&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"CacheLoaderClass\"&gt;\n"
-#~ "            org.jboss.ejb3.cache.tree.StatefulCacheLoader\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "        &lt;attribute name=\"CacheLoaderConfig\"&gt;\n"
-#~ "            location=statefulClustered\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "   &lt;/mbean&gt;\n"
-#~ "&lt;/server&gt;"
-#~ msgstr ""
-#~ "&lt;server&gt;\n"
-#~ "   &lt;mbean code=\"org.jboss.ejb3.cache.tree.PassivationTreeCache\"\n"
-#~ "       name=\"jboss.cache:service=EJB3SFSBClusteredCache\"&gt;\n"
-#~ "      \n"
-#~ "        &lt;attribute name=\"IsolationLevel\"&gt;READ_UNCOMMITTED&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"CacheMode\"&gt;REPL_SYNC&lt;/attribute&gt;\n"
-#~ "        &lt;attribute name=\"ClusterName\"&gt;SFSB-Cache&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"ClusterConfig\"&gt;\n"
-#~ "            ... ...\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--  Number of milliseconds to wait until all responses for "
-#~ "a\n"
-#~ "              synchronous call have been received.\n"
-#~ "        --&gt;\n"
-#~ "        &lt;attribute name=\"SyncReplTimeout\"&gt;10000&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--  Max number of milliseconds to wait for a lock "
-#~ "acquisition --&gt;\n"
-#~ "        &lt;attribute name=\"LockAcquisitionTimeout\"&gt;15000&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--  Name of the eviction policy class. --&gt;\n"
-#~ "        &lt;attribute name=\"EvictionPolicyClass\"&gt;\n"
-#~ "            org.jboss.ejb3.cache.tree.StatefulEvictionPolicy\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--  Specific eviction policy configurations. This is LRU --"
-#~ "&gt;\n"
-#~ "        &lt;attribute name=\"EvictionPolicyConfig\"&gt;\n"
-#~ "            &lt;config&gt;\n"
-#~ "                &lt;attribute name=\"wakeUpIntervalSeconds\"&gt;1&lt;/"
-#~ "attribute&gt;\n"
-#~ "                &lt;name&gt;statefulClustered&lt;/name&gt;\n"
-#~ "                &lt;region name=\"/_default_\"&gt;\n"
-#~ "                    &lt;attribute name=\"maxNodes\"&gt;1000000&lt;/"
-#~ "attribute&gt;\n"
-#~ "                    &lt;attribute name=\"timeToIdleSeconds\"&gt;300&lt;/"
-#~ "attribute&gt;\n"
-#~ "                &lt;/region&gt;\n"
-#~ "            &lt;/config&gt;\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;attribute name=\"CacheLoaderFetchPersistentState\"&gt;"
-#~ "false&lt;/attribute&gt;\n"
-#~ "        &lt;attribute name=\"CacheLoaderFetchTransientState\"&gt;true&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"FetchStateOnStartup\"&gt;true&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"CacheLoaderClass\"&gt;\n"
-#~ "            org.jboss.ejb3.cache.tree.StatefulCacheLoader\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "        &lt;attribute name=\"CacheLoaderConfig\"&gt;\n"
-#~ "            location=statefulClustered\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "   &lt;/mbean&gt;\n"
-#~ "&lt;/server&gt;"
-
-#, 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>&lt;"
-#~ "clustered&gt;</literal> element to the application&#39;s <literal>jboss."
-#~ "xml</literal> descriptor file. Below is a typical <literal>jboss.xml</"
-#~ "literal> file."
-#~ msgstr ""
-#~ "要群集 EJB 2.x entity beans，你需要把 <literal>&lt;clustered&gt;</"
-#~ "literal> 元素加入到应用程序的 <literal>jboss.xml</literal> 描述符文件里。"
-#~ "下面是一个典型的 <literal>jboss.xml</literal> 文件。"
-
-#~ msgid ""
-#~ "&lt;jboss&gt;    \n"
-#~ "    &lt;enterprise-beans&gt;      \n"
-#~ "        &lt;entity&gt;        \n"
-#~ "            &lt;ejb-name&gt;nextgen.EnterpriseEntity&lt;/ejb-"
-#~ "name&gt;        \n"
-#~ "            &lt;jndi-name&gt;nextgen.EnterpriseEntity&lt;/jndi-"
-#~ "name&gt;          \n"
-#~ "            &lt;clustered&gt;True&lt;/clustered&gt;         \n"
-#~ "            &lt;cluster-config&gt;            \n"
-#~ "                &lt;partition-name&gt;DefaultPartition&lt;/partition-"
-#~ "name&gt;            \n"
-#~ "                &lt;home-load-balance-policy&gt;                 \n"
-#~ "                    org.jboss.ha.framework.interfaces."
-#~ "RoundRobin            \n"
-#~ "                &lt;/home-load-balance-policy&gt;            \n"
-#~ "                &lt;bean-load-balance-policy&gt;                \n"
-#~ "                    org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable            \n"
-#~ "                &lt;/bean-load-balance-policy&gt;          \n"
-#~ "            &lt;/cluster-config&gt;      \n"
-#~ "        &lt;/entity&gt;    \n"
-#~ "    &lt;/enterprise-beans&gt;  \n"
-#~ "&lt;/jboss&gt;"
-#~ msgstr ""
-#~ "&lt;jboss&gt;    \n"
-#~ "    &lt;enterprise-beans&gt;      \n"
-#~ "        &lt;entity&gt;        \n"
-#~ "            &lt;ejb-name&gt;nextgen.EnterpriseEntity&lt;/ejb-"
-#~ "name&gt;        \n"
-#~ "            &lt;jndi-name&gt;nextgen.EnterpriseEntity&lt;/jndi-"
-#~ "name&gt;          \n"
-#~ "            &lt;clustered&gt;True&lt;/clustered&gt;         \n"
-#~ "            &lt;cluster-config&gt;            \n"
-#~ "                &lt;partition-name&gt;DefaultPartition&lt;/partition-"
-#~ "name&gt;            \n"
-#~ "                &lt;home-load-balance-policy&gt;                 \n"
-#~ "                    org.jboss.ha.framework.interfaces."
-#~ "RoundRobin            \n"
-#~ "                &lt;/home-load-balance-policy&gt;            \n"
-#~ "                &lt;bean-load-balance-policy&gt;                \n"
-#~ "                    org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable            \n"
-#~ "                &lt;/bean-load-balance-policy&gt;          \n"
-#~ "            &lt;/cluster-config&gt;      \n"
-#~ "        &lt;/entity&gt;    \n"
-#~ "    &lt;/enterprise-beans&gt;  \n"
-#~ "&lt;/jboss&gt;"
-
-#~ 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>&lt;row-lock&gt;</"
-#~ "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>&lt;row-lock&gt;</"
-#~ "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 ""
-#~ "&lt;server&gt;\n"
-#~ "    &lt;mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ "            name=\"jboss.cache:service=EJB3EntityTreeCache\"&gt;\n"
-#~ "        \n"
-#~ "        &lt;depends&gt;jboss:service=Naming&lt;/depends&gt;\n"
-#~ "        &lt;depends&gt;jboss:service=TransactionManager&lt;/depends&gt;\n"
-#~ "\n"
-#~ "        &lt;!-- Configure the TransactionManager --&gt;\n"
-#~ "        &lt;attribute name=\"TransactionManagerLookupClass\"&gt;\n"
-#~ "            org.jboss.cache.JBossTransactionManagerLookup\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;attribute name=\"IsolationLevel\"&gt;REPEATABLE_READ&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"CacheMode\"&gt;REPL_SYNC&lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--Name of cluster. Needs to be the same for all clusters, \n"
-#~ "            in order to find each other --&gt;\n"
-#~ "        &lt;attribute name=\"ClusterName\"&gt;EJB3-entity-cache&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;attribute name=\"ClusterConfig\"&gt;\n"
-#~ "            ... ...\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;attribute name=\"InitialStateRetrievalTimeout\"&gt;5000&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"SyncReplTimeout\"&gt;10000&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"LockAcquisitionTimeout\"&gt;15000&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;attribute name=\"EvictionPolicyClass\"&gt;\n"
-#~ "            org.jboss.cache.eviction.LRUPolicy\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--  Specific eviction policy configurations. This is LRU --"
-#~ "&gt;\n"
-#~ "        &lt;attribute name=\"EvictionPolicyConfig\"&gt;\n"
-#~ "            &lt;config&gt;\n"
-#~ "                &lt;attribute name=\"wakeUpIntervalSeconds\"&gt;5&lt;/"
-#~ "attribute&gt;\n"
-#~ "                &lt;!--  Cache wide default --&gt;\n"
-#~ "                &lt;region name=\"/_default_\"&gt;\n"
-#~ "                    &lt;attribute name=\"maxNodes\"&gt;5000&lt;/"
-#~ "attribute&gt;\n"
-#~ "                    &lt;attribute name=\"timeToLiveSeconds\"&gt;1000&lt;/"
-#~ "attribute&gt;\n"
-#~ "                &lt;/region&gt;\n"
-#~ "            &lt;/config&gt;\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "    &lt;/mbean&gt;\n"
-#~ "&lt;/server&gt;"
-#~ msgstr ""
-#~ "&lt;server&gt;\n"
-#~ "    &lt;mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ "            name=\"jboss.cache:service=EJB3EntityTreeCache\"&gt;\n"
-#~ "        \n"
-#~ "        &lt;depends&gt;jboss:service=Naming&lt;/depends&gt;\n"
-#~ "        &lt;depends&gt;jboss:service=TransactionManager&lt;/depends&gt;\n"
-#~ "\n"
-#~ "        &lt;!-- Configure the TransactionManager --&gt;\n"
-#~ "        &lt;attribute name=\"TransactionManagerLookupClass\"&gt;\n"
-#~ "            org.jboss.cache.JBossTransactionManagerLookup\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;attribute name=\"IsolationLevel\"&gt;REPEATABLE_READ&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"CacheMode\"&gt;REPL_SYNC&lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--Name of cluster. Needs to be the same for all clusters, \n"
-#~ "            in order to find each other --&gt;\n"
-#~ "        &lt;attribute name=\"ClusterName\"&gt;EJB3-entity-cache&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;attribute name=\"ClusterConfig\"&gt;\n"
-#~ "            ... ...\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;attribute name=\"InitialStateRetrievalTimeout\"&gt;5000&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"SyncReplTimeout\"&gt;10000&lt;/"
-#~ "attribute&gt;\n"
-#~ "        &lt;attribute name=\"LockAcquisitionTimeout\"&gt;15000&lt;/"
-#~ "attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;attribute name=\"EvictionPolicyClass\"&gt;\n"
-#~ "            org.jboss.cache.eviction.LRUPolicy\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "\n"
-#~ "        &lt;!--  Specific eviction policy configurations. This is LRU --"
-#~ "&gt;\n"
-#~ "        &lt;attribute name=\"EvictionPolicyConfig\"&gt;\n"
-#~ "            &lt;config&gt;\n"
-#~ "                &lt;attribute name=\"wakeUpIntervalSeconds\"&gt;5&lt;/"
-#~ "attribute&gt;\n"
-#~ "                &lt;!--  Cache wide default --&gt;\n"
-#~ "                &lt;region name=\"/_default_\"&gt;\n"
-#~ "                    &lt;attribute name=\"maxNodes\"&gt;5000&lt;/"
-#~ "attribute&gt;\n"
-#~ "                    &lt;attribute name=\"timeToLiveSeconds\"&gt;1000&lt;/"
-#~ "attribute&gt;\n"
-#~ "                &lt;/region&gt;\n"
-#~ "            &lt;/config&gt;\n"
-#~ "        &lt;/attribute&gt;\n"
-#~ "    &lt;/mbean&gt;\n"
-#~ "&lt;/server&gt;"
-
-#, 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 ""
-#~ "&lt;!-- Clustered cache with TreeCache --&gt;\n"
-#~ "&lt;property name=\"cache.provider_class\"&gt;\n"
-#~ "    org.jboss.ejb3.entity.TreeCacheProviderHook\n"
-#~ "&lt;/property&gt;"
-#~ msgstr ""
-#~ "&lt;!-- Clustered cache with TreeCache --&gt;\n"
-#~ "&lt;property name=\"cache.provider_class\"&gt;\n"
-#~ "    org.jboss.ejb3.entity.TreeCacheProviderHook\n"
-#~ "&lt;/property&gt;"
-
-#~ msgid ""
-#~ "The following property element defines the object name of the cache to be "
-#~ "used, and the MBean name."
-#~ msgstr "下面的属性元素定义了所使用的缓存对象名和 MBean 名。"
-
-#~ msgid ""
-#~ "&lt;property name=\"treecache.mbean.object_name\"&gt;\n"
-#~ "    jboss.cache:service=EJB3EntityTreeCache\n"
-#~ "&lt;/property&gt;"
-#~ msgstr ""
-#~ "&lt;property name=\"treecache.mbean.object_name\"&gt;\n"
-#~ "    jboss.cache:service=EJB3EntityTreeCache\n"
-#~ "&lt;/property&gt;"
-
-#~ 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 ""
-#~ "&lt;server&gt;  \n"
-#~ "  &lt;mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ "         name=\"jboss.cache:service=EJB3EntityTreeCache\"&gt;  \n"
-#~ "    &lt;depends&gt;jboss:service=Naming \n"
-#~ "    &lt;depends&gt;jboss:service=TransactionManager \n"
-#~ "    ... ... \n"
-#~ "    &lt;attribute name=\"EvictionPolicyConfig\"&gt;  \n"
-#~ "      &lt;config&gt;  \n"
-#~ "        &lt;attribute name=\"wakeUpIntervalSeconds\"&gt;5&lt;/"
-#~ "attribute&gt;  \n"
-#~ "        &lt;region name=\"/_default_\"&gt;  \n"
-#~ "          &lt;attribute name=\"maxNodes\"&gt;5000&lt;/attribute&gt;  \n"
-#~ "          &lt;attribute name=\"timeToLiveSeconds\"&gt;1000&lt;/"
-#~ "attribute&gt;  \n"
-#~ "        &lt;/region&gt;  \n"
-#~ "        &lt;region name=\"/mycompany/Customer\"&gt;  \n"
-#~ "          &lt;attribute name=\"maxNodes\"&gt;10&lt;/attribute&gt;  \n"
-#~ "          &lt;attribute name=\"timeToLiveSeconds\"&gt;5000&lt;/"
-#~ "attribute&gt;  \n"
-#~ "        &lt;/region&gt;  \n"
-#~ "        ... ... \n"
-#~ "      &lt;/config&gt;  \n"
-#~ "    &lt;/attribute&gt;  \n"
-#~ "  &lt;/mbean&gt; \n"
-#~ "&lt;/server&gt;"
-#~ msgstr ""
-#~ "&lt;server&gt;  \n"
-#~ "  &lt;mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ "         name=\"jboss.cache:service=EJB3EntityTreeCache\"&gt;  \n"
-#~ "    &lt;depends&gt;jboss:service=Naming \n"
-#~ "    &lt;depends&gt;jboss:service=TransactionManager \n"
-#~ "    ... ... \n"
-#~ "    &lt;attribute name=\"EvictionPolicyConfig\"&gt;  \n"
-#~ "      &lt;config&gt;  \n"
-#~ "        &lt;attribute name=\"wakeUpIntervalSeconds\"&gt;5&lt;/"
-#~ "attribute&gt;  \n"
-#~ "        &lt;region name=\"/_default_\"&gt;  \n"
-#~ "          &lt;attribute name=\"maxNodes\"&gt;5000&lt;/attribute&gt;  \n"
-#~ "          &lt;attribute name=\"timeToLiveSeconds\"&gt;1000&lt;/"
-#~ "attribute&gt;  \n"
-#~ "        &lt;/region&gt;  \n"
-#~ "        &lt;region name=\"/mycompany/Customer\"&gt;  \n"
-#~ "          &lt;attribute name=\"maxNodes\"&gt;10&lt;/attribute&gt;  \n"
-#~ "          &lt;attribute name=\"timeToLiveSeconds\"&gt;5000&lt;/"
-#~ "attribute&gt;  \n"
-#~ "        &lt;/region&gt;  \n"
-#~ "        ... ... \n"
-#~ "      &lt;/config&gt;  \n"
-#~ "    &lt;/attribute&gt;  \n"
-#~ "  &lt;/mbean&gt; \n"
-#~ "&lt;/server&gt;"
-
-#~ 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 "HTTP Services"
-#~ msgstr "HTTP 服务"
-
-#~ msgid ""
-#~ "HTTP session replication is used to replicate the state associated with "
-#~ "your web clients on other nodes of a cluster. Thus, in the event one of "
-#~ "your node crashes, another node in the cluster will be able to recover. "
-#~ "Two distinct functions must be performed:"
-#~ msgstr ""
-#~ "HTTP 会话复制（session replication）用来复制和你在群集里其他节点上的 web "
-#~ "客户相关的状态。因此，如果其中一个节点崩溃了，群集里的其他节点将能够恢复。"
-#~ "有两个不同的功能必须被执行："
-
-#~ msgid "Session state replication"
-#~ msgstr "会话状态复制（Session state replication）"
-
-#~ msgid "Load-balance of incoming invocations"
-#~ msgstr "传入调用（incoming invocations）的负载平衡"
-
-#~ msgid ""
-#~ "State replication is directly handled by JBoss. When you run JBoss in the "
-#~ "<literal>all</literal> configuration, session state replication is "
-#~ "enabled by default. Just deploy your web application and its session "
-#~ "state is already replicated across all JBoss instances in the cluster."
-#~ msgstr ""
-#~ "状态复制（State replication）由 JBoss 直接处理。当你在 <literal>all</"
-#~ "literal> 配置里运行 JBoss，会话状态复制缺省是启用的。只要部署了你的 web 应"
-#~ "用程序，它的会话状态就已经复制在群集里的所有 JBoss 实例中了。"
-
-#~ msgid ""
-#~ "However, Load-balancing is a different story, it is not handled by JBoss "
-#~ "itself and requires additional software. As a very common scenario, we "
-#~ "will demonstrate how to setup Apache and mod_jk. This activity could be "
-#~ "either performed by specialized hardware switches or routers (Cisco "
-#~ "LoadDirector for example) or any other dedicated software though."
-#~ msgstr ""
-#~ "然而，负载平衡是不一样的。它不是由 JBoss 自己处理的，它需要额外的软件。我"
-#~ "们将演示怎样设立 Apache 和 mod_jk，这是一个很常见的例子。但这需要专门的硬"
-#~ "件开关，路由器（如 Cisco LoadDirector）或其他专门的软件来执行。"
-
-#~ msgid ""
-#~ "A load-balancer tracks the HTTP requests and, depending on the session to "
-#~ "which is linked the request, it dispatches the request to the appropriate "
-#~ "node. This is called a load-balancer with sticky-sessions: once a session "
-#~ "is created on a node, every future request will also be processed by the "
-#~ "same node. Using a load-balancer that supports sticky-sessions without "
-#~ "replicating the sessions allows you to scale very well without the cost "
-#~ "of session state replication: each query will always be handled by the "
-#~ "same node. But in the case a node dies, the state of all client sessions "
-#~ "hosted by this node are lost (the shopping carts, for example) and the "
-#~ "clients will most probably need to login on another node and restart with "
-#~ "a new session. In many situations, it is acceptable not to replicate HTTP "
-#~ "sessions because all critical state is stored in the database. In other "
-#~ "situations, loosing a client session is not acceptable and, in this case, "
-#~ "session state replication is the price one has to pay."
-#~ msgstr ""
-#~ "负载平衡系统跟踪 HTTP 请求，它依据请求所链接的会话把请求分派给合适的节点。"
-#~ "一旦会话在节点上被创建，将来的每个请求都被同一节点所处理：这被称作使用 "
-#~ "sticky-sessions 的负载平衡系统。使用支持不复制会话的 sticky-sessions 的负"
-#~ "载平衡系统允许你不付出复制状态的代价就可以很好地扩充：每个查询将总是由同一"
-#~ "节点来处理。但是，如果某个节点崩溃了，所有以这个节点为宿主的客户会话状态就"
-#~ "将全部丢失（如购物车），客户很有可能需要登录另外一节点来启动新的会话。在大"
-#~ "部分情况下，不复制 HTTP 会话是可以接受的，因为所有关键状态都存储在数据库"
-#~ "里。在丢失客户会话是不能接受的情况下，采用会话状态复制就是必须付出的代价"
-#~ "了。"
-
-#~ msgid ""
-#~ "Apache is a well-known web server which can be extended by plugging "
-#~ "modules. One of these modules, mod_jk (and the newest mod_jk2) has been "
-#~ "specifically designed to allow forward requests from Apache to a Servlet "
-#~ "container. Furthermore, it is also able to load-balance HTTP calls to a "
-#~ "set of Servlet containers while maintaining sticky sessions, and this is "
-#~ "what is actually interesting for us."
-#~ msgstr ""
-#~ "Apache 是一个很有名的 web 服务器，它可以通过插件来扩展。mod_jk（和最新的 "
-#~ "mod_jk2）已经被特别的设计成可以允许从 Apache 转发请求到 Servlet 容器里。而"
-#~ "且，当维护 sticky sessions 时，它也能够对 Servlet 容器的 HTTP 调用的负载进"
-#~ "行平衡，这正是让我们感兴趣的地方。"
-
-#~ msgid "Download the software"
-#~ msgstr "下载软件"
-
-#~ msgid ""
-#~ "First of all, make sure that you have Apache installed. You can download "
-#~ "Apache directly from Apache web site at <literal>http://httpd.apache.org/"
-#~ "</literal>. Its installation is pretty straightforward and requires no "
-#~ "specific configuration. As several versions of Apache exist, we advise "
-#~ "you to use version 2.0.x. We will consider, for the next sections, that "
-#~ "you have installed Apache in the <literal>APACHE_HOME</literal> directory."
-#~ msgstr ""
-#~ "首先，确保你已经安装了 Apache。你可以直接从 Apache 网站 <literal>http://"
-#~ "httpd.apache.org/</literal> 下载 Apache。它的安装是非常直接的，不需要任何"
-#~ "特殊的配置。Apache 有好几个版本，我们建议你使用 2.0.x 版本。在下面的内容"
-#~ "里，我们假设你已经把 Apache 安装在 <literal>APACHE_HOME</literal> 目录下"
-#~ "了。"
-
-#~ msgid ""
-#~ "Next, download mod_jk binaries. Several versions of mod_jk exist as well. "
-#~ "We strongly advise you to use mod_jk 1.2.x, as both mod_jk and mod_jk2 "
-#~ "are deprecated, unsupported and no further developments are going on in "
-#~ "the community. The mod_jk 1.2.x binary can be downloaded from "
-#~ "<literal>http://www.apache.org/dist/jakarta/tomcat-connectors/jk/binaries/"
-#~ "</literal>. Rename the downloaded file to <literal>mod_jk.so</literal> "
-#~ "and copy it under <literal>APACHE_HOME/modules/</literal>."
-#~ msgstr ""
-#~ "其次，下载 mod_jk binaries。它也有几个版本。我们强烈建议你使用 mod_jk 1.2."
-#~ "x，因为 mod_jk 和 mod_jk2 都已经被取消了，在社区里不再会有后续的开发和支"
-#~ "持。你可以从 <literal>http://www.apache.org/dist/jakarta/tomcat-"
-#~ "connectors/jk/binaries/</literal> 下载 mod_jk 1.2.x binary。把下载的文件改"
-#~ "名为 <literal>mod_jk.so</literal> 并拷贝到 <literal>APACHE_HOME/modules/</"
-#~ "literal> 目录下。"
-
-#~ msgid "Configure Apache to load mod_jk"
-#~ msgstr "配置 Apache 来装载 mod_jk"
-
-#~ msgid ""
-#~ "Modify APACHE_HOME/conf/httpd.conf and add a single line at the end of "
-#~ "the file:"
-#~ msgstr "在 APACHE_HOME/conf/httpd.conf 文件的最后加入一行："
-
-#, fuzzy
-#~ msgid ""
-#~ "# Include mod_jk&#39;s specific configuration file  \n"
-#~ "Include conf/mod-jk.conf"
-#~ msgstr ""
-#~ "# Include mod_jk's specific configuration file  \n"
-#~ "Include conf/mod-jk.conf"
-
-#~ msgid ""
-#~ "Next, create a new file named <literal>APACHE_HOME/conf/mod-jk.conf</"
-#~ "literal>:"
-#~ msgstr ""
-#~ "然后，建立一个叫 <literal>APACHE_HOME/conf/mod-jk.conf</literal> 的文件。"
-
-#~ msgid ""
-#~ "# Load mod_jk module\n"
-#~ "# Specify the filename of the mod_jk lib\n"
-#~ "LoadModule jk_module modules/mod_jk.so\n"
-#~ " \n"
-#~ "# Where to find workers.properties\n"
-#~ "JkWorkersFile conf/workers.properties\n"
-#~ "\n"
-#~ "# Where to put jk logs\n"
-#~ "JkLogFile logs/mod_jk.log\n"
-#~ " \n"
-#~ "# Set the jk log level [debug/error/info]\n"
-#~ "JkLogLevel info \n"
-#~ " \n"
-#~ "# Select the log format\n"
-#~ "JkLogStampFormat  \"[%a %b %d %H:%M:%S %Y]\"\n"
-#~ " \n"
-#~ "# JkOptions indicates to send SSK KEY SIZE\n"
-#~ "JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories\n"
-#~ " \n"
-#~ "# JkRequestLogFormat\n"
-#~ "JkRequestLogFormat \"%w %V %T\"\n"
-#~ "               \n"
-#~ "# Mount your applications\n"
-#~ "JkMount /application/* loadbalancer\n"
-#~ " \n"
-#~ "# You can use external file for mount points.\n"
-#~ "# It will be checked for updates each 60 seconds.\n"
-#~ "# The format of the file is: /url=worker\n"
-#~ "# /examples/*=loadbalancer\n"
-#~ "JkMountFile conf/uriworkermap.properties               \n"
-#~ "\n"
-#~ "# Add shared memory.\n"
-#~ "# This directive is present with 1.2.10 and\n"
-#~ "# later versions of mod_jk, and is needed for\n"
-#~ "# for load balancing to work properly\n"
-#~ "JkShmFile logs/jk.shm \n"
-#~ "              \n"
-#~ "# Add jkstatus for managing runtime data\n"
-#~ "&lt;Location /jkstatus/&gt;\n"
-#~ "    JkMount status\n"
-#~ "    Order deny,allow\n"
-#~ "    Deny from all\n"
-#~ "    Allow from 127.0.0.1\n"
-#~ "&lt;/Location&gt;"
-#~ msgstr ""
-#~ "# Load mod_jk module\n"
-#~ "# Specify the filename of the mod_jk lib\n"
-#~ "LoadModule jk_module modules/mod_jk.so\n"
-#~ " \n"
-#~ "# Where to find workers.properties\n"
-#~ "JkWorkersFile conf/workers.properties\n"
-#~ "\n"
-#~ "# Where to put jk logs\n"
-#~ "JkLogFile logs/mod_jk.log\n"
-#~ " \n"
-#~ "# Set the jk log level [debug/error/info]\n"
-#~ "JkLogLevel info \n"
-#~ " \n"
-#~ "# Select the log format\n"
-#~ "JkLogStampFormat  \"[%a %b %d %H:%M:%S %Y]\"\n"
-#~ " \n"
-#~ "# JkOptions indicates to send SSK KEY SIZE\n"
-#~ "JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories\n"
-#~ " \n"
-#~ "# JkRequestLogFormat\n"
-#~ "JkRequestLogFormat \"%w %V %T\"\n"
-#~ "               \n"
-#~ "# Mount your applications\n"
-#~ "JkMount /application/* loadbalancer\n"
-#~ " \n"
-#~ "# You can use external file for mount points.\n"
-#~ "# It will be checked for updates each 60 seconds.\n"
-#~ "# The format of the file is: /url=worker\n"
-#~ "# /examples/*=loadbalancer\n"
-#~ "JkMountFile conf/uriworkermap.properties               \n"
-#~ "\n"
-#~ "# Add shared memory.\n"
-#~ "# This directive is present with 1.2.10 and\n"
-#~ "# later versions of mod_jk, and is needed for\n"
-#~ "# for load balancing to work properly\n"
-#~ "JkShmFile logs/jk.shm \n"
-#~ "              \n"
-#~ "# Add jkstatus for managing runtime data\n"
-#~ "&lt;Location /jkstatus/&gt;\n"
-#~ "    JkMount status\n"
-#~ "    Order deny,allow\n"
-#~ "    Deny from all\n"
-#~ "    Allow from 127.0.0.1\n"
-#~ "&lt;/Location&gt;"
-
-#~ msgid "Please note that two settings are very important:"
-#~ msgstr "请注意有两个设置非常重要："
-
-#~ msgid ""
-#~ "The <literal>LoadModule</literal> directive must reference the mod_jk "
-#~ "library you have downloaded in the previous section. You must indicate "
-#~ "the exact same name with the \"modules\" file path prefix."
-#~ msgstr ""
-#~ "<literal>LoadModule</literal> 指令（directive）必须引用你在前面下载的 "
-#~ "mod_jk 库。你必须使用有 \"modules\" 前缀的完全一致的名字。"
-
-#~ msgid ""
-#~ "The <literal>JkMount</literal> directive tells Apache which URLs it "
-#~ "should forward to the mod_jk module (and, in turn, to the Servlet "
-#~ "containers). In the above file, all requests with URL path <literal>/"
-#~ "application/*</literal> are sent to the mod_jk load-balancer. This way, "
-#~ "you can configure Apache to server static contents (or PHP contents) "
-#~ "directly and only use the loadbalancer for Java applications. If you only "
-#~ "use mod_jk as a loadbalancer, you can also forward all URLs (i.e., "
-#~ "<literal>/*</literal>) to mod_jk."
-#~ msgstr ""
-#~ "<literal>JkMount</literal> 指令告诉 Apache 应该把 URLs 转发给哪个 mod_jk "
-#~ "模块（和 Servlet 容器）。在上面的文件里，所有基于 URL 路径 <literal>/"
-#~ "application/*</literal> 的请求都被发送到  mod_jk 负载平衡系统（load-"
-#~ "balancer）。这样的话，你能够使 Apache 直接处理静态内容 （或 PHP 内容）而只"
-#~ "对 Java 应用程序使用负载平衡系统。如果你只把 mod_jk 当作负载平衡系统使用，"
-#~ "你也可以把所有的 URLs （也就是 <literal>/*</literal>）转发给 mod_jk。"
-
-#~ msgid ""
-#~ "In addition to the <literal>JkMount</literal> directive, you can also use "
-#~ "the <literal>JkMountFile</literal> directive to specify a mount points "
-#~ "configuration file, which contains multiple Tomcat forwarding URL "
-#~ "mappings. You just need to create a <literal>uriworkermap.properties</"
-#~ "literal> file in the <literal>APACHE_HOME/conf</literal> directory. The "
-#~ "format of the file is <literal>/url=worker_name</literal>. To get things "
-#~ "started, paste the following example into the file you created:"
-#~ msgstr ""
-#~ "除了 <literal>JkMount</literal> 指令以外，你也能够用 "
-#~ "<literal>JkMountFile</literal> 指令来指定配置文件的挂载点（mount "
-#~ "points），它包含了多重的 Tomcat forwarding URL mappings。你只需要在 "
-#~ "<literal>APACHE_HOME/conf</literal> 目录下建立一个 <literal>uriworkermap."
-#~ "properties</literal> 文件。文件的格式是 <literal>/url=worker_name</"
-#~ "literal>。首先，把下例拷贝到你创建的文件里："
-
-#~ msgid ""
-#~ "# Simple worker configuration file\n"
-#~ "\n"
-#~ "# Mount the Servlet context to the ajp13 worker\n"
-#~ "/jmx-console=loadbalancer\n"
-#~ "/jmx-console/*=loadbalancer\n"
-#~ "/web-console=loadbalancer\n"
-#~ "/web-console/*=loadbalancer"
-#~ msgstr ""
-#~ "# Simple worker configuration file\n"
-#~ "\n"
-#~ "# Mount the Servlet context to the ajp13 worker\n"
-#~ "/jmx-console=loadbalancer\n"
-#~ "/jmx-console/*=loadbalancer\n"
-#~ "/web-console=loadbalancer\n"
-#~ "/web-console/*=loadbalancer"
-
-#~ msgid ""
-#~ "This will configure mod_jk to forward requests to <literal>/jmx-console</"
-#~ "literal> and <literal>/web-console</literal> to Tomcat."
-#~ msgstr ""
-#~ "这将使 mod_jk 把发送到 <literal>/jmx-console</literal> 和 <literal>/web-"
-#~ "console</literal> 的请求转发至 Tomcat。"
-
-#~ msgid ""
-#~ "You will most probably not change the other settings in <literal>mod_jk."
-#~ "conf</literal>. They are used to tell mod_jk where to put its logging "
-#~ "file, which logging level to use and so on."
-#~ msgstr ""
-#~ "你很可能不需要修改 <literal>mod_jk.conf</literal> 里的设置，这些设置用来告"
-#~ "诉 mod_jk 日志文件放在什么地方，使用哪个日志级别等等。"
-
-#~ msgid "Configure worker nodes in mod_jk"
-#~ msgstr "配置 mod_jk 里的 worker 节点"
-
-#~ msgid ""
-#~ "Next, you need to configure mod_jk workers file <literal>conf/workers."
-#~ "properties</literal>. This file specify where are located the different "
-#~ "Servlet containers and how calls should be load-balanced across them. The "
-#~ "configuration file contains one section for each target servlet container "
-#~ "and one global section. For a two nodes setup, the file could look like "
-#~ "this:"
-#~ msgstr ""
-#~ "然后，你需要配置 mod_jk 的 workers 文件 <literal>conf/workers.properties</"
-#~ "literal>。这个文件指定不同的 Servlet 容器的存放位置和怎样对它们之间的调用"
-#~ "进行负载平衡。这个配置文件包含了一个全局设置部分以及针对每个目标 Servlet "
-#~ "容器的设置部分。对于两个节点的设立，这个文件如下所示："
-
-#~ msgid ""
-#~ "# Define list of workers that will be used\n"
-#~ "# for mapping requests\n"
-#~ "worker.list=loadbalancer,status\n"
-#~ "\n"
-#~ "# Define Node1\n"
-#~ "# modify the host as your host IP or DNS name.\n"
-#~ "worker.node1.port=8009\n"
-#~ "worker.node1.host=node1.mydomain.com \n"
-#~ "worker.node1.type=ajp13\n"
-#~ "worker.node1.lbfactor=1\n"
-#~ "worker.node1.cachesize=10\n"
-#~ "\n"
-#~ "# Define Node2\n"
-#~ "# modify the host as your host IP or DNS name.\n"
-#~ "worker.node2.port=8009\n"
-#~ "worker.node2.host= node2.mydomain.com\n"
-#~ "worker.node2.type=ajp13\n"
-#~ "worker.node2.lbfactor=1\n"
-#~ "worker.node2.cachesize=10\n"
-#~ "\n"
-#~ "# Load-balancing behaviour\n"
-#~ "worker.loadbalancer.type=lb\n"
-#~ "worker.loadbalancer.balance_workers=node1,node2\n"
-#~ "worker.loadbalancer.sticky_session=1\n"
-#~ "#worker.list=loadbalancer\n"
-#~ "\n"
-#~ "# Status worker for managing load balancer\n"
-#~ "worker.status.type=status"
-#~ msgstr ""
-#~ "# Define list of workers that will be used\n"
-#~ "# for mapping requests\n"
-#~ "worker.list=loadbalancer,status\n"
-#~ "\n"
-#~ "# Define Node1\n"
-#~ "# modify the host as your host IP or DNS name.\n"
-#~ "worker.node1.port=8009\n"
-#~ "worker.node1.host=node1.mydomain.com \n"
-#~ "worker.node1.type=ajp13\n"
-#~ "worker.node1.lbfactor=1\n"
-#~ "worker.node1.cachesize=10\n"
-#~ "\n"
-#~ "# Define Node2\n"
-#~ "# modify the host as your host IP or DNS name.\n"
-#~ "worker.node2.port=8009\n"
-#~ "worker.node2.host= node2.mydomain.com\n"
-#~ "worker.node2.type=ajp13\n"
-#~ "worker.node2.lbfactor=1\n"
-#~ "worker.node2.cachesize=10\n"
-#~ "\n"
-#~ "# Load-balancing behaviour\n"
-#~ "worker.loadbalancer.type=lb\n"
-#~ "worker.loadbalancer.balance_workers=node1,node2\n"
-#~ "worker.loadbalancer.sticky_session=1\n"
-#~ "#worker.list=loadbalancer\n"
-#~ "\n"
-#~ "# Status worker for managing load balancer\n"
-#~ "worker.status.type=status"
-
-#~ msgid ""
-#~ "Basically, the above file configures mod_jk to perform weighted round-"
-#~ "robin load balancing with sticky sessions between two servlet containers "
-#~ "(JBoss Tomcat) node1 and node2 listening on port 8009."
-#~ msgstr ""
-#~ "基本上，上面的配置使 mod_jk 对两个 servlet 容器（JBoss Tomcat）（侦听 "
-#~ "8009 端口的节点 1 和节点 2）之间的 sticky sessions 执行重量级的 round-"
-#~ "robin 负载平衡。"
-
-#~ msgid ""
-#~ "In the <literal>works.properties</literal> file, each node is defined "
-#~ "using the <literal>worker.XXX</literal> naming convention where "
-#~ "<literal>XXX</literal> represents an arbitrary name you choose for one of "
-#~ "the target Servlet container. For each worker, you must give the host "
-#~ "name (or IP address) and port number of the AJP13 connector running in "
-#~ "the Servlet container."
-#~ msgstr ""
-#~ "在 <literal>works.properties</literal> 文件里，每个节点都用 "
-#~ "<literal>worker.XXX</literal> 命名规则命名，<literal>XXX</literal> 代表你"
-#~ "给其中一个目标 Servlet 容器选取的任意名字。对于每一个 worker，你必须给出"
-#~ "在 Servlet 容器运行的 AJP13 connector 的主机名（或 IP 地址）和端口号。"
-
-#~ 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 should have over other nodes. The higher this number is, the more "
-#~ "HTTP requests it will receive. This setting can be used to differentiate "
-#~ "servers with different processing power."
-#~ msgstr ""
-#~ "<literal>lbfactor</literal> 属性是对于特定的 worker 的负载平衡因子。它用来"
-#~ "定义一个节点对于其他节点的优先级（或权重）。这个数字越大，就要接收越多的 "
-#~ "HTTP 请求。这个设置可以用来调节不同服务器的处理能力。"
-
-#~ msgid ""
-#~ "The <literal>cachesize</literal> attribute defines the size of the thread "
-#~ "pools associated to the Servlet container (i.e. the number of concurrent "
-#~ "requests it will forward to the Servlet container). Make sure this number "
-#~ "does not outnumber the number of threads configured on the AJP13 "
-#~ "connector of the Servlet container. Please review <literal>http://jakarta."
-#~ "apache.org/tomcat/connectors-doc/config/workers.html</literal> for "
-#~ "comments on <literal>cachesize</literal> for Apache 1.3.x."
-#~ msgstr ""
-#~ "<literal>cachesize</literal> 属性定义与 Servlet 容器相关的线程池的大小（也"
-#~ "就是转发给 Servlet 容器的并发请求的数量）。请确保这个数字不要超过 Servlet "
-#~ "容器的 AJP13 connector 所配置的线程数。请参考 <literal>http://jakarta."
-#~ "apache.org/tomcat/connectors-doc/config/workers.html</literal> 里关于 "
-#~ "Apache 1.3.x 的 <literal>cachesize</literal> 的注释。"
-
-#~ msgid ""
-#~ "The last part of the <literal>conf/workers.properties</literal> file "
-#~ "defines the loadbalancer worker. The only thing you must change is the "
-#~ "<literal>worker.loadbalancer.balanced_workers</literal> line: it must "
-#~ "list all workers previously defined in the same file: load-balancing will "
-#~ "happen over these workers."
-#~ msgstr ""
-#~ "<literal>conf/workers.properties</literal> 文件最后一部分定义 "
-#~ "loadbalancer worker。你只需要修改 <literal>worker.loadbalancer."
-#~ "balanced_workers</literal> 行：它列出了之前所有在这个文件里定义的 "
-#~ "workers：负载平衡将在这些 workers 上进行。"
-
-#, fuzzy
-#~ msgid ""
-#~ "The <literal>sticky_session</literal> property specifies the cluster "
-#~ "behavior for HTTP sessions. If you specify <literal>worker.loadbalancer."
-#~ "sticky_session=0</literal>, each request will be load balanced between "
-#~ "node1 and node2. But when a user opens a session on one server, it is a "
-#~ "good idea to always forward this user&#39;s requests to the same server. "
-#~ "This is called a \"sticky session\", as the client is always using the "
-#~ "same server he reached on his first request. Otherwise the user&#39;s "
-#~ "session data would need to be synchronized between both servers (session "
-#~ "replication, see <xref linkend=\"HTTP_Services-"
-#~ "Configure_HTTP_session_state_replication\"/>). To enable session "
-#~ "stickiness, you need to set <literal>worker.loadbalancer.sticky_session</"
-#~ "literal> to 1."
-#~ msgstr ""
-#~ "<literal>sticky_session</literal> 属性指定 HTTP 会话的群集系统行为。如果你"
-#~ "指定 <literal>worker.loadbalancer.sticky_session=0</literal>，每个请求会在"
-#~ "节点 1 和节点 2 之间进行负载平衡。但是当用户在服务器上开始一个会话，把这个"
-#~ "的用户的请求转发到同一服务器会是个好主意。这被称作 \"sticky session\"，因"
-#~ "为客户总是使用处理他第一个请求的服务器。否则用户的会话数据就必须在两个服务"
-#~ "器之间同步（即会话复制，请参考 <xref linkend=\"clustering-http-state\"/"
-#~ ">）。为了启用 session stickiness，你需要把 <literal>worker.loadbalancer."
-#~ "sticky_session</literal> 设置为 1。"
-
-#~ msgid ""
-#~ "A non-loadbalanced setup with a single node required the <literal>worker."
-#~ "list=node1</literal> entry before mod_jk would function correctly."
-#~ msgstr ""
-#~ "单节点的非负载平衡的设立需要设置 <literal>worker.list=node1</literal> 条"
-#~ "目，才能使 mod_jk 正常工作。"
-
-#~ msgid "Configure JBoss"
-#~ msgstr "配置 JBoss"
-
-#~ msgid ""
-#~ "Finally, we must configure the JBoss Tomcat instances on all clustered "
-#~ "nodes so that they can expect requests forwarded from the mod_jk "
-#~ "loadbalancer."
-#~ msgstr ""
-#~ "最后，我们必须在所有群集节点上配置 JBoss Tomcat 实例，它们才能接收从 "
-#~ "mod_jk 负载平衡系统转发的请求。"
-
-#, fuzzy
-#~ 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 instance node1, edit the <literal>JBOSS_HOME/server/all/deploy/"
-#~ "jboss-web.deployer/server.xml</literal> file (replace <literal>/all</"
-#~ "literal> with your own server name if necessary). Locate the <literal>&lt;"
-#~ "Engine&gt;</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> 文件（有必要"
-#~ "的话用你自己的服务器名代替<literal>/all</literal>）。定位 <literal>&lt;"
-#~ "Engine&gt;</literal> 元素并加入一个 <literal>jvmRoute</literal> 属性："
-
-#~ msgid ""
-#~ "&lt;Engine name=\"jboss.web\" defaultHost=\"localhost\" jvmRoute=\"node1"
-#~ "\"&gt;\n"
-#~ "... ...\n"
-#~ "&lt;/Engine&gt;"
-#~ msgstr ""
-#~ "&lt;Engine name=\"jboss.web\" defaultHost=\"localhost\" jvmRoute=\"node1"
-#~ "\"&gt;\n"
-#~ "... ...\n"
-#~ "&lt;/Engine&gt;"
-
-#, fuzzy
-#~ msgid ""
-#~ "Then, for each JBoss Tomcat instance in the cluster, we need to tell it "
-#~ "to add the <literal>jvmRoute</literal> value to its session cookies so "
-#~ "that mod_jk can route incoming requests. Edit the <literal>JBOSS_HOME/"
-#~ "server/all/deploy/jboss-web.deployer/META-INF/jboss-service.xml</literal> "
-#~ "file (replace <literal>/all</literal> with your own server name). Locate "
-#~ "the <literal>&lt;attribute&gt;</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</literal>）。用 <literal>UseJK</literal>名来定位"
-#~ "<literal>&lt;attribute&gt;</literal> 元素，把它的值设置为 <literal>true</"
-#~ "literal>："
-
-#~ msgid "&lt;attribute name=\"UseJK\"&gt;true&lt;/attribute&gt;"
-#~ msgstr "&lt;attribute name=\"UseJK\"&gt;true&lt;/attribute&gt;"
-
-#~ msgid ""
-#~ "At this point, you have a fully working Apache+mod_jk load-balancer setup "
-#~ "that will balance call to the Servlet containers of your cluster while "
-#~ "taking care of session stickiness (clients will always use the same "
-#~ "Servlet container)."
-#~ msgstr ""
-#~ "现在，你有了完全工作的 Apache+mod_jk load-balancer 系统，它将平衡对群集里"
-#~ "的 Servlet 容器的调用，同时顾及到 session stickiness（客户将总使用相同的 "
-#~ "Servlet 容器）。"
-
-#~ msgid ""
-#~ "For more updated information on using mod_jk 1.2 with JBoss Tomcat, "
-#~ "please refer to the JBoss wiki page at <literal>http://wiki.jboss.org/"
-#~ "wiki/Wiki.jsp?page=UsingMod_jk1.2WithJBoss</literal>."
-#~ msgstr ""
-#~ "对于和 JBoss Tomcat 一起使用 mod_jk 1.2 的更新信息，请参考 "
-#~ "<literal>http://wiki.jboss.org/wiki/Wiki.jsp?"
-#~ "page=UsingMod_jk1.2WithJBoss</literal> 的 JBoss wiki 页。"
-
-#~ msgid "Configure HTTP session state replication"
-#~ msgstr "配置 HTTP 会话状态复制（session state replication）"
-
-#, fuzzy
-#~ msgid ""
-#~ "In <xref linkend=\"HTTP_Services-Configure_worker_nodes_in_mod_jk\"/>, we "
-#~ "covered how to use sticky sessions to make sure that a client in a "
-#~ "session always hits the same server node in order to maintain the session "
-#~ "state. However, that is not an ideal solution. The load might be unevenly "
-#~ "distributed over the nodes over time and if a node goes down, all its "
-#~ "session data is lost. A better and more reliable solution is to replicate "
-#~ "session data across all nodes in the cluster. This way, the client can "
-#~ "hit any server node and obtain the same session states."
-#~ msgstr ""
-#~ "在 <xref linkend=\"clustering-http-nodes\"/> 里，我们涉及了怎样使用 "
-#~ "sticky sessions 来确保会话里的客户总是利用相同的服务器来维护会话状态。然"
-#~ "而，这并非一个理想的解决方案。如果某一节点崩溃了并丢失了所有的会话数据，负"
-#~ "载就有可能没有均衡分布在节点上。一个更好的和可靠的办法就是在群集里的所有节"
-#~ "点上复制会话数据。这样的话，客户可以访问任何节点而获得相同的会话数据。"
-
-#, fuzzy
-#~ msgid ""
-#~ "The <literal>jboss.cache:service=TomcatClusteringCache</literal> MBean "
-#~ "makes use of JBoss Cache to provide HTTP session replication service to "
-#~ "the HTTP load balancer in a JBoss Tomcat cluster. This MBean is defined "
-#~ "in the <literal>deploy/jboss-web-cluster.sar/META-INF/jboss-service.xml</"
-#~ "literal> file."
-#~ 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> 文件里定义了这个 MBean。"
-
-#, fuzzy
-#~ msgid ""
-#~ "Before AS 4.0.4 CR2, the HTTP session cache configuration file is the "
-#~ "<literal>deploy/tc5-cluster-service.xml</literal> file. Please see AS 4.2 "
-#~ "documentation for more details."
-#~ msgstr ""
-#~ "在 AS 4.0.4 CR2 之前， HTTP 会话缓存配置文件是 <literal>deploy/tc5-"
-#~ "cluster-service.xml</literal>。请参考 AS 4.0.3 文档来获得更多细节。"
-
-#, fuzzy
-#~ msgid ""
-#~ "Below is a typical <literal>deploy/jboss-web-cluster.sar/META-INF/jboss-"
-#~ "service.xml</literal> file. The configuration attributes in the "
-#~ "<literal>TomcatClusteringCache</literal> MBean is very similar to those "
-#~ "in <xref linkend=\"JBossCache_and_JGroups_Services-"
-#~ "JBossCache_Configuration\"/>."
-#~ msgstr ""
-#~ "下面是一个典型的 <literal>deploy/tc5-cluster.sar/META-INF/jboss-service."
-#~ "xml</literal> 文件。<literal>TomcatClusteringCache</literal> MBean 里的配"
-#~ "置属性和 <xref linkend=\"jbosscache-cache\"/> 里的非常相似。"
-
-#~ msgid ""
-#~ "&lt;mbean code=\"org.jboss.cache.aop.TreeCacheAop\"\n"
-#~ "    name=\"jboss.cache:service=TomcatClusteringCache\"&gt;\n"
-#~ "\n"
-#~ "    &lt;depends&gt;jboss:service=Naming&lt;/depends&gt;\n"
-#~ "    &lt;depends&gt;jboss:service=TransactionManager&lt;/depends&gt;\n"
-#~ "    &lt;depends&gt;jboss.aop:service=AspectDeployer&lt;/depends&gt;\n"
-#~ "\n"
-#~ "    &lt;attribute name=\"TransactionManagerLookupClass\"&gt;\n"
-#~ "        org.jboss.cache.BatchModeTransactionManagerLookup\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"IsolationLevel\"&gt;REPEATABLE_READ&lt;/"
-#~ "attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"CacheMode\"&gt;REPL_ASYNC&lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"ClusterName\"&gt;\n"
-#~ "      Tomcat-${jboss.partition.name:Cluster}\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"UseMarshalling\"&gt;false&lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"InactiveOnStartup\"&gt;false&lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"ClusterConfig\"&gt;\n"
-#~ "        ... ...\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"LockAcquisitionTimeout\"&gt;15000&lt;/"
-#~ "attribute&gt;\n"
-#~ "&lt;/mbean&gt;"
-#~ msgstr ""
-#~ "&lt;mbean code=\"org.jboss.cache.aop.TreeCacheAop\"\n"
-#~ "    name=\"jboss.cache:service=TomcatClusteringCache\"&gt;\n"
-#~ "\n"
-#~ "    &lt;depends&gt;jboss:service=Naming&lt;/depends&gt;\n"
-#~ "    &lt;depends&gt;jboss:service=TransactionManager&lt;/depends&gt;\n"
-#~ "    &lt;depends&gt;jboss.aop:service=AspectDeployer&lt;/depends&gt;\n"
-#~ "\n"
-#~ "    &lt;attribute name=\"TransactionManagerLookupClass\"&gt;\n"
-#~ "        org.jboss.cache.BatchModeTransactionManagerLookup\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"IsolationLevel\"&gt;REPEATABLE_READ&lt;/"
-#~ "attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"CacheMode\"&gt;REPL_ASYNC&lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"ClusterName\"&gt;\n"
-#~ "      Tomcat-${jboss.partition.name:Cluster}\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"UseMarshalling\"&gt;false&lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"InactiveOnStartup\"&gt;false&lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"ClusterConfig\"&gt;\n"
-#~ "        ... ...\n"
-#~ "    &lt;/attribute&gt;\n"
-#~ "    \n"
-#~ "    &lt;attribute name=\"LockAcquisitionTimeout\"&gt;15000&lt;/"
-#~ "attribute&gt;\n"
-#~ "&lt;/mbean&gt;"
-
-#, fuzzy
-#~ msgid ""
-#~ "The detailed configuration for the <literal>TreeCache</literal> MBean is "
-#~ "covered in <xref linkend=\"JBossCache_and_JGroups_Services-"
-#~ "JBossCache_Configuration\"/>. 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）最为相关的几个属性。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">TransactionManagerLookupClass</emphasis> sets the "
-#~ "transaction manager factory. The default value is <literal>org.jboss."
-#~ "cache.BatchModeTransactionManagerLookup</literal>. It tells the cache NOT "
-#~ "to participate in JTA-specific transactions. Instead, the cache manages "
-#~ "its own transaction to support finely grained replications."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">TransactionManagerLookupClass</emphasis> 设置 "
-#~ "transaction manager factory。它的缺省值是 <literal>org.jboss.cache."
-#~ "BatchModeTransactionManagerLookup</literal>。它告诉缓存不要参与 JTA 相关的"
-#~ "事务。作为替代，缓存管理自己的事务来支持细颗粒度的复制。"
-
-#~ 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\">ClusterName</emphasis> specifies the name of the "
-#~ "cluster that the cache works within. The default cluster name is the the "
-#~ "word \"Tomcat-\" appended by the current JBoss partition name. All the "
-#~ "nodes should use the same cluster name. Although session replication can "
-#~ "share the same channel (multicast address and port) with other clustered "
-#~ "services in JBoss, replication should have it&#39;s own cluster name."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">ClusterName</emphasis> 指定了缓存所服务的群集的名"
-#~ "字。缺省的群集名是 \"Tomcat-\" 后面跟着当前的 JBoss 分区名。所有节点都应该"
-#~ "使用相同的群集名。虽然会话复制能够和 JBoss 的其他群集服务共享同一通道（多"
-#~ "点传送地址和端口），复制还是应该有自己的群集名。"
-
-#~ msgid ""
-#~ "The <emphasis role=\"bold\">UseMarshalling</emphasis> and <emphasis role="
-#~ "\"bold\">InactiveOnStartup</emphasis> attributes must have the same "
-#~ "value. They must be <literal>true</literal> if <literal>FIELD</literal> "
-#~ "level session replication is needed (see later). Otherwise, they are "
-#~ "default to <literal>false</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">UseMarshalling</emphasis> 和 <emphasis role=\"bold"
-#~ "\">InactiveOnStartup</emphasis> 属性必须有相同的值。如果需要使用 "
-#~ "<literal>FIELD</literal> 级会话复制（请参考后面的内容），它们的值必须是 "
-#~ "<literal>true</literal>。否则，它们的缺省值是 <literal>false</literal>。"
-
-#, 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\">LockAcquisitionTimeout</emphasis> sets the "
-#~ "maximum number of milliseconds to wait for a lock acquisition. The "
-#~ "default value is 15000."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">LockAcquisitionTimeout</emphasis> 设置以毫秒为单位"
-#~ "的等待所锁定捕获（lock acquisition）的最长时间。它的缺省值是 15000。"
-
-#~ 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 "
-#~ "在发送更新之前，复制队列里所允许的最大元素数目。"
-
-#~ msgid "Enabling session replication in your application"
-#~ msgstr "在你的应用程序里启用会话复制"
-
-#, fuzzy
-#~ msgid ""
-#~ "To enable clustering of your web application you must it as distributable "
-#~ "in the <literal>web.xml</literal> descriptor. Here&#39;s an example:"
-#~ msgstr ""
-#~ "为了启用 web 应用程序的群集，你必须在 <literal>web.xml</literal> 描述符里"
-#~ "把它标记为 distributable。下面是一个例子："
-
-#, fuzzy
-#~ msgid ""
-#~ "&lt;?xml version=\"1.0\"?&gt; \n"
-#~ "&lt;web-app  xmlns=\"http://java.sun.com/xml/ns/\"Whats_new_in_JBoss_4-"
-#~ "J2EE_Certification_and_Standards_Compliance\"\n"
-#~ "          xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" \n"
-#~ "          xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee \n"
-#~ "                              http://java.sun.com/xml/ns/j2ee/web-app_2_4."
-#~ "xsd\" \n"
-#~ "          version=\"2.4\"&gt;\n"
-#~ "    <emphasis role=\"bold\">&lt;distributable/&gt;</emphasis>\n"
-#~ "    &lt;!-- ... --&gt;\n"
-#~ "&lt;/web-app&gt;"
-#~ msgstr ""
-#~ "&lt;?xml version=\"1.0\"?&gt; \n"
-#~ "&lt;web-app  xmlns=\"http://java.sun.com/xml/ns/j2ee\"\n"
-#~ "          xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" \n"
-#~ "          xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee \n"
-#~ "                              http://java.sun.com/xml/ns/j2ee/web-app_2_4."
-#~ "xsd\" \n"
-#~ "          version=\"2.4\"&gt;\n"
-#~ "    <emphasis role=\"bold\">&lt;distributable/&gt;</emphasis>\n"
-#~ "    &lt;!-- ... --&gt;\n"
-#~ "&lt;/web-app&gt;"
-
-#~ msgid ""
-#~ "You can futher configure session replication using the "
-#~ "<literal>replication-config</literal> element in the <literal>jboss-web."
-#~ "xml</literal> file. Here is an example:"
-#~ msgstr ""
-#~ "你可以用 <literal>jboss-web.xml</literal> 文件里的 <literal>replication-"
-#~ "config</literal> 元素进一步配置会话复制。下面是一个例子："
-
-#~ msgid ""
-#~ "&lt;jboss-web&gt;\n"
-#~ "    &lt;replication-config&gt;\n"
-#~ "        &lt;replication-trigger&gt;SET_AND_NON_PRIMITIVE_GET&lt;/"
-#~ "replication-trigger&gt;\n"
-#~ "        &lt;replication-granularity&gt;SESSION&lt;/replication-"
-#~ "granularity&gt;\n"
-#~ "        &lt;replication-field-batch-mode&gt;true&lt;/replication-field-"
-#~ "batch-mode&gt;\n"
-#~ "    &lt;/replication-config&gt;\n"
-#~ "&lt;/jboss-web&gt;"
-#~ msgstr ""
-#~ "&lt;jboss-web&gt;\n"
-#~ "    &lt;replication-config&gt;\n"
-#~ "        &lt;replication-trigger&gt;SET_AND_NON_PRIMITIVE_GET&lt;/"
-#~ "replication-trigger&gt;\n"
-#~ "        &lt;replication-granularity&gt;SESSION&lt;/replication-"
-#~ "granularity&gt;\n"
-#~ "        &lt;replication-field-batch-mode&gt;true&lt;/replication-field-"
-#~ "batch-mode&gt;\n"
-#~ "    &lt;/replication-config&gt;\n"
-#~ "&lt;/jboss-web&gt;"
-
-#~ msgid ""
-#~ "The <literal>replication-trigger</literal> element determines what "
-#~ "triggers a session replication (or when is a session is considered "
-#~ "dirty). It has 4 options:"
-#~ msgstr ""
-#~ "<literal>replication-trigger</literal> 元素决定用什么触发状态复制（或什么"
-#~ "时候会话被认为是 dirty 的）。它有四个选项："
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">SET</emphasis>: With this policy, the session is "
-#~ "considered dirty only when an attribute is set in the session. If your "
-#~ "application always writes changed value back into the session, this "
-#~ "option will be most optimized in term of performance. If an object is "
-#~ "retrieved from the session and modified without being written back into "
-#~ "the session, the change to that object will not be replicated."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">SET</emphasis>：在这个选项下，只有在会话里设置了属"
-#~ "性，会话才被认为是 dirty。如果你的应用程序总把改变的写回到会话里，从性能角"
-#~ "度来讲这个选项可能是最优化的。如果只从会话里取出一个对象而不把它写回到会话"
-#~ "里，对这个对象的修改将不会被复制。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">SET_AND_GET</emphasis>: With this policy, any "
-#~ "attribute that is get or set will be marked as dirty. If an object is "
-#~ "retrieved from the session and modified without being written back into "
-#~ "the session, the change to that object will be replicated. This option "
-#~ "can have significant performance implications."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">SET_AND_GET</emphasis>：如使用这个策略，所有 get "
-#~ "或 set 的属性都会被标记为 ditry。如果从会话里取出一个对象并修改它，但没有"
-#~ "写回到这个会话里，这些修改也将被复制。这个选项对性能有比较大的影响。"
-
-#, 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&#39;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\">ACCESS</emphasis>: This option causes the session "
-#~ "to be marked as dirty whenever it is accessed. Since a the session is "
-#~ "accessed during each HTTP request, it will be replicated with each "
-#~ "request. The access time stamp in the session instance will be updated as "
-#~ "well. Since the time stamp may not be updated in other clustering nodes "
-#~ "because of no replication, the session in other nodes may expire before "
-#~ "the active node if the HTTP request does not retrieve or modify any "
-#~ "session attributes. When this option is set, the session timestamps will "
-#~ "be synchronized throughout the cluster nodes. Note that use of this "
-#~ "option can have a significant performance impact, so use it with caution."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">ACCESS</emphasis>：这个选项表示：只要会话被访问，"
-#~ "就把会话标记为 ditry。因为在每个 HTTP 请求的过程中，会话都会被访问，所以会"
-#~ "话每次都会被复制。会话实例里的时间戳也会相应地更新。由于复制并没有包括时间"
-#~ "戳，其他群集节点的时间戳可能不会被更新。如果 HTTP 请求没有取出或修改任何会"
-#~ "话属性，其他节点的会话就可能会先于活动节点过期。当设置了这个选项，会话的时"
-#~ "间戳将在所有群集节点中同步。注意采用这个选项对性能影响很大，需要小心行事。"
-
-#~ msgid ""
-#~ "The <literal>replication-granularity</literal> element controls the size "
-#~ "of the replication units. The supported values are:"
-#~ msgstr ""
-#~ "<literal>replication-granularity</literal> 元素控制复制单元的大小。它所支"
-#~ "持的值如下："
-
-#~ 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>：复制仅针对于会话属性对象里的数据"
-#~ "字段（后面会有更多内容）。"
-
-#~ msgid ""
-#~ "The <literal>replication-field-batch-mode</literal> element indicates "
-#~ "whether you want to have batch update between each http request or not. "
-#~ "Default is <literal>true</literal>."
-#~ msgstr ""
-#~ "<literal>replication-field-batch-mode</literal> 指出你是否在每个 HTTP 请求"
-#~ "之间进行批量更新。它的缺省值是 <literal>true</literal>。"
-
-#, fuzzy
-#~ msgid ""
-#~ "If your sessions are generally small, SESSION is the better policy. If "
-#~ "your session is larger and some parts are infrequently accessed, "
-#~ "ATTRIBUTE replication will be more effective. If your application has "
-#~ "very big data objects in session attributes and only fields in those "
-#~ "objects are frequently modified, the FIELD policy would be the best. In "
-#~ "the next section, let&#39;s discuss exactly how the FIELD level "
-#~ "replication works."
-#~ msgstr ""
-#~ "如果你的会话通常很小，使用 SESSION 选项是更好的策略。如果你的会话更大些而"
-#~ "且某些部分并不常被访问，ATTRIBUTE 方式的复制就会更有效。如果你的应用程序在"
-#~ "会话属性里拥有非常大的数据对象，而且只有这些对象里的某些字段被经常修改，采"
-#~ "用 FIELD 策略将是最佳选择。在后面的内容里，让我们讨论一下怎样使用 FIELD 级"
-#~ "的复制。"
-
-#~ msgid "Use FIELD level replication"
-#~ msgstr "使用字段级（FIELD level）的复制"
-
-#, fuzzy
-#~ msgid ""
-#~ "FIELD-level replication only replicates modified data fields inside "
-#~ "objects stored in the session. It could potentially drastically reduce "
-#~ "the data traffic between clustered nodes, and hence improve the "
-#~ "performance of the whole cluster. To use FIELD-level replication, you "
-#~ "only need to annotated your POJOs the same way you do for EJB3 beans."
-#~ msgstr ""
-#~ "字段级复制只复制存储在会话里的对象内部的被修改的数据字段。它能够极大地减少"
-#~ "群集节点之间的数据通信，也因此提高了整个群集系统的性能。为了使用字段级复"
-#~ "制，你首先得用 Java 类来指出哪个字段要被复制。它是通过在 JavaDocs 嵌入的 "
-#~ "JDK 1.4 风格的注解（annotations）来完成的。"
-
-#, 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> 注解类时，它所有的子类都将自"
-#~ "动被注解。例如,"
-
-#, fuzzy
-#~ msgid ""
-#~ "@org.jboss.cache.aop.annotation.InstanceOfPojoCacheable\n"
-#~ "public class Person \n"
-#~ "{\n"
-#~ "...\n"
-#~ "}"
-#~ msgstr ""
-#~ "/*\n"
-#~ " *\n"
-#~ " * @@org.jboss.web.tomcat.tc5.session.InstanceOfAopMarker\n"
-#~ " */\n"
-#~ "public class Person \n"
-#~ "{\n"
-#~ "...\n"
-#~ "}"
-
-#~ 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> 的子类，所以它将自动被注解。"
-
-#, fuzzy
-#~ msgid ""
-#~ "You can see a complete example on how to build, deploy, and validate a "
-#~ "FIELD-level replicated web application in JDK 1.4 from this page: "
-#~ "<literal>http://wiki.jboss.org/wiki/Wiki.jsp?"
-#~ "page=Http_session_field_level_example</literal>."
-#~ msgstr ""
-#~ "或者，你也能够在 <literal>http://wiki.jboss.org/wiki/Wiki.jsp?"
-#~ "page=Http_session_field_level_example</literal> 里看到一个怎样构建"
-#~ "（build），部署（deploy），和验证（validate）采用字段级复制的 web 应用程序"
-#~ "的完整例子。这个例子捆绑了 pre- 和 post-compile 工具，所以你不需要再下载单"
-#~ "独的 JBoss AOP 了。"
-
-#~ msgid ""
-#~ "When you deploy the web application into JBoss AS, make sure that the "
-#~ "following configurations are correct:"
-#~ msgstr "当你把 web 应用程序部署到 JBoss AS 时，请确保下面的配置是正确的："
-
-#, fuzzy
-#~ msgid ""
-#~ "In the server&#39;s <literal>deploy/jboss-web-cluster.sar/META-INF/jboss-"
-#~ "service.xml</literal> file, the <literal>inactiveOnStartup</literal> and "
-#~ "<literal>useMarshalling</literal> attributes must both be <literal>true</"
-#~ "literal>."
-#~ msgstr ""
-#~ "在服务器的 <literal>deploy/tc5-cluster.sar/META-INF/jboss-service.xml</"
-#~ "literal> 文件里，<literal>inactiveOnStartup</literal> 和"
-#~ "<literal>useMarshalling</literal> 属性必须都为 <literal>true</literal>。"
-
-#, fuzzy
-#~ msgid ""
-#~ "In the application&#39;s <literal>jboss-web.xml</literal> file, the "
-#~ "<literal>replication-granularity</literal> attribute must be "
-#~ "<literal>FIELD</literal>."
-#~ msgstr ""
-#~ "在应用程序的 <literal>jboss-web.xml</literal> 文件里，"
-#~ "<literal>replication-granularity</literal> 属性必须为 <literal>FIELD</"
-#~ "literal>。"
-
-#, fuzzy
-#~ msgid ""
-#~ "Finally, let&#39;s see an example on how to use FIELD-level replication "
-#~ "on those data classes. Notice that there is no need to call "
-#~ "<literal>session.setAttribute()</literal> after you make changes to the "
-#~ "data object, and all changes to the fields are automatically replicated "
-#~ "across the cluster."
-#~ msgstr ""
-#~ "最后，让我们看一个怎样在哪些数据类上使用字段级（FIELD-level）复制的例子。"
-#~ "请注意你不需要在修改数据对象（data object）后调用 <literal>session."
-#~ "setAttribute（）</literal>，对字段的所有修改都自动跨群集地被复制了。"
-
-#, fuzzy
-#~ msgid ""
-#~ "// Do this only once. So this can be in init(), e.g.\n"
-#~ "if(firstTime)\n"
-#~ "{\n"
-#~ "  Person joe = new Person(\"Joe\", 40);\n"
-#~ "  Person mary = new Person(\"Mary\", 30);\n"
-#~ "  Address addr = new Address();\n"
-#~ "  addr.setZip(94086);\n"
-#~ "\n"
-#~ "  joe.setAddress(addr);\n"
-#~ "  mary.setAddress(addr); // joe and mary share the same address!\n"
-#~ "\n"
-#~ "  session.setAttribute(\"joe\", joe); // that&#39;s it.\n"
-#~ "  session.setAttribute(\"mary\", mary); // that&#39;s it.\n"
-#~ "}\n"
-#~ "\n"
-#~ "Person mary = (Person)session.getAttribute(\"mary\");\n"
-#~ "mary.getAddress().setZip(95123); // this will update and replicate the "
-#~ "zip code."
-#~ msgstr ""
-#~ "// Do this only once. So this can be in init(), e.g.\n"
-#~ "if(firstTime)\n"
-#~ "{\n"
-#~ "  Person joe = new Person(\"Joe\", 40);\n"
-#~ "  Person mary = new Person(\"Mary\", 30);\n"
-#~ "  Address addr = new Address();\n"
-#~ "  addr.setZip(94086);\n"
-#~ "\n"
-#~ "  joe.setAddress(addr);\n"
-#~ "  mary.setAddress(addr); // joe and mary share the same address!\n"
-#~ "\n"
-#~ "  session.setAttribute(\"joe\", joe); // that's it.\n"
-#~ "  session.setAttribute(\"mary\", mary); // that's it.\n"
-#~ "}\n"
-#~ "\n"
-#~ "Person mary = (Person)session.getAttribute(\"mary\");\n"
-#~ "mary.getAddress().setZip(95123); // this will update and replicate the "
-#~ "zip code."
-
-#~ msgid ""
-#~ "Besides plain objects, you can also use regular Java collections of those "
-#~ "objects as session attributes. JBoss cache automatically figures out how "
-#~ "to handle those collections and replicate field changes in their member "
-#~ "objects."
-#~ msgstr ""
-#~ "除了简单的对象（plain objects），你还可以使用那些对象的常规 Java 集合"
-#~ "（Java collection）作为会话属性。JBoss cache 会自动地判断怎样处理这些集合"
-#~ "和复制它们的成员对象里的字段的变更。"
-
-#~ msgid "Monitoring session replication"
-#~ msgstr "监控会话复制"
-
-#~ msgid ""
-#~ "If you have deployed and accessed your application, go to the "
-#~ "<literal>jboss.cache:service=TomcatClusteringCache</literal> MBean and "
-#~ "invoke the <literal>printDetails</literal> operation. You should see "
-#~ "output resembling the following."
-#~ msgstr ""
-#~ "如果你已经部署和访问了你的应用程序，你可以使用 <literal>jboss.cache:"
-#~ "service=TomcatClusteringCache</literal> MBean 和调用 "
-#~ "<literal>printDetails</literal> 操作。你应该看到下面的输出结果。"
-
-#~ msgid ""
-#~ "/JSESSION\n"
-#~ "\n"
-#~ "/quote\n"
-#~ "\n"
-#~ "/FB04767C454BAB3B2E462A27CB571330\n"
-#~ "VERSION: 6\n"
-#~ "FB04767C454BAB3B2E462A27CB571330: org.jboss.invocation."
-#~ "MarshalledValue at 1f13a81c\n"
-#~ "\n"
-#~ "/AxCI8Ovt5VQTfNyYy9Bomw**\n"
-#~ "VERSION: 4\n"
-#~ "AxCI8Ovt5VQTfNyYy9Bomw**: org.jboss.invocation.MarshalledValue at e076e4c8"
-#~ msgstr ""
-#~ "/JSESSION\n"
-#~ "\n"
-#~ "/quote\n"
-#~ "\n"
-#~ "/FB04767C454BAB3B2E462A27CB571330\n"
-#~ "VERSION: 6\n"
-#~ "FB04767C454BAB3B2E462A27CB571330: org.jboss.invocation."
-#~ "MarshalledValue at 1f13a81c\n"
-#~ "\n"
-#~ "/AxCI8Ovt5VQTfNyYy9Bomw**\n"
-#~ "VERSION: 4\n"
-#~ "AxCI8Ovt5VQTfNyYy9Bomw**: org.jboss.invocation.MarshalledValue at e076e4c8"
-
-#, fuzzy
-#~ msgid ""
-#~ "This output shows two separate web sessions, in one application named "
-#~ "<emphasis>quote</emphasis>, that are being shared via JBossCache. This "
-#~ "example uses a <literal>replication-granularity</literal> of "
-#~ "<literal>session</literal>. Had <literal>attribute</literal> level "
-#~ "replication been used, there would be additional entries showing each "
-#~ "replicated session attribute. In either case, the replicated values are "
-#~ "stored in an opaque <literal>MarshelledValue</literal> container. There "
-#~ "aren&#39;t currently any tools that allow you to inspect the contents of "
-#~ "the replicated session values. If you don&#39;t see any output, either "
-#~ "the application was not correctly marked as <literal>distributable</"
-#~ "literal> or you haven&#39;t accessed a part of application that places "
-#~ "values in the HTTP session. The <literal>org.jboss.cache</literal> and "
-#~ "<literal>org.jboss.web</literal> logging categories provide additional "
-#~ "insight into session replication useful for debugging purposes."
-#~ msgstr ""
-#~ "这个输出结果展示了在一个叫 <emphasis>quote</emphasis> 应用程序里的两个独立"
-#~ "的 web 会话，它们通过 JBossCache 来共享。这个例子使用了 <literal>session</"
-#~ "literal> 的 <literal>replication-granularity</literal>。如果使用了 "
-#~ "<literal>attribute</literal> 级的复制，应该可以看到展示每个被复制的会话属"
-#~ "性的其他条目。在两种情况下，被复制的值都存储在一个不透明的 "
-#~ "<literal>MarshelledValue</literal> 容器里。目前还没有任何工具可以让你查看"
-#~ "这些被复制的会话值。如果你没有看到任何输出，要么是应用程序没有正确地标记为"
-#~ "<literal>distributable</literal>，要么就是你根本没有访问把值写入 HTTP 会话"
-#~ "的应用程序。<literal>org.jboss.cache</literal> 和  <literal>org.jboss."
-#~ "web</literal> 日志类别提供了可用于调试目的对会话复制的其他视角。"
-
-#~ msgid "Using Single Sign On"
-#~ msgstr "使用单点登录（Single Sign On）"
-
-#, fuzzy
-#~ msgid ""
-#~ "JBoss supports clustered single sign-on, allowing a user to authenticate "
-#~ "to one application on a JBoss server and to be recognized on all "
-#~ "applications, on that same machine or on another node in the cluster, "
-#~ "that are deployed on the same virtual host. Authentication replication is "
-#~ "handled by the HTTP session replication service. Although session "
-#~ "replication does not need to be explicitly enabled for the applications "
-#~ "in question, the <literal>jboss-web-cluster.sar</literal> application "
-#~ "does need to be deployed (e.g., in the <varname>all</varname> "
-#~ "configuration)."
-#~ msgstr ""
-#~ "JBoss 支持群集的单点登录（single sign-on），允许用户在一个 JBoss 服务器上"
-#~ "验证应用程序，然后被在同一个主机或群集里的其他节点里的被部署在同一个虚拟主"
-#~ "机上的所有应用程序识别。HTTP 会话复制服务处理复制验证（Authentication "
-#~ "replication）。虽然会话复制不需要显性地为这个应用程序启用，但 "
-#~ "<literal>tc5-cluster-service.xml</literal> 文件必须被部署。 "
-
-#~ msgid ""
-#~ "To enable single sign-on, you must add the "
-#~ "<literal>ClusteredSingleSignOn</literal> valve to the appropriate "
-#~ "<literal>Host</literal> elements of the tomcat <literal>server.xml</"
-#~ "literal> file. The valve configuration is shown here:"
-#~ msgstr ""
-#~ "为了启用单点登录，你必须在 <literal>server.xml</literal> 文件的 "
-#~ "<literal>Host</literal> 元素里加入 <literal>ClusteredSingleSignOn</"
-#~ "literal> 开关（valve）。这个开关（valve）的配置如下："
-
-#, fuzzy
-#~ msgid ""
-#~ "&lt;Valve className=\"org.jboss.web.tomcat.service.sso."
-#~ "ClusteredSingleSignOn\" /&gt;"
-#~ msgstr ""
-#~ "&lt;Valve className=\"org.jboss.web.tomcat.tc5.sso.ClusteredSingleSignOn"
-#~ "\" /&gt;"
-
-#~ 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 ""
-#~ "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> 目录里然后启"
-#~ "动服务器，这个应用不会被检测到且运用到群集里。我们正在努力解决这个问题。"
-
-#~ msgid ""
-#~ "/*\n"
-#~ " * My usual comments here first.\n"
-#~ " * @@org.jboss.web.tomcat.tc5.session.AopMarker\n"
-#~ " */\n"
-#~ "public class Address \n"
-#~ "{\n"
-#~ "...\n"
-#~ "}"
-#~ msgstr ""
-#~ "/*\n"
-#~ " * My usual comments here first.\n"
-#~ " * @@org.jboss.web.tomcat.tc5.session.AopMarker\n"
-#~ " */\n"
-#~ "public class Address \n"
-#~ "{\n"
-#~ "...\n"
-#~ "}"
-
-#~ msgid ""
-#~ "However, since we only support JDK 1.4 style annotation (provided by "
-#~ "JBoss Aop) now, you will need to perform a pre-processing step. You need "
-#~ "to use the JBoss AOP pre-compiler <literal>annotationc</literal> and post-"
-#~ "compiler <literal>aopc</literal> to process the above source code before "
-#~ "and after they are compiled by the Java compiler. Here is an example on "
-#~ "how to invoke those commands from command line."
-#~ msgstr ""
-#~ "然而，既然目前我们只支持 JDK 1.4 风格的注解（由 JBoss Aop 提供），你将需要"
-#~ "执行一个预处理步骤。在 Java 编译器编译之前和之后，你需要用 JBoss AOP pre-"
-#~ "compiler <literal>annotationc</literal> 和 post-compiler <literal>aopc</"
-#~ "literal> 来处理上面的源码。这里是一个怎样从命令行调用这些命令的例子。"
-
-#~ msgid ""
-#~ "$ annotationc [classpath] [source files or directories]\n"
-#~ "$ javac -cp [classpath] [source files or directories]\n"
-#~ "$ aopc [classpath] [class files or directories]"
-#~ msgstr ""
-#~ "$ annotationc [classpath] [source files or directories]\n"
-#~ "$ javac -cp [classpath] [source files or directories]\n"
-#~ "$ aopc [classpath] [class files or directories]"
-
-#~ msgid ""
-#~ "Please see the JBoss AOP documentation for the usage of the pre- and post-"
-#~ "compiler. The JBoss AOP project also provides easy to use ANT tasks to "
-#~ "help integrate those steps into your application build process. In the "
-#~ "next AS release, JDK 5.0 annotation support will be provided for greater "
-#~ "transparency. But for now, it is important that you perform the pre- and "
-#~ "post-compilation steps for your source code."
-#~ msgstr ""
-#~ "请参考 JBoss AOP 文档关于怎样使用 pre- 和 post-compiler。JBoss AOP 项目也"
-#~ "提供使用 ANT 来把上述步骤集成在应用程序的 build 过程中的简单方法。下一个 "
-#~ "AS 发布版本将提供对 JDK 5.0 注解的更透明的支持。但是现在，你还得用 pre- "
-#~ "和 post-compiler 来编译你的源码。"

More information about the jboss-cvs-commits mailing list