activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbert...@apache.org
Subject [27/51] [partial] activemq-6 git commit: ACTIVEMQ6-1 - Initial HornetQ Donation Commit
Date Mon, 10 Nov 2014 16:32:38 GMT
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/configuring-transports.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/configuring-transports.xml b/docs/user-manual/zh/configuring-transports.xml
new file mode 100644
index 0000000..123051a
--- /dev/null
+++ b/docs/user-manual/zh/configuring-transports.xml
@@ -0,0 +1,376 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- ============================================================================= -->
+<!-- Copyright © 2009 Red Hat, Inc. and others.                                    -->
+<!--                                                                               -->
+<!-- The text of and illustrations in this document are licensed by Red Hat under  -->
+<!-- a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). -->
+<!--                                                                               -->
+<!-- An explanation of CC-BY-SA is available at                                    -->
+<!--                                                                               -->
+<!--            http://creativecommons.org/licenses/by-sa/3.0/.                    -->
+<!--                                                                               -->
+<!-- In accordance with CC-BY-SA, if you distribute this document or an adaptation -->
+<!-- of it, you must provide the URL for the original version.                     -->
+<!--                                                                               -->
+<!-- Red Hat, as the licensor of this document, waives the right to enforce,       -->
+<!-- and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent        -->
+<!-- permitted by applicable law.                                                  -->
+<!-- ============================================================================= -->
+<chapter id="configuring-transports">
+    <title>传输层的配置</title>
+    <para>HornetQ的传输层是“可插拔的”。通过灵活的配置和一套服务提供接口(SPI),HornetQ可以很容易地更换其传输层。</para>
+    <para>在本章中我们将对HornetQ的传输相关的概念作出解释,并说明它的配置方法。</para>
+    <section id="configuring-transports.acceptors">
+        <title>接收器(Acceptor)</title>
+        <para>接收器(<emphasis>acceptor</emphasis>)是 HornetQ 的传输层中最为重要的概念之一。首先
+            介绍一下在文件<literal>hornetq-configuration.xml</literal>中是怎样定义一个接收器的:</para>
+        <programlisting>
+&lt;acceptors&gt;                
+    &lt;acceptor name="netty"&gt;
+        &lt;factory-class&gt;
+org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory
+        &lt;/factory-class&gt;
+        &lt;param key="port" value="5446"/&gt;
+    &lt;/acceptor&gt;
+&lt;/acceptors&gt;            
+        </programlisting>
+        <para>所有接收器都在 <literal>acceptors</literal>单元(element)内定义。在<literal>acceptors</literal>
+            内可以有零个或多个接收器的定义。每个服务器所拥有的接收器的数量是没有限制的。</para>
+        <para>每个接收器都要定义其与HornetQ服务器连接的方式。</para>
+        <para>以上的例子中我们定义了一个<ulink
+                url="http://jboss.org/netty">Netty</ulink>接收器。它在端口<literal>5446</literal>监听连接请求。</para>
+        <para>在<literal>acceptor</literal>单元内有一个子单元<literal>factory-class</literal>。这个单元是用来
+            定义创建连接器的工厂类。一个连接器工厂类必须要实现<literal>AcceptorFactory</literal>接口。上例中我们定义
+            的连接器工厂是类NettyAcceptorFactory使用Netty来建立连接。有个这个类定义,HornetQ就知道了用什么传输来建立连接了。</para>
+        <para>在<literal>acceptor</literal>中还可以配置零或多个参数<literal>param</literal>。在每个<literal>param</literal>
+            中定义的是键-值对(key-value)。这些参数用来配置某个传输实现。不同传输有不同的配置参数。</para>
+        <para>像IP地址、端口号等都是传输配置参数的例子。</para>
+    </section>
+    <section id="configuring-transports.connectors">
+        <title>连接器(Connectors)</title>
+        <para>接收器定义的是如何在服务器端接收连接,而连接器则是定义客户端如何连接到服务器。</para>
+        <para>以下是<literal>hornetq-configuration.xml</literal>文件中一个连接器配置的例子。</para>
+        <programlisting>
+&lt;connectors&gt;
+    &lt;connector name="netty"&gt;
+        &lt;factory-class&gt;
+            org.hornetq.core.remoting.impl.netty.NettyConnectorFactory
+        &lt;/factory-class&gt;
+        &lt;param key="port" value="5446"/&gt;
+    &lt;/connector&gt;
+&lt;/connectors&gt;            
+        </programlisting>
+        <para>连接器的配置在<literal>connectors</literal>单元中。可以定义一个或多个连接器。每个服务器配置的连接器
+            数量是没有限制的。</para>
+        <para>你可能注意到了,既然连接器是定义<emphasis>客户端</emphasis>如何连接服务器的,那么为什么要定义在
+              <emphasis>服务器</emphasis>端呢?原因如下:</para>
+        <itemizedlist>
+            <listitem>
+                <para>服务器有时也需要做为客户端去连接其它的服务器,比如当一个服务器通过桥连接到另一个服务器,或者是集群
+                    中服务器之间的互相通迅。在这种情况下服务器就要知道如何与另一台服务器建立连接。因此需要在
+                    <emphasis>connectors</emphasis>下定义连接器。</para>
+            </listitem>
+            <listitem>
+                <para>如果你使用JMS服务,需要创建连接工厂的实例并绑定到JNDI。在HornetQ创建
+                    <literal>HornetQConnectionFactory</literal>时需要连接器的必要信息,以便这个连接工厂
+                    能知道它如何与HornetQ服务器相连接。</para>
+                <para>这一信息被定义在配置文件<literal
+                        >hornetq-jms.xml</literal>中的<literal>connector-ref</literal>单元下。下面这段配置
+                        就是从该配置文件中提取的相关部分,它展示了JMS的连接工厂是如何引用定义在配置文件<literal
+                        >hornetq-configuration.xml</literal>中的连接器的:</para>
+                <programlisting>
+&lt;connection-factory name="ConnectionFactory"&gt;
+    &lt;connectors>
+       &lt;connector-ref connector-name="netty"/&gt;
+    &lt;/connectors>
+    &lt;entries&gt;
+        &lt;entry name="ConnectionFactory"/&gt;
+        &lt;entry name="XAConnectionFactory"/&gt;
+    &lt;/entries&gt;
+&lt;/connection-factory&gt;                
+            </programlisting>
+            </listitem>
+        </itemizedlist>
+    </section>
+    <section id="configuring-transports.client.side">
+        <title>在客户端直接配置传输层</title>
+        <para>怎样配置一个内核<literal>ClientSessionFactory</literal>以让它知道如何连接服务器的信息呢?</para>
+        <para>在直接配置内核<literal>ClientSessionFactory</literal>的时候,可以间接地使用连接器。当然在这种情况
+            下在服务器端定义连接器是没有意义的。我们通过将必要参数传给<literal>ClientSessionFactory</literal>的
+            方法来告诉使用什么样的连接器工厂。</para>
+        <para>在下面的例子中,我们创建了一个<literal>ClientSessionFactory</literal>,它可以直接连接到我们先前定
+            义的接收器上。它使用的是标准的Netty TCP传输层,连接主机是localhost(默认),端口5446:</para>
+        <programlisting>
+Map&lt;String, Object&gt; connectionParams = new HashMap&lt;String, Object&gt;();
+    
+connectionParams.put(org.hornetq.core.remoting.impl.netty.TransportConstants.PORT_PROP_NAME, 
+                    5446);
+
+TransportConfiguration transportConfiguration = 
+    new TransportConfiguration(
+    "org.hornetq.core.remoting.impl.netty.NettyConnectorFactory", 
+    connectionParams);
+
+ClientSessionFactory sessionFactory = HornetQClient.createClientSessionFactory(transportConfiguration);
+
+ClientSession session = sessionFactory.createSession(...);
+
+etc                       
+        </programlisting>
+        <para>如果在客户端直接使用JMS的连接工厂的话,也可以用类似的方法而不需要在服务器端定义连接器或在
+            <literal>hornetq-jms.xml</literal>配置文件中创建连接工厂:</para>
+        <programlisting>
+Map&lt;String, Object&gt; connectionParams = new HashMap&lt;String, Object&gt;();
+
+connectionParams.put(org.hornetq.core.remoting.impl.netty.TransportConstants.PORT_PROP_NAME, 5446);
+
+TransportConfiguration transportConfiguration = 
+    new TransportConfiguration(
+    "org.hornetq.core.remoting.impl.netty.NettyConnectorFactory", 
+    connectionParams);
+
+ConnectionFactory connectionFactory = HornetQJMSClient.createConnectionFactory(transportConfiguration);
+
+Connection jmsConnection = connectionFactory.createConnection();
+
+etc                       
+        </programlisting>
+    </section>
+    <section>
+        <title>配置 Netty 传输层</title>
+        <para>HornetQ当前使用<ulink url="http://www.jboss.org/netty/"
+                >Netty</ulink>作为其默认的连接层。Netty是一个高性能的底层网络库.</para>
+        <para>Netty传输的配置有几种不同的方法。它可以使用传统的Java IO(阻塞方式)、NIO(非阻塞)或直接使用
+            TCP socket及SSL。或者使用HTTP或HTTPS协议。同时还可能使用servlet进行传输。</para>
+        <para>采用Netty应该能满足绝大部分的传输要求。</para>
+        <section>
+            <title>配置 Netty TCP</title>
+            <para>Netty TCP 是简单的非加密的基于TCP socket的传输。它可以使用阻塞式的Java IO或非阻塞式的Java NIO。
+                我们建议在服务器端采用非阻塞式的NIO以获得良好的并发处理能力。当并发能力并不是很重要时,可以使用阻塞式
+                的方式以增加响应的速度。</para>
+            <para>如果你的应用是运行在不信任的网络上,你应该选择使用SSL或HTTPS。</para>
+            <para>Netty TCP的所有连接都是从客户端发起的。服务器端不向客户端发起任何连接。在有防火墙的环境中,这种方式
+                是比较适合的。因为防火墙只允许单方向的连接。</para>
+            <para>在<literal>org.hornetq.core.remoting.impl.netty.TransportConstants</literal>类中定义了所
+                有的配置参数的名称(key)。它们当中绝大多娄既用于配置接收器也用于配置连接器,有一些只适用于接收器。
+                下面列出的参数用以配置一个简单的Netty TCP:</para>
+            <itemizedlist>
+                <listitem>
+                    <para><literal>use-nio</literal>。如果设为<literal>true</literal>则使用非阻塞的Java
+                        NIO。如果<literal>false</literal>则使用传统的阻塞方式的Java IO。</para>
+                    <para>我们建议使用Java NIO处理并行连接。因为Java NIO不是为每一个连接分配一个线程,所以它要比传统的阻塞式
+                        Java IO具有更强的并发连接的处理能力。如果你不需要处理并发连接,那么使用旧的阻塞式的IO性能会好一些。这个参
+                        数的默认值在服务器端是<literal>false</literal>,在客户端是<literal>false</literal>。
+                        </para>
+                </listitem>
+                <listitem>
+                    <para><literal>host</literal>。主机名或IP地址。对于接收器来说,它是服务器接收连接的地址。
+                        对于连接器端,它是客户端连接的目标地址。默认值是<literal>localhost</literal>。
+                        在配置接收器时可以指定多个主机名或IP地址,中间用逗号隔开。如果指定的主机是<code>0.0.0.0</code>,
+                        则接收器将从主机上所有的网络接口中接受连接请求。连接器不允许指定多个主机地址,它只能与一个
+                        地址建立连接。</para>
+                    <note>
+                        <para>一定不要忘记指定一个主机名或IP地址!一个服务器要想接受来自其它节点的连接就必需有一个
+                            主机名或IP地址来绑定及监听外部的连接请求。默认的主机名localhost是不能接受外部的
+                            连接请求的!</para>
+                    </note>
+                </listitem>
+                <listitem>
+                    <para><literal>port</literal>。连接的端口。用于配置连接器或接收器。连接器用此端口来建立
+                        连接。接收器在些端口上监听连接请求。默认值是<literal>5445</literal>。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>tcp-no-delay</literal>。将它设为<literal>true</literal>就会使用
+                            <ulink url="http://en.wikipedia.org/wiki/Nagle's_algorithm">Nagle
+                            算法</ulink>.默认值是<literal>true</literal>。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>tcp-send-buffer-size</literal>。这个参数指定了TCP的发送缓冲大小,单位是字节。
+                        默认值是<literal>32768</literal>字节(32KiB)。</para>
+                    <para>这个参数要根据你的网络的带宽与时延的情况而调整。<ulink url="http://www-didc.lbl.gov/TCP-tuning/">
+                        这个链接</ulink>对此有很好的论述。</para>
+                    <para>简言之,TCP的发送/接收缓冲的大小可以用下面公式来计算:</para>
+                    <programlisting>
+                        缓冲大小 = 带宽 * RTT
+                    </programlisting>
+                    <para>其中带宽的单位是 <emphasis>每秒字节数</emphasis>,RTT(网络往返程时间)的单位是秒。
+                          使用<literal>ping</literal>工具可以方便地测量出RTT。</para>
+                    <para>对于快速网络可以适当加大缓冲的大小。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>tcp-receive-buffer-size</literal>。这个参数指定了TCP接收缓冲的大小,单位是字节。
+                        默认值是<literal>32768</literal>字节(32KiB)。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>batch-delay</literal>。HornetQ可以通过配置该参数,在数据包写入传输层之前有一个
+                        最大延时(毫秒),达到批量写入的目的。这样可以提高小消息的发送效率。但这样做会增加单个消息的平均发送
+                        延迟。默认值为<literal>0</literal>毫秒。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>direct-deliver</literal>。消息到达服务器后,默认是由一个不同的线程来将消息传递
+                        到接收者。这样可以使服务的呑吐量和可扩展性达到最佳,特别是在多核的系统上效果更为明显。但是线程切换
+                        会带来一些传递的延迟。如果你希望延迟最小,并不在意呑吐量的话,可以将参数<literal
+                            >direct-deliver</literal>设为true。默认值是<literal>true</literal>。如果你更希望有
+                        较大的呑吐量的话,将它设为<literal>false</literal>。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>nio-remoting-threads</literal>。如果使用NIO,默认情况下HornetQ会使用系统中处理
+                        器内核(或超线程)数量三倍的线程来处理接收的数据包。内核的数量是通过调用<literal
+                            >Runtime.getRuntime().availableProcessors()</literal>来得到的。如果你想改变这个数量,
+                        你可以设定本参数。默认的值是<literal>-1</literal>,表示线程数为<literal
+                            >Runtime.getRuntime().availableProcessors()</literal> * 3。</para>
+                </listitem>
+            </itemizedlist>
+        </section>
+        <section>
+            <title>配置Netty SSL</title>
+            <para>Netty SSL的配置与Netty TCP相似。它采用了安全套接字层(SSL)来提供加密的TCP连接。</para>
+            <para>我们提供了一个Netty SSL的例子来演示其配置和应用。</para>
+            <para>Netty SSL拥有Netty TCP一样的参数,另外还有下列的附加参数:</para>
+            <itemizedlist>
+                <listitem>
+                    <para><literal>ssl-enabled</literal>。必须设为<literal>true</literal>以使用SSL。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>key-store-path</literal>。存放SSL密钥的路径(key store)。这是存放客户端证书的地方。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>key-store-password</literal>。用于访问key store的密码。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>trust-store-path</literal>。服务器端存放可信任客户证书的路径。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>trust-store-password</literal>。用于访问可信任客户证书(trust store)的密码。</para>
+                </listitem>
+            </itemizedlist>
+        </section>
+        <section>
+            <title>配置Netty HTTP</title>
+            <para>Netty HTTP 通过HTTP通道传送数据包。在有些用户环境中防火墙只允许有HTTP通信,这时采用Netty HTTP作为HornetQ
+                的传输层就能解决问题。</para>
+            <para>我们提供了一个Netty HTTP的例子来演示其配置和应用。</para>
+            <para>Netty HTTP具有和Netty TCP同样的配置参数,另外它还有以下参数:</para>
+            <itemizedlist>
+                <listitem>
+                    <para><literal>http-enabled</literal>。如果要使用HTTP,这个参数必须设为<literal>true</literal>。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>http-client-idle-time</literal>。客户端空闲时间。如果客户端的空闲时间超过
+                        这个值,Netty就会发送一个空的HTTP请求以保持连接不被关闭。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>http-client-idle-scan-period</literal>。扫描空闲客户端的间隔时间。单位是毫秒。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>http-response-time</literal>。服务器端向客户端发送空的http响应前的最大等待时间。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>http-server-scan-period</literal>。服务器扫描需要响应的客户端的时间间隔。单位是毫秒。</para>
+                </listitem>
+                <listitem>
+                    <para><literal>http-requires-session-id</literal>。如果设为true,客户端在第一次请求后将等待
+                        接收一个会话ID。http 连接器用它来连接servlet接收器(不建议这样使用)。</para>
+                </listitem>
+            </itemizedlist>
+        </section>
+        <section>
+            <title>配置Netty Servlet</title>
+            <para>HornetQ可以使用Netty servlet来传输消息。使用servlet可以将HornetQ的数据通过HTTP传送到一个
+                运行的servlet,再由servlet转发给HornetQ服务器。</para>
+            <para>servlet与HTTP的不同之处在于,当用HTTP传输时,HornetQ如同一个web服务器,它监听在某个端口上的HTTP
+                请求并返回响应。比如80端口或8080端口。而当使用servlet时,HornetQ的传输数据是通过运行在某一servlet容器
+                中的一个特定的servlet来转发的。而这个sevlet容器中同时还可能运行其他的应用,如web服务。当一个公司有多个应用
+                但只允许一个http端口可以访问时,servlet传输可以很好的解决HornetQ的传输问题。</para>
+            <para>请参见HornetQ所提供的servlet例子来了解详细的配置方法。</para>
+            <para>要在HornetQ中使用Netty servlet传输方式,需要以下步骤:</para>
+            <itemizedlist>
+                <listitem>
+                    <para>部署servlet。下面是一个web.xml例子:</para>
+                    <programlisting>&lt;?xml version="1.0" encoding="UTF-8"?>
+&lt;web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
+         version="2.4">
+   &lt;servlet>
+      &lt;servlet-name>HornetQServlet&lt;/servlet-name>
+      &lt;servlet-class>org.jboss.netty.channel.socket.http.HttpTunnelingServlet&lt;/servlet-class>
+      &lt;init-param>
+             &lt;param-name>endpoint&lt;/param-name>
+             &lt;param-value>local:org.hornetq&lt;/param-value>
+           &lt;/init-param>
+           &lt;load-on-startup>1&lt;/load-on-startup>
+   &lt;/servlet>
+
+   &lt;servlet-mapping>
+      &lt;servlet-name>HornetQServlet&lt;/servlet-name>
+      &lt;url-pattern>/HornetQServlet&lt;/url-pattern>
+   &lt;/servlet-mapping>
+&lt;/web-app>
+
+</programlisting>
+                </listitem>
+                <listitem>
+                    <para>我们还需要在服务器端加上一个特殊的Netty invm 接收器。</para>
+                    <para>下面是从<literal>hornetq-configuration.xml</literal>配置文件中摘取的定义接收器的配置部分:</para>
+                    <programlisting>                    
+&lt;acceptors>
+
+      &lt;acceptor name="netty-invm">
+         &lt;factory-class>
+            org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory
+         &lt;/factory-class>
+         &lt;param key="use-invm" value="true"/>
+         &lt;param key="host" value="org.hornetq"/>
+      &lt;/acceptor>
+
+&lt;/acceptors>                                         
+                </programlisting>
+                </listitem>
+                <listitem>
+                    <para>最后我们需要在客户端配置连接器,也是在<literal>hornetq-configuration.xml</literal>文件中来做。如下所示:</para>
+                    <programlisting>&lt;connectors>
+
+      &lt;connector name="netty-servlet">
+         &lt;factory-class>
+            org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory
+         &lt;/factory-class>
+         &lt;param key="host" value="localhost"/>
+         &lt;param key="port" value="8080"/>
+         &lt;param key="use-servlet" value="true"/>
+         &lt;param key="servlet-path" value="/messaging/HornetQServlet"/>
+      &lt;/connector>
+
+ &lt;/connectors></programlisting>
+                </listitem>
+            </itemizedlist>
+            <para>下面列出了初始化参数以及它们的用途:</para>
+            <itemizedlist>
+                <listitem>
+                    <para>endpoint - Netty接收器的名字。servlet将向它转发数据包。它与<literal
+                            >host</literal>参数的值是对应的。</para>
+                </listitem>
+            </itemizedlist>
+            <para>在<literal>web.xml</literal>中定义的servlet的URL形式与在连接器配置文件中定义的
+                <literal>servlet-path</literal>值应该相匹配。</para>
+            <para>servlet可以与SSL一起使用。只需要在连接器配置中加上下面的配置即可:<programlisting>    &lt;connector name="netty-servlet">
+         &lt;factory-class>org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory&lt;/factory-class>
+         &lt;param key="host" value="localhost"/>
+         &lt;param key="port" value="8443"/>
+         &lt;param key="use-servlet" value="true"/>
+         &lt;param key="servlet-path" value="/messaging/HornetQServlet"/>
+         &lt;param key="ssl-enabled" value="true"/>
+         &lt;param key="key-store-path" value="path to a keystoree"/>
+         &lt;param key="key-store-password" value="keystore password"/>
+      &lt;/connector>
+</programlisting></para>
+            <para>另外你还需要为服务器指定一个KeyStore。打开<literal>server/default/deploy/jbossweb.sar</literal>
+                   下的<literal>server.xml</literal>文件,按照下面的内容编辑其中的SSL/TLS连接器配置:<programlisting>&lt;Connector protocol="HTTP/1.1" SSLEnabled="true"
+           port="8443" address="${jboss.bind.address}"
+           scheme="https" secure="true" clientAuth="false"
+           keystoreFile="path to a keystore"
+           keystorePass="keystore password" sslProtocol = "TLS" />
+
+</programlisting>SSL需要keystore和访问密码。参见servlet ssl例子以了解更多的有关信息。</para>
+        </section>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/connection-ttl.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/connection-ttl.xml b/docs/user-manual/zh/connection-ttl.xml
new file mode 100644
index 0000000..c9ff36f
--- /dev/null
+++ b/docs/user-manual/zh/connection-ttl.xml
@@ -0,0 +1,139 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- ============================================================================= -->
+<!-- Copyright © 2009 Red Hat, Inc. and others.                                    -->
+<!--                                                                               -->
+<!-- The text of and illustrations in this document are licensed by Red Hat under  -->
+<!-- a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). -->
+<!--                                                                               -->
+<!-- An explanation of CC-BY-SA is available at                                    -->
+<!--                                                                               -->
+<!--            http://creativecommons.org/licenses/by-sa/3.0/.                    -->
+<!--                                                                               -->
+<!-- In accordance with CC-BY-SA, if you distribute this document or an adaptation -->
+<!-- of it, you must provide the URL for the original version.                     -->
+<!--                                                                               -->
+<!-- Red Hat, as the licensor of this document, waives the right to enforce,       -->
+<!-- and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent        -->
+<!-- permitted by applicable law.                                                  -->
+<!-- ============================================================================= -->
+<chapter id="connection-ttl">
+    <title>失效连接的检测</title>
+    <para>本章将讨论连接的生存时间(TTL)以及HornetQ如何处理出现故障的客户端或者异常退出的客户端(即客户端在
+        退出时没有合理的关闭相关资源)。</para>
+    <section id="dead.connections">
+        <title>服务器端对失效连接的清除</title>
+        <para>当客户端的应用程序退出时,应该关闭所使用的资源。在<literal>finally</literal>进行资源的关闭
+            是一个很好的方法。</para>
+        <para>下面的例子中,一个Hornet客户端在finally中关闭了它的会话(session)和会话工厂(session factory):</para>
+        <programlisting>
+ClientSessionFactory sf = null;
+ClientSession session = null;
+
+try
+{
+   sf = HornetQClient.createClientSessionFactory(...);
+
+   session = sf.createSession(...);
+   
+   ... do some stuff with the session...
+}
+finally
+{
+   if (session != null)
+   {
+      session.close();
+   }
+   
+   if (sf != null)
+   {
+      sf.close();
+   }
+}
+        </programlisting>
+        <para>下面的例子给出了一个JMS客户端是如何适当关闭相关资源的:</para>
+        <programlisting>
+Connection jmsConnection = null;
+
+try
+{
+   ConnectionFactory jmsConnectionFactory = HornetQJMSClient.createConnectionFactory(...);
+
+   jmsConnection = jmsConnectionFactory.createConnection();
+
+   ... do some stuff with the connection...
+}
+finally
+{
+   if (connection != null)
+   {
+      connection.close();
+   }
+}
+        </programlisting>
+        <para>然而有时候资源在客户端得不到合理的关闭。有的客户端应用在结束时忘记了关闭资源,有的客户端有时发生故障导致
+            程序突然中断,相关资源也没有来得及关闭!</para>
+        <para>如果上述情况发生了,那么这些资源就会留在服务器端而不会被清理。这就会造成资源泄漏现象并最終导致服务器内存
+            溢出或其它资源的溢出错误。</para>
+        <para>因此在服务器端要有某种机制来避免资源的泄漏。也就是对无效资源进行回收。在判断什么是无效资源时,HornetQ
+            考虑到了客户端重新连接的情况。就是当一个连接由于网络临时中断后又恢复正常时,客户端有可能通过不断重试
+            成功地连接到服务器端。如果服务器端过早清除了相关的连接资源,则客户端就可能重试失败。</para>
+        <para>HornetQ的资源回收是完全可配置的。每个 <literal
+                >ClientSessionFactory</literal> 有一个<emphasis>连接 TTL</emphasis>的参数。
+            这个参数的意义是当客户端的一个连接没有任何数到达服务器时,服务器充许这个连接有效的最长时间。客户端通过定
+            时向服务器端发送“ping“数据包来维持连接的有效,以免被服务器关掉。如果服务器在TTL指定的时间内没有收到任何
+            数据包,则认为该连接无效,继而关闭与该连接相关的所有的会话(session)。</para>
+        <para>如果使用JMS,<literal>HornetQConnectionFactory</literal>的<literal>ConnectionTTL</literal>
+            属性是用来定义连接的存活时间的。如果你将JMS连接工厂部署到JNDI中,则应使用配置文件中的<literal
+                >connection-ttl</literal>参数来定义连接的TTL。</para>
+        <para>默认的连接TTL值是<literal>60000</literal>毫秒,即一分钟。 <literal>ConnectionTTL</literal>
+            设为<literal>-1</literal>表示服务器永远不检测超时的连接。</para>
+        <para>如果你不想让客户端来规定连接存活时间(TTL),你可以在服务器端的配置文件中定义
+            <literal>connection-ttl-override</literal>属性。它的默认值是<literal>-1</literal>,表示
+            服务器端该属性无效(即客户端可以定义自己的连接TTL)。</para>
+        <section>
+            <title>关闭没有被成功关闭的核心会话或JMS连接</title>
+            <para>如前所述,在使用完毕后在<literal>finally</literal>中将所有的核心会话或JMS连接关闭是十分重要的。</para>
+            <para>如果你没有这样做,HornetQ会在拉圾回收时进行检测并会在日志中打印类似以下的警告(如果是JMS则在警告中
+                  是相应的JMS连接):</para>
+            <programlisting>
+                
+[Finalizer] 20:14:43,244 WARNING [org.hornetq.core.client.impl.DelegatingSession]  I'm closin
+g a ClientSession you left open. Please make sure you close all ClientSessions explicitly before let
+ting them go out of scope!
+[Finalizer] 20:14:43,244 WARNING [org.hornetq.core.client.impl.DelegatingSession]  The sessi
+on you didn't close was created here:
+java.lang.Exception
+at org.hornetq.core.client.impl.DelegatingSession.&lt;init&gt;(DelegatingSession.java:83)
+at org.acme.yourproject.YourClass (YourClass.java:666)    
+                
+            </programlisting>
+            <para>HornetQ然后将未关闭的连接/会话关闭。</para>
+            <para>注意在日志的警告中还给出了创建JMS连接/客户端会话的具体行号,以便准确地确定出错的地方。</para>
+        </section>
+    </section>
+    <section>
+        <title>客户端的故障检测</title>
+        <para>前面讲述了客户端如何向服务器发送ping以及服务器端如何清理失效的连接。发送ping还有另外一个目的,就是能
+            让客户端检测网络或服务器是否出现故障。</para>
+        <para>从客户端的角度来看,只要客户端能从一个连接不断接收服务器的数据,那么这个连接就被认为是一个有效的连接。</para>
+        <para>如果在属性<literal>client-failure-check-period</literal>所定义的时间内(单位毫秒)客户端没有
+            收到任何数据,客户端就认为这们连接发生了故障。根据不同的配置,客户端在这种情况下要么进行failover,要么
+            调用<literal>FailureListener</literal>的接口(或者是JMS的<literal>ExceptionListener</literal>)。</para>
+        <para>如果使用JMS,这个参数是<literal>HornetQConnectionFactory</literal>的<literal>ClientFailureCheckPeriod</literal>。
+            如果你向JNDI部署JMS连接工厂,那么相应的参数在<literal>hornetq-jms.xml</literal>配置文件中,参数名
+            为<literal>client-failure-check-period</literal>。</para>
+        <para>这个参数的默认值是<literal>30000</literal>毫秒,即半分钟。<literal>-1</literal>表示客户端不检查
+            连接的有效性。即不论是否有数据来自服务器,连接都一直有效。这一参数通常要比服务器端的连接TTL小许多,以使
+            客户端在出现短暂连接故障的情况下可以与服务器成功地重新连接。</para>
+    </section>
+    <section id="connection-ttl.async-connection-execution">
+        <title>配置异步连接任务执行</title>
+        <para>默认情况下,服务器接收到的数据包被远程模块的线程处理。</para>
+        <para>为了避免远程模块的线程被长时间占用,数据包可以转给另外的一个线程池来处理。要注意这样做的增加了一些时间延迟。
+            因此如果数据包处理耗时很少,还是由远程模块线程来处理较好。
+
+            要配置这样的异步连接很行任务,将<literal>hornetq-configuration.xml</literal>文件中的
+                <literal>async-connection-execution-enabled</literal> 参数设为<literal>true</literal>
+               (默认值是 <literal>true</literal>)。</para>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/core-bridges.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/core-bridges.xml b/docs/user-manual/zh/core-bridges.xml
new file mode 100644
index 0000000..5adc9e2
--- /dev/null
+++ b/docs/user-manual/zh/core-bridges.xml
@@ -0,0 +1,179 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- ============================================================================= -->
+<!-- Copyright © 2009 Red Hat, Inc. and others.                                    -->
+<!--                                                                               -->
+<!-- The text of and illustrations in this document are licensed by Red Hat under  -->
+<!-- a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). -->
+<!--                                                                               -->
+<!-- An explanation of CC-BY-SA is available at                                    -->
+<!--                                                                               -->
+<!--            http://creativecommons.org/licenses/by-sa/3.0/.                    -->
+<!--                                                                               -->
+<!-- In accordance with CC-BY-SA, if you distribute this document or an adaptation -->
+<!-- of it, you must provide the URL for the original version.                     -->
+<!--                                                                               -->
+<!-- Red Hat, as the licensor of this document, waives the right to enforce,       -->
+<!-- and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent        -->
+<!-- permitted by applicable law.                                                  -->
+<!-- ============================================================================= -->
+<chapter id="core-bridges">
+    <title>核心桥</title>
+    <para>桥的功能是从一个源队列中接收消息,再将消息转发到目的地址。通常这个目的地址在另外一个HornetQ服务器中。</para>
+    <para>源与目的不需要在同一个集群中。所以桥很适合将消息从一个集群中可靠地转发到另一个集群。比如通过一个WAN,或
+        internet,等连接不稳定的网络。</para>
+    <para>桥有处理故障的能力。如果目的服务器的连接失败(像网络故障),桥会重试与目的服务器的连接,直接连接成功
+        为止。当连接成功后,桥则继续进行工作。</para>
+    <para>总之,桥是可靠连接两个HornetQ服务器的一种手段。使用核心桥时源和目的服务器必须都是HornetQ服务器。</para>
+    <para>桥可以通过配置提供<emphasis>一次且只有一次</emphasis>的传递保证。其采用的方法是重复检测(详细
+        描述在<xref linkend="duplicate-detection"/>)。</para>
+    <note>
+        <para>核心桥的功能与JMS桥的功能相似,但是不能将它们混淆!</para>
+        <para>核心桥用来连接两个HornetQ节点,它不使用JMS接口。JMS桥使用的是JMS接口,它连接的是任何两个符合
+            JMS 1.1规范的服务器。因此,JMS桥可以将两个不同的JMS服务器连接起来。从性能角度考虑,核心桥由于采用
+            重复检测来实现<emphasis>一次且只一次</emphasis>的传递保证,可以提供更高的性能。
+            JMS桥则需要使用XA这种复杂的机制来提供同样的传递保证,因些性能要比核心桥低。</para>
+    </note>
+    <section>
+        <title>桥的配置</title>
+        <para>桥的配置在<literal>hornetq-configuration.xml</literal>文件中。让我们先看一个配置的例子
+            (它实际上出自bridge例子):</para>
+        <programlisting>
+&lt;bridge name="my-bridge"&gt;
+    &lt;queue-name&gt;jms.queue.sausage-factory&lt;/queue-name&gt;
+    &lt;forwarding-address&gt;jms.queue.mincing-machine&lt;/forwarding-address&gt;
+    &lt;filter-string="name='aardvark'"/&gt;
+    &lt;transformer-class-name&gt;
+        org.hornetq.jms.example.HatColourChangeTransformer
+    &lt;/transformer-class-name&gt;
+    &lt;retry-interval&gt;1000&lt;/retry-interval&gt;
+    &lt;retry-interval-multiplier&gt;1.0&lt;/retry-interval-multiplier&gt;
+    &lt;reconnect-attempts&gt;-1&lt;/reconnect-attempts&gt;
+    &lt;failover-on-server-shutdown&gt;false&lt;/failover-on-server-shutdown&gt;
+    &lt;use-duplicate-detection&gt;true&lt;/use-duplicate-detection&gt;
+    &lt;confirmation-window-size&gt;10000000&lt;/confirmation-window-size&gt;
+    &lt;connector-ref connector-name="remote-connector" 
+        backup-connector-name="backup-remote-connector"/&gt;     
+    &lt;user&gt;foouser&lt;/user&gt;
+    &lt;password&gt;foopassword&lt;/password&gt;
+&lt;/bridge&gt;                        
+        </programlisting>
+        <para>在上面的配置中包括了桥的所有参数。在实际应用中可能其中很多的参数可以使用默认值,不需要在配置中
+            指定。</para>
+        <para>下面我们对每个参数分别说明:</para>
+        <itemizedlist>
+            <listitem>
+                <para><literal>name</literal>参数。所有桥都必须有一个唯一的名字。</para>
+            </listitem>
+            <listitem>
+                <para><literal>queue-name</literal>。本地队列的名字。桥从本地队列中接收消息。
+                    这是一个必要的参数。</para>
+                <para>这个队列在桥的启动之前必须已经存在。</para>
+                <note>
+                    <para>如果使用JMS,JMS的配置文件<literal
+                            >hornetq-jms.xml</literal>在核心配置文件<literal>
+                         hornetq-configuration.xml</literal>之后装载。所以如果你的桥要从JMS
+                         队列接收消息,就需要保证JMS队列同时要作为核心队列部署。具体方法可以参见
+                         bridge例子。</para>
+                </note>
+            </listitem>
+            <listitem>
+                <para><literal>forwarding-address</literal>。目的服务器中的地址。消息将被转发到这个地址。
+                    如果没有指定这个转发地址,消息的原始地址将会保留。</para>
+            </listitem>
+            <listitem>
+                <para><literal>filter-string</literal>。一个可选的过滤器表达式。它表示只有过滤器表达式选择
+                    的消息才被转发。过滤器表达式的语法参见 <xref linkend="filter-expressions"
+                    />。</para>
+            </listitem>
+            <listitem>
+                <para><literal>transformer-class-name</literal>。可选的转换器类名。这是一个用户定义的
+                    类,它需要实现接口<literal>org.hornetq.core.server.cluster.Transformer</literal>
+                    。</para>
+                <para>如果指定了这个类,每当一个消息被转发之前,它的<literal>transform()</literal>方法
+                    就会被调用。用户利用这个机会可以对消息本身或消息头信息进行修改。</para>
+            </listitem>
+            <listitem>
+                <para><literal>retry-interval</literal>。这个可选参数决定了在进行连接重试时,两次重试
+                    之间的时间间隔。默认值是<literal>2000</literal>毫秒。</para>
+            </listitem>
+            <listitem>
+                <para><literal>retry-interval-multiplier</literal>。这个可选参数基于前一次重试连接
+                    的时间间隔来计算下一次重试的间隔,即前一次的间隔乘以该参数。</para>
+                <para>这样可以实现重试间隔的<emphasis>指数延迟(exponential backoff)</emphasis>。</para>
+                <para>让我们看一个例子:</para>
+                <para>假设<literal>retry-interval</literal>为<literal>1000</literal> ms,并且我们
+                    将<literal>retry-interval-multiplier</literal>设为<literal>2.0</literal>,如果
+                    第一次尝试失败,则等待<literal>1000</literal>毫秒后进行第二次重试,如果再失败,则每三次重
+                    试要在<literal>2000</literal>毫秒后进行,第四次要等待<literal>4000</literal>毫秒,
+                    以此类推。</para>
+                <para>默认值是<literal>1.0</literal>,表示每次重试间隔相同的时间。</para>
+            </listitem>
+            <listitem>
+                <para><literal>reconnect-attempts</literal>。可选参数。它表示要进行多少重试后才放弃
+                    并退出。<literal>-1</literal>表示进行无限次重试。默认值是<literal>-1</literal>。</para>
+            </listitem>
+            <listitem>
+                <para><literal>failover-on-server-shutdown</literal>。可选参数。它指定了当目的服务器正常
+                    退出时桥是否尝试失效备援(failover)到备份服务器(如果配置了的话)上。</para>
+                <para>桥的连接器可以配置一个主服务器和一个备份服务器。如果配置了备份服务器,并且这个参数是
+                    <literal>true</literal>时,在主服务器正常退出时,桥会自动地连接到备份服务器上继续工作。
+                    如果桥的连接器没有配置备份服务器,则这个参数不起作用。</para>
+                <para>你的桥配置了备份服务器后,有时你需要临时将主服务器关闭进行一些维护,此时并不希望桥连接到备份服务
+                    器中。使用该参数就可以达到这个目的。</para>
+                <para>这个参数的默认值是<literal>false</literal>。</para>
+            </listitem>
+            <listitem>
+                <para><literal>use-duplicate-detection</literal>。可选参数。它控制桥是否在转发的消息中自动
+                    添加一个重复ID的属性。</para>
+                <para>添加这样一个属性可以使目的服务器对来自源服务器的消息进行重复检测。当出现连接故障或服务器崩溃时,
+                    桥在恢复时将重新转发那些没有被通知的消息。这在目的服务器端有可能造成重复发送。使用重复检测功能,可
+                    以将重复发送的消息过滤掉。</para>
+                <para>使用这个功能,服务器就可以保证 <emphasis>一次并且只有一次</emphasis>的传递,而不需要使用
+                    重量级的方法,如XA(参见 <xref
+                        linkend="duplicate-detection"/>)。</para>
+                <para>默认的值是<literal>true</literal>.</para>
+            </listitem>
+            <listitem>
+                <para><literal>confirmation-window-size</literal>。这个可选参数决定了向目的服务器转发消息时
+                    所使用的确认窗口的大小。详细的描述在<xref linkend="client-reconnection"/>。</para>
+                <para>
+                    <warning>当桥从一个设置了max-size-bytes参数的队列接收并转发消息时,一个重要的事情就是要将
+                        confirmation-window-size的值设置为小于等于
+                        <literal>max-size-bytes</literal>的值,以避免造成消息流的停止。</warning>
+                </para>
+            </listitem>
+            <listitem>
+                <para><literal>connector-ref</literal>。这是一个必需的参数。它指定了桥用来连接目的服务器的
+                        <emphasis>连接器</emphasis>。</para>
+                <para><emphasis>connector</emphasis>包含了所用的传输(TCP, SSL, HTTP等),以及服务器连接参数
+                    (如主机名,端口等)。关于连接器的详细信息请参见(<xref linkend="configuring-transports"/>)。</para>
+                <para><literal>connector-ref</literal>有两个参数:</para>
+                <itemizedlist>
+                    <listitem>
+                        <para><literal>connector-name</literal>。这个指的是核心配置文件<literal
+                                >hornetq-configuration.xml</literal>中定义的连接器的名字。桥使用
+                            这个连接器创建与目的服务器的连接。这个参数是必需指定的。</para>
+                    </listitem>
+                    <listitem>
+                        <para><literal>backup-connector-name</literal>。这个可选参数同样指定一个在核心
+                            配置文件<literal>hornetq-configuration.xml</literal>中定义的连接器名字。
+                            当目的服务器出现故障时,或者正常退出但是参数<literal
+                                >failover-on-server-shutdown</literal>的值设为<literal
+                                >true</literal>时,桥使用这个参数指定的连接器通过失效备援(failover)连接
+                            到备用的服务器。</para>
+                    </listitem>
+                </itemizedlist>
+            </listitem>
+            <listitem>
+                <para><literal>user</literal>。这个可选参数指定了桥在创建与远程服务器连接时所用的用户名。如果
+                    没有指定用户名,在配置文件<literal>hornetq-configuration.xml</literal>中
+                    <literal>cluster-user</literal>所定义的默认集群用户名将被使用。 </para>
+            </listitem>
+            <listitem>
+                <para><literal>password</literal>。这个可选的参数给出的是桥创建与远程服务器连接所使用的密码。
+                    如果没有指定密码,在配置文件<literal>hornetq-configuration.xml</literal>中
+                    <literal>cluster-password</literal>所定义的默认集群密码将被使用。</para>
+            </listitem>
+        </itemizedlist>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/diagrams/architecture-diagrams.odg
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/diagrams/architecture-diagrams.odg b/docs/user-manual/zh/diagrams/architecture-diagrams.odg
new file mode 100644
index 0000000..33d99cf
Binary files /dev/null and b/docs/user-manual/zh/diagrams/architecture-diagrams.odg differ

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/diagrams/ha-replicated-store.odg
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/diagrams/ha-replicated-store.odg b/docs/user-manual/zh/diagrams/ha-replicated-store.odg
new file mode 100644
index 0000000..495c672
Binary files /dev/null and b/docs/user-manual/zh/diagrams/ha-replicated-store.odg differ

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/diagrams/ha-shared-store.odg
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/diagrams/ha-shared-store.odg b/docs/user-manual/zh/diagrams/ha-shared-store.odg
new file mode 100644
index 0000000..3b97692
Binary files /dev/null and b/docs/user-manual/zh/diagrams/ha-shared-store.odg differ

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/diverts.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/diverts.xml b/docs/user-manual/zh/diverts.xml
new file mode 100644
index 0000000..fe51e6b
--- /dev/null
+++ b/docs/user-manual/zh/diverts.xml
@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- ============================================================================= -->
+<!-- Copyright © 2009 Red Hat, Inc. and others.                                    -->
+<!--                                                                               -->
+<!-- The text of and illustrations in this document are licensed by Red Hat under  -->
+<!-- a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). -->
+<!--                                                                               -->
+<!-- An explanation of CC-BY-SA is available at                                    -->
+<!--                                                                               -->
+<!--            http://creativecommons.org/licenses/by-sa/3.0/.                    -->
+<!--                                                                               -->
+<!-- In accordance with CC-BY-SA, if you distribute this document or an adaptation -->
+<!-- of it, you must provide the URL for the original version.                     -->
+<!--                                                                               -->
+<!-- Red Hat, as the licensor of this document, waives the right to enforce,       -->
+<!-- and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent        -->
+<!-- permitted by applicable law.                                                  -->
+<!-- ============================================================================= -->
+
+<chapter id="diverts">
+    <title>消息的转发(divert)与分流</title>
+    <para>在HornetQ中可以配置一些称为转发器(<emphasis>diverts</emphasis>)的对象。</para>
+    <para>转发器可以将路由到一个地址的消息透明地转发到其它的地址去,不需要客户端的参与。</para>
+    <para>转发器可以是<emphasis>唯一(exclusive)</emphasis>的,即消息只转发到新的地址,不发到原
+        来的地址;也可以是<emphasis>不唯一(non-exclusive)</emphasis>的,即消息在发往原有地址的
+        同时,它的一个<emphasis>拷贝</emphasis>被发往新的地址。不唯一的转发器可以在应用中将消息进行
+        <emphasis>分流(splitting)</emphasis>。比如在一个订单系统中它可以用于监视发往订单队列中
+        的每个订单消息。</para>
+    <para>转发器还可以带一个可选的消息选择器。只有被选择器选择的消息才会被转发。</para>
+    <para>转发器还可以带有一个<literal>转换器(Transformer)</literal>。它可以将消息进行转换。</para>
+    <para>转发器只在同一个服务器中的地址间进行转发。如果要向另外服务器中的地址进行转发,可以采用转发器与桥配合
+        来实现。先将消息通过转发器转发到一个存储与转发的队列中,再由一个桥将这个队列的消息转发到远程服务器的目的
+        地址中。</para>
+    <para>由转发器与桥进行配合可以组成复杂的路由系统。在服务器中由一组转发器可以形成一个消息路由表。如果加上桥,就
+        可以进一步形成一个分布式的可靠的消息路由网。</para>
+    <para>转发器的配置在<literal>hornetq-configuration.xml</literal>中定义。可以配置零个或多个转发器。</para>
+    <para>参见转发器的例子<xref linkend="divert-example" />,它展示了如何配置与使用转发器。</para>
+    <para>让我们看一些转发器的配置例子:</para>
+    <section>
+        <title>唯一式转发器</title>
+        <para>下面是一个唯一式转发器的例子。它将所有符合条件的消息转发到新的地址,而旧的地址将不能得到这些消息。</para>
+        <para>以下配置来自于divert例子:</para>
+        <programlisting>
+&lt;divert name="prices-divert"&gt;                  
+    &lt;address&gt;jms.topic.priceUpdates&lt;/address&gt;
+    &lt;forwarding-address&gt;jms.queue.priceForwarding&lt;/forwarding-address&gt;    
+    &lt;filter string="office='New York'"/&gt;
+    &lt;transformer-class-name&gt;
+        org.hornetq.jms.example.AddForwardingTimeTransformer
+    &lt;/transformer-class-name&gt;     
+    &lt;exclusive&gt;true&lt;/exclusive&gt;
+&lt;/divert&gt;                        
+        </programlisting>
+        <para>在这里我们定义了一相名为“<literal>prices-divert</literal>”的转发器,它将发往
+            “<literal>jms.topic.priceUpdates</literal>”(对应JMS话题<literal
+            >priceUpdates</literal>)的消息转向另一个本地地址“<literal
+                >jms.queue.priceForwarding</literal>”(对应JMS队列
+                <literal>priceForwarding</literal>)。</para>
+        <para>我们还配置了一相消息过滤器。只有<literal>office</literal>属性值为<literal>New York</literal>
+            的消息才被转发到新地址,其它消息则继续发往原地址。如果没有定义过滤器,所有消息将被转发。</para>
+        <para>本例中还配置了一个转换器的类。当每转发一个消息时,该转换器就被执行一次。转换器可以对消息在转发前进行
+            更改。这里的转换器只是在消息中加入了一个记录转发时间的消息头。</para>
+        <para>本例中消息被转发到一个’存贮与转发是‘队列,然后通过一个桥将消息转发到另一个HornetQ服务器中。</para>
+    </section>
+    <section>
+        <title>不唯一转发器</title>
+        <para>下面我们来看一个不唯一的转发器。不唯一转发器将消息的<emphasis>拷贝</emphasis>转发到新的地址中,
+            原消息则继续发往原有地址。</para>
+        <para>因此不唯一转发器可以将消息进行分流(splitting)。</para>
+        <para>不唯一转发器的配置与唯一转发器的配置中一样的,也可以带一个可选的过滤器和转换器。下面的配置也是出自
+             divert例子:</para>
+        <programlisting>
+&lt;divert name="order-divert"&gt;                 
+    &lt;address&gt;jms.queue.orders&lt;/address&gt;
+    &lt;forwarding-address&gt;jms.topic.spyTopic&lt;/forwarding-address&gt;         
+    &lt;exclusive&gt;false&lt;/exclusive&gt;
+&lt;/divert&gt;                       
+        </programlisting>
+        <para>The above divert example takes a copy of every message sent to the address '<literal
+                >jms.queue.orders</literal>' (Which corresponds to a JMS Queue called '<literal
+                >orders</literal>') and sends it to a local address called '<literal
+                >jms.topic.SpyTopic</literal>' (which corresponds to a JMS Topic called '<literal
+                >SpyTopic</literal>').</para>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/duplicate-detection.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/duplicate-detection.xml b/docs/user-manual/zh/duplicate-detection.xml
new file mode 100644
index 0000000..de675ac
--- /dev/null
+++ b/docs/user-manual/zh/duplicate-detection.xml
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- ============================================================================= -->
+<!-- Copyright © 2009 Red Hat, Inc. and others.                                    -->
+<!--                                                                               -->
+<!-- The text of and illustrations in this document are licensed by Red Hat under  -->
+<!-- a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). -->
+<!--                                                                               -->
+<!-- An explanation of CC-BY-SA is available at                                    -->
+<!--                                                                               -->
+<!--            http://creativecommons.org/licenses/by-sa/3.0/.                    -->
+<!--                                                                               -->
+<!-- In accordance with CC-BY-SA, if you distribute this document or an adaptation -->
+<!-- of it, you must provide the URL for the original version.                     -->
+<!--                                                                               -->
+<!-- Red Hat, as the licensor of this document, waives the right to enforce,       -->
+<!-- and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent        -->
+<!-- permitted by applicable law.                                                  -->
+<!-- ============================================================================= -->
+
+<chapter id="duplicate-detection">
+    <title>重复消息检测</title>
+    <para>HornetQ具有强大的自动检测重复消息的功能。应用层无需实现复杂的重复检测。本章解释了什么是重复检测,它
+        在HornetQ中如何工作的,以及如何进行配置。</para>
+    <para>当客户端向服务器端发送消息时,或者从一个服务器向另一个服务器传递消息时,如果消息发送后目标服务器或者
+        连接出现故障,导致发送一方没有收到发送成功的确认信息,发送方因此就无法确定消息是否已经成功发送到了目标地
+        址。</para>
+    <para>如果上述的故障发生在消息被成功接收并处理后,但是在向发送方返回功能确认信息之前,那么消息实际上可以到达
+        其目的地址;如果故障发生在消息的接收及处理过程中,则消息不会到达其目的地址。从发送方的角度看,它无法区分
+        这两种情况。</para>
+    <para>当服务器恢复后,客户端面临的困难的选择。它知道服务器出了故障,但是不知道刚刚发送的消息是否成功到达目的
+        地址。如果它重新发送这个消息,就有可能造成消息的重复。如果这个消息是一个订单的话,重复发送消息就会产生两
+        个相同的订单,这当然不是所希望的結果。</para>
+    <para>将消息的发送放到一个事务中也不能解决这个问题。如果在事务提交的过程中发生故障,同样不能确定这个事务是否提交
+        成功!</para>
+    <para>为了解决这个问题,HornetQ提供了自动消息重复检测功能。</para>
+    <section>
+        <title>在消息发送中应用重复检测</title>
+        <para>在消息发送中启用重复检测功能十分简单:你只需将消息的一个特殊属性设置一个唯一值。你可以用任意方法来
+            计算这个值,但是要保证它的唯一性。当目标服务器接收到这个消息时,它会检查这个属性是否被设置,如果设置了,
+            就检查内存缓存中是否已经接收到了相同值的消息。如果发现已经接收过具有相同属性值的消息,它将忽略这个消息。</para>
+        <note>
+            <para>在节点之间的消息传递使用重复消息检测可以保证<emphasis>一次且只一次</emphasis>的传递,和使用
+                XA事务接收消息的效果一样,但是比XA消耗的资源要少,并且更容易。</para>
+        </note>
+        <para>如果是在一个事务中发送消息,则只需要设置其中一个消息的属性值。在服务器端如果服务器检测到一个事务中某一个
+            消息重复,则会忽略整个事务。</para>
+        <para>这个属性的名称由<literal
+                >org.hornetq.api.core.HDR_DUPLICATE_DETECTION_ID</literal>定义,即:
+               <literal>_HQ_DUPL_ID</literal>。</para>
+        <para>该属性的值可以是<literal>byte[]</literal>类型或<literal
+                >SimpleString</literal>类型(核心接口)。如果使用JMS,它必须是<literal>String</literal>
+            类型。它的值一定是唯一的。一个简单的方法是使用UUID。</para>
+        <para>下面是一个使用核心接口设置这个属性的例子:</para>
+        <programlisting>
+...     
+
+ClientMessage message = session.createMessage(true);
+
+SimpleString myUniqueID = "This is my unique id";   // Could use a UUID for this
+
+message.setStringProperty(HDR_DUPLICATE_DETECTION_ID, myUniqueID);
+
+...
+        </programlisting>
+        <para>下面则是一个使用JMS的例子:</para>
+        <programlisting>
+...     
+
+Message jmsMessage = session.createMessage();
+
+String myUniqueID = "This is my unique id";   // Could use a UUID for this
+
+message.setStringProperty(HDR_DUPLICATE_DETECTION_ID.toString(), myUniqueID);
+
+...
+        </programlisting>
+    </section>
+    <section id="duplicate.id.cache">
+        <title>配置重复ID缓存</title>
+        <para>服务器缓存中保存接收到的消息的<literal
+                >org.hornetq.core.message.impl.HDR_DUPLICATE_DETECTION_ID</literal>属性值。每个地址有
+              单独的缓存。</para>
+        <para>缓存的大小是固定的,循环使用。如果缓存的最大可以存放<literal
+                >n</literal>条记录,那么<literal>n + 1</literal>条记录将会覆盖缓存中的第<literal>0</literal>
+                条记录。</para>
+        <para>缓存的最大容量在文件<literal>hornetq-configuration.xml</literal>中配置,参数是<literal
+                >id-cache-size</literal>。默认值是<literal>2000</literal>条记录。</para>
+        <para>在文件<literal>hornetq-configuration.xml</literal>中还可以配置将缓存持久化到磁盘。相应的参数
+            是<literal>persist-id-cache</literal>。如果设为<literal>true</literal>,则每加入一个id就将
+            它同时保存到磁盘中。默认值是<literal>true</literal>。</para>
+        <note>
+            <para>注意在设置缓存大小时,一定要保证缓存能保存足夠数量的记录,当消息被重新发送时,之前发送的ID不被
+                覆盖掉。</para>
+        </note>
+    </section>
+    <section>
+        <title>桥与重复检测</title>
+        <para>核心桥可以通过配置在将消息发向目的服务器之前自动向消息中添加唯一的id(如果消息中还没有的话)。这样
+            如果目的服务器发生故障,核心桥在重新发送消息时,目的服务器就可以自动检测重复的消息,发现重复消息即丢弃。</para>
+        <para>要配置核心桥的自动添加id的功能,需要在<literal>hornetq-configuration.xml</literal>中桥的配置
+              里将<parameter>use-duplicate-detection</parameter>参数设为<literal>true</literal>。</para>
+        <para>这个参数的默认值是<literal>true</literal>。</para>
+        <para>关于核心桥的配置和使用,参见<xref linkend="core-bridges" />。</para>
+    </section>
+    <section>
+        <title>重复检测与集群连接</title>
+        <para>集群连接内部使用核心桥在节点间可靠地移动消息,因此它们的核心桥也可以配置自动添加id的功能。</para>
+        <para>配置的方法是在<literal>hornetq-configuration.xml</literal>文件中将集群连接的
+              <parameter>use-duplicate-detection</parameter>参数设为<literal>true</literal>。</para>
+        <para>这个参数的默认值是<literal>true</literal>。</para>
+        <para>有关集群连接配置的更多信息,请参见<xref linkend="clusters"/>。</para>
+    </section>
+    <section>
+        <title>分页转存与重复检测</title>
+        <para>HornetQ在将消息进行分页转存中也使用了重复检测。当分页转存消息被从磁盘中读回到内存时,如果服务器发生故障,
+            重复检测可以避免在这一过程中有消息被重复读入,即避免了消息的重复传递。</para>
+        <para>关于分页转存的配置信息请参见<xref linkend="paging" />。</para>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/embedding-hornetq.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/embedding-hornetq.xml b/docs/user-manual/zh/embedding-hornetq.xml
new file mode 100644
index 0000000..1569b01
--- /dev/null
+++ b/docs/user-manual/zh/embedding-hornetq.xml
@@ -0,0 +1,178 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- ============================================================================= -->
+<!-- Copyright © 2009 Red Hat, Inc. and others.                                    -->
+<!--                                                                               -->
+<!-- The text of and illustrations in this document are licensed by Red Hat under  -->
+<!-- a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). -->
+<!--                                                                               -->
+<!-- An explanation of CC-BY-SA is available at                                    -->
+<!--                                                                               -->
+<!--            http://creativecommons.org/licenses/by-sa/3.0/.                    -->
+<!--                                                                               -->
+<!-- In accordance with CC-BY-SA, if you distribute this document or an adaptation -->
+<!-- of it, you must provide the URL for the original version.                     -->
+<!--                                                                               -->
+<!-- Red Hat, as the licensor of this document, waives the right to enforce,       -->
+<!-- and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent        -->
+<!-- permitted by applicable law.                                                  -->
+<!-- ============================================================================= -->
+<chapter id="embedding-hornetq">
+    <title>嵌入式HornetQ</title>
+    <para>HornetQ是由简单传统Java对象(POJO)实现,因此它可以在任何依赖注入的框架中运行,比如JBoss
+        Microcontainer,Sprint或Google Guice。另外如果你的应用程序内部需要消息功能,你可以在程序中
+        <emphasis>直接实例化</emphasis>HornetQ的客户端或服务器端。我们称之为<emphasis>嵌入式</emphasis>
+        HornetQ。</para>
+    <para>有些应用需要高性能、事务性及持久化的消息服务,但是又不希望自己去费时费力实现它。于是嵌入式HornetQ就
+        成为了一个很适当的选择。</para>
+    <para>要使用嵌入式HornetQ只需要几个简单的步骤。首先初始化配置对象,再初始化服务器并启动它,在你的虚拟机
+        中就运行越来了一个HornetQ服务器。就是这么简单。</para>
+    <section>
+        <title>POJO的初始化</title>
+        <para>按照以下步骤去做:</para>
+        <para>创建配置对象--这个对象包装了HornetQ的配置信息。如果你想使用配置文件,则使用<literal
+                >FileConfigurationImpl</literal>。</para>
+        <programlisting>import org.hornetq.core.config.Configuration;
+import org.hornetq.core.config.impl.FileConfiguration;
+
+...
+
+
+Configuration config = new FileConfiguration();
+config.setConfigurationUrl(urlToYourconfigfile);
+config.start();</programlisting>
+        <para>如果不需要配置文件,可以用<literal>ConfigurationImpl</literal>,只要将其中的各种配置参数设置好
+            即可。如添加适当的接收器。</para>
+        <para><literal>ConfigurationImpl</literal>用来配置接收器。和主要配置文件相似,只需要添加
+            <literal>NettyAcceptorFactory</literal>即可。</para>
+        <programlisting>import org.hornetq.core.config.Configuration;
+import org.hornetq.core.config.impl.ConfigurationImpl;
+
+...
+
+Configuration config = new ConfigurationImpl();
+HashSet&lt;TransportConfiguration> transports = new HashSet&lt;TransportConfiguration>();
+      
+transports.add(new TransportConfiguration(NettyAcceptorFactory.class.getName()));
+transports.add(new TransportConfiguration(InVMAcceptorFactory.class.getName()));
+
+config.setAcceptorConfigurations(transports);</programlisting>
+        <para>接着就需要初始化并启动HornetQ服务。<literal
+                >org.hornetq.api.core.server.HornetQ</literal>类有一些静态方法可用来创建HornetQ服务器。</para>
+        <programlisting>import org.hornetq.api.core.server.HornetQ;
+import org.hornetq.core.server.HornetQServer;
+
+...
+
+HornetQServer server = HornetQ.newHornetQServer(config);
+
+server.start();</programlisting>
+        <para>你还可以直接实例化<literal>HornetQServerImpl</literal>:</para>
+        <programlisting>HornetQServer server = 
+        new HornetQServerImpl(config);
+server.start();</programlisting>
+    </section>
+    <section>
+        <title>使用依赖注入框架</title>
+        <para>你还可以使用一个依赖注入框架来启动HornetQ,比如<trademark>JBoss
+                Microcontainer</trademark>或<trademark>Spring框架</trademark>。</para>
+        <para>HornetQ独立服务器使用的是JBoss Microcontainer作为其框架。在HornetQ的发布中包括的<literal
+                >HornetQBootstrapServer</literal>和<literal>hornetq-beans.xml</literal>文件共同实现了
+                在JBoss Microcontainer中对HornetQ服务器的引导。</para>
+        <para>要使用JBoss Microcontainer,需要在xml文件中声明<literal>HornetQServer</literal>
+            和<literal>Configuration</literal>对象。另外还可以注入一个安全管理器和一个MBean服务器。但是这些
+            注入是可选的。</para>
+        <para>下面是一个基本的JBoss Microcontainer的XML Bean的声明:</para>
+        <programlisting>&lt;?xml version="1.0" encoding="UTF-8"?>
+
+&lt;deployment xmlns="urn:jboss:bean-deployer:2.0">
+   
+   &lt;!-- The core configuration -->
+   &lt;bean name="Configuration" 
+         class="org.hornetq.core.config.impl.FileConfiguration">
+   &lt;/bean>
+
+   	&lt;!-- The core server -->
+   &lt;bean name="HornetQServer" 
+         class="org.hornetq.core.server.impl.HornetQServerImpl">      
+      &lt;constructor>
+         &lt;parameter>
+            &lt;inject bean="Configuration"/>
+         &lt;/parameter>            
+      &lt;/constructor>         
+   &lt;/bean>
+   &lt;/deployment></programlisting>
+        <para><literal>HornetQBootstrapServer</literal>实现了JBoss Microcontainer的简单封装。</para>
+        <programlisting>HornetQBootstrapServer bootStrap = 
+        new HornetQBootstrapServer(new String[] {"hornetq-beans.xml"});
+        bootStrap.run();</programlisting>
+    </section>
+    <section>
+        <title>连接嵌入式HornetQ</title>
+        <para>嵌入式HornetQ的连接和普通的连接一样要创建连接工厂:</para>
+        <section>
+            <title>核心接口</title>
+            <para>使用核心接口,需要创建一个<literal>ClientSessionFactory</literal>然后正常建立连接。</para>
+            <programlisting>ClientSessionFactory nettyFactory =  HornetQClient.createClientSessionFactory(
+                                        new TransportConfiguration(
+                                           InVMConnectorFactory.class.getName()));
+
+ClientSession session = factory.createSession();
+
+session.createQueue("example", "example", true);
+
+ClientProducer producer = session.createProducer("example");
+
+ClientMessage message = session.createMessage(true);
+
+message.getBody().writeString("Hello");
+
+producer.send(message);
+
+session.start();
+
+ClientConsumer consumer = session.createConsumer("example");
+
+ClientMessage msgReceived = consumer.receive();
+
+System.out.println("message = " + msgReceived.getBody().readString());
+
+session.close();</programlisting>
+        </section>
+        <section>
+            <title>JMS接口</title>
+            <para>使用JMS接口连接嵌入HornetQ同样简单。只需要直接实例化
+                    <literal>ConnectionFactory</literal>即可。如下面例子所示:</para>
+            <programlisting>ConnectionFactory cf =
+    HornetQJMSClient.createConnectionFactory(
+       new TransportConfiguration(InVMConnectorFactory.class.getName()));
+
+Connection conn = cf.createConnection();
+
+conn.start();
+
+Session sess = conn.createSession(true, Session.SESSION_TRANSACTED);
+
+MessageProducer prod = sess.createProducer(queue);
+
+TextMessage msg = sess.createTextMessage("Hello!");
+
+prod.send(msg);
+
+sess.commit();
+
+MessageConsumer consumer = sess.createConsumer(queue);
+
+TextMessage txtmsg = (TextMessage)consumer.receive();
+
+System.out.println("Msg = " + txtmsg.getText());
+
+sess.commit();
+
+conn.close();</programlisting>
+        </section>
+    </section>
+    <section>
+        <title>JMS嵌入式HornetQ的例子</title>
+        <para>有关如何设置与运行JMS嵌入式HornetQ的例子请参见<xref linkend="examples.embedded"/>。</para>
+    </section>
+</chapter>


Mime
View raw message