[jboss-cvs] JBossAS SVN: r73072 - projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Tue May 6 03:10:30 EDT 2008
Author: xhuang at jboss.com
Date: 2008-05-06 03:10:30 -0400 (Tue, 06 May 2008)
New Revision: 73072
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/The_CMP_Engine.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-06 06:16:41 UTC (rev 73071)
+++ projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/Clustering_Guide_Intro.po 2008-05-06 07:10:30 UTC (rev 73072)
@@ -1,18 +1,21 @@
+# translation of Clustering_Guide_Intro.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_Intro\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-06 17:09+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_Intro.xml:5
@@ -34,7 +37,7 @@
#. Tag: para
#: Clustering_Guide_Intro.xml:10
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"Clustering allows us to run an application on several parallel servers (a.k."
"a cluster nodes) while providing a single view to application clients. Load "
@@ -46,10 +49,9 @@
"the clustering infrastructure that supports the redundancy needed for high "
"availability."
msgstr ""
-"群集系统（Clustering）允许我们在多台平行的服务器（群集节点）上运行一个应用程"
-"序。负载分布在不同的服务器上，即使其中任何一台崩溃，应用程序还是可以在其他群"
-"集节点（cluster nodes）上运行。群集对于可扩展性企业级应用程序是很关键的，因为"
-"你简单地把更多节点加入到群集系统里就可以提高性能。"
+"群集系统（Clustering）允许我们在多台平行的服务器（cluster node，群集节点）上运行一个应用程"
+"序，且为客户提供一个单一的视图。负载分布在不同的服务器上，即使其中任何一台崩溃，应用程序还是可以在其他群集节点上运行。群集对于可扩展性企业级应用程序是很关键的，因为"
+"你简单地把更多节点加入到群集系统里就可以提高性能。群集系统对于高可用性企业级应用程序也是很关键的，群集架构支持高可用性所需的冗余。"
#. Tag: para
#: Clustering_Guide_Intro.xml:14
@@ -69,7 +71,7 @@
#. Tag: para
#: Clustering_Guide_Intro.xml:17
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"In the first section of this chapter, we discuss basic concepts behind "
"JBoss's clustering services. It is important that you understand these "
@@ -89,6 +91,7 @@
#. 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 "
@@ -106,7 +109,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 ""
+msgstr "群集由一系列节点组成，它们相互通信并实现一个共同的目标。在 JBoss 应用服务器群集（也称为“partition”）里，节点是一个 JBoss 应用服务器实例。节点之间的通信由 JGroups 组通信库进行处理，而 JGroups Channel 提供核心功能"
#. Tag: para
#: Clustering_Guide_Intro.xml:29
@@ -917,3644 +920,3 @@
"next several sections.."
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 ""
-#~ "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 配置，每个节点可以根据它所需要加"
-#~ "入的群集来选择其中一个配置。如果节点启动的时候，它指定的群集不存在，这个群"
-#~ "集将被创建。相同地，当群集系统的所有节点都被删除后，这个群集也将被删除。"
-
-#, 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 ""
-#~ "A cluster (partition) contains a set of nodes that work toward a same "
-#~ "goal. Some clustering features require to sub-partition the cluster to "
-#~ "achieve a better scalability. For example, let's imagine that we have "
-#~ "a 10-node cluster and we want to replicate in memory the state of "
-#~ "stateful session beans on all 10 different nodes to provide for fault-"
-#~ "tolerant behaviour. It would mean that each node has to store a backup of "
-#~ "the 9 other nodes. This would not scale at all (each node would need to "
-#~ "carry the whole state cluster load). It is probably much better to have "
-#~ "some kind of sub-partitions inside a cluster and have beans state "
-#~ "exchanged only between nodes that are part of the same sub-partition. The "
-#~ "future JBoss clustering implementation will support sub-partitions and it "
-#~ "will allow the cluster administrator to determine the optimal size of a "
-#~ "sub-partition. The sub-partition topology computation will be done "
-#~ "dynamically by the cluster."
-#~ msgstr ""
-#~ "群集系统（partition）包含了实现同一目标的节点。某些群集特征需要用群集的子"
-#~ "分区（sub-partition）来实现更好的扩展性。例如，假设有一个 10 个节点的群"
-#~ "集，我们想把所有 10 个不同的节点上的 stateful session beans 的状态复制在内"
-#~ "存里来提供容错行为。这意味着每个节点都存有其他 9 个节点的备份。其实这根本"
-#~ "就不能扩展（因为每个节点都承担了整个群集负载）。在这个情况下，使用群集里的"
-#~ "某种子分区（sub-partition），只在同一子分区内的节点之间交换 beans 状态可能"
-#~ "会更好。以后的 JBoss 群集实现将支持子分区，允许群集管理者来决定子分区的最"
-#~ "佳规模。子分区的拓扑计算将由群集系统动态地完成。"
-
-#, 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 "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 "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 里的一样。"
-
-#, 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 ""
-#~ "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 ""
-#~ "<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 "Clustered JNDI Services"
-#~ msgstr "群集的 JNDI 服务"
-
-#~ msgid ""
-#~ "JNDI is one of the most important services provided by the application "
-#~ "server. The JBoss clustered JNDI service is based on the client-side "
-#~ "interceptor architecture. The client must obtain a JNDI stub object (via "
-#~ "the <literal>InitialContext</literal> object) and invoke JNDI lookup "
-#~ "services on the remote server through the stub. Furthermore, JNDI is the "
-#~ "basis for many other interceptor-based clustering services: those "
-#~ "services register themselves with the JNDI so that the client can lookup "
-#~ "their stubs and make use of their services."
-#~ msgstr ""
-#~ "JNDI 是应用服务器提供的最重要的服务之一。JBoss 的群集 JNDI 服务基于客户端"
-#~ "拦截器架构。客户必须获得一个 JNDI 占位对象（stub object）（通过"
-#~ "<literal>InitialContext</literal>对象）和通过 stub 在远程服务器上调用 "
-#~ "JNDI 查找服务。而且，JNDI 是许多其他基于拦截器的群集服务的基础：这些服务"
-#~ "在 JNDI 上注册，客户就可以查找它们的 stubs 并使用它们的服务。"
-
-#~ msgid "How it works"
-#~ msgstr "它怎样工作"
-
-#~ msgid ""
-#~ "The JBoss HA-JNDI (High Availability JNDI) service maintains a cluster-"
-#~ "wide context tree. The cluster wide tree is always available as long as "
-#~ "there is one node left in the cluster. Each JNDI node in the cluster also "
-#~ "maintains its own local JNDI context. The server side application can "
-#~ "bind its objects to either trees. In this section, you will learn the "
-#~ "distinctions of the two trees and the best practices in application "
-#~ "development. The design rational of this architecture is as follows."
-#~ msgstr ""
-#~ "JBoss HA-JNDI （高可用性 JNDI）服务维护了一个跨群集的上下文树（context "
-#~ "tree）。只要群集里有一个节点，这个树就会存在。群集里的每个 JNDI 节点也维护"
-#~ "子集的本地 JNDI 上下文。服务器端的应用程序可以把它的对象绑定在两者中的任意"
-#~ "一个上。在本部分内容里，你将学习怎样区分这两种树和在应用部署时的最佳做法。"
-#~ "这个架构的合理设计如下："
-
-#, fuzzy
-#~ msgid ""
-#~ "We didn't want any migration issues with applications already "
-#~ "assuming that their JNDI implementation was local. We wanted clustering "
-#~ "to work out-of-the-box with just a few tweaks of configuration files."
-#~ msgstr ""
-#~ "我们不希望在本地实现 JNDI 的应用程序有任何的移植问题。我们希望通过简单的配"
-#~ "置群集系统就可以正常工作。"
-
-#~ msgid ""
-#~ "We needed a clean distinction between locally bound objects and cluster-"
-#~ "wide objects."
-#~ msgstr "我们需要清晰地区分本地绑定的对象和跨群集的对象。"
-
-#~ msgid ""
-#~ "In a homogeneous cluster, this configuration actually cuts down on the "
-#~ "amount of network traffic."
-#~ msgstr "在同样的群集里，这个配置实际上降低了网络的负载。"
-
-#~ msgid ""
-#~ "Designing it in this way makes the HA-JNDI service an optional service "
-#~ "since all underlying cluster code uses a straight new "
-#~ "<literal>InitialContext()</literal> to lookup or create bindings."
-#~ msgstr ""
-#~ "既然所有下面的群集节点都使用一个新的 <literal>InitialContext()</literal> "
-#~ "来查找或创建绑定，用这个方法来设计可以使 HA-JNDI 服务成为一种可选的服务。"
-
-#~ msgid ""
-#~ "On the server side, <literal>new InitialContext()</literal>, will be "
-#~ "bound to a local-only, non-cluster-wide JNDI Context (this is actually "
-#~ "basic JNDI). So, all EJB homes and such will not be bound to the cluster-"
-#~ "wide JNDI Context, but rather, each home will be bound into the local "
-#~ "JNDI. When a remote client does a lookup through HA-JNDI, HA-JNDI will "
-#~ "delegate to the local JNDI Context when it cannot find the object within "
-#~ "the global cluster-wide Context. The detailed lookup rule is as follows."
-#~ msgstr ""
-#~ "在服务器端，<literal>new InitialContext()</literal> 将会绑定到一个仅用于本"
-#~ "地的，非跨群集的 JNDI 上下文（实际上是基本 JNDI）。因此，所有 EJB 主接口"
-#~ "（homes）都不会绑定到跨群集的 JNDI 上下文。但是，每个主接口都会绑定到本地 "
-#~ "JNDI 上。当远程的客户通过 HA-JNDI 发起一个查找，HA-JNDI 在全局跨群集上下文"
-#~ "找不到这个对象时会委托给本地 JNDI 上下文。详细的查找规则如下所示。"
-
-#~ msgid ""
-#~ "If the binding is available in the cluster-wide JNDI tree and it returns "
-#~ "it."
-#~ msgstr "如果这个绑定在跨群集的 JNDI 树（JNDI tree）里可用。"
-
-#~ msgid ""
-#~ "If the binding is not in the cluster-wide tree, it delegates the lookup "
-#~ "query to the local JNDI service and returns the received answer if "
-#~ "available."
-#~ msgstr ""
-#~ "如果这个绑定不在跨群集的树里，它会把查找请求委托给本地 JNDI 服务并返回可用"
-#~ "的结果。"
-
-#~ msgid ""
-#~ "If not available, the HA-JNDI services asks all other nodes in the "
-#~ "cluster if their local JNDI service owns such a binding and returns the "
-#~ "an answer from the set it receives."
-#~ msgstr ""
-#~ "如果没有可用的结果，HA-JNDI 服务会查找其他群集里的节点，如果它们的本地 "
-#~ "JNDI 服务拥有这样的绑定，就会返回相应的结果。"
-
-#~ msgid ""
-#~ "If no local JNDI service owns such a binding, a "
-#~ "<literal>NameNotFoundException</literal> is finally raised."
-#~ msgstr ""
-#~ "如果没有任何本地 JNDI 服务有这样的一个绑定，最后会产生 "
-#~ "<literal>NameNotFoundException</literal> 异常。"
-
-#~ msgid ""
-#~ "So, an EJB home lookup through HA-JNDI, will always be delegated to the "
-#~ "local JNDI instance. If different beans (even of the same type, but "
-#~ "participating in different clusters) use the same JNDI name, it means "
-#~ "that each JNDI server will have a different \"target\" bound (JNDI on "
-#~ "node 1 will have a binding for bean A and JNDI on node 2 will have a "
-#~ "binding, under the same name, for bean B). Consequently, if a client "
-#~ "performs a HA-JNDI query for this name, the query will be invoked on any "
-#~ "JNDI server of the cluster and will return the locally bound stub. "
-#~ "Nevertheless, it may not be the correct stub that the client is expecting "
-#~ "to receive!"
-#~ msgstr ""
-#~ "所以，当 EJB home 通过 HA-JNDI 查找，总会委托给本地 JNDI 实例。如果不同的 "
-#~ "beans（即使是相同的类型,但在不同的群集里）使用同一个 JNDI 名称，这意味着每"
-#~ "个 JNDI 服务器将会有一个不同的 \"target\" 绑定（节点 1 上的 JNDI 将有一个"
-#~ "用于 bean A 的绑定,节点 2 会有一个用于 bean B 的相同名字的绑定）。因此，如"
-#~ "果客户为这个名字执行 HA-JNDI 查询，这个查询会在群集里的任何 JNDI 服务器上"
-#~ "调用并返回本地绑定的 stub。而且，它未必是客户所希望的正确的 stub!"
-
-#~ msgid ""
-#~ "You cannot currently use a non-JNP JNDI implementation (i.e. LDAP) for "
-#~ "your local JNDI implementation if you want to use HA-JNDI. However, you "
-#~ "can use JNDI federation using the <literal>ExternalContext</literal> "
-#~ "MBean to bind non-JBoss JNDI trees into the JBoss JNDI namespace. "
-#~ "Furthermore, nothing prevents you though of using one centralized JNDI "
-#~ "server for your whole cluster and scrapping HA-JNDI and JNP."
-#~ msgstr ""
-#~ "如果你想使用 HA-JNDI，你不能有一个用于本地 JNDI 实现的 non-JNP JNDI 实现"
-#~ "（如：LDAP）。然而，你可以用 <literal>ExternalContext</literal> MBean 来运"
-#~ "用 JNDI 联合把非 JBoss JNDI trees 绑定到 JBoss JNDI 命名空间里。而且，你也"
-#~ "可以对整个群集使用集中式的 JNDI 服务器，而不用 HA-JNDI 和 JNP。"
-
-#~ msgid ""
-#~ "If a binding is only made available on a few nodes in the cluster (for "
-#~ "example because a bean is only deployed on a small subset of nodes in the "
-#~ "cluster), the probability to lookup a HA-JNDI server that does not own "
-#~ "this binding is higher and the lookup will need to be forwarded to all "
-#~ "nodes in the cluster. Consequently, the query time will be longer than if "
-#~ "the binding would have been available locally. Moral of the story: as "
-#~ "much as possible, cache the result of your JNDI queries in your client."
-#~ msgstr ""
-#~ "如果绑定只在群集（例如，bean 只在群集里某一小的子集里部署）里的一些节点上"
-#~ "可用，查找没有这个绑定 HA-JNDI 服务器的可能性就增高了，而且需要将查找转发"
-#~ "给群集里的所有节点。因此，查询时间会比这个绑定在本地可用的情况更长。这就告"
-#~ "诉我们：尽可能地在客户端缓存你的 JNDI 查询结果。"
-
-#~ msgid ""
-#~ "If you want to access HA-JNDI from the server side, you must explicitly "
-#~ "get an <literal>InitialContext</literal> by passing in JNDI properties. "
-#~ "The following code shows how to access the HA-JNDI."
-#~ msgstr ""
-#~ "如果你要从服务器端访问 HA-JNDI，你必须传入 JNDI 属性来显性地得到 "
-#~ "<literal>InitialContext</literal>。下面的代码展示了怎样访问 HA-JNDI。"
-
-#~ msgid ""
-#~ "Properties p = new Properties(); \n"
-#~ "p.put(Context.INITIAL_CONTEXT_FACTORY, \n"
-#~ " \"org.jnp.interfaces.NamingContextFactory\"); \n"
-#~ "p.put(Context.URL_PKG_PREFIXES, \"jboss.naming:org.jnp.interfaces\"); \n"
-#~ "p.put(Context.PROVIDER_URL, \"localhost:1100\"); // HA-JNDI port. \n"
-#~ "return new InitialContext(p);"
-#~ msgstr ""
-#~ "Properties p = new Properties(); \n"
-#~ "p.put(Context.INITIAL_CONTEXT_FACTORY, \n"
-#~ " \"org.jnp.interfaces.NamingContextFactory\"); \n"
-#~ "p.put(Context.URL_PKG_PREFIXES, \"jboss.naming:org.jnp.interfaces\"); \n"
-#~ "p.put(Context.PROVIDER_URL, \"localhost:1100\"); // HA-JNDI port. \n"
-#~ "return new InitialContext(p);"
-
-#, fuzzy
-#~ msgid ""
-#~ "The <literal>Context.PROVIDER_URL</literal> property points to the HA-"
-#~ "JNDI service configured in the <literal>HANamingService</literal> MBean "
-#~ "(see <xref linkend=\"Clustered_JNDI_Services-JBoss_configuration\"/>)."
-#~ msgstr ""
-#~ "<literal>Context.PROVIDER_URL</literal> 属性指向 "
-#~ "<literal>HANamingService</literal> MBean （参看 <xref linkend="
-#~ "\"clustering-jndi-jboss\"/>）里配置的 HA-JNDI 服务。"
-
-#~ msgid "Client configuration"
-#~ msgstr "客户端配置"
-
-#, fuzzy
-#~ msgid ""
-#~ "The JNDI client needs to be aware of the HA-JNDI cluster. You can pass a "
-#~ "list of JNDI servers (i.e., the nodes in the HA-JNDI cluster) to the "
-#~ "<literal>java.naming.provider.url</literal> JNDI setting in the "
-#~ "<literal>jndi.properties</literal> file. Each server node is identified "
-#~ "by its IP address and the JNDI port number. The server nodes are "
-#~ "separated by commas (see <xref linkend=\"Clustered_JNDI_Services-"
-#~ "JBoss_configuration\"/> on how to configure the servers and ports)."
-#~ msgstr ""
-#~ "JNDI 客户需要意识到 HA-JNDI 的群集方式。你可以把 JNDI 服务器的列表（HA-"
-#~ "JNDI群集里的节点）写入到 <literal>jndi.properties</literal> 文件里的 "
-#~ "<literal>java.naming.provider.url</literal> 设置里。每个服务器节点都用它"
-#~ "的 IP 地址和 JNDI 端口号码来识别。服务器节点用逗号来隔开（关于怎么配置服务"
-#~ "器和端口，请参看 <xref linkend=\"clustering-jndi-jboss\"/> ）。"
-
-#~ msgid ""
-#~ "java.naming.provier.url=server1:1100,server2:1100,server3:1100,"
-#~ "server4:1100"
-#~ msgstr ""
-#~ "java.naming.provier.url=server1:1100,server2:1100,server3:1100,"
-#~ "server4:1100"
-
-#~ msgid ""
-#~ "When initialising, the JNP client code will try to get in touch with each "
-#~ "server node from the list, one after the other, stopping as soon as one "
-#~ "server has been reached. It will then download the HA-JNDI stub from this "
-#~ "node."
-#~ msgstr ""
-#~ "初始化时，JNP 客户代码会试图连接列表里的每个服务器，一个接一个，只要连接到"
-#~ "一个服务器它就会停止尝试。然后它将从这个节点下载 HA-JNDI stub。"
-
-#~ msgid ""
-#~ "There is no load balancing behavior in the JNP client lookup process. It "
-#~ "just goes through the provider list and use the first available server. "
-#~ "The HA-JNDI provider list only needs to contain a subset of HA-JNDI nodes "
-#~ "in the cluster."
-#~ msgstr ""
-#~ "JNP 客户的查找过程中没有用到负载平衡。它只是遍历这个列表来使用第一个可用的"
-#~ "服务器。HA-JNDI 提供者列表只需要包含群集里的 HA-JNDI 节点的一个子集。"
-
-#~ msgid ""
-#~ "The downloaded smart stub contains the logic to fail-over to another node "
-#~ "if necessary and the updated list of currently running nodes. "
-#~ "Furthermore, each time a JNDI invocation is made to the server, the list "
-#~ "of targets in the stub interceptor is updated (only if the list has "
-#~ "changed since the last call)."
-#~ msgstr ""
-#~ "下载的 smart stub 包含了必要时失效切换（fail-over）至另一节点的逻辑和更新"
-#~ "的当前运行节点的列表。而且，每次对服务器执行 JNDI 调用后，stub "
-#~ "interceptor 里的目标节点列表都会被更新（只有在上次调用后又有修改的情况下）"
-
-#, fuzzy
-#~ msgid ""
-#~ "If the property string <literal>java.naming.provider.url</literal> is "
-#~ "empty or if all servers it mentions are not reachable, the JNP client "
-#~ "will try to discover a bootstrap HA-JNDI server through a multicast call "
-#~ "on the network (auto-discovery). See <xref linkend="
-#~ "\"Clustered_JNDI_Services-JBoss_configuration\"/> on how to configure "
-#~ "auto-discovery on the JNDI server nodes. Through auto-discovery, the "
-#~ "client might be able to get a valid HA-JNDI server node without any "
-#~ "configuration. Of course, for the auto-discovery to work, the client must "
-#~ "reside in the same LAN as the server cluster (e.g., the web servlets "
-#~ "using the EJB servers). The LAN or WAN must also be configured to "
-#~ "propagate such multicast datagrams."
-#~ msgstr ""
-#~ "如果属性字符串 <literal>java.naming.provider.url</literal> 是空或者它标明"
-#~ "的所有服务器是不可到达的，JNP client 会试图通过网络上的多点传送"
-#~ "（multicast）调用来恢复 HA-JNDI 服务器。请参考 <xref linkend=\"clustering-"
-#~ "jndi-jboss\"/>关于怎样在 JNDI 服务器节点上配置自动恢复（auto-discovery）的"
-#~ "内容。通过自动恢复，客户端不需要任何配置就可以获得一个有效的 HA-JNDI 服务"
-#~ "器节点。当然，为了自动恢复能够工作，客户应用程序必须和服务器节点（使用 "
-#~ "EJB 服务器的 web servlets）在同一局域网里。局域网和广域网也必须配置成可以"
-#~ "传送这样的多点传送数据包。"
-
-#~ msgid ""
-#~ "The auto-discovery feature uses multicast group address 230.0.0.4:1102."
-#~ msgstr "自动恢复（auto-discovery）特征使用多点传送组地址 230.0.0.4:1102。"
-
-#~ msgid ""
-#~ "In addition to the <literal>java.naming.provier.url</literal> property, "
-#~ "you can specify a set of other properties. The following list shows all "
-#~ "client side properties you can specify, when creating a new "
-#~ "<literal>InitialContext</literal>."
-#~ msgstr ""
-#~ "除 <literal>java.naming.provier.url</literal> 属性以外，你还可以指定一系列"
-#~ "其他属性。下面的列表展示了当建立一个新的 <literal>InitialContext</"
-#~ "literal> 时，你可以指定的所有客户端属性。"
-
-#~ msgid ""
-#~ "<literal>java.naming.provier.url</literal>: Provides a list of IP "
-#~ "addresses and port numbers for HA-JNDI provider nodes in the cluster. The "
-#~ "client tries those providers one by one and uses the first one that "
-#~ "responds."
-#~ msgstr ""
-#~ "<literal>java.naming.provier.url</literal>：提供群集里 HA-JNDI 提供者节点"
-#~ "的 IP 地址和端口号的列表。客户端会尝试这些提供者并使用第一个响应的服务器。"
-
-#~ msgid ""
-#~ "<literal>jnp.disableDiscovery</literal>: When set to <literal>true</"
-#~ "literal>, this property disables the automatic discovery feature. Default "
-#~ "is <literal>false</literal>."
-#~ msgstr ""
-#~ "<literal>jnp.disableDiscovery</literal>：当设置为 <literal>true</literal> "
-#~ "时，这个属性关闭了自动恢复（automatic discovery）特征。它的缺省值是 "
-#~ "<literal>false</literal>。"
-
-#~ msgid ""
-#~ "<literal>jnp.partitionName</literal>: In an environment where multiple HA-"
-#~ "JNDI services, which are bound to distinct clusters (i.e., partitions), "
-#~ "are started, this property allows you to configure which cluster you "
-#~ "broadcast to when the automatic discovery feature is used. If you do not "
-#~ "use the automatic discovery feature (e.g., you could explicitly provide a "
-#~ "list of valid JNDI nodes in <literal>java.naming.provider.url</literal>), "
-#~ "this property is not used. By default, this property is not set and the "
-#~ "automatic discovery select the first HA-JNDI server that responds, "
-#~ "independently of the cluster partition name."
-#~ msgstr ""
-#~ "<literal>jnp.partitionName</literal>：在有多个绑定在不同的群集系统的 HA-"
-#~ "JNDI 服务的环境里，这个属性允许你配置当使用自动恢复（automatic discovery）"
-#~ "特征时广播至哪个群集。如果你没有使用自动恢复特征（就是说你可在以在 "
-#~ "<literal>java.naming.provider.url</literal> 里显性地提供有效的 JNDI 节点的"
-#~ "列表），这个属性就不会被使用。在缺省情况下，这个属性不会被设置，自动恢复选"
-#~ "择第一个响应的 HA-JNDI 服务器，而不管在哪个群集系统里。"
-
-#~ msgid ""
-#~ "<literal>jnp.discoveryTimeout</literal>: Determines how much time the "
-#~ "context will wait for a response to its automatic discovery packet. "
-#~ "Default is 5000 ms."
-#~ msgstr ""
-#~ "<literal>jnp.discoveryTimeout</literal>：决定上下文（context）等待对它的自"
-#~ "动恢复数据包应答的的时间，它的缺省值是 5000 毫秒。"
-
-#~ msgid ""
-#~ "<literal>jnp.discoveryGroup</literal>: Determines which multicast group "
-#~ "address is used for the automatic discovery. Default is "
-#~ "<literal>230.0.0.4</literal>."
-#~ msgstr ""
-#~ "<literal>jnp.discoveryGroup</literal>：决定用于自动恢复的多点传送组地址。"
-#~ "它的缺省值是 <literal>230.0.0.4</literal>。"
-
-#~ msgid ""
-#~ "<literal>jnp.discoveryPort</literal>: Determines which multicast group "
-#~ "port is used for the automatic discovery. Default is <literal>1102</"
-#~ "literal>."
-#~ msgstr ""
-#~ "<literal>jnp.discoveryPort</literal>：决定用于自动恢复的多点传送组端口。它"
-#~ "的缺省值是 <literal>1102</literal>。"
-
-#~ msgid "JBoss configuration"
-#~ msgstr "JBoss 配置"
-
-#~ msgid ""
-#~ "The <literal>cluster-service.xml</literal> file in the <literal>all/"
-#~ "deploy</literal> directory includes the following MBean to enable HA-JNDI "
-#~ "services."
-#~ msgstr ""
-#~ "<literal>all/deploy</literal> 目录下的 <literal>cluster-service.xml</"
-#~ "literal> 文件包括了下列启用 HA-JNDI 服务的 MBean。"
-
-#~ msgid ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>jboss:service=DefaultPartition</depends> \n"
-#~ "</mbean>"
-#~ msgstr ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>jboss:service=DefaultPartition</depends> \n"
-#~ "</mbean>"
-
-#~ msgid ""
-#~ "You can see that this MBean depends on the <literal>DefaultPartition</"
-#~ "literal> MBean defined above it (discussed in an earlier section in this "
-#~ "chapter). In other configurations, you can put that element in the "
-#~ "<literal>jboss-services.xml</literal> file or any other JBoss "
-#~ "configuration files in the <literal>/deploy</literal> directory to enable "
-#~ "HA-JNDI services. The available attributes for this MBean are listed "
-#~ "below."
-#~ msgstr ""
-#~ "你可以看到这个 MBean 依赖于在它之上定义的 <literal>DefaultPartition</"
-#~ "literal> MBean（在本章之前的部分曾讨论过）。在其他配置里，你可以把那个元素"
-#~ "（element）放在 <literal>jboss-services.xml</literal> 或者 <literal>/"
-#~ "deploy</literal> 目录下的其他 JBoss 配置文件里来启用 HA-JNDI 服务。这个 "
-#~ "MBean 的可用属性如下所示。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> is an optional attribute "
-#~ "to specify the name of the cluster for the different nodes of the HA-JNDI "
-#~ "service to communicate. The default value is <literal>DefaultPartition</"
-#~ "literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> 是一个可选的属性，它指定"
-#~ "与 HA-JNDI 服务通讯的不同节点的群集的名字。它的缺省值是 "
-#~ "<literal>DefaultPartition</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">BindAddress</emphasis> is an optional attribute "
-#~ "to specify the address to which the HA-JNDI server will bind waiting for "
-#~ "JNP clients. Only useful for multi-homed computers."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">BindAddress</emphasis> 是一个可选属性，它指定 HA-"
-#~ "JNDI 服务器绑定的等待 JNP 客户连接的地址。它只对多宿主主机（multi-homed "
-#~ "computers）有用。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">Port</emphasis> is an optional attribute to "
-#~ "specify the port to which the HA-JNDI server will bind waiting for JNP "
-#~ "clients. The default value is <literal>1100</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">Port</emphasis> 是一个可选属性，它指定 HA-JNDI 服"
-#~ "务器等待 JNP 客户连接所绑定的端口。它的缺省值是 <literal>1100</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">Backlog</emphasis> is an optional attribute to "
-#~ "specify the backlog value used for the TCP server socket waiting for JNP "
-#~ "clients. The default value is <literal>50</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">Backlog</emphasis> 是一个可选属性，它指定 TCP 服务"
-#~ "器套接字等待 JNP 客户所使用的 backlog 值。它的缺省值是 <literal>50</"
-#~ "literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">RmiPort</emphasis> determines which port the "
-#~ "server should use to communicate with the downloaded stub. This attribute "
-#~ "is optional. If it is missing, the server automatically assigns a RMI "
-#~ "port."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">RmiPort</emphasis> 决定服务器应与下载的 stub 通信"
-#~ "所用的端口。这个属性是可选的。如果它没有设置，服务器会自动分配一个 RMI 端"
-#~ "口。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryAddress</emphasis> is an optional "
-#~ "attribute to specify the multicast address to listen to for JNDI "
-#~ "automatic discovery. The default value is <literal>230.0.0.4</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryAddress</emphasis> 是一个可选属性，它"
-#~ "指定侦听的用于 JNDI 自动恢复的多点传送地址。它的缺省值是 "
-#~ "<literal>230.0.0.4</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryGroup</emphasis> is an optional "
-#~ "attribute to specify the multicast group to listen to for JNDI automatic "
-#~ "discovery.. The default value is <literal>1102</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryGroup</emphasis> 是一个可选属性，它指"
-#~ "定侦听的用于 JNDI 自动恢复的多点传送组。它的缺省值是 <literal>1102</"
-#~ "literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">LookupPool</emphasis> specifies the thread pool "
-#~ "service used to control the bootstrap and auto discovery lookups."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">LookupPool</emphasis> 指定用于控制引导程序和自动恢"
-#~ "复查找的线程池服务。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">DiscoveryDisabled</emphasis> is a boolean flag "
-#~ "that disables configuration of the auto discovery multicast listener."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">DiscoveryDisabled</emphasis> 是一个布尔值标记，它"
-#~ "可用来取消自动恢复多点传送侦听者（multicast listener）的配置。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryBindAddress</emphasis> sets the auto-"
-#~ "discovery bootstrap multicast bind address. If this attribute is not "
-#~ "specified and a <literal>BindAddress</literal> is specified, the "
-#~ "<literal>BindAddress</literal> will be used.."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryBindAddress</emphasis> 设置自动恢复引"
-#~ "导程序绑定的地址。如果这个属性没有指定而设置了 <literal>BindAddress</"
-#~ "literal>，<literal>BindAddress</literal> 将被使用。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryTTL</emphasis> specifies the TTL "
-#~ "(time-to-live) for autodiscovery IP multicast packets."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">AutoDiscoveryTTL</emphasis> 为用于自动恢复的 IP 多"
-#~ "点传送数据包指定 TTL （time-to-live）。"
-
-#~ msgid ""
-#~ "The full default configuration of the <literal>HANamingService</literal> "
-#~ "MBean is as follows."
-#~ msgstr "<literal>HANamingService</literal> MBean 的完整缺省配置如下所示。"
-
-#~ msgid ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>\n"
-#~ " jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ " </depends> \n"
-#~ " <! -- Name of the partition to which the service is linked --"
-#~ "> \n"
-#~ " <attribute name=\"PartitionName\">\n"
-#~ " ${jboss.partition.name:DefaultPartition}\n"
-#~ " </attribute> \n"
-#~ " <! -- Bind address of bootstrap and HA-JNDI RMI endpoints --> \n"
-#~ " <attribute name=\"BindAddress\">${jboss.bind.address}</"
-#~ "attribute> \n"
-#~ " <! -- Port on which the HA-JNDI stub is made available --> \n"
-#~ " <attribute name=\"Port\">1100</attribute> \n"
-#~ " <! -- RmiPort to be used by the HA-JNDI service once bound. \n"
-#~ " 0 is for auto. --> \n"
-#~ " <attribute name=\"RmiPort\">1101</attribute> \n"
-#~ " <! -- Accept backlog of the bootstrap socket --> \n"
-#~ " <attribute name=\"Backlog\">50</attribute> \n"
-#~ " <! -- The thread pool service used to control the bootstrap and \n"
-#~ " auto discovery lookups --> \n"
-#~ " <depends optional-attribute-name=\"LookupPool\" \n"
-#~ " proxy-type=\"attribute\">jboss.system:service=ThreadPool</"
-#~ "depends>\n"
-#~ "\n"
-#~ " <! -- A flag to disable the auto discovery via multicast --> \n"
-#~ " <attribute name=\"DiscoveryDisabled\">false</attribute> \n"
-#~ " <! -- Set the auto-discovery bootstrap multicast bind address. --"
-#~ "> \n"
-#~ " <attribute name=\"AutoDiscoveryBindAddress\">\n"
-#~ " ${jboss.bind.address}\n"
-#~ " </attribute> \n"
-#~ " \n"
-#~ " <! -- Multicast Address and group port used for auto-discovery --"
-#~ "> \n"
-#~ " <attribute name=\"AutoDiscoveryAddress\">\n"
-#~ " ${jboss.partition.udpGroup:230.0.0.4}\n"
-#~ " </attribute> \n"
-#~ " <attribute name=\"AutoDiscoveryGroup\">1102</attribute> \n"
-#~ " <! -- The TTL (time-to-live) for autodiscovery IP multicast "
-#~ "packets --> \n"
-#~ " <attribute name=\"AutoDiscoveryTTL\">16</attribute>\n"
-#~ "\n"
-#~ " <! -- Client socket factory to be used for client-server \n"
-#~ " RMI invocations during JNDI queries \n"
-#~ " <attribute name=\"ClientSocketFactory\">custom</"
-#~ "attribute> \n"
-#~ " --> \n"
-#~ " <! -- Server socket factory to be used for client-server \n"
-#~ " RMI invocations during JNDI queries \n"
-#~ " <attribute name=\"ServerSocketFactory\">custom</"
-#~ "attribute> \n"
-#~ " --> \n"
-#~ "</mbean>"
-#~ msgstr ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>\n"
-#~ " jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ " </depends> \n"
-#~ " <! -- Name of the partition to which the service is linked --"
-#~ "> \n"
-#~ " <attribute name=\"PartitionName\">\n"
-#~ " ${jboss.partition.name:DefaultPartition}\n"
-#~ " </attribute> \n"
-#~ " <! -- Bind address of bootstrap and HA-JNDI RMI endpoints --> \n"
-#~ " <attribute name=\"BindAddress\">${jboss.bind.address}</"
-#~ "attribute> \n"
-#~ " <! -- Port on which the HA-JNDI stub is made available --> \n"
-#~ " <attribute name=\"Port\">1100</attribute> \n"
-#~ " <! -- RmiPort to be used by the HA-JNDI service once bound. \n"
-#~ " 0 is for auto. --> \n"
-#~ " <attribute name=\"RmiPort\">1101</attribute> \n"
-#~ " <! -- Accept backlog of the bootstrap socket --> \n"
-#~ " <attribute name=\"Backlog\">50</attribute> \n"
-#~ " <! -- The thread pool service used to control the bootstrap and \n"
-#~ " auto discovery lookups --> \n"
-#~ " <depends optional-attribute-name=\"LookupPool\" \n"
-#~ " proxy-type=\"attribute\">jboss.system:service=ThreadPool</"
-#~ "depends>\n"
-#~ "\n"
-#~ " <! -- A flag to disable the auto discovery via multicast --> \n"
-#~ " <attribute name=\"DiscoveryDisabled\">false</attribute> \n"
-#~ " <! -- Set the auto-discovery bootstrap multicast bind address. --"
-#~ "> \n"
-#~ " <attribute name=\"AutoDiscoveryBindAddress\">\n"
-#~ " ${jboss.bind.address}\n"
-#~ " </attribute> \n"
-#~ " \n"
-#~ " <! -- Multicast Address and group port used for auto-discovery --"
-#~ "> \n"
-#~ " <attribute name=\"AutoDiscoveryAddress\">\n"
-#~ " ${jboss.partition.udpGroup:230.0.0.4}\n"
-#~ " </attribute> \n"
-#~ " <attribute name=\"AutoDiscoveryGroup\">1102</attribute> \n"
-#~ " <! -- The TTL (time-to-live））for autodiscovery IP multicast "
-#~ "packets --> \n"
-#~ " <attribute name=\"AutoDiscoveryTTL\">16</attribute>\n"
-#~ "\n"
-#~ " <! -- Client socket factory to be used for client-server \n"
-#~ " RMI invocations during JNDI queries \n"
-#~ " <attribute name=\"ClientSocketFactory\">custom</"
-#~ "attribute> \n"
-#~ " --> \n"
-#~ " <! -- Server socket factory to be used for client-server \n"
-#~ " RMI invocations during JNDI queries \n"
-#~ " <attribute name=\"ServerSocketFactory\">custom</"
-#~ "attribute> \n"
-#~ " --> \n"
-#~ "</mbean>"
-
-#~ msgid ""
-#~ "It is possible to start several HA-JNDI services that use different "
-#~ "clusters. This can be used, for example, if a node is part of many "
-#~ "clusters. In this case, make sure that you set a different port or IP "
-#~ "address for both services. For instance, if you wanted to hook up HA-JNDI "
-#~ "to the example cluster you set up and change the binding port, the Mbean "
-#~ "descriptor would look as follows."
-#~ msgstr ""
-#~ "你可以启动几个使用不同群集的 HA-JNDI 服务。例如，这可以用在如果某一节点是"
-#~ "属于多个群集系统的情况下。这个时候，你要确保给不同服务设置了不同的端口号"
-#~ "或 IP 地址。例如，如果你想把 HA-JNDI 与 example 群集挂钩并改变绑定的端口，"
-#~ "Mbean 描述会象下面的样子。"
-
-#~ msgid ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>jboss:service=MySpecialPartition</depends> \n"
-#~ " <attribute name=\"PartitionName\">MySpecialPartition</"
-#~ "attribute> \n"
-#~ " <attribute name=\"Port\">56789</attribute> \n"
-#~ "</mbean>"
-#~ msgstr ""
-#~ "<mbean code=\"org.jboss.ha.jndi.HANamingService\" \n"
-#~ " name=\"jboss:service=HAJNDI\"> \n"
-#~ " <depends>jboss:service=MySpecialPartition</depends> \n"
-#~ " <attribute name=\"PartitionName\">MySpecialPartition</"
-#~ "attribute> \n"
-#~ " <attribute name=\"Port\">56789</attribute> \n"
-#~ "</mbean>"
-
-#~ msgid "Clustered Session EJBs"
-#~ msgstr "群集的 Session EJBs"
-
-#, fuzzy
-#~ msgid ""
-#~ "Session EJBs provide remote invocation services. They are clustered based "
-#~ "on the client-side interceptor architecture. The client application for a "
-#~ "clustered session bean is exactly the same as the client for the non-"
-#~ "clustered version of the session bean, except for a minor change to the "
-#~ "<literal>java.naming.provier.url</literal> system property to enable HA-"
-#~ "JNDI lookup (see previous section). No code change or re-compilation is "
-#~ "needed on the client side. Now, let's check out how to configure "
-#~ "clustered session beans in EJB 2.x and EJB 3.0 server applications "
-#~ "respectively."
-#~ msgstr ""
-#~ "Session EJBs 提供远程的调用服务。它们按照客户端拦截器架构（client-side "
-#~ "interceptor architecture）组成群集系统。群集的 session bean 的客户应用程序"
-#~ "和非群集的版本是一模一样的，除了对启用 HA-JNDI 查找的 <literal>java."
-#~ "naming.provier.url</literal> 系统属性的少许改动。对于客户端来说，不需要任"
-#~ "何的源码改动或重新编译。现在，让我们看看怎么分别在 EJB 2.x 和 EJB 3.0 服务"
-#~ "器应用程序里配置群集的 session beans。"
-
-#~ msgid "Stateless Session Bean in EJB 2.x"
-#~ msgstr "EJB 2.x 里的 Stateless Session Bean"
-
-#~ msgid ""
-#~ "Clustering stateless session beans is most probably the easiest case: as "
-#~ "no state is involved, calls can be load-balanced on any participating "
-#~ "node (i.e. any node that has this specific bean deployed) of the cluster. "
-#~ "To make a bean clustered, you need to modify its <literal>jboss.xml</"
-#~ "literal> descriptor to contain a <literal><clustered></literal> tag."
-#~ msgstr ""
-#~ "群集的 stateless session beans 有可能是最简单的：因为不涉及到状态，调用可"
-#~ "以在群集里的任何节点（部署有这个 bean 的节点）上进行负载平衡。要群集一个 "
-#~ "bean，你需要修改它的 <literal>jboss.xml</literal> 描述符，使它包含一个 "
-#~ "<literal><clustered></literal> 标签。"
-
-#~ msgid ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans> \n"
-#~ " <session> \n"
-#~ " <ejb-name>nextgen.StatelessSession</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.StatelessSession</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name> \n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces.RoundRobin\n"
-#~ " </bean-load-balance-policy>\n"
-#~ " </cluster-config>\n"
-#~ " </session>\n"
-#~ " </enterprise-beans>\n"
-#~ "</jboss>"
-#~ msgstr ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans> \n"
-#~ " <session> \n"
-#~ " <ejb-name>nextgen.StatelessSession</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.StatelessSession</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name> \n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces.RoundRobin\n"
-#~ " </bean-load-balance-policy>\n"
-#~ " </cluster-config>\n"
-#~ " </session>\n"
-#~ " </enterprise-beans>\n"
-#~ "</jboss>"
-
-#~ msgid ""
-#~ "The <literal><clustered>True</clustered></literal> element is "
-#~ "really just an alias for the <literal><configuration-name>Clustered "
-#~ "Stateless SessionBean</configuration-name></literal> element."
-#~ msgstr ""
-#~ "<literal><clustered>True</clustered></literal> 元素实际上是 "
-#~ "<literal><configuration-name>Clustered Stateless SessionBean</"
-#~ "configuration-name></literal> 元素的一个别名。"
-
-#~ msgid ""
-#~ "In the bean configuration, only the <literal><clustered></literal> "
-#~ "element is mandatory. It indicates that the bean works in a cluster. The "
-#~ "<literal><cluster-config></literal> element is optional and the "
-#~ "default values of its attributes are indicated in the sample "
-#~ "configuration above. Below is a description of the attributes in the "
-#~ "<literal><cluster-config></literal> element."
-#~ msgstr ""
-#~ "在 bean 配置里，只有 <literal><clustered></literal> 元素是强制的。它"
-#~ "指出这个 bean 在群集里运行。<literal><cluster-config></literal> 元素"
-#~ "是可选的，我们在上面的配置样本里指出了它的缺省值。下面是关于 <literal><"
-#~ "cluster-config></literal> 元素里属性的描述。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">partition-name</emphasis> specifies the name of "
-#~ "the cluster the bean participates in. The default value is "
-#~ "<literal>DefaultPartition</literal>. The default partition name can also "
-#~ "be set system-wide using the <literal>jboss.partition.name</literal> "
-#~ "system property."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">partition-name</emphasis> 指定 bean 所参与的群集"
-#~ "名。它的缺省值是 <literal>DefaultPartition</literal>。缺省的分区名也可以"
-#~ "用 <literal>jboss.partition.name</literal> 系统属性跨系统地被指定。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">home-load-balance-policy</emphasis> indicates the "
-#~ "class to be used by the home stub to balance calls made on the nodes of "
-#~ "the cluster. By default, the proxy will load-balance calls in a "
-#~ "<literal>RoundRobin</literal> fashion. You can also implement your own "
-#~ "load-balance policy class or use the class <literal>FirstAvailable</"
-#~ "literal> that persists to use the first node available that it meets "
-#~ "until it fails."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">home-load-balance-policy</emphasis> 指出 home "
-#~ "stub 所用来平衡节点上的调用的类。在缺省情况下，代理（proxy）会用 "
-#~ "<literal>RoundRobin</literal> 方式平衡调用负载。你也可以实现自己的负载平衡"
-#~ "策略类或持续使用所遇到的第一个可用节点直至其消亡的 "
-#~ "<literal>FirstAvailable</literal> 类。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">bean-load-balance-policy</emphasis> Indicates the "
-#~ "class to be used by the bean stub to balance calls made on the nodes of "
-#~ "the cluster. Comments made for the <literal>home-load-balance-policy</"
-#~ "literal> attribute also apply."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">bean-load-balance-policy</emphasis>指出 home stub "
-#~ "所使用的平衡节点上的调用的类。对于 <literal>home-load-balance-policy</"
-#~ "literal> 属性的注释也同样适用。"
-
-#, fuzzy
-#~ msgid ""
-#~ "In JBoss 3.0.x, each client-side stub has its own list of available "
-#~ "target nodes. Consequently, some side-effects can occur. For example, if "
-#~ "you cache your home stub and re-create a remote stub for a stateless "
-#~ "session bean (with the Round-Robin policy) each time you need to make an "
-#~ "invocation, a new remote stub, containing the list of available targets, "
-#~ "will be downloaded for each invocation. Consequently, as the first target "
-#~ "node is always the first in the list, calls will not seemed to be load-"
-#~ "balanced because there is no usage-history between different stubs. In "
-#~ "JBoss 3.2+, the proxy families (i.e., the \"First "
-#~ "AvailableIdenticalAllProxies\" load balancing policy, see <xref linkend="
-#~ "\"Load_Balancing_Policies-JBoss_AS_3.2\"/>) remove this side effect as "
-#~ "the home and remote stubs of a given EJB are in two different families."
-#~ msgstr ""
-#~ "在 JBoss 3.0.x 里，每个客户端 stub 都有自己的可用目标节点的列表。由此会产"
-#~ "生某些副作用。例如，每次你需要进行一次调用时，你都为 stateless session "
-#~ "bean（应用 Round-Robin 策略） 缓存你的 home stub 并重新创建一个远程 stub，"
-#~ "每次调用都会下载包含可用节点列表的新的远程 stub。因此，由于第一个目标节点"
-#~ "总是列表里的第一项，而且不同的 stubs 之间并没有一个节点的使用记录，调用负"
-#~ "载看起来并没有被平衡。在 JBoss 3.2+ 里，proxy families（也就是 \"First "
-#~ "AvailableIdenticalAllProxies\" 负载平衡策略，请参考 <xref linkend="
-#~ "\"clustering-intro-balancepolicy-32\"/>） 消除了这个副作用，因为给定 EJB "
-#~ "的 home 和 remote stubs 分别在两个不同的族（familiy）里。"
-
-#~ msgid "Handle Cluster Restart"
-#~ msgstr "处理群集系统重启"
-
-#, fuzzy
-#~ msgid ""
-#~ "We have covered the HA smart client architecture in <xref linkend="
-#~ "\"Service_Architectures-Client_side_interceptor\"/>. The default HA smart "
-#~ "proxy client can only failover as long as one node in the cluster exists. "
-#~ "If there is a complete cluster shutdown, the proxy becomes orphanned and "
-#~ "looses knowledge of the available nodes in the cluster. There is no way "
-#~ "for the proxy to recover from this. The proxy needs to be looked up out "
-#~ "of JNDI/HAJNDI when the nodes are restarted."
-#~ msgstr ""
-#~ "我们已经在 <xref linkend=\"clustering-intro-arch-proxy\"/> 介绍了 HA "
-#~ "smart client architecture。缺省的 HA smart proxy client 只能在群集里一个节"
-#~ "点故障时进行失效切换（failover）。如果整个群集都关闭了，代理（proxy）将失"
-#~ "去所有群集里可用节点的信息。在这种情况下，代理没有什么办法来恢复系统。当节"
-#~ "点重启时，需要在 JNDI/HAJNDI 之外查找代理。"
-
-#, fuzzy
-#~ msgid ""
-#~ "The 3.2.7+/4.2+ releases contain a <literal>RetryInterceptor</literal> "
-#~ "that can be added to the proxy client side interceptor stack to allow for "
-#~ "a transparent recovery from such a restart failure. To enable it for an "
-#~ "EJB, setup an <literal>invoker-proxy-binding</literal> that includes the "
-#~ "<literal>RetryInterceptor</literal>. Below is an example <literal>jboss."
-#~ "xml</literal> configuration."
-#~ msgstr ""
-#~ "3.2.7+/4.0.2+ 版本包含了 <literal>RetryInterceptor</literal>，它可以加入到"
-#~ "代理客户端拦截器栈里，允许在这样的重启故障后进行透明恢复（transparent "
-#~ "recovery）。为了启用这个机制，你可以设立包含 <literal>RetryInterceptor</"
-#~ "literal> 的 <literal>invoker-proxy-binding</literal>。下面是 "
-#~ "<literal>jboss.xml</literal> 配置的一个示例。"
-
-#~ msgid ""
-#~ "<jboss>\n"
-#~ " <session>\n"
-#~ " <ejb-name>nextgen_RetryInterceptorStatelessSession</ejb-"
-#~ "name>\n"
-#~ " <invoker-bindings>\n"
-#~ " <invoker>\n"
-#~ " <invoker-proxy-binding-name>\n"
-#~ " clustered-retry-stateless-rmi-invoker\n"
-#~ " </invoker-proxy-binding-name>\n"
-#~ " <jndi-name>\n"
-#~ " nextgen_RetryInterceptorStatelessSession\n"
-#~ " </jndi-name>\n"
-#~ " </invoker>\n"
-#~ " </invoker-bindings>\n"
-#~ " <clustered>true</clustered>\n"
-#~ " </session>\n"
-#~ "\n"
-#~ " <invoker-proxy-binding>\n"
-#~ " <name>clustered-retry-stateless-rmi-invoker</name>\n"
-#~ " <invoker-mbean>jboss:service=invoker,type=jrmpha</"
-#~ "invoker-mbean>\n"
-#~ " <proxy-factory>org.jboss.proxy.ejb.ProxyFactoryHA</proxy-"
-#~ "factory>\n"
-#~ " <proxy-factory-config>\n"
-#~ " <client-interceptors>\n"
-#~ " <home>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.HomeInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.SecurityInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.TransactionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.invocation.InvokerInterceptor\n"
-#~ " </interceptor>\n"
-#~ " </home>\n"
-#~ " <bean>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.StatelessSessionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.SecurityInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.TransactionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.invocation.InvokerInterceptor\n"
-#~ " </interceptor>\n"
-#~ " </bean>\n"
-#~ " </client-interceptors>\n"
-#~ " </proxy-factory-config>\n"
-#~ " </invoker-proxy-binding>"
-#~ msgstr ""
-#~ "<jboss>\n"
-#~ " <session>\n"
-#~ " <ejb-name>nextgen_RetryInterceptorStatelessSession</ejb-"
-#~ "name>\n"
-#~ " <invoker-bindings>\n"
-#~ " <invoker>\n"
-#~ " <invoker-proxy-binding-name>\n"
-#~ " clustered-retry-stateless-rmi-invoker\n"
-#~ " </invoker-proxy-binding-name>\n"
-#~ " <jndi-name>\n"
-#~ " nextgen_RetryInterceptorStatelessSession\n"
-#~ " </jndi-name>\n"
-#~ " </invoker>\n"
-#~ " </invoker-bindings>\n"
-#~ " <clustered>true</clustered>\n"
-#~ " </session>\n"
-#~ "\n"
-#~ " <invoker-proxy-binding>\n"
-#~ " <name>clustered-retry-stateless-rmi-invoker</name>\n"
-#~ " <invoker-mbean>jboss:service=invoker,type=jrmpha</"
-#~ "invoker-mbean>\n"
-#~ " <proxy-factory>org.jboss.proxy.ejb.ProxyFactoryHA</proxy-"
-#~ "factory>\n"
-#~ " <proxy-factory-config>\n"
-#~ " <client-interceptors>\n"
-#~ " <home>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.HomeInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.SecurityInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.TransactionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.invocation.InvokerInterceptor\n"
-#~ " </interceptor>\n"
-#~ " </home>\n"
-#~ " <bean>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.StatelessSessionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.SecurityInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.TransactionInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.proxy.ejb.RetryInterceptor\n"
-#~ " </interceptor>\n"
-#~ " <interceptor>\n"
-#~ " org.jboss.invocation.InvokerInterceptor\n"
-#~ " </interceptor>\n"
-#~ " </bean>\n"
-#~ " </client-interceptors>\n"
-#~ " </proxy-factory-config>\n"
-#~ " </invoker-proxy-binding>"
-
-#~ msgid "Stateful Session Bean in EJB 2.x"
-#~ msgstr "EJB 2.x 里的 Stateful Session Bean"
-
-#~ msgid ""
-#~ "Clustering stateful session beans is more complex than clustering their "
-#~ "stateless counterparts since JBoss needs to manage the state information. "
-#~ "The state of all stateful session beans are replicated and synchronized "
-#~ "across the cluster each time the state of a bean changes. The JBoss AS "
-#~ "uses the <literal>HASessionState</literal> MBean to manage distributed "
-#~ "session states for clustered EJB 2.x stateful session beans. In this "
-#~ "section, we cover both the session bean configuration and the "
-#~ "<literal>HASessionState</literal> MBean configuration."
-#~ msgstr ""
-#~ "既然 JBoss 需要管理状态信息，群集 stateful session beans 就比群集 "
-#~ "stateles ssession beans 更为复杂。当 stateful session beans 的状态改变时，"
-#~ "所有状态在群集中复制和同步。JBoss AS 使用 <literal>HASessionState</"
-#~ "literal> MBean 来为群集的 EJB 2.x stateful session beans 管理分布式的会话"
-#~ "状态。在这部分内容里，我们将介绍 session bean 的配置和 "
-#~ "<literal>HASessionState</literal> MBean 的配置。"
-
-#~ msgid "The EJB application configuration"
-#~ msgstr "EJB 应用程序配置"
-
-#~ msgid ""
-#~ "In the EJB application, you need to modify the <literal>jboss.xml</"
-#~ "literal> descriptor file for each stateful session bean and add the "
-#~ "<literal><clustered></literal> tag."
-#~ msgstr ""
-#~ "在 EJB 应用程序里，你需要为每个 stateful session bean 修改 <literal>jboss."
-#~ "xml</literal> 描述符文件并加入 <literal><clustered></literal> 标签。"
-
-#~ msgid ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans>\n"
-#~ " <session> \n"
-#~ " <ejb-name>nextgen.StatefulSession</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.StatefulSession</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name>\n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable \n"
-#~ " </bean-load-balance-policy> \n"
-#~ " <session-state-manager-jndi-name> \n"
-#~ " /HASessionState/Default \n"
-#~ " </session-state-manager-jndi-name> \n"
-#~ " </cluster-config> \n"
-#~ " </session> \n"
-#~ " </enterprise-beans>\n"
-#~ "</jboss>"
-#~ msgstr ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans>\n"
-#~ " <session> \n"
-#~ " <ejb-name>nextgen.StatefulSession</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.StatefulSession</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name>\n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable \n"
-#~ " </bean-load-balance-policy> \n"
-#~ " <session-state-manager-jndi-name> \n"
-#~ " /HASessionState/Default \n"
-#~ " </session-state-manager-jndi-name> \n"
-#~ " </cluster-config> \n"
-#~ " </session> \n"
-#~ " </enterprise-beans>\n"
-#~ "</jboss>"
-
-#~ msgid ""
-#~ "In the bean configuration, only the <literal><clustered></literal> "
-#~ "tag is mandatory to indicate that the bean works in a cluster. The "
-#~ "<literal><cluster-config></literal> element is optional and its "
-#~ "default attribute values are indicated in the sample configuration above."
-#~ msgstr ""
-#~ "在 bean 的配置文件里，只有 <literal><clustered></literal> 标签是强制"
-#~ "的，它指出 bean 处在群集系统里。<literal><cluster-config></literal> "
-#~ "元素是可选的，我们在上面的配置文件样本里指出了它的缺省属性值。"
-
-#~ msgid ""
-#~ "The <literal><session-state-manager-jndi-name></literal> tag is "
-#~ "used to give the JNDI name of the <literal>HASessionState</literal> "
-#~ "service to be used by this bean."
-#~ msgstr ""
-#~ "<literal><session-state-manager-jndi-name></literal> 标签用来说明这"
-#~ "个 bean 所用的 <literal>HASessionState</literal> 服务的名字。"
-
-#, fuzzy
-#~ msgid ""
-#~ "The description of the remaining tags is identical to the one for "
-#~ "stateless session bean. Actions on the clustered stateful session "
-#~ "bean's home interface are by default load-balanced, round-robin. Once "
-#~ "the bean's remote stub is available to the client, calls will not be "
-#~ "load-balanced round-robin any more and will stay \"sticky\" to the first "
-#~ "node in the list."
-#~ msgstr ""
-#~ "余下的标签的描述和 stateless session bean 的描述是一样的。群集的 stateful "
-#~ "session bean 的主接口上的动作缺省是基于 round-robin 负载平衡策略的。一旦 "
-#~ "bean 的 remote stub 对于客户可用时，调用将不会再进行负载平衡而\"粘"
-#~ "\"（sticky）在列表里的第一个节点上。"
-
-#~ msgid "Optimize state replication"
-#~ msgstr "优化状态复制"
-
-#~ msgid ""
-#~ "As the replication process is a costly operation, you can optimise this "
-#~ "behaviour by optionally implementing in your bean class a method with the "
-#~ "following signature:"
-#~ msgstr ""
-#~ "因为复制过程是很消耗资源的，为了优化这个过程，你可以选择性地在你的 bean 类"
-#~ "里实现有下面的签名的方法："
-
-#~ msgid "public boolean isModified ();"
-#~ msgstr "public boolean isModified ();"
-
-#~ msgid ""
-#~ "Before replicating your bean, the container will detect if your bean "
-#~ "implements this method. If your bean does, the container calls the "
-#~ "<literal>isModified()</literal> method and it only replicates the bean "
-#~ "when the method returns <literal>true</literal>. If the bean has not been "
-#~ "modified (or not enough to require replication, depending on your own "
-#~ "preferences), you can return <literal>false</literal> and the replication "
-#~ "would not occur. This feature is available on JBoss AS 3.0.1+ only."
-#~ msgstr ""
-#~ "在复制你的 bean 之前，容器（container）将检测 bean 是否实现了这个方法。如"
-#~ "果是，容器会调用 <literal>isModified()</literal> 方法并只在方法返回 "
-#~ "<literal>true</literal> 时复制这个 bean。如果 bean 还没被更改(或者还不够来"
-#~ "请求复制，这取决于你的喜好，你可以返回 <literal>false</literal>，这样复制"
-#~ "就不会发生。"
-
-#~ msgid "The HASessionState service configuration"
-#~ msgstr "HASessionState 服务配置"
-
-#, fuzzy
-#~ msgid ""
-#~ "The <literal>HASessionState</literal> service MBean is defined in "
-#~ "the<code>all/deploy/cluster-service.xml</code>file."
-#~ msgstr ""
-#~ "<code>all/deploy/cluster-service.xml</code> 文件里定义了 "
-#~ "<literal>HASessionState</literal> 服务 MBean。"
-
-#~ msgid ""
-#~ "<mbean code=\"org.jboss.ha.hasessionstate.server.HASessionStateService"
-#~ "\"\n"
-#~ " name=\"jboss:service=HASessionState\">\n"
-#~ " <depends>\n"
-#~ " jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ " </depends>\n"
-#~ " <!-- Name of the partition to which the service is linked -->\n"
-#~ " <attribute name=\"PartitionName\">\n"
-#~ " ${jboss.partition.name:DefaultPartition}\n"
-#~ " </attribute>\n"
-#~ " <!-- JNDI name under which the service is bound -->\n"
-#~ " <attribute name=\"JndiName\">/HASessionState/Default</"
-#~ "attribute>\n"
-#~ " <!-- Max delay before cleaning unreclaimed state.\n"
-#~ " Defaults to 30*60*1000 => 30 minutes -->\n"
-#~ " <attribute name=\"BeanCleaningDelay\">0</attribute>\n"
-#~ "</mbean>"
-#~ msgstr ""
-#~ "<mbean code=\"org.jboss.ha.hasessionstate.server.HASessionStateService"
-#~ "\"\n"
-#~ " name=\"jboss:service=HASessionState\">\n"
-#~ " <depends>\n"
-#~ " jboss:service=${jboss.partition.name:DefaultPartition}\n"
-#~ " </depends>\n"
-#~ " <!-- Name of the partition to which the service is linked -->\n"
-#~ " <attribute name=\"PartitionName\">\n"
-#~ " ${jboss.partition.name:DefaultPartition}\n"
-#~ " </attribute>\n"
-#~ " <!-- JNDI name under which the service is bound -->\n"
-#~ " <attribute name=\"JndiName\">/HASessionState/Default</"
-#~ "attribute>\n"
-#~ " <!-- Max delay before cleaning unreclaimed state.\n"
-#~ " Defaults to 30*60*1000 => 30 minutes -->\n"
-#~ " <attribute name=\"BeanCleaningDelay\">0</attribute>\n"
-#~ "</mbean>"
-
-#~ msgid ""
-#~ "The configuration attributes in the <literal>HASessionState</literal> "
-#~ "MBean are listed below."
-#~ msgstr "<literal>HASessionState</literal> MBean 里的配置属性如下所示："
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">JndiName</emphasis> is an optional attribute to "
-#~ "specify the JNDI name under which this <literal>HASessionState</literal> "
-#~ "service is bound. The default value is <literal>/HAPartition/Default</"
-#~ "literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">JndiName</emphasis> 是一个可选属性，它指定这个 "
-#~ "<literal>HASessionState</literal> 服务被绑定的 JNDI 名。它的缺省值是 "
-#~ "<literal>/HAPartition/Default</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> is an optional attribute "
-#~ "to specify the name of the cluster in which the current "
-#~ "<literal>HASessionState</literal> protocol will work. The default value "
-#~ "is <literal>DefaultPartition</literal>."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">PartitionName</emphasis> 是一个可选属性，它指定了"
-#~ "当前 <literal>HASessionState</literal> 协议所服务的群集名称。它的缺省值是 "
-#~ "<literal>DefaultPartition</literal>。"
-
-#~ msgid ""
-#~ "<emphasis role=\"bold\">BeanCleaningDelay</emphasis> is an optional "
-#~ "attribute to specify the number of miliseconds after which the "
-#~ "<literal>HASessionState</literal> service can clean a state that has not "
-#~ "been modified. If a node, owning a bean, crashes, its brother node will "
-#~ "take ownership of this bean. Nevertheless, the container cache of the "
-#~ "brother node will not know about it (because it has never seen it before) "
-#~ "and will never delete according to the cleaning settings of the bean. "
-#~ "That is why the <literal>HASessionState</literal> service needs to do "
-#~ "this cleanup sometimes. The default value is <literal>30*60*1000</"
-#~ "literal> milliseconds (i.e., 30 minutes)."
-#~ msgstr ""
-#~ "<emphasis role=\"bold\">BeanCleaningDelay</emphasis> 是一个可选属性，它指"
-#~ "定了一个状态在多久没有变化后 <literal>HASessionState</literal> 服务就可以"
-#~ "清除它，它的单位是毫秒。例如，如果拥有某一 bean 的节点崩溃了，它的兄弟节点"
-#~ "将接管这个 bean。但是，这个兄弟节点的容器缓存并不会知道这个信息（因为之前"
-#~ "并没有这个信息），也永远不会按照这个 bean 的清除设置来删除它。这就是为什"
-#~ "么 <literal>HASessionState</literal> 服务需要来做这个清除工作。它的缺省值"
-#~ "是 <literal>30*60*1000</literal> 毫秒（也就是 30 分钟）。"
-
-#~ msgid "Stateless Session Bean in EJB 3.0"
-#~ msgstr "EJB 3.0 里的 Stateless Session Bean"
-
-#~ msgid ""
-#~ "To cluster a stateless session bean in EJB 3.0, all you need to do is to "
-#~ "annotate the bean class withe the <literal>@Cluster</literal> annotation. "
-#~ "You can pass in the load balance policy and cluster partition as "
-#~ "parameters to the annotation. The default load balance policy is "
-#~ "<literal>org.jboss.ha.framework.interfaces.RandomRobin</literal> and the "
-#~ "default cluster is <literal>DefaultPartition</literal>. Below is the "
-#~ "definition of the <literal>@Cluster</literal> annotation."
-#~ msgstr ""
-#~ "要在 EJB 3.0 内群集一个 stateless session bean，你所需要做的就是用 "
-#~ "<literal>@Cluster</literal> 注解来注解（annotate）bean 类。你可以把负载平"
-#~ "衡策略（load balance policy）和群集分区名当作参数传入这个注解。缺省的负载"
-#~ "平衡策略是 <literal>org.jboss.ha.framework.interfaces.RandomRobin</"
-#~ "literal>，缺省的群集是 <literal>DefaultPartition</literal>。下面是 "
-#~ "<literal>@Cluster</literal> 注解的定义。"
-
-#~ msgid ""
-#~ "public @interface Clustered {\n"
-#~ " Class loadBalancePolicy() default LoadBalancePolicy.class;\n"
-#~ " String partition() default \"DefaultPartition\";\n"
-#~ "}"
-#~ msgstr ""
-#~ "public @interface Clustered {\n"
-#~ " Class loadBalancePolicy() default LoadBalancePolicy.class;\n"
-#~ " String partition() default \"DefaultPartition\";\n"
-#~ "}"
-
-#~ msgid ""
-#~ "Here is an example of a clustered EJB 3.0 stateless session bean "
-#~ "implementation."
-#~ msgstr "这里是一个群集的 EJB 3.0 stateless session bean 实现的例子。"
-
-#~ msgid ""
-#~ "@Stateless\n"
-#~ "@Clustered\n"
-#~ "public class MyBean implements MySessionInt {\n"
-#~ " \n"
-#~ " public void test() {\n"
-#~ " // Do something cool\n"
-#~ " }\n"
-#~ "}"
-#~ msgstr ""
-#~ "@Stateless\n"
-#~ "@Clustered\n"
-#~ "public class MyBean implements MySessionInt {\n"
-#~ " \n"
-#~ " public void test() {\n"
-#~ " // Do something cool\n"
-#~ " }\n"
-#~ "}"
-
-#~ msgid "Stateful Session Bean in EJB 3.0"
-#~ msgstr "EJB 3.0 里的 Stateful Session Bean"
-
-#~ msgid ""
-#~ "To cluster stateful session beans in EJB 3.0, you need to tag the bean "
-#~ "implementation class with the <literal>@Cluster</literal> annotation, "
-#~ "just as we did with the EJB 3.0 stateless session bean earlier."
-#~ msgstr ""
-#~ "为了在 EJB 3.0 里群集 stateful session beans，你需要用 <literal>@Cluster</"
-#~ "literal> 注解来标记 bean 实现类，就和我们之前对 EJB 3.0 stateless session "
-#~ "bean 做的一样。"
-
-#~ msgid ""
-#~ "@Stateful\n"
-#~ "@Clustered\n"
-#~ "public class MyBean implements MySessionInt {\n"
-#~ " \n"
-#~ " private int state = 0;\n"
-#~ "\n"
-#~ " public void increment() {\n"
-#~ " System.out.println(\"counter: \" + (state++));\n"
-#~ " }\n"
-#~ "}"
-#~ msgstr ""
-#~ "@Stateful\n"
-#~ "@Clustered\n"
-#~ "public class MyBean implements MySessionInt {\n"
-#~ " \n"
-#~ " private int state = 0;\n"
-#~ "\n"
-#~ " public void increment() {\n"
-#~ " System.out.println(\"counter: \" + (state++));\n"
-#~ " }\n"
-#~ "}"
-
-#~ msgid ""
-#~ "JBoss Cache provides the session state replication service for EJB 3.0 "
-#~ "stateful session beans. The related MBean service is defined in the "
-#~ "<literal>ejb3-clustered-sfsbcache-service.xml</literal> file in the "
-#~ "<literal>deploy</literal> directory. The contents of the file are as "
-#~ "follows."
-#~ msgstr ""
-#~ "JBoss Cache 为 EJB 3.0 stateful session beans 提供会话状态复制服务"
-#~ "（session state replication service）。<literal>deploy</literal> 目录下 "
-#~ "<literal>ejb3-clustered-sfsbcache-service.xml</literal> 文件定义了相关的 "
-#~ "MBean 服务。文件的内容如下："
-
-#~ msgid ""
-#~ "<server>\n"
-#~ " <mbean code=\"org.jboss.ejb3.cache.tree.PassivationTreeCache\"\n"
-#~ " name=\"jboss.cache:service=EJB3SFSBClusteredCache\">\n"
-#~ " \n"
-#~ " <attribute name=\"IsolationLevel\">READ_UNCOMMITTED</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheMode\">REPL_SYNC</attribute>\n"
-#~ " <attribute name=\"ClusterName\">SFSB-Cache</"
-#~ "attribute>\n"
-#~ " <attribute name=\"ClusterConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Number of milliseconds to wait until all responses for "
-#~ "a\n"
-#~ " synchronous call have been received.\n"
-#~ " -->\n"
-#~ " <attribute name=\"SyncReplTimeout\">10000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <!-- Max number of milliseconds to wait for a lock "
-#~ "acquisition -->\n"
-#~ " <attribute name=\"LockAcquisitionTimeout\">15000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <!-- Name of the eviction policy class. -->\n"
-#~ " <attribute name=\"EvictionPolicyClass\">\n"
-#~ " org.jboss.ejb3.cache.tree.StatefulEvictionPolicy\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Specific eviction policy configurations. This is LRU --"
-#~ ">\n"
-#~ " <attribute name=\"EvictionPolicyConfig\">\n"
-#~ " <config>\n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">1</"
-#~ "attribute>\n"
-#~ " <name>statefulClustered</name>\n"
-#~ " <region name=\"/_default_\">\n"
-#~ " <attribute name=\"maxNodes\">1000000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"timeToIdleSeconds\">300</"
-#~ "attribute>\n"
-#~ " </region>\n"
-#~ " </config>\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"CacheLoaderFetchPersistentState\">"
-#~ "false</attribute>\n"
-#~ " <attribute name=\"CacheLoaderFetchTransientState\">true</"
-#~ "attribute>\n"
-#~ " <attribute name=\"FetchStateOnStartup\">true</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheLoaderClass\">\n"
-#~ " org.jboss.ejb3.cache.tree.StatefulCacheLoader\n"
-#~ " </attribute>\n"
-#~ " <attribute name=\"CacheLoaderConfig\">\n"
-#~ " location=statefulClustered\n"
-#~ " </attribute>\n"
-#~ " </mbean>\n"
-#~ "</server>"
-#~ msgstr ""
-#~ "<server>\n"
-#~ " <mbean code=\"org.jboss.ejb3.cache.tree.PassivationTreeCache\"\n"
-#~ " name=\"jboss.cache:service=EJB3SFSBClusteredCache\">\n"
-#~ " \n"
-#~ " <attribute name=\"IsolationLevel\">READ_UNCOMMITTED</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheMode\">REPL_SYNC</attribute>\n"
-#~ " <attribute name=\"ClusterName\">SFSB-Cache</"
-#~ "attribute>\n"
-#~ " <attribute name=\"ClusterConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Number of milliseconds to wait until all responses for "
-#~ "a\n"
-#~ " synchronous call have been received.\n"
-#~ " -->\n"
-#~ " <attribute name=\"SyncReplTimeout\">10000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <!-- Max number of milliseconds to wait for a lock "
-#~ "acquisition -->\n"
-#~ " <attribute name=\"LockAcquisitionTimeout\">15000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <!-- Name of the eviction policy class. -->\n"
-#~ " <attribute name=\"EvictionPolicyClass\">\n"
-#~ " org.jboss.ejb3.cache.tree.StatefulEvictionPolicy\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Specific eviction policy configurations. This is LRU --"
-#~ ">\n"
-#~ " <attribute name=\"EvictionPolicyConfig\">\n"
-#~ " <config>\n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">1</"
-#~ "attribute>\n"
-#~ " <name>statefulClustered</name>\n"
-#~ " <region name=\"/_default_\">\n"
-#~ " <attribute name=\"maxNodes\">1000000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"timeToIdleSeconds\">300</"
-#~ "attribute>\n"
-#~ " </region>\n"
-#~ " </config>\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"CacheLoaderFetchPersistentState\">"
-#~ "false</attribute>\n"
-#~ " <attribute name=\"CacheLoaderFetchTransientState\">true</"
-#~ "attribute>\n"
-#~ " <attribute name=\"FetchStateOnStartup\">true</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheLoaderClass\">\n"
-#~ " org.jboss.ejb3.cache.tree.StatefulCacheLoader\n"
-#~ " </attribute>\n"
-#~ " <attribute name=\"CacheLoaderConfig\">\n"
-#~ " location=statefulClustered\n"
-#~ " </attribute>\n"
-#~ " </mbean>\n"
-#~ "</server>"
-
-#, fuzzy
-#~ msgid ""
-#~ "The configuration attributes in the <literal>PassivationTreeCache</"
-#~ "literal> MBean are essentially the same as the attributes in the standard "
-#~ "JBoss Cache <literal>TreeCache</literal> MBean discussed in <xref linkend="
-#~ "\"JBossCache_and_JGroups_Services\"/>. Again, we omitted the JGroups "
-#~ "configurations in the <literal>ClusterConfig</literal> attribute (see "
-#~ "more in <xref linkend=\"JBossCache_and_JGroups_Services-"
-#~ "JGroups_Configuration\"/>)."
-#~ msgstr ""
-#~ "<literal>PassivationTreeCache</literal> MBean 里的配置属性基本上和在 "
-#~ "<xref linkend=\"jbosscache.chapt\"/> 里讨论的标准 JBoss Cache "
-#~ "<literal>TreeCache</literal> MBean 一样。我们再一次忽略了 "
-#~ "<literal>ClusterConfig</literal> 属性（详情请参考 <xref linkend="
-#~ "\"jbosscache-jgroups\"/>）的 JGroups 配置。"
-
-#~ msgid "Clustered Entity EJBs"
-#~ msgstr "群集的 Entity EJBs"
-
-#~ msgid ""
-#~ "In a JBoss AS cluster, the entity bean instances need to replicated "
-#~ "across all nodes. If an entity bean provides remote services, the service "
-#~ "methods need to be load balanced as well."
-#~ msgstr ""
-#~ "在 JBoss AS 群集系统里，entity bean 实例需要跨节点的复制。如果某个 entity "
-#~ "bean 提供远程服务，那么服务方法（service methods）也需要进行负载平衡。"
-
-#~ msgid ""
-#~ "To use a clustered entity bean, the application does not need to do "
-#~ "anything special, except for looking up bean references from the "
-#~ "clustered HA-JNDI."
-#~ msgstr ""
-#~ "为了使用群集的 entity bean，应用程序不需要做任何特殊的事情，除了从群集的 "
-#~ "HA-JNDI 里查找 bean 的引用。"
-
-#~ msgid "Entity Bean in EJB 2.x"
-#~ msgstr "EJB 2.x 里的 Entity Bean"
-
-#~ msgid ""
-#~ "First of all, it is worth to note that clustering 2.x entity beans is a "
-#~ "bad thing to do. Its exposes elements that generally are too fine grained "
-#~ "for use as remote objects to clustered remote objects and introduces data "
-#~ "synchronization problems that are non-trivial. Do NOT use EJB 2.x entity "
-#~ "bean clustering unless you fit into the sepecial case situation of read-"
-#~ "only, or one read-write node with read-only nodes synched with the cache "
-#~ "invalidation services."
-#~ msgstr ""
-#~ "首先，值得注意的是群集 2.x 的 entity beans 不是件好事。它向群集的远程对象"
-#~ "开放（exposes）通常过于细颗粒度的元素（elements），导致了严重的数据同步问"
-#~ "题。除非你遇到特殊的情况，如只读或者只写的节点和使用缓存失效服务（cache "
-#~ "invalidation services）的只读节点同步，否则不要使用 EJB 2.x entity bean 的"
-#~ "群集。"
-
-#, fuzzy
-#~ msgid ""
-#~ "To cluster EJB 2.x entity beans, you need to add the <literal><"
-#~ "clustered></literal> element to the application's <literal>jboss."
-#~ "xml</literal> descriptor file. Below is a typical <literal>jboss.xml</"
-#~ "literal> file."
-#~ msgstr ""
-#~ "要群集 EJB 2.x entity beans，你需要把 <literal><clustered></"
-#~ "literal> 元素加入到应用程序的 <literal>jboss.xml</literal> 描述符文件里。"
-#~ "下面是一个典型的 <literal>jboss.xml</literal> 文件。"
-
-#~ msgid ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans> \n"
-#~ " <entity> \n"
-#~ " <ejb-name>nextgen.EnterpriseEntity</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.EnterpriseEntity</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name> \n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable \n"
-#~ " </bean-load-balance-policy> \n"
-#~ " </cluster-config> \n"
-#~ " </entity> \n"
-#~ " </enterprise-beans> \n"
-#~ "</jboss>"
-#~ msgstr ""
-#~ "<jboss> \n"
-#~ " <enterprise-beans> \n"
-#~ " <entity> \n"
-#~ " <ejb-name>nextgen.EnterpriseEntity</ejb-"
-#~ "name> \n"
-#~ " <jndi-name>nextgen.EnterpriseEntity</jndi-"
-#~ "name> \n"
-#~ " <clustered>True</clustered> \n"
-#~ " <cluster-config> \n"
-#~ " <partition-name>DefaultPartition</partition-"
-#~ "name> \n"
-#~ " <home-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "RoundRobin \n"
-#~ " </home-load-balance-policy> \n"
-#~ " <bean-load-balance-policy> \n"
-#~ " org.jboss.ha.framework.interfaces."
-#~ "FirstAvailable \n"
-#~ " </bean-load-balance-policy> \n"
-#~ " </cluster-config> \n"
-#~ " </entity> \n"
-#~ " </enterprise-beans> \n"
-#~ "</jboss>"
-
-#~ msgid ""
-#~ "The EJB 2.x entity beans are clustered for load balanced remote "
-#~ "invocations. All the bean instances are synchronized to have the same "
-#~ "contents on all nodes."
-#~ msgstr ""
-#~ "为了平衡远程调用的负载，我们群集 EJB 2.x entity beans。所有的 bean 实例都"
-#~ "实现同步，具有所有节点上的相同内容。"
-
-#~ msgid ""
-#~ "However, clustered EJB 2.x Entity Beans do not have a distributed locking "
-#~ "mechanism or a distributed cache. They can only be synchronized by using "
-#~ "row-level locking at the database level (see <literal><row-lock></"
-#~ "literal> in the CMP specification) or by setting the Transaction "
-#~ "Isolation Level of your JDBC driver to be "
-#~ "<literal>TRANSACTION_SERIALIZABLE</literal>. Because there is no "
-#~ "supported distributed locking mechanism or distributed cache Entity Beans "
-#~ "use Commit Option \"B\" by default (See <literal>standardjboss.xml</"
-#~ "literal> and the container configurations Clustered CMP 2.x EntityBean, "
-#~ "Clustered CMP EntityBean, or Clustered BMP EntityBean). It is not "
-#~ "recommended that you use Commit Option \"A\" unless your Entity Bean is "
-#~ "read-only. (There are some design patterns that allow you to use Commit "
-#~ "Option \"A\" with read-mostly beans. You can also take a look at the "
-#~ "Seppuku pattern <ulink url=\"http://dima.dhs.org/misc/readOnlyUpdates.html"
-#~ "\"></ulink>. JBoss may incorporate this pattern into later versions.)"
-#~ msgstr ""
-#~ "然而，群集的 EJB 2.x Entity Beans 没有分布式的锁定机制或是缓存。它们只能用"
-#~ "数据库层面的行级锁定（请参考 CMP 规范的<literal><row-lock></"
-#~ "literal>）或是把 JDBC 驱动的事务隔离（Transaction Isolation）级别设为 "
-#~ "<literal>TRANSACTION_SERIALIZABLE</literal> 来实现同步。因为缺乏分布式的锁"
-#~ "定机制或是缓存支持，Entity Beans 缺省使用提交选项 \"B\"（请参考 "
-#~ "<literal>standardjboss.xml</literal> 和 the container configurations "
-#~ "Clustered CMP 2.x EntityBean，Clustered CMP EntityBean，或 Clustered BMP "
-#~ "EntityBean）。我们不推荐你使用提交选项 \"A\"，除非你的 Entity Bean 是只读"
-#~ "的。（有些设计模式允许你把提交选项\"A\" 用于 read-mostly beans。你也可以看"
-#~ "看 Seppuku 模式：<ulink url=\"http://dima.dhs.org/misc/readOnlyUpdates."
-#~ "html\"></ulink>。JBoss 有可能把这个模式集成到以后的版本里。）"
-
-#~ msgid ""
-#~ "If you are using Bean Managed Persistence (BMP), you are going to have to "
-#~ "implement synchronization on your own. The MVCSoft CMP 2.0 persistence "
-#~ "engine (see <ulink url=\"http://www.jboss.org/jbossgroup/partners.jsp\"></"
-#~ "ulink>) provides different kinds of optimistic locking strategies that "
-#~ "can work in a JBoss cluster."
-#~ msgstr ""
-#~ "如果你正在使用 Bean Managed Persistence (BMP），你将不得不实现自己的同步机"
-#~ "制。MVCSoft CMP 2.0 持久化引擎（persistence engine）(请参考 <ulink url="
-#~ "\"http://www.jboss.org/jbossgroup/partners.jsp\"></ulink>）提供可以在 "
-#~ "JBoss 群集里使用的各种优化锁定策略。"
-
-#~ msgid "Entity Bean in EJB 3.0"
-#~ msgstr "EJB 3.0 里的 Entity Bean"
-
-#~ msgid ""
-#~ "In EJB 3.0, the entity beans primarily serve as a persistence data model. "
-#~ "They do not provide remote services. Hence, the entity bean clustering "
-#~ "service in EJB 3.0 primarily deals with distributed caching and "
-#~ "replication, instead of load balancing."
-#~ msgstr ""
-#~ "在 EJB 3.0 里，entity beans 主要以持久化数据模型出现。它们不提供远程服务。"
-#~ "因此，EJB 3.0 里的 entity bean 群集服务主要处理分布式缓存和复制，而不是负"
-#~ "载平衡。"
-
-#~ msgid "Configure the distributed cache"
-#~ msgstr "配置分布式缓存"
-
-#~ msgid ""
-#~ "To avoid round trips to the database, you can use a cache for your "
-#~ "entities. JBoss EJB 3.0 is implemented by Hibernate, which has support "
-#~ "for a second-level cache. The Hibernate setup used for the JBoss EJB 3.0 "
-#~ "implementation uses JBoss Cache as its underlying cache implementation. "
-#~ "The cache provides the following functionalities."
-#~ msgstr ""
-#~ "为了避免多次访问数据库，你可以为你的 entities 使用缓存。JBoss EJB 3.0 是"
-#~ "用 Hibernate 实现的，它支持两级缓存。用于 JBoss EJB 3.0 实现的 Hibernate "
-#~ "setup 把 JBoss Cache 当作底层缓存实现使用。这个缓存提供了下面的功能："
-
-#~ msgid ""
-#~ "If you persist a cache enabled entity bean instance to the database via "
-#~ "the entity manager the entity will inserted into the cache."
-#~ msgstr ""
-#~ "如果你通过 entity manager 来使应用缓存的 entity bean 的实例持久化，这个 "
-#~ "entity 会被储存到缓存里。"
-
-#~ msgid ""
-#~ "If you update an entity bean instance and save the changes to the "
-#~ "database via the entity manager the entity will updated in the cache."
-#~ msgstr ""
-#~ "如果你通过 entity manager 更新 entity bean 实例并把更改保存到数据库里，缓"
-#~ "存里的这个 entity 将被更新。"
-
-#~ msgid ""
-#~ "If you remove an entity bean instance from the database via the entity "
-#~ "manager the entity will removed from the cache."
-#~ msgstr ""
-#~ "如果你通过 entity manager 把 entity bean 实例从数据库里删除，这个 entity "
-#~ "也将从缓存里删除。"
-
-#~ msgid ""
-#~ "If loading a cached entity from the database via the entity manager, and "
-#~ "that entity does not exist in the database, it will be inserted into the "
-#~ "cache."
-#~ msgstr ""
-#~ "如果你通过 entity manager 从数据库里载入缓存的 entity，而这个这个 entity "
-#~ "并不在缓存里，这个 entity 会被插入到缓存里。"
-
-#, fuzzy
-#~ msgid ""
-#~ "JBoss Cache service for EJB 3.0 entity beans is configured in a "
-#~ "<literal>TreeCache</literal> MBean (see <xref linkend="
-#~ "\"JBossCache_and_JGroups_Services-JBossCache_Configuration\"/>) in the "
-#~ "<literal>deploy/ejb3-entity-cache-service.xml</literal> file. The name of "
-#~ "the cache MBean service is <literal>jboss.cache:"
-#~ "service=EJB3EntityTreeCache</literal>. Below is the contents of the "
-#~ "<literal>ejb3-entity-cache-service.xml</literal> file in the standard "
-#~ "JBoss distribution. Again, we omitted the JGroups configuration element "
-#~ "<literal>ClusterConfig</literal>."
-#~ msgstr ""
-#~ "JEJB 3.0 entity beans 采用的 Boss Cache 服务在 <literal>deploy/ejb3-"
-#~ "entity-cache-service.xml</literal> 文件里的 <literal>TreeCache</literal> "
-#~ "MBean（请参考<xref linkend=\"jbosscache-cache\"/>） 里被配置。缓存 MBean "
-#~ "服务名是<literal>jboss.cache:service=EJB3EntityTreeCache</literal>。下面是"
-#~ "标准 JBoss 发行版本里的 <literal>ejb3-entity-cache-service.xml</literal> "
-#~ "文件的内容。我们再次忽略了 JGroups 的配置元素 <literal>ClusterConfig</"
-#~ "literal>。"
-
-#~ msgid ""
-#~ "<server>\n"
-#~ " <mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ " name=\"jboss.cache:service=EJB3EntityTreeCache\">\n"
-#~ " \n"
-#~ " <depends>jboss:service=Naming</depends>\n"
-#~ " <depends>jboss:service=TransactionManager</depends>\n"
-#~ "\n"
-#~ " <!-- Configure the TransactionManager -->\n"
-#~ " <attribute name=\"TransactionManagerLookupClass\">\n"
-#~ " org.jboss.cache.JBossTransactionManagerLookup\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"IsolationLevel\">REPEATABLE_READ</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheMode\">REPL_SYNC</attribute>\n"
-#~ "\n"
-#~ " <!--Name of cluster. Needs to be the same for all clusters, \n"
-#~ " in order to find each other -->\n"
-#~ " <attribute name=\"ClusterName\">EJB3-entity-cache</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"ClusterConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"InitialStateRetrievalTimeout\">5000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"SyncReplTimeout\">10000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"LockAcquisitionTimeout\">15000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"EvictionPolicyClass\">\n"
-#~ " org.jboss.cache.eviction.LRUPolicy\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Specific eviction policy configurations. This is LRU --"
-#~ ">\n"
-#~ " <attribute name=\"EvictionPolicyConfig\">\n"
-#~ " <config>\n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">5</"
-#~ "attribute>\n"
-#~ " <!-- Cache wide default -->\n"
-#~ " <region name=\"/_default_\">\n"
-#~ " <attribute name=\"maxNodes\">5000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"timeToLiveSeconds\">1000</"
-#~ "attribute>\n"
-#~ " </region>\n"
-#~ " </config>\n"
-#~ " </attribute>\n"
-#~ " </mbean>\n"
-#~ "</server>"
-#~ msgstr ""
-#~ "<server>\n"
-#~ " <mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ " name=\"jboss.cache:service=EJB3EntityTreeCache\">\n"
-#~ " \n"
-#~ " <depends>jboss:service=Naming</depends>\n"
-#~ " <depends>jboss:service=TransactionManager</depends>\n"
-#~ "\n"
-#~ " <!-- Configure the TransactionManager -->\n"
-#~ " <attribute name=\"TransactionManagerLookupClass\">\n"
-#~ " org.jboss.cache.JBossTransactionManagerLookup\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"IsolationLevel\">REPEATABLE_READ</"
-#~ "attribute>\n"
-#~ " <attribute name=\"CacheMode\">REPL_SYNC</attribute>\n"
-#~ "\n"
-#~ " <!--Name of cluster. Needs to be the same for all clusters, \n"
-#~ " in order to find each other -->\n"
-#~ " <attribute name=\"ClusterName\">EJB3-entity-cache</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"ClusterConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"InitialStateRetrievalTimeout\">5000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"SyncReplTimeout\">10000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"LockAcquisitionTimeout\">15000</"
-#~ "attribute>\n"
-#~ "\n"
-#~ " <attribute name=\"EvictionPolicyClass\">\n"
-#~ " org.jboss.cache.eviction.LRUPolicy\n"
-#~ " </attribute>\n"
-#~ "\n"
-#~ " <!-- Specific eviction policy configurations. This is LRU --"
-#~ ">\n"
-#~ " <attribute name=\"EvictionPolicyConfig\">\n"
-#~ " <config>\n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">5</"
-#~ "attribute>\n"
-#~ " <!-- Cache wide default -->\n"
-#~ " <region name=\"/_default_\">\n"
-#~ " <attribute name=\"maxNodes\">5000</"
-#~ "attribute>\n"
-#~ " <attribute name=\"timeToLiveSeconds\">1000</"
-#~ "attribute>\n"
-#~ " </region>\n"
-#~ " </config>\n"
-#~ " </attribute>\n"
-#~ " </mbean>\n"
-#~ "</server>"
-
-#, fuzzy
-#~ msgid ""
-#~ "As we discussed in <xref linkend=\"JBossCache_and_JGroups_Services-"
-#~ "JBossCache_Configuration\"/>, JBoss Cache allows you to specify timeouts "
-#~ "to cached entities. Entities not accessed within a certain amount of time "
-#~ "are dropped from the cache in order to save memory. If running within a "
-#~ "cluster, and the cache is updated, changes to the entries in one node "
-#~ "will be replicated to the corresponding entries in the other nodes in the "
-#~ "cluster."
-#~ msgstr ""
-#~ "正如我们在 <xref linkend=\"jbosscache-cache\"/> 所讨论的，JBoss Cache 允许"
-#~ "你指定缓存的 entities 的超时时间。在某个时段内没有被访问的 entities 将从缓"
-#~ "存里删除，这样可以节省内存。如果这个缓存是在群集里运行，那么它会被更新。对"
-#~ "某个节点的 entries 的改动都会复制到群集里其他节点的相应条目里。"
-
-#~ msgid ""
-#~ "Now, we have JBoss Cache configured to support distributed caching of EJB "
-#~ "3.0 entity beans. We still have to configure individual entity beans to "
-#~ "use the cache service."
-#~ msgstr ""
-#~ "现在，我们配置了 JBoss Cache 来支持 EJB 3.0 entity beans 的分布式缓存。我"
-#~ "们仍不得不配置单个的 entity bean 来使用这个缓存服务。"
-
-#~ msgid "Configure the entity beans for cache"
-#~ msgstr "配置 entity beans 的缓存"
-
-#~ msgid ""
-#~ "You define your entity bean classes the normal way. Future versions of "
-#~ "JBoss EJB 3.0 will support annotating entities and their relationship "
-#~ "collections as cached, but for now you have to configure the underlying "
-#~ "hibernate engine directly. Take a look at the <literal>persistence.xml</"
-#~ "literal> file, which configures the caching options for hibernate via its "
-#~ "optional <literal>property</literal> elements. The following element in "
-#~ "<literal>persistence.xml</literal> defines that caching should be enabled:"
-#~ msgstr ""
-#~ "你用正常方式定义你的 entity bean 类。JBoss EJB 3.0 将来的版本将支持 "
-#~ "annotating entities 和所缓存的它们的关系的集合，但是现在你不得不直接配置底"
-#~ "层的 hibernate 引擎。让我们看看通过可选的 <literal>property</literal> 元素"
-#~ "配置 hibernate 缓存选项的 <literal>persistence.xml</literal> 文件。下面 "
-#~ "<literal>persistence.xml</literal> 里的定义缓存的元素应该被启用："
-
-#~ msgid ""
-#~ "<!-- Clustered cache with TreeCache -->\n"
-#~ "<property name=\"cache.provider_class\">\n"
-#~ " org.jboss.ejb3.entity.TreeCacheProviderHook\n"
-#~ "</property>"
-#~ msgstr ""
-#~ "<!-- Clustered cache with TreeCache -->\n"
-#~ "<property name=\"cache.provider_class\">\n"
-#~ " org.jboss.ejb3.entity.TreeCacheProviderHook\n"
-#~ "</property>"
-
-#~ msgid ""
-#~ "The following property element defines the object name of the cache to be "
-#~ "used, and the MBean name."
-#~ msgstr "下面的属性元素定义了所使用的缓存对象名和 MBean 名。"
-
-#~ msgid ""
-#~ "<property name=\"treecache.mbean.object_name\">\n"
-#~ " jboss.cache:service=EJB3EntityTreeCache\n"
-#~ "</property>"
-#~ msgstr ""
-#~ "<property name=\"treecache.mbean.object_name\">\n"
-#~ " jboss.cache:service=EJB3EntityTreeCache\n"
-#~ "</property>"
-
-#~ msgid ""
-#~ "Next we need to configure what entities be cached. The default is to not "
-#~ "cache anything, even with the settings shown above. We use the "
-#~ "<literal>@Cache</literal> annotation to tag entity beans that needs to be "
-#~ "cached."
-#~ msgstr ""
-#~ "下一步我们需要配置 entities 被缓存的内容。就像上面所展示的样，缺省是什么都"
-#~ "不缓存。我们使用 <literal>@Cache</literal> 注解来标记需要缓存的 entity "
-#~ "beans。"
-
-#~ msgid ""
-#~ "@Entity \n"
-#~ "@Cache(usage=CacheConcurrencyStrategy.TRANSACTIONAL) \n"
-#~ "public class Customer implements Serializable { \n"
-#~ " // ... ... \n"
-#~ "}"
-#~ msgstr ""
-#~ "@Entity \n"
-#~ "@Cache(usage=CacheConcurrencyStrategy.TRANSACTIONAL） \n"
-#~ "public class Customer implements Serializable { \n"
-#~ " // ... ... \n"
-#~ "}"
-
-#~ msgid ""
-#~ "A very simplified rule of thumb is that you will typically want to do "
-#~ "caching for objects that rarely change, and which are frequently read. "
-#~ "You can fine tune the cache for each entity bean in the <literal>ejb3-"
-#~ "entity-cache-service.xml</literal> configuration file. For instance, you "
-#~ "can specify the size of the cache. If there are too many objects in the "
-#~ "cache, the cache could evict oldest objects (or least used objects, "
-#~ "depending on configuration) to make room for new objects. The cache for "
-#~ "the <literal>mycompany.Customer</literal> entity bean is <literal>/"
-#~ "mycompany/Customer</literal> cache region."
-#~ msgstr ""
-#~ "一个简单的原则就是，你应该对很少变动和频繁使用的对象进行缓存.你可以在 "
-#~ "<literal>ejb3-entity-cache-service.xml</literal> 配置文件里为每个 entity "
-#~ "bean 微调缓存设置。例如，你可以指定缓存的大小。如果缓存里的对象太多，缓存"
-#~ "有可能挤掉最老的对象（或者最少用的对象，依你的配置而定）来给新对象留出空"
-#~ "间。<literal>mycompany.Customer</literal> entity bean 的缓存区（cache "
-#~ "region）是 <literal>/mycompany/Customer</literal>。"
-
-#~ msgid ""
-#~ "<server> \n"
-#~ " <mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ " name=\"jboss.cache:service=EJB3EntityTreeCache\"> \n"
-#~ " <depends>jboss:service=Naming \n"
-#~ " <depends>jboss:service=TransactionManager \n"
-#~ " ... ... \n"
-#~ " <attribute name=\"EvictionPolicyConfig\"> \n"
-#~ " <config> \n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">5</"
-#~ "attribute> \n"
-#~ " <region name=\"/_default_\"> \n"
-#~ " <attribute name=\"maxNodes\">5000</attribute> \n"
-#~ " <attribute name=\"timeToLiveSeconds\">1000</"
-#~ "attribute> \n"
-#~ " </region> \n"
-#~ " <region name=\"/mycompany/Customer\"> \n"
-#~ " <attribute name=\"maxNodes\">10</attribute> \n"
-#~ " <attribute name=\"timeToLiveSeconds\">5000</"
-#~ "attribute> \n"
-#~ " </region> \n"
-#~ " ... ... \n"
-#~ " </config> \n"
-#~ " </attribute> \n"
-#~ " </mbean> \n"
-#~ "</server>"
-#~ msgstr ""
-#~ "<server> \n"
-#~ " <mbean code=\"org.jboss.cache.TreeCache\" \n"
-#~ " name=\"jboss.cache:service=EJB3EntityTreeCache\"> \n"
-#~ " <depends>jboss:service=Naming \n"
-#~ " <depends>jboss:service=TransactionManager \n"
-#~ " ... ... \n"
-#~ " <attribute name=\"EvictionPolicyConfig\"> \n"
-#~ " <config> \n"
-#~ " <attribute name=\"wakeUpIntervalSeconds\">5</"
-#~ "attribute> \n"
-#~ " <region name=\"/_default_\"> \n"
-#~ " <attribute name=\"maxNodes\">5000</attribute> \n"
-#~ " <attribute name=\"timeToLiveSeconds\">1000</"
-#~ "attribute> \n"
-#~ " </region> \n"
-#~ " <region name=\"/mycompany/Customer\"> \n"
-#~ " <attribute name=\"maxNodes\">10</attribute> \n"
-#~ " <attribute name=\"timeToLiveSeconds\">5000</"
-#~ "attribute> \n"
-#~ " </region> \n"
-#~ " ... ... \n"
-#~ " </config> \n"
-#~ " </attribute> \n"
-#~ " </mbean> \n"
-#~ "</server>"
-
-#~ msgid ""
-#~ "If you do not specify a cache region for an entity bean class, all "
-#~ "instances of this class will be cached in the <literal>/_default</"
-#~ "literal> region as defined above. The EJB3 <literal>Query</literal> API "
-#~ "provides means for you to save to load query results (i.e., collections "
-#~ "of entity beans) from specified cache regions."
-#~ msgstr ""
-#~ "如果你没有为 entity bean 类指定缓存区（cache region），这个类的所有实例将"
-#~ "象上面定义的一样缓存在 <literal>/_default</literal> 区里。EJB3 "
-#~ "<literal>Query</literal> API 提供了让你在指定的缓存区里保存或载入查询结果"
-#~ "（就是 entity beans 的集合）的方法。"
-
-#~ msgid "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'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"
-#~ "<Location /jkstatus/>\n"
-#~ " JkMount status\n"
-#~ " Order deny,allow\n"
-#~ " Deny from all\n"
-#~ " Allow from 127.0.0.1\n"
-#~ "</Location>"
-#~ 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"
-#~ "<Location /jkstatus/>\n"
-#~ " JkMount status\n"
-#~ " Order deny,allow\n"
-#~ " Deny from all\n"
-#~ " Allow from 127.0.0.1\n"
-#~ "</Location>"
-
-#~ 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'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'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><"
-#~ "Engine></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><"
-#~ "Engine></literal> 元素并加入一个 <literal>jvmRoute</literal> 属性："
-
-#~ msgid ""
-#~ "<Engine name=\"jboss.web\" defaultHost=\"localhost\" jvmRoute=\"node1"
-#~ "\">\n"
-#~ "... ...\n"
-#~ "</Engine>"
-#~ msgstr ""
-#~ "<Engine name=\"jboss.web\" defaultHost=\"localhost\" jvmRoute=\"node1"
-#~ "\">\n"
-#~ "... ...\n"
-#~ "</Engine>"
-
-#, 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><attribute></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><attribute></literal> 元素，把它的值设置为 <literal>true</"
-#~ "literal>："
-
-#~ msgid "<attribute name=\"UseJK\">true</attribute>"
-#~ msgstr "<attribute name=\"UseJK\">true</attribute>"
-
-#~ 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 ""
-#~ "<mbean code=\"org.jboss.cache.aop.TreeCacheAop\"\n"
-#~ " name=\"jboss.cache:service=TomcatClusteringCache\">\n"
-#~ "\n"
-#~ " <depends>jboss:service=Naming</depends>\n"
-#~ " <depends>jboss:service=TransactionManager</depends>\n"
-#~ " <depends>jboss.aop:service=AspectDeployer</depends>\n"
-#~ "\n"
-#~ " <attribute name=\"TransactionManagerLookupClass\">\n"
-#~ " org.jboss.cache.BatchModeTransactionManagerLookup\n"
-#~ " </attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"IsolationLevel\">REPEATABLE_READ</"
-#~ "attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"CacheMode\">REPL_ASYNC</attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"ClusterName\">\n"
-#~ " Tomcat-${jboss.partition.name:Cluster}\n"
-#~ " </attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"UseMarshalling\">false</attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"InactiveOnStartup\">false</attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"ClusterConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"LockAcquisitionTimeout\">15000</"
-#~ "attribute>\n"
-#~ "</mbean>"
-#~ msgstr ""
-#~ "<mbean code=\"org.jboss.cache.aop.TreeCacheAop\"\n"
-#~ " name=\"jboss.cache:service=TomcatClusteringCache\">\n"
-#~ "\n"
-#~ " <depends>jboss:service=Naming</depends>\n"
-#~ " <depends>jboss:service=TransactionManager</depends>\n"
-#~ " <depends>jboss.aop:service=AspectDeployer</depends>\n"
-#~ "\n"
-#~ " <attribute name=\"TransactionManagerLookupClass\">\n"
-#~ " org.jboss.cache.BatchModeTransactionManagerLookup\n"
-#~ " </attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"IsolationLevel\">REPEATABLE_READ</"
-#~ "attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"CacheMode\">REPL_ASYNC</attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"ClusterName\">\n"
-#~ " Tomcat-${jboss.partition.name:Cluster}\n"
-#~ " </attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"UseMarshalling\">false</attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"InactiveOnStartup\">false</attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"ClusterConfig\">\n"
-#~ " ... ...\n"
-#~ " </attribute>\n"
-#~ " \n"
-#~ " <attribute name=\"LockAcquisitionTimeout\">15000</"
-#~ "attribute>\n"
-#~ "</mbean>"
-
-#, 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'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's an example:"
-#~ msgstr ""
-#~ "为了启用 web 应用程序的群集，你必须在 <literal>web.xml</literal> 描述符里"
-#~ "把它标记为 distributable。下面是一个例子："
-
-#, fuzzy
-#~ msgid ""
-#~ "<?xml version=\"1.0\"?> \n"
-#~ "<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\">\n"
-#~ " <emphasis role=\"bold\"><distributable/></emphasis>\n"
-#~ " <!-- ... -->\n"
-#~ "</web-app>"
-#~ msgstr ""
-#~ "<?xml version=\"1.0\"?> \n"
-#~ "<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\">\n"
-#~ " <emphasis role=\"bold\"><distributable/></emphasis>\n"
-#~ " <!-- ... -->\n"
-#~ "</web-app>"
-
-#~ 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 ""
-#~ "<jboss-web>\n"
-#~ " <replication-config>\n"
-#~ " <replication-trigger>SET_AND_NON_PRIMITIVE_GET</"
-#~ "replication-trigger>\n"
-#~ " <replication-granularity>SESSION</replication-"
-#~ "granularity>\n"
-#~ " <replication-field-batch-mode>true</replication-field-"
-#~ "batch-mode>\n"
-#~ " </replication-config>\n"
-#~ "</jboss-web>"
-#~ msgstr ""
-#~ "<jboss-web>\n"
-#~ " <replication-config>\n"
-#~ " <replication-trigger>SET_AND_NON_PRIMITIVE_GET</"
-#~ "replication-trigger>\n"
-#~ " <replication-granularity>SESSION</replication-"
-#~ "granularity>\n"
-#~ " <replication-field-batch-mode>true</replication-field-"
-#~ "batch-mode>\n"
-#~ " </replication-config>\n"
-#~ "</jboss-web>"
-
-#~ 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'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'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'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'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'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'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."
-#~ 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't currently any tools that allow you to inspect the contents of "
-#~ "the replicated session values. If you don't see any output, either "
-#~ "the application was not correctly marked as <literal>distributable</"
-#~ "literal> or you haven'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 ""
-#~ "<Valve className=\"org.jboss.web.tomcat.service.sso."
-#~ "ClusteredSingleSignOn\" />"
-#~ msgstr ""
-#~ "<Valve className=\"org.jboss.web.tomcat.tc5.sso.ClusteredSingleSignOn"
-#~ "\" />"
-
-#~ msgid "Clustered JMS Services"
-#~ msgstr "群集的 JMS 服务"
-
-#~ msgid ""
-#~ "JBoss AS 3.2.4 and above support high availability JMS (HA-JMS) services "
-#~ "in the <literal>all</literal> server configuration. In the current "
-#~ "production release of JBoss AS, the HA-JMS service is implemented as a "
-#~ "clustered singleton fail-over service."
-#~ msgstr ""
-#~ "JBoss AS 3.2.4 和更高的版本支持高可用性的 <literal>all</literal> 服务器配"
-#~ "置里的 JMS（HA-JMS）服务。在 JBoss AS 当前的发布版本里，HA-JMS 服务用一个"
-#~ "群集的 singleton fail-over 服务来实现。"
-
-#~ msgid ""
-#~ "If you are willing to configure HA-JMS yourself, you can get it to work "
-#~ "with earlier versions of JBoss AS. We have a customer who uses HA-JMS "
-#~ "successfully in JBoss AS 3.0.7. Please contact JBoss support for more "
-#~ "questions."
-#~ msgstr ""
-#~ "如果你希望自己来配置 HA-JMS，你可以在以前的 JBoss AS 版本里让它运行。我们"
-#~ "有一个客户成功地在 JBoss AS 3.0.7 里使用 HA-JMS。如果你有更多问题的话，请"
-#~ "联系 JBoss 支持部门。"
-
-#~ msgid "High Availability Singleton Fail-over"
-#~ msgstr "高可用性的 Singleton Fail-over"
-
-#~ msgid ""
-#~ "The JBoss HA-JMS service (i.e., message queues and topics) only runs on a "
-#~ "single node (i.e., the master node) in the cluster at any given time. If "
-#~ "that node fails, the cluster simply elects another node to run the JMS "
-#~ "service (fail-over). This setup provides redundancy against server "
-#~ "failures but does not reduce the work load on the JMS server node."
-#~ msgstr ""
-#~ "JBoss HA-JMS 服务（也就是消息队列和主题）任何给定时间都只在群集里的单节点"
-#~ "运行（主节点）。如果这个节点崩溃了，群集系统简单地选取另外一节点来运行 "
-#~ "JMS 服务（fail-over）。这种设置提供了针对服务器瘫痪的冗余措施，但并没有降"
-#~ "低 JMS 服务器节点的负载。"
-
-#, fuzzy
-#~ msgid ""
-#~ "While you cannot load balance HA-JMS queues (there is only one master "
-#~ "node that runs the queues), you can load balance the MDBs that process "
-#~ "messages from those queues (see <xref linkend="
-#~ "\"High_Availability_Singleton_Fail_over-Load_Balanced_HA_JMS_MDBs\"/>)."
-#~ msgstr ""
-#~ "虽然你不能够对 HA-JMS 队列进行负载平衡（只有一个运行这个队列的主节点），但"
-#~ "是你可以平衡处理队列里信息的 MDBs 的负载（请参考 <xref linkend="
-#~ "\"clustering-jms-loadbalanced\"/>）。"
-
-#~ msgid "Server Side Configuration"
-#~ msgstr "服务端配置"
-
-#~ msgid ""
-#~ "To use the singleton fail-over HA-JMS service, you must configure JMS "
-#~ "services identically on all nodes in the cluster. That includes all JMS "
-#~ "related service MBeans and all deployed JMS applications."
-#~ msgstr ""
-#~ "为了使用 singleton fail-over HA-JMS 服务，你必须在群集里的所有节点上配置相"
-#~ "同的 JMS 服务。这包括所有和 JMS 相关的 MBeans 以及部署的 JMS 应用程序。"
-
-#~ msgid ""
-#~ "The JMS server is configured to persist its data in the "
-#~ "<literal>DefaultDS</literal>. By default, that is the embedded HSQLDB. In "
-#~ "most cluster environments, however, all nodes need to persist data "
-#~ "against a shared database. So, the first thing to do before you start "
-#~ "clustered JMS is to setup a shared database for JMS. You need to do the "
-#~ "following:"
-#~ msgstr ""
-#~ "JMS 服务器被设置成在 <literal>DefaultDS</literal> 里持久化它的数据。在缺省"
-#~ "的情况下，那就是内含的 HSQLDB。然而，在大部分群集环境里，所有节点都需要把"
-#~ "数据持久化到一个共享数据库里。因此，在你启动群集 JMS 之前要做的第一件事就"
-#~ "是建立一个共享数据库。你需要做如下的事情："
-
-#, fuzzy
-#~ msgid ""
-#~ "Configure <literal>DefaultDS</literal> to point to the database server of "
-#~ "your choice. That is to replace the <literal>deploy/hsqlsb-ds.xml</"
-#~ "literal> file with the <literal>xxx-ds.xml</literal> file in the "
-#~ "<literal>docs/examples/jca</literal> directory, where <literal>xxx</"
-#~ "literal> is the name of the target shared database (e.g., <literal>mysql-"
-#~ "ds.xml</literal>, see <xref linkend=\"Connectors_on_JBoss-"
-#~ "Configuring_JDBC_DataSources\"/>)."
-#~ msgstr ""
-#~ "配置 <literal>DefaultDS</literal> 来指向你选择的数据库服务器。就是用 "
-#~ "<literal>docs/examples/jca</literal> 目录下的 <literal>xxx-ds.xml</"
-#~ "literal> 文件代替 <literal>deploy/hsqlsb-ds.xml</literal> 文件，其中 "
-#~ "<literal>xxx</literal> 是目标共享数据库的名字（例如，<literal>mysql-ds."
-#~ "xml</literal> ）"
-
-#~ msgid ""
-#~ "Replace the <literal>hsqldb-jdbc2-service.xml</literal> file under the "
-#~ "<literal>server/all/deploy-hasingleton/jms</literal> directory with one "
-#~ "tuned to the specific database. For example if you use MySQL the file is "
-#~ "<literal>mysql-jdbc2-service.xml</literal>. Configuration files for a "
-#~ "number of RDBMS are bundled with the JBoss AS distribution. They can be "
-#~ "found under <literal>docs/examples/jms</literal>."
-#~ msgstr ""
-#~ "把 <literal>server/all/deploy-hasingleton/jms</literal> 目录下的 "
-#~ "<literal>hsqldb-jdbc2-service.xml</literal>文件用特定数据库的文件代替。例"
-#~ "如，MySQL 的文件就是 <literal>mysql-jdbc2-service.xml</literal>。JBoss AS "
-#~ "发行版本捆绑了一些 RDBMS 的配置文件。它们可以在 <literal>docs/examples/"
-#~ "jms</literal> 下找到。"
-
-#~ msgid ""
-#~ "There is no need to replace the <literal>hsqldb-jdbc-state-service.xml</"
-#~ "literal> file under the <literal>server/all/deploy-hasingleton/jms</"
-#~ "literal> directory. Despite the <literal>hsql</literal> in its name, it "
-#~ "works with all SQL92 compliant databases, including HSQL, MySQL, SQL "
-#~ "Server, and more. It automatically uses the <literal>DefaultDS</literal> "
-#~ "for storage, as we configured above."
-#~ msgstr ""
-#~ "你不需要替换 <literal>server/all/deploy-hasingleton/jms</literal> 目录下"
-#~ "的 <literal>hsqldb-jdbc-state-service.xml</literal> 文件。尽管它的名字里包"
-#~ "含 <literal>hsql</literal>，它适用于所有兼容 SQL92 的数据库，包括 HSQL，"
-#~ "MySQL，SQL Server 和更多数据库。象我们上面配置的那样，它自动使用 "
-#~ "<literal>DefaultDS</literal> 来存放数据。"
-
-#~ msgid "HA-JMS Client"
-#~ msgstr "HA-JMS 客户"
-
-#~ msgid ""
-#~ "The HA-JMS client is different from regular JMS clients in two important "
-#~ "aspects."
-#~ msgstr "HA-JMS 客户和常规的 JMS 客户在两个方面有所不同。"
-
-#~ msgid ""
-#~ "The HA-JMS client must obtain JMS connection factories from the HA-JNDI "
-#~ "(the default port is 1100)."
-#~ msgstr ""
-#~ "HA-JMS 客户必须获得 HA-JNDI 里的 JMS connection factories（缺省端口是"
-#~ "1100）。"
-
-#~ msgid ""
-#~ "The client connection must listens for server exceptions. When the "
-#~ "cluster fail-over to a different master node, all client operations on "
-#~ "the current connection fails with exceptions. The client must know to re-"
-#~ "connect."
-#~ msgstr ""
-#~ "客户连接必须监控服务器异常（exceptions）。当群集系统 fail-over 到另外一个"
-#~ "主节点时，所有在当前连接上的的客户端操作都会失败并产生异常（exceptions）。"
-#~ "客户端必须知道该重新连接。"
-
-#~ msgid ""
-#~ "While the HA-JMS connection factory knows the current master node that "
-#~ "runs JMS services, there is no smart client side interceptor. The client "
-#~ "stub only knows the fixed master node and cannot adjust to server "
-#~ "topography changes."
-#~ msgstr ""
-#~ "虽然 HA-JMS 连接工厂（connection factory）知道运行 JMS 服务的当前主节点，"
-#~ "但并不存在智能的客户端拦截器（client side interceptor）。客户端 stub 只知"
-#~ "道固定的主节点，它不能够依服务器拓扑结构的变化而调整。"
-
-#~ msgid "Load Balanced HA-JMS MDBs"
-#~ msgstr "负载平衡的 HA-JMS MDBs "
-
-#~ msgid ""
-#~ "While the HA-JMS queues and topics only run on a single node at a time, "
-#~ "MDBs on multiple nodes can receive and process messages from the HA-JMS "
-#~ "master node. The contested queues and topics result in load balancing "
-#~ "behavior for MDBs. To enable loading balancing for MDBs, you can specify "
-#~ "a receiver for the queue. The receiver records which node is waiting for "
-#~ "a message and in which order the messages should be processed. JBoss "
-#~ "provides three receiver implementations."
-#~ msgstr ""
-#~ "虽然 HA-JMS 队列（queues）和主题（topics）在同一时间只在单节点上运行，但其"
-#~ "他节点上的 MDBs 也能够接收和处理 HA-JMS 主节点上的信息。这种竞争的情况导"
-#~ "致 MDBs 的平衡负载行为。为了启用 MDBs 的平衡负载，你可以指定队列的 "
-#~ "receiver。这个 receiver 记录哪个节点正在等待信息和信息该按什么样的顺序来处"
-#~ "理。JBoss 提供三个 receiver 的实现（implementations）。"
-
-#~ msgid ""
-#~ "The <literal>org.jboss.mq.server.ReceiversImpl</literal> is the default "
-#~ "implementation using a <literal>HashSet</literal>."
-#~ msgstr ""
-#~ "<literal>org.jboss.mq.server.ReceiversImpl</literal> 是 <literal>HashSet</"
-#~ "literal> 的缺省实现（implementation）。"
-
-#~ msgid ""
-#~ "The <literal>org.jboss.mq.server.ReceiversImplArrayList</literal> is "
-#~ "theimplementation using an <literal>ArrayList</literal>."
-#~ msgstr ""
-#~ "<literal>org.jboss.mq.server.ReceiversImplArrayList</literal> 是 "
-#~ "<literal>ArrayList</literal> 的实现。"
-
-#~ msgid ""
-#~ "The <literal>org.jboss.mq.server.ReceiversImplLinkedList</literal> is the "
-#~ "implementation using a <literal>LinkedList</literal>."
-#~ msgstr ""
-#~ "<literal>org.jboss.mq.server.ReceiversImplLinkedList</literal> 是 "
-#~ "<literal>LinkedList</literal> 的实现。"
-
-#, fuzzy
-#~ msgid ""
-#~ "You can specify the receiver implementation class name as an attribute in "
-#~ "the MBean that defines the permanent JMS <literal>Queue</literal> or "
-#~ "<literal>DestinationManager</literal> on each node (see <xref linkend="
-#~ "\"Messaging_on_JBoss\"/>). For best load balancing performance, we "
-#~ "suggest you to use the <literal>ReceiversImplArrayList</literal> or "
-#~ "<literal>ReceiversImplArrayList</literal> implementations due to an "
-#~ "undesirable implementation detail of <literal>HashSet</literal> in the "
-#~ "JVM."
-#~ msgstr ""
-#~ "你可以指定 receiver 实现的类名作为在每个节点上定义永久 JMS "
-#~ "<literal>Queue</literal> 或 <literal>DestinationManager</literal> 的 "
-#~ "MBean 的一个属性。为了获得最好的负载平衡性能，我们建议你使用 "
-#~ "<literal>ReceiversImplArrayList</literal> 或 "
-#~ "<literal>ReceiversImplArrayList</literal> 实现，因为 JVM 里的 "
-#~ "<literal>HashSet</literal> 的实现不是很好。"
-
-#~ msgid ""
-#~ "Currently, due to an implementation bug, the farm deployment service only "
-#~ "works for hot-deployed archives. If you put an application in the "
-#~ "<literal>farm/</literal> directory first and then start the server, the "
-#~ "application would not be detected and pushed across the cluster. We are "
-#~ "working to resolve this issue."
-#~ msgstr ""
-#~ "目前，由于一个实现的程序缺陷， farm 部署服务只能用于热部署（hot-deployed）"
-#~ "档案文件。如果你先把一个应用程序放在 <literal>farm/</literal> 目录里然后启"
-#~ "动服务器，这个应用不会被检测到且运用到群集里。我们正在努力解决这个问题。"
-
-#~ 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 来编译你的源码。"
Modified: projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/The_CMP_Engine.po
===================================================================
--- projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/The_CMP_Engine.po 2008-05-06 06:16:41 UTC (rev 73071)
+++ projects/docs/trunk/AS_4/Server_Configuration_Guide/zh-CN/The_CMP_Engine.po 2008-05-06 07:10:30 UTC (rev 73072)
@@ -9,7 +9,7 @@
"Project-Id-Version: The_CMP_Engine\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2007-11-05 06:04+0000\n"
-"PO-Revision-Date: 2008-05-06 11:05+1000\n"
+"PO-Revision-Date: 2008-05-06 16:53+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -515,6 +515,8 @@
"linkend=\"The_CMP_Engine-Defaults\"/> for the details of the defaults "
"content."
msgstr ""
+"<emphasis role=\"bold\">defaults</emphasis>：defaults 部分允许对控制 Entity Bean 的行为的缺省行文/设置进行定义。这简化了 entity beans 部分里公用行为所需的信息。关于 defaults 内容的细节，请参考 <xref "
+"linkend=\"The_CMP_Engine-Defaults\"/>。"
#. Tag: para
#: The_CMP_Engine.xml:102
@@ -526,10 +528,13 @@
"descriptor. This is described in detail in <xref linkend=\"The_CMP_Engine-"
"Entity_Beans\"/>."
msgstr ""
+"<emphasis role=\"bold\">enterprise-beans</emphasis>：<literal>enterprise-"
+"beans</literal> 元素允许自定义 <literal>ejb-jar.xml</literal><literal>enterprise-beans</literal> 描述符里定义的 entity bean。<xref linkend=\"The_CMP_Engine-"
+"Entity_Beans\"/> 里对它进行了详细描述。"
#. Tag: para
#: The_CMP_Engine.xml:107
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<emphasis role=\"bold\">relationships</emphasis>: The "
"<literal>relationships</literal> element allows for the customization of "
@@ -537,9 +542,8 @@
"in detail in <xref linkend=\"The_CMP_Engine-Container_Managed_Relationships"
"\"/>."
msgstr ""
-"<emphasis role=\"bold\">PartitionConfig</emphasis> 是一个用来为这个群集（参"
-"看 <xref linkend=\"jbosscache-jgroups\"/>）指定 JGroup 配置选项的元素"
-"（element）。"
+"<emphasis role=\"bold\">relationships</emphasis>：<literal>relationships</literal> 元素允许对 entity 关系表和加载行为进行自定义。<xref linkend=\"The_CMP_Engine-Container_Managed_Relationships"
+"\"/> 对它进行了详细描述。"
#. Tag: para
#: The_CMP_Engine.xml:112
@@ -551,6 +555,8 @@
"value classes are described in detail in <xref linkend=\"CMP_Fields-"
"Dependent_Value_Classes_DVCs\"/> (DVCs)."
msgstr ""
+"<emphasis role=\"bold\">dependent-value-classes</emphasis>：<literal>dependent-value-classes</literal> 元素允许对 dependent value 类和表之间的映射进行自定义。<xref linkend=\"CMP_Fields-"
+"Dependent_Value_Classes_DVCs\"/> 里对 Dependent value 类进行了详细描述。"
#. Tag: para
#: The_CMP_Engine.xml:117
@@ -561,6 +567,8 @@
"database, along with SQL templates, and function mappings. This is described "
"in detail in <xref linkend=\"The_CMP_Engine-Datasource_Customization\"/>."
msgstr ""
+"<emphasis role=\"bold\">type-mappings</emphasis>：<literal>type-"
+"mappings</literal> 元素定义了用于数据库的 Java 与 SQL 类型的映射关系、SQL 模板以及函数映射。<xref linkend=\"The_CMP_Engine-Datasource_Customization\"/> 里对它进行了详细描述。"
#. Tag: para
#: The_CMP_Engine.xml:122
@@ -572,6 +580,10 @@
"store. This is described in detail in <xref linkend=\"The_CMP_Engine-"
"Entity_Commands_and_Primary_Key_Generation\"/>."
msgstr ""
+"<emphasis role=\"bold\">entity-commands</emphasis>：<literal>entity-"
+"commands</literal> 元素定义负责在持久性存储里创建 Entity 实例的 entity creation "
+"command 实例。<xref linkend=\"The_CMP_Engine-"
+"Entity_Commands_and_Primary_Key_Generation\"/> 里对它进行了详细描述。"
#. Tag: para
#: The_CMP_Engine.xml:127
@@ -585,6 +597,9 @@
"user type. Details of the user type mappings are described in <xref linkend="
"\"Datasource_Customization-User_Type_Mappings\"/>."
msgstr ""
+"<emphasis role=\"bold\">user-type-mappings</emphasis>：<literal>user-"
+"type-mappings</literal> 元素用 mapper 类定义了用户类型和列之间的映射。Mapper 类就像一个中介。进行存储时，它获取用户类型的实例并将其转换成 column 值。当进行加载时，它获取一个 Column 值并转换成用户类型的实例。<xref linkend="
+"\"Datasource_Customization-User_Type_Mappings\"/> 里对用户类型映射进行了详细描述。"
#. Tag: para
#: The_CMP_Engine.xml:132
@@ -595,12 +610,14 @@
"escaped when generating tables. Each reserved word is specified as the "
"content of a <literal>word</literal> element."
msgstr ""
+"<emphasis role=\"bold\">reserved-words</emphasis>：<literal>reserved-"
+"words</literal> 元素定义了产生表时不能使用的一个或多个保留字。每个保留字都通过 <literal>word</literal> 元素进行指定。"
#. Tag: title
#: The_CMP_Engine.xml:140
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Entity Beans"
-msgstr "实体查询（Entity queries）"
+msgstr "Entity Bean"
#. Tag: para
#: The_CMP_Engine.xml:141
@@ -612,7 +629,7 @@
"remote entity beans with pass-by-reference semantics for calls in the same "
"VM to get the performance benefit as from local entity beans, the use of "
"local entity beans is strongly encouraged."
-msgstr ""
+msgstr "通过 crime portal 里的一个 CMP Entity Bean，我们将开始学习 JBoss 里的 entity bean。我们将讨论作为本地 CMP entity bean 实现的 gangster bean。虽然 JBoss 可以提供远程 entity bean，它在相同的 VM 里使用引用传递（pass-by-reference）模式来获取和本地 entity bean 一样的性能优化。但我们还是鼓励尽量使用本地 entity bean。"
#. Tag: para
#: The_CMP_Engine.xml:144
@@ -621,7 +638,7 @@
"We'll start with the required home interface. Since we're only "
"concerned with the CMP fields at this point, we'll show only the methods "
"dealing with the CMP fields."
-msgstr ""
+msgstr "我们将从必需的 home 接口开始。既然目前我们只关心 CMP 字段，我们将只显示和 CMP 字段相关的方法。"
#. Tag: programlisting
#: The_CMP_Engine.xml:147
@@ -653,7 +670,7 @@
msgid ""
"The local interface is what clients will use to talk. Again, it contains "
"only the CMP field accessors."
-msgstr ""
+msgstr "客户用 local 接口来进行对话。它只包含 CMP 字段的 accessor。"
#. Tag: programlisting
#: The_CMP_Engine.xml:151
@@ -695,7 +712,7 @@
msgid ""
"Finally, we have the actual gangster bean. Despite it's size, very "
"little code is actually required. The bulk of the class is the create method."
-msgstr ""
+msgstr "最后，我们看到的实际的 gangster bean。它实际上只需要极少的代码。这个类的主要部分是 create 方法。"
#. Tag: programlisting
#: The_CMP_Engine.xml:155
@@ -795,6 +812,8 @@
"descriptor. Although the actual bean class is named <literal>GangsterBean</"
"literal>, we've called the entity <literal>GangsterEJB</literal>."
msgstr ""
+"现在唯一缺少的是 <literal>ejb-jar.xml</literal> 部署描述符。虽然实际的 bean 的类名是<literal>GangsterBean</"
+"literal>，我们将称其为 entity <literal>GangsterEJB</literal>。"
#. Tag: programlisting
#: The_CMP_Engine.xml:159
@@ -904,13 +923,13 @@
"indicate that this is EJB 2.x CMP entity bean. The abstract schema name was "
"set to <literal>gangster</literal>. That will be important when we look at "
"EJB-QL queries in <xref linkend=\"The_CMP_Engine-Queries\"/>."
-msgstr ""
+msgstr "请注意，我们已经指定了 CMP 版本为 <literal>2.x</literal> 以表示这是一个 EJB 2.x CMP entity bean。抽象模式名称被设置为 <literal>gangster</literal>。在 <xref linkend=\"The_CMP_Engine-Queries\"/> 里讨论 EJB-QL 查询时，这将很重要。"
#. Tag: title
#: The_CMP_Engine.xml:164
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Entity Mapping"
-msgstr "继承映射（Inheritance Mapping）"
+msgstr "Entity 映射"
#. Tag: para
#: The_CMP_Engine.xml:165
@@ -925,6 +944,8 @@
"the top level <literal>jbosscmp-jdbc</literal> element. A stubbed out entity "
"configuration is shown below."
msgstr ""
+"该 entity 的 JBoss 配置用 <literal>jbosscmp-jdbc.xml</literal> 文件里的 <literal>entity</"
+"literal> 元素进行声明。这个文件存在于 EJB JAR 的 <literal>META-INF</literal> 目录下，它包含所有用来配置 CMP 映射的可选配置信息。每个 entity bean 的 <literal>entity</literal> 元素都在 <literal>enterprise-beans</literal> 里进行分组，以 <literal>jbosscmp-jdbc</literal> 为顶层元素。下面是这个 entity 的根配置。"
#. Tag: programlisting
#: The_CMP_Engine.xml:168
@@ -973,6 +994,7 @@
#. Tag: para
#: The_CMP_Engine.xml:169
#, no-c-format
+#, fuzzy
msgid ""
"The <literal>ejb-name</literal> element is required to match the entity "
"specification here with the one in the <literal>ejb-jar.xml</literal> file. "
@@ -987,32 +1009,31 @@
"\"The_CMP_Engine-Defaults\"/>. <xref linkend=\"Entity_Mapping-"
"The_entity_element_content_model\"/> shows the full <literal>entity</"
"literal> content model."
-msgstr ""
+msgstr "<literal>ejb-name</literal> 元素需要匹配 <literal>ejb-jar.xml</literal> 文件里的 entity 定义。这个元素的剩余部分指定？"
#. Tag: title
#: The_CMP_Engine.xml:173
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The entity element content model"
-msgstr "The descriptors element content model"
+msgstr "entity 元素的内容模型"
#. Tag: para
#: The_CMP_Engine.xml:180
#, no-c-format
msgid "A detailed description of each entity element follows:"
-msgstr ""
+msgstr "下面是对每个 entity 元素的详细描述："
#. Tag: para
#: The_CMP_Engine.xml:185
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<emphasis role=\"bold\">ejb-name</emphasis>: This required element is the "
"name of the EJB to which this configuration applies. This element must match "
"an <literal>ejb-name</literal> of an entity in the <literal>ejb-jar.xml</"
"literal> file."
msgstr ""
-"<emphasis role=\"bold\">name</emphasis>：这是虚拟主机的 DNS 名。至少一个 "
-"<literal>Host</literal> 元素必须用对应于所包含的 <literal>Engine</literal> "
-"的 <literal>defaultHost</literal> 值的名字来配置。"
+"<emphasis role=\"bold\">ejb-name</emphasis>：这个元素是配置所适用的 EJB 的名称。这个元素必须匹配 <literal>ejb-jar.xml</"
+"literal> 文件里的某个 entity 的 <literal>ejb-name</literal>。"
#. Tag: para
#: The_CMP_Engine.xml:190
@@ -1025,7 +1046,7 @@
"it vastly constrains the domain over which finders and ejbSelects can query. "
"The default is <literal>java:/DefaultDS</literal> unless overridden in the "
"defaults section."
-msgstr ""
+msgstr "<emphasis role=\"bold\">datasource</emphasis>：这个可选元素是用来查找数据库的 <literal>jndi-name</literal>。entity 或关系型表使用的所有数据库连接都从数据源（datasource）获得。我们不推荐把不同的数据源用于 entity，因为这极大地限制了 finders 和 ejbSelects 可以查询的范围。除非在 defaults 部分进行覆盖，它的缺省值是 <literal>java:/DefaultDS</literal>。"
#. Tag: para
#: The_CMP_Engine.xml:195
@@ -1038,6 +1059,9 @@
"\"Datasource_Customization-Mapping\"/>. The default is <literal>Hypersonic "
"SQL</literal> unless overridden in the defaults section."
msgstr ""
+"<emphasis role=\"bold\">datasource-mapping</emphasis>：这个可选元素指定 <literal>type-mapping</literal> 的名称，它决定 Java 类型如何映射到 SQL 类型，以及 EJB-QL 功能如何映射到数据库专有的功能。<xref linkend="
+"\"Datasource_Customization-Mapping\"/> 里将讨论类型映射。除非在 defaults 部分进行覆盖，它的缺省值是 <literal>Hypersonic "
+"SQL</literal>。"
#. Tag: para
#: The_CMP_Engine.xml:200
@@ -1050,7 +1074,7 @@
"is not created. This option is very useful during the early stages of "
"development when the table structure changes often. The default is false "
"unless overridden in the defaults section."
-msgstr ""
+msgstr "<emphasis role=\"bold\">create-table</emphasis>：如果设置这个可选元素为 true，表示 JBoss 应该试图为这个 entity 创建一个表。当应用程序被部署时，JBoss 将在创建表之前检查它是否已经存在。如果找到了一个表，JBoss 将进行记录且不再创建。在部署的早期，但表结果经常变动时，这个选项非常有用。除非在 defauts 部分进行覆盖，它的缺省值为 false。"
#. Tag: para
#: The_CMP_Engine.xml:205 The_CMP_Engine.xml:2553
@@ -1061,18 +1085,21 @@
"literal> can be used to keep the schema current with changes to the entity "
"bean. Alter table will perform the following specific tasks:"
msgstr ""
+"<emphasis role=\"bold\">alter-table</emphasis>：如果 <literal>create-table</"
+"literal> 被用来自动创建表，<literal>alter-table</"
+"literal> 则被用来应用 entity bean 的当前变动。Alter table 将执行下面的特殊任务："
#. Tag: para
#: The_CMP_Engine.xml:210 The_CMP_Engine.xml:2558
#, no-c-format
msgid "new fields will be created"
-msgstr ""
+msgstr "添加新的字段"
#. Tag: para
#: The_CMP_Engine.xml:215 The_CMP_Engine.xml:2563
#, no-c-format
msgid "fields which are no longer used will be removed"
-msgstr ""
+msgstr "不再使用的字段将被删除"
#. Tag: para
#: The_CMP_Engine.xml:220 The_CMP_Engine.xml:2568
@@ -1080,7 +1107,7 @@
msgid ""
"string fields which are shorter than the declared length will have their "
"length increased to the declared length. (not supported by all databases)"
-msgstr ""
+msgstr "字符串字段如果比所声明的要短，则扩大至所声明的长度。（不是所有数据库都支持）"
#. Tag: para
#: The_CMP_Engine.xml:227
@@ -1092,7 +1119,7 @@
"attempt to drop the table. This option is very useful during the early "
"stages of development when the table structure changes often. The default is "
"false unless overridden in the defaults section."
-msgstr ""
+msgstr "<emphasis role=\"bold\">remove-table</emphasis>：如果这个可选元素为 true，JBoss 将试图删除每个 entity 以及关系型表匹配的关系所对应的表。当应用程序被卸载时，JBoss 将试图删除这个表。在部署的早期，当表结构经常变动时，这个选项非常有用。除非在 defauts 部分进行覆盖，它的缺省值是 false。"
#. Tag: para
#: The_CMP_Engine.xml:232 The_CMP_Engine.xml:801
@@ -1103,7 +1130,7 @@
"after the database table is created. This command is only executed if "
"<literal>create-table</literal> is true and the table did not previously "
"exist."
-msgstr ""
+msgstr "<emphasis role=\"bold\">post-table-create</emphasis>：这个可选元素指定在数据库表被创建后立即执行的任意 SQL 语句。如果 <literal>create-table</literal> 为 true 且表以前不存在时，这个命令才会被执行。去"
#. Tag: para
#: The_CMP_Engine.xml:237
More information about the jboss-cvs-commits
mailing list