activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbert...@apache.org
Subject [25/51] [partial] activemq-6 git commit: ACTIVEMQ6-1 - Initial HornetQ Donation Commit
Date Mon, 10 Nov 2014 16:32:36 GMT
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/interoperability.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/interoperability.xml b/docs/user-manual/zh/interoperability.xml
new file mode 100644
index 0000000..4baed4a
--- /dev/null
+++ b/docs/user-manual/zh/interoperability.xml
@@ -0,0 +1,142 @@
+<?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="interoperability">
+    <title>互操作性</title>
+    <section id="stomp">
+        <title>Stomp</title>
+        <para><ulink url="http://stomp.codehaus.org/">Stomp</ulink>是一个基于文本的协议。使用Stomp协议的
+            客户端可以与Stomp的代理(broker)进行通迅。</para>
+        <para><ulink url="http://stomp.codehaus.org/Clients">Stomp客户端</ulink>支持多种语言和平台,因此
+        它有着很好的互操作性。</para>
+        <section id="stomp.native">
+          <title>内建Stomp支持</title>
+          <para>HornetQ内建支持Stomp功能。要使用Stomp发送与接收消息,必须配置一个<literal>NettyAcceptor</literal>,
+            其中的<literal>protocol</literal>参数值应设为<literal>stomp</literal>:</para>
+<programlisting>
+	&lt;acceptor name="stomp-acceptor">
+		&lt;factory-class>org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory&lt;/factory-class>		&lt;param key="protocol"  value="stomp"/>
+		&lt;param key="port"  value="61613"/>
+	&lt;/acceptor>
+</programlisting>
+          <para>有了上述的配置,HornetQ就可以在端口<literal>61613</literal>(这是Stomp代理的默认端口)接受Stomp连接了。</para>
+          <para><literal>stomp</literal>例子展示了如何在HornetQ中配置Stomp。</para>
+          <section>
+            <title>限制</title>
+            <para>消息的通知不是事务性的。ACK信号不能作为事务的一部分来传输(如果设置了<literal>transaction</literal>
+              属性,它将被忽略)。</para>
+          </section>
+        </section>
+        <section>
+          <title>Stomp目标与HornetQ的地址和队列的映射</title>
+          <para>Stomp客户端在消息发送和订阅中使用的是<emphasis>目标(destination)</emphasis>。目标名称是简单的字符串,对应的是服务
+            器端的目的地。不同服务器对这种映射有着不同的实现。</para>
+           <para>在HornetQ中这些目标被映射为<emphasis>地址</emphasis>和<emphasis>队列</emphasis>。
+            当一个Stomp客户端发送一个消息(使用<literal>SEND</literal>信号)到一个目标时,这个目标被映射到一个地址。
+            如果一个Stomp客户端订阅(或解除订阅)一个目标时(使用<literal>SUBSCRIBE</literal>或
+            <literal>UNSUBSCRIBE</literal>),这个目标被映射到一个HornetQ的队列。</para>
+        </section>
+        <section>
+          <title>Stomp与JMS的互操作性</title>
+          <section>
+            <title>使用JMS目标</title>
+            <para>正如<xref linkend="jms-core-mapping" />解释的那样,JMS的目标同样映射到HornetQ的地址与队列。如果你使用
+              Stomp向JMS的目标发送消息,那么Stomp的目标必须要遵照相同的命名规则:</para>
+            <itemizedlist>
+              <listitem>
+                <para>如果向JMS<emphasis>队列</emphasis>发送数据或订阅它,则队列的名称前缀必须是<literal>jms.queue.</literal>。</para>
+                <para>例如,如果向名为<literal>orders</literal>的JMS队列发送消息,Stomp客户端必须发送以下信息:</para>
+                <programlisting>
+SEND
+destination:jms.queue.orders
+
+hello queue orders
+^@
+                </programlisting>
+              </listitem>
+              <listitem>
+                <para>如果向JMS <emphasis>话题(topic)</emphasis>发送或订阅消息,话题名称前缀必须是<literal>jms.topic.</literal>。</para>
+                <para>例如,如果订阅名为 <literal>stocks</literal>的JMS话题,Stomp客户端必须发送以下信息:</para>
+                <programlisting>
+  SUBSCRIBE
+  destination:jms.topic.stocks
+  
+  ^@
+                </programlisting>
+              </listitem>
+             </itemizedlist>
+           </section>
+
+           <section>
+             <title>使用JMS或核心接口发送和接收Stomp消息</title>
+             <para>Stomp基本上是一个基于文本的协议。为了使用更简单,我们的Stomp实现通过检查<literal>content-length</literal>的值
+               来决定如何将一个Stomp消息映射成一个JMS消息或核心消息。
+             </para>
+             <para>如果在Stomp消息中<emphasis>没有</emphasis><literal>content-length</literal>头,它将被映射为一个JMS的
+               <emphasis>TextMessage</emphasis>,或者是一个核心消息,其消息体的缓存是一个SimpleString。</para>
+             <para>如果Stomp消息中<emphasis>有</emphasis><literal>content-length</literal>,则它被映射为一个JMS的
+                   <emphasis>BytesMessage</emphasis>,或者是一个核心消息,其消息体缓存中是一个字节数组byte[]。</para>
+             <para>从一个JMS消息或核心消息映射为Stomp消息时遵从同样的逻辑。一个Stomp客户端可以通过检查
+                   <literal>content-length</literal>来决定消息体的类型(字符串或字节)。</para>
+          </section>
+        </section>
+        <section id="stomp.websockets">
+         <title>通过Web Sockets使用Stomp</title>
+         <para>HornetQ还支持通过<ulink url="http://dev.w3.org/html5/websockets/">Web Sockets</ulink>使用Stomp。任何支持
+            Web Socket的浏览器中可以利用HornetQ来发送和接收Stomp消息。</para>
+         <para>要使用些功能,必须配置一个<literal>NettyAcceptor</literal>,并设置<literal>protocol</literal>
+            的值为<literal>stomp_ws</literal>:</para>
+         <programlisting>
+&lt;acceptor name="stomp-ws-acceptor">
+	&lt;factory-class>org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory&lt;/factory-class>
+	&lt;param key="protocol" value="stomp_ws"/>
+	&lt;param key="port" value="61614"/>
+&lt;/acceptor>
+         </programlisting>
+         <para>使用上面配置,HornetQ在URL路径<literal>/stomp</literal>下端口<literal>61614</literal>接收Stomp连接。
+            浏览器然后就可以连接到<literal>ws://&lt;server&gt;:61614/stomp</literal>,使用Web Socket来发送和接收
+            Stomp消息了。</para>
+         <para>为了简化客户端的开发,在<ulink url="http://github.com/jmesnil/stomp-websocket">GitHub</ulink>
+            上提供了一个JavaScript库(参见<ulink url="http://jmesnil.net/stomp-websocket/doc/">文档</ulink>)。</para>
+         <para><literal>stomp-websockets</literal>例子给出一如何配置HornetQ服务器以使浏览器和Java应用程序通过一个JMS话题
+            进行消息的传递。</para>
+        </section>
+        <section id="stompconnect">
+          <title>StompConnect</title>
+          <para><ulink url="http://stomp.codehaus.org/StompConnect">StompConnect</ulink>是一个Stomp代理服务器,
+            它可以将Stomp协议转换为标准的JMS接口调用。因此,通过StompConnect的作用HornetQ可以作为一个Stomp代理,
+            与任何一个Stomp客户端通迅。这些客户端可以由C、C++、C#及.net等语言实现。</para>
+          <para>要运行StompConnect首先要启动HornetQ服务以及JNDI服务。</para>
+          <para>Stomp需要<literal>jndi.properties</literal>文件要在classpath中。该文件
+            应有如下类似的内容:</para>
+          <programlisting>java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
+java.naming.provider.url=jnp://localhost:1099
+java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces</programlisting>
+          <para>要确保该文件与StompConnect的jar包以及HornetQ的jar文件都在classpath中。最后,运行
+            <literal>java org.codehaus.stomp.jms.Main</literal>。</para>
+        </section>
+    </section>
+    <section>
+        <title>REST</title>
+        <para>HornetQ即将支持REST!</para>
+    </section>
+    <section>
+        <title>AMQP</title>
+        <para>HornetQ即将支持AMQP!</para>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/jms-bridge.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/jms-bridge.xml b/docs/user-manual/zh/jms-bridge.xml
new file mode 100644
index 0000000..b2896b4
--- /dev/null
+++ b/docs/user-manual/zh/jms-bridge.xml
@@ -0,0 +1,382 @@
+<?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="jms-bridge">
+        <title>JMS桥(Bridge)</title>
+        <para>HornetQ提供了JMS消息桥服务。</para>
+        <para>桥的作用是从一个消息源队列或话题(topic)接收消息,然后将它们发送到一个目标队列或话题。通常源和
+            目的不在同一台服务器上。</para>
+        <para>作为消息源的服务器与目的服务器不必在同一个集群内。通过桥的作用,两台服务器可以通过非可靠的网络连接
+            起来,比如WAN。</para>
+        <para>桥可以作为单独的服务部署,或者部署于HornetQ单独服务器内,或者部署在JBoss应用服务器中。源或目的可以
+            在同一个VM中,也可以在其它的VM中。</para>
+        <para>桥还可以在HornetQ服务器与其它JMS 1.1 兼容的服务器之间进行消息的传递。
+        <note><para>还要将JMS桥与核心桥混淆。JMB桥可以连接两个JMS 1.1兼容的服务器,它使用的是JMS接口。
+                    而核心桥(在<xref linkend="core-bridges"/>中描述)使用核心API将两个HornetQ实例连接
+                    起来。核心桥的性能通常要比JMS桥的性能高,所以尽可能使用核心桥。另外核心桥可以不用XA
+                    就可以实现<emphasis>一次并只有一次</emphasis>的消息传递保证。</para></note></para>
+        <para>桥可以适当处理连接故障。当源的连接或目的的连接发生故障时,例如网络故障,桥将不断重试连接直到连接
+            恢复为止。当连接恢复后,桥会继续正常工作。</para>
+        <para>桥还可以有一个可选的JMS选择器,它可以使桥只接收选择器选择的消息。</para>
+        <para>可以配置桥从队列还是从话题中接收消息。如果配置成从话题中接收消息,还以设定是以非持久订阅的方式接收,还是
+            以持久订阅的方式接收。</para>
+        <para>通常桥是通过一个bean配置文件由JBoss Micro Container部署到JBoss应用服务器中。下面的就是一
+            个桥的bean文件例子。这个桥将同一服务器上的两个目标连接起来。</para>
+        <programlisting>&lt;?xml version="1.0" encoding="UTF-8"?>
+
+&lt;deployment xmlns="urn:jboss:bean-deployer:2.0">
+
+       &lt;bean name="JMSBridge" class="org.hornetq.api.jms.bridge.impl.JMSBridgeImpl">
+           &lt;!-- HornetQ must be started before the bridge -->
+           &lt;depends>HornetQServer&lt;/depends>
+           &lt;constructor>
+               &lt;!-- Source ConnectionFactory Factory -->
+               &lt;parameter>
+                   &lt;inject bean="SourceCFF"/>
+               &lt;/parameter>
+               &lt;!-- Target ConnectionFactory Factory -->
+               &lt;parameter>
+                   &lt;inject bean="TargetCFF"/>
+               &lt;/parameter>
+               &lt;!-- Source DestinationFactory -->
+               &lt;parameter>
+                   &lt;inject bean="SourceDestinationFactory"/>
+               &lt;/parameter>
+               &lt;!-- Target DestinationFactory -->
+               &lt;parameter>
+                   &lt;inject bean="TargetDestinationFactory"/>
+               &lt;/parameter>
+               &lt;!-- Source User Name (no username here) -->
+               &lt;parameter>&lt;null />&lt;/parameter>
+               &lt;!-- Source Password (no password here)-->
+               &lt;parameter>&lt;null />&lt;/parameter>
+               &lt;!-- Target User Name (no username here)-->
+               &lt;parameter>&lt;null />&lt;/parameter>
+               &lt;!-- Target Password (no password here)-->
+               &lt;parameter>&lt;null />&lt;/parameter>
+               &lt;!-- Selector -->
+               &lt;parameter>&lt;null />&lt;/parameter>
+               &lt;!-- Failure Retry Interval (in ms) -->
+               &lt;parameter>5000&lt;/parameter>
+               &lt;!-- Max Retries -->
+               &lt;parameter>10&lt;/parameter>
+               &lt;!-- Quality Of Service -->
+               &lt;parameter>ONCE_AND_ONLY_ONCE&lt;/parameter>
+               &lt;!-- Max Batch Size -->
+               &lt;parameter>1&lt;/parameter>
+               &lt;!-- Max Batch Time (-1 means infinite) -->
+               &lt;parameter>-1&lt;/parameter>
+               &lt;!-- Subscription name (no subscription name here)-->
+               &lt;parameter>&lt;null />&lt;/parameter>
+               &lt;!-- Client ID  (no client ID here)-->
+               &lt;parameter>&lt;null />&lt;/parameter>
+               &lt;!-- Add MessageID In Header -->
+               &lt;parameter>true&lt;/parameter>
+               &lt;!-- register the JMS Bridge in the AS MBeanServer -->
+               &lt;parameter>
+                   &lt;inject bean="MBeanServer"/>
+               &lt;/parameter>
+               &lt;parameter>org.hornetq:service=JMSBridge&lt;/parameter>
+             &lt;/constructor>
+           &lt;property name="transactionManager">
+               &lt;inject bean="RealTransactionManager"/>
+           &lt;/property>
+       &lt;/bean>
+
+       &lt;!-- SourceCFF describes the ConnectionFactory used to connect to the 
+            source destination -->
+       &lt;bean name="SourceCFF" 
+            class="org.hornetq.api.jms.bridge.impl.JNDIConnectionFactoryFactory">
+           &lt;constructor>
+               &lt;parameter>
+                   &lt;inject bean="JNDI" />
+               &lt;/parameter>
+               &lt;parameter>/ConnectionFactory&lt;/parameter>
+           &lt;/constructor>  
+       &lt;/bean>
+
+       &lt;!-- TargetCFF describes the ConnectionFactory used to connect to the 
+        target destination -->
+       &lt;bean name="TargetCFF" 
+            class="org.hornetq.api.jms.bridge.impl.JNDIConnectionFactoryFactory">
+           &lt;constructor>
+               &lt;parameter>
+                   &lt;inject bean="JNDI" />
+               &lt;/parameter>
+               &lt;parameter>/ConnectionFactory&lt;/parameter>
+           &lt;/constructor>  
+       &lt;/bean>
+
+       &lt;!-- SourceDestinationFactory describes the Destination used as the source -->
+       &lt;bean name="SourceDestinationFactory" 
+            class="org.hornetq.api.jms.bridge.impl.JNDIDestinationFactory">
+           &lt;constructor>
+               &lt;parameter>
+                   &lt;inject bean="JNDI" />
+               &lt;/parameter>
+               &lt;parameter>/queue/source&lt;/parameter>
+           &lt;/constructor>  
+       &lt;/bean>
+
+       &lt;!-- TargetDestinationFactory describes the Destination used as the target -->
+       &lt;bean name="TargetDestinationFactory" 
+            class="org.hornetq.api.jms.bridge.impl.JNDIDestinationFactory">
+           &lt;constructor>
+               &lt;parameter>
+                   &lt;inject bean="JNDI" />
+               &lt;/parameter>
+               &lt;parameter>/queue/target&lt;/parameter>
+           &lt;/constructor>  
+       &lt;/bean>
+       
+       &lt;!-- JNDI is a Hashtable containing the JNDI properties required -->
+       &lt;!-- to connect to the sources and targets JMS resrouces         -->       
+      &lt;bean name="JNDI" class="java.util.Hashtable">
+         &lt;constructor class="java.util.Map">
+            &lt;map class="java.util.Hashtable" keyClass="String"
+                                             valueClass="String">
+               &lt;entry>
+                  &lt;key>java.naming.factory.initial&lt;/key>
+                  &lt;value>org.jnp.interfaces.NamingContextFactory&lt;/value>
+               &lt;/entry>
+               &lt;entry>
+                  &lt;key>java.naming.provider.url&lt;/key>
+                  &lt;value>jnp://localhost:1099&lt;/value>
+               &lt;/entry>
+               &lt;entry>
+                  &lt;key>java.naming.factory.url.pkgs&lt;/key>
+                  &lt;value>org.jboss.naming:org.jnp.interfaces"&lt;/value>
+               &lt;/entry>
+               &lt;entry>
+                  &lt;key>jnp.timeout&lt;/key>
+                  &lt;value>5000&lt;/value>
+               &lt;/entry>
+               &lt;entry>
+                  &lt;key>jnp.sotimeout&lt;/key>
+                  &lt;value>5000&lt;/value>
+               &lt;/entry>
+            &lt;/map>
+         &lt;/constructor>
+      &lt;/bean>
+
+      &lt;bean name="MBeanServer" class="javax.management.MBeanServer">
+         &lt;constructor factoryClass="org.jboss.mx.util.MBeanServerLocator"
+                      factoryMethod="locateJBoss"/>
+      &lt;/bean>
+&lt;/deployment></programlisting>
+        <section>
+            <title>JMS桥的配置参数</title>
+            <para>桥的主要的bean是<literal>JMSBridge</literal>。所有的配置参数需要传递给这个bean的
+                构造函数。</para>
+            <note>
+                <para>如果不想指定某个参数的值(例如匿名认证或没有选择器),将该参数设为<literal>&lt;null
+                        /&gt;</literal>即可。</para>
+            </note>
+            <itemizedlist>
+                <listitem>
+                    <para>源连接工厂的工厂(Source ConnectionFactory Factory)</para>
+                    <para>这个参数注入一个<literal>SourceCFF</literal>bean(由bean文件定义)。它被
+                        用来创建<emphasis>源</emphasis>的<literal>ConnectionFactory</literal>
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>目标连接工厂的工厂(Target ConnectionFactory Factory)</para>
+                    <para>这个参数注入一个<literal>TargetCFF</literal>bean(由bean文件定义)。它被
+                        用来创建<emphasis>目的</emphasis>的<literal>ConnectionFactory</literal>
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>源目标工厂(Source DestinationFactory)</para>
+                    <para>这个参数注入一个<literal>SourceDestinationFactory</literal>bean(由
+                        bean文件定义)。它用来创建<emphasis>源</emphasis>
+                        <literal>目标(Destination)</literal>
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>目的目标工厂(Target DestinationFactory)</para>
+                    <para>这个参数注入一个<literal>TargetDestinationFactory</literal>bean(由
+                        bean文件定义)。它用来创建<emphasis>目的</emphasis>
+                        <literal>目标(Destination)</literal>
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>源用户名(Source User Name)</para>
+                    <para>用于创建到<emphasis>源</emphasis>的连接的用户名</para>
+                </listitem>
+                <listitem>
+                    <para>源密码(Source Password)</para>
+                    <para>用于创建<emphasis>源</emphasis>连接的密码</para>
+                </listitem>
+                <listitem>
+                    <para>目的用户名(Target User Name)</para>
+                    <para>用于创建<emphasis>目的</emphasis>连接的用户名</para>
+                </listitem>
+                <listitem>
+                    <para>目的密码(Target Password)</para>
+                    <para>t用于创建<emphasis>目的</emphasis>连接的密码</para>
+                </listitem>
+                <listitem>
+                    <para>选择器(Selector)</para>
+                    <para>这是一个JMS的选择器表达式,它用于从源目标接收消息。只有与选择器相匹配的消息才会被桥
+                        转发到目的目标</para>
+                    <para>选择器必须符合<ulink
+                            url="http://java.sun.com/j2ee/1.4/docs/api/javax/jms/Message.html">JMS
+                            选择器语法</ulink></para>
+                </listitem>
+                <listitem>
+                    <para>故障重试间隔(Failure Retry Interval)</para>
+                    <para>代表当桥发现连接故障时在每两次重试连接之间所要等待的时间间隔,单位毫秒</para>
+                </listitem>
+                <listitem>
+                    <para>最大重试次数(Max Retries)</para>
+                    <para>表示桥在发现连接故障时所进行的最大重试次数。超过这个次数,桥就放弃重试。
+                          <literal
+                            >-1</literal>代表一直重试下去</para>
+                </listitem>
+                <listitem>
+                    <para>服务质量(Quality Of Service)</para>
+                    <para>这个参数代表所需要的服务质量模式</para>
+                    <para>有效的值为:</para>
+                    <itemizedlist>
+                        <listitem>
+                            <para><literal>AT_MOST_ONCE</literal></para>
+                        </listitem>
+                        <listitem>
+                            <para><literal>DUPLICATES_OK</literal></para>
+                        </listitem>
+                        <listitem>
+                            <para><literal>ONCE_AND_ONLY_ONCE</literal></para>
+                        </listitem>
+                    </itemizedlist>
+                    <para>有关这些模式的解释,参见<xref linkend="quality-of-service"/>。</para>
+                </listitem>
+                <listitem>
+                    <para>最大批量(Max Batch Size)</para>
+                    <para>表示桥一次性从源目标最多接收多少消息,并将它们一次发往目的地。它的值必须是
+                        <literal>>= 1</literal>
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>最大批时间(Max Batch Time)</para>
+                    <para>代表桥在将一批消息发向目的之前等待的最大毫秒数。这个时间过后,即使接收的消息数小于
+                        <literal>MaxBatchSize</literal>,桥也会开始向目的发送消息。它的值必须是
+                        <literal>-1</literal> (代表永远等待)或<literal>>= 1</literal>。</para>
+                </listitem>
+                <listitem>
+                    <para>订阅名(Subscription Name)</para>
+                    <para>如果源的目标是一个话题(topic),你想使用持久的订阅来接收消息的话,这个参数可以指定
+                        订阅名。</para>
+                </listitem>
+                <listitem>
+                    <para>客户ID(Client ID)</para>
+                    <para>如果源的目标是一个话题(topic),你想使用持久的订阅来接收消息的话,这个参数可以指定
+                        JMS的客户ID。它用于创建/查找持久订阅。</para>
+                </listitem>
+                <listitem>
+                    <para>在消息头添加MessageID(Add MessageID In Header)</para>
+                    <para>如果值为<literal>true</literal>,原始的消息ID在发往目的是回到消息的名为<literal
+                            >HORNETQ_BRIDGE_MSG_ID_LIST</literal>的头中。如果一个消息被桥转发了多次,
+                        则每次转发的消息ID都添加在这个头中。这用于分布式请求/回答的消息模式。</para>
+                    <note>
+                        <para>当收到一个消息时,通过它的相关ID(coorelation id)可以发送一个回答。这样
+                            在消息发送方得到这个回答消息时,它可以与原消息相关联起来。</para>
+                    </note>
+                </listitem>
+               <listitem>
+                   <para>MBean服务器(MBean Server)</para>
+                   <para>要使用JMX管理JMS桥,需指定JMS桥所要注册的MBeanServer(如JVM Platform MBeanServer 或
+                      JBoss 应用服务器的MBeanServer)</para>
+               </listitem>
+               <listitem>
+                   <para>ObjectName</para>
+                   <para>设置了MBeanServer后,你还需要设置JMS桥MBean注册用的ObjectName(必须是唯一的)</para>
+               </listitem>
+            </itemizedlist>
+        </section>
+        <section>
+            <title>源和目的的连接工厂</title>
+            <para>源工目的的连接工厂分别用于创建到源和到目的的连接。</para>
+            <para>上面的配置例子中使用的是HornetQ提供的默认实现。它使用JNDI查找连接工厂。对于其它的应用服务器
+                或JMS提供者,需要实现相应的实现,即实现<literal
+                    >org.hornetq.jms.bridge.ConnectionFactoryFactory</literal>接口。</para>
+        </section>
+        <section>
+            <title>源和目的的目标工厂</title>
+            <para>它们用来创建或查找相应的目标。</para>
+            <para>上面例子中,我们使用了HornetQ的默认实现,从JNDI中查找相应的对象。</para>
+            <para>要提供新的实现,只要实现接口<literal
+                    >org.hornetq.jms.bridge.DestinationFactory</literal>即可。</para>
+        </section>
+        <section id="quality-of-service">
+            <title>服务质量</title>
+            <para>下面给是桥的三种服务质量的详细说明。</para>
+            <section>
+                <title>AT_MOST_ONCE</title>
+                <para>这种QoS模式表示的是消息最多送达目标一次。在消息发往目的之前,消息就会被通知。因此,
+                    如果在消息被源删除但并未到达目的时发生故障,消息有可能丢失。所以说消息的
+                    发送最多一次。 </para>
+                <para>这个模式适用于持久或非持久的消息。</para>
+            </section>
+            <section>
+                <title>DUPLICATES_OK</title>
+                <para>在这个QoS模式下,消息从源接收后再发送到目的,之后才对源进行消息通知。这样如果在发送成功之后
+                    消息通知前的时间内发生故障的话,在故障恢复时同一个消息可能被再次传递。結果可能是在目的处
+                    该消息收到了两次。</para>
+                <para>这个模式适用于持久或非持久的消息。</para>
+            </section>
+            <section>
+                <title>ONCE_AND_ONLY_ONCE</title>
+                <para>这个模式保证消息从源发送到目的一次,并且只有一次。(有时这个模式又称为“只一次”)。若源与目的处于
+                    同一个HornetQ服务器中,这个模式通过本地事务来保证消息的发送和通知。如果是在不同的服务器上,
+                    则会使用一个JTA的事务将发送和接收包括其中。这里使用的JTA事务是JBoss的实现,它包含有一个
+                    完整的事务恢复管理器,所以能提供高度可靠的持久性。如果使用JTA则桥的所有连接工厂必须是
+                    XAConnectionFactory。这种模式的效率通常是最低的,因为它需要额外记录事务的日志。</para>
+                <para>这个模式只适用于持久性消息。</para>
+                <note>
+                    <para>某些情况下可以不使用ONCE_AND_ONLY_ONCE模式,而同样可以保证“一次且只一次”的效果。
+                        这是通过使用DUPLICATES_OK模式,加上在目的端应用程序来检测重复的消息,如果有则将其丢弃。
+                        一些JMS服务器本身提供自动重复消息检测的功能,这样节省了在应用层实现的工作。在应用层常见
+                        的实现方法是将接收到的消息的ID存放到缓存文件中,然后与每个新到的消息进行对比。这种方式
+                        可能在某段时间内有效,所以它不如ONCE_AND_ONLY_ONCE那样严格,它视具体情况也可能是一个
+                        不错的选择。</para>
+                </note>
+            </section>
+           <section>
+              <title>JMS bridge中的超时问题</title>
+              <para>有时候目标服务器或源服务器会连接不上,这里桥就会尝试重新连接。重新连接的次数由<literal>Max Retries</literal>
+              参数决定,两次重新连接的时间间隔由<literal>Failure Retry Interval</literal>定义。</para>
+              <para>在重新尝试时会进行JNDI的查找。HornetQ的JNDI使用的是JBoss的实现,如果在JNDI查找过程中网络出现故障,
+              查找的操作可能挂起。为了避免这种情况的发生,我们可以为JNDI设置适当的超时。这是通过定义初始上下文的
+              <literal>jnp.timeout</literal>参数和<literal>jnp.sotimeout</literal>参数来
+              实现的。第一个参数定义了初始连接的超时,第二个参数定义的是套接字的读取超时。</para>
+              <note>
+                 <para>一旦JNDI连接成功,所有调用都是通过RMI完成。如果你想要控制RMI连接的超时,你需要定义相应的系统变量。
+                 JBoss使用Sun的RMI实现,它的控制参数可以在<ulink
+                            url="http://java.sun.com/j2se/1.5.0/docs/guide/rmi/sunrmiproperties.html">这里</ulink>找到。
+                 默认的连接超时是10秒,默认的读超时是18秒。</para>
+              </note>
+              <para>如果你使用自己的实现来查找JMS资源,你需要注意超时问题。</para>
+           </section>
+            <section>
+                <title>例子</title>
+                <para>参见<xref linkend="examples.javaee.jms-bridge"/>。这个例子展示了如何在JBoss应用服务器中配置并使用
+                    JMS桥从一处目标将消息转发到另一个目标。</para>
+                <para>关于如何在两个单独HornetQ服务器间使用桥的例子,请参见<xref linkend="examples.jms.jms-bridge"/>。</para>
+            </section>
+        </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/jms-core-mapping.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/jms-core-mapping.xml b/docs/user-manual/zh/jms-core-mapping.xml
new file mode 100644
index 0000000..5086104
--- /dev/null
+++ b/docs/user-manual/zh/jms-core-mapping.xml
@@ -0,0 +1,42 @@
+<?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="jms-core-mapping">
+    <title>JMS与内核API之间的映射关系</title>
+    <para>本意讲述JMS的目标实体(destination)如何映射到HornetQ的地址(addresses)。</para>
+    <para>HornetQ的内核没有JMS的任何实现。在内核中没有topic的概念,它是通过在一个地址上(相当于topic的名字)绑定
+        零或多个queue来实现JMS topic的功能的。每个绑定的queue相当于该topic的一个订阅(subscription)。
+        类似地通过在一个地址上(相当于queue的名字)绑定单一的queue就可以实现JMS queue的功能。</para>
+    <para>按照惯例,所有的JMS queue所对应的内核queue的名字都以<literal>jms.queue.</literal>做为开头。比如
+        当JMS queue的名字是"orders.europe"时,其对应的内核queue的名字应该是"jms.queue.orders.europe"。
+        那么内核queue所绑定的地址的名字和该内核queue的名字是相同的。</para>
+    <para>同样,所有JMS topic所对应的内核地址的名字都以 "jms.topic."为前缀。比如当一个JMS topic的名字是"news.europe"
+        时,它对应的内核的地址应该是"jms.topic.news.europe"。</para>
+    <para>换句话说就是如果你向JMS queue “orders.europe"发送一个消息,这个消息就会被路由到绑定在内核地址为“jms.queue.orders.europe”
+        的同名内核queue中。 如果是向JMS topic “news.europe“发送一个消息,它会被路由到绑定到内核地址为
+        ”jms.topic.news.europe“的所有的内核queue中。</para>
+    <para>具体要配置一个名为“orders.europe"的JMS队列时,你需要配置相应的内核queue“jms.queue.orders.europe“:</para>
+    <programlisting>
+&lt;!-- expired messages in JMS Queue "orders.europe"
+    will be sent to the JMS Queue "expiry.europe" --&gt;
+&lt;address-setting match="jms.queue.orders.europe"&gt;
+   &lt;expiry-address&gt;jms.queue.expiry.europe&lt;/expiry-address&gt;
+   ...
+&lt;/address-setting&gt;
+   </programlisting>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/large-messages.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/large-messages.xml b/docs/user-manual/zh/large-messages.xml
new file mode 100644
index 0000000..641bcea
--- /dev/null
+++ b/docs/user-manual/zh/large-messages.xml
@@ -0,0 +1,234 @@
+<?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="large-messages">
+    <title>大消息</title>
+    <para>HornetQ支持超大消息的发送和接收。消息的大小不受客户端或服务器端的内存限制。它只受限于你的磁盘空间的大小。
+        在我们作过的测试中,消息最大可达8GiB,而客户端和服务器端的内存只有50MiB!</para>
+    <para>要发送一个大消息,用户需要为大消息提供一个<literal>InputStream</literal>,当大消息被发送时,
+        HornetQ从该<literal>InputStream</literal>读取消息。例如,要将一个磁盘中的大文件以消息形式发送,可以
+        使用<literal>FileInputStream</literal>。</para>
+    <para>数据从<literal>InputStream</literal>读出并分解为一个个数据片段向服务器以流的形式发送。服务器在收到
+        这些片段后将它们保存到磁盘上。当服务器准备向接收者传递消息时,它将这些片段读回,同样以片段流的形式向接收者
+        一端发送。当接收者开始接收时,最初收到的只是一个空的消息体。它需要为其设置一个<literal>OutputStream</literal>
+        以便向大消息保存到磁盘上或其它地方。从发送到接收整个过程中不需要整个消息都在内存中。</para>
+    <section id="large.message.configuring">
+        <title>服务器端的配置</title>
+        <para>大消息在服务器端是直接保存在磁盘目录中。这一目录可以在HornetQ的配置文件中定义。</para>
+        <para>这个参数的名字是<literal>large-messages-directory</literal>:</para>
+        <programlisting>&lt;configuration xmlns="urn:hornetq"
+               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+               xsi:schemaLocation="urn:hornetq /schema/hornetq-configuration.xsd">
+
+...
+
+&lt;large-messages-directory>/data/large-messages&lt;/large-messages-directory>
+
+...
+
+&lt;/configuration</programlisting>
+        <para>默认的大消息保存目录是<literal>data/largemessages</literal>。</para>
+        <para>为了提高性能,我们建议将大消息的保存目录定义到与消息日志(journal)或分页转存目录分开的物理卷上。</para>
+    </section>
+    <section>
+        <title>设定限制</title>
+        <para>参数<literal>min-large-message-size</literal>定义了大消息的最小值。
+              任何消息的大小如果超过了该值就被视为大消息。一旦成为大消息,它将被分成小的
+              片段来传送。</para>
+        <para>默认值是100KiB.</para>
+        <section id="large-messages.core.config">
+            <title>使用核心的API</title>
+            <para>如果使用HornetQ的核心,<literal>ClientSessionFactory.setMinLargeMessageSize</literal>方法
+                  可以设置大消息的最小值。</para>
+            <programlisting>ClientSessionFactory factory = 
+            HornetQClient.createClientSessionFactory(new 
+            TransportConfiguration(NettyConnectorFactory.class.getName()), null);
+factory.setMinLargeMessageSize(25 * 1024);</programlisting>
+            <para><xref linkend="configuring-transports.client.side"/>对于如何实例化一个会话工厂(session factory)
+                给出了进一步的说明。</para>
+        </section>
+        <section>
+            <title>使用JMS</title>
+            <para>如果连接工厂是通过JNDI方式获得的,则需要在<literal>hornetq-jms.xml</literal>文件中定义:</para>
+            <programlisting>...
+&lt;connection-factory name="ConnectionFactory">
+&lt;connectors>
+   &lt;connector-ref connector-name="netty"/>
+&lt;/connectors>
+&lt;entries>
+   &lt;entry name="ConnectionFactory"/>
+   &lt;entry name="XAConnectionFactory"/>
+&lt;/entries>
+                
+&lt;min-large-message-size>250000&lt;/min-large-message-size>
+&lt;/connection-factory>
+...</programlisting>
+            <para>如果是直接实例化连接工厂,则使用<literal
+                    >HornetQConnectionFactory.setMinLargeMessageSize</literal>方法来定义。</para>
+        </section>
+    </section>
+    <section>
+        <title>大消息与流(stream)</title>
+        <para>在HornetQ中可以定义大消息所使用的输入和输出流(<literal>java.lang.io</literal>)。</para>
+        <para>HornetQ将使用定义的流来发送(输入流)和接收(输出流)大消息。</para>
+        <para>在使用输出流接收大消息时,有两种选择:你可以用<literal>ClientMessage.saveOutputStream</literal>方法
+            以阻塞的方式保存大消息;或者你可以使用<literal>ClientMessage.setOutputstream</literal>方法
+            以异步方法保存大消息。在采用后一种方法时,必须保证接收者(consumer)在大消息的接收过程中保持
+            有效状态。</para>
+        <para>根据需要选择所适合的流。最常见的情况是将磁盘文件以消息方式发送,也有可能是JDBC的Blob数据,
+            或者是一个<literal>SocketInputStream</literal>,或是来自<literal>HTTPRequests</literal>
+            的数据等等。只要是实现了<literal>java.io.InputStream</literal>和
+            <literal>java.io.OutputStream</literal>的数据源都可以作为大消息传送。</para>
+        <section>
+            <title>核心API中流的使用</title>
+            <para>下表列出了<literal>ClientMessage</literal>上可以使用的方法。
+                  通过相应的对象属性也可以在JMS中应用。</para>
+            <table frame="topbot" id="large-messages.ClientMessageAPI">
+                <title>org.hornetq.api.core.client.ClientMessage API</title>
+                <tgroup cols="3">
+                    <colspec colname="Name" colnum="1"/>
+                    <colspec colname="Descr" colnum="2"/>
+                    <colspec colname="JMS" colnum="3"/>
+                    <thead>
+                        <row>
+                            <entry>名称</entry>
+                            <entry>说明</entry>
+                            <entry>JMS相对应的属性</entry>
+                        </row>
+                    </thead>
+                    <tbody>
+                        <row>
+                            <entry>setBodyInputStream(InputStream)</entry>
+                            <entry>设定大消息发送时所使用的输入流。</entry>
+                            <entry>JMS_HQ_InputStream</entry>
+                        </row>
+                        <row>
+                            <entry>setOutputStream(OutputStream)</entry>
+                            <entry>设定异步接收大消息所使用的输出流。</entry>
+                            <entry>JMS_HQ_OutputStream</entry>
+                        </row>
+                        <row>
+                            <entry>saveOutputStream(OutputStream)</entry>
+                            <entry>设定保存大消息所使用的输出流。这个方法将会阻塞直到大消息全部
+                                   保存完毕才返回。</entry>
+                            <entry>JMS_HQ_SaveStream</entry>
+                        </row>
+                    </tbody>
+                </tgroup>
+            </table>
+            <para>下面代码中设定了接收核心消息所用的输出流: </para>
+            <programlisting>
+...
+ClientMessage msg = consumer.receive(...);
+
+
+// This will block here until the stream was transferred
+msg.saveOutputStream(someOutputStream); 
+
+ClientMessage msg2 = consumer.receive(...);
+
+// This will not wait the transfer to finish
+msg.setOutputStream(someOtherOutputStream); 
+...
+                
+            </programlisting>
+            <para> 设定发送核心消息所用的输入流: </para>
+            <programlisting>
+...
+ClientMessage msg = session.createMessage();
+msg.setInputStream(dataInputStream);
+...
+            </programlisting>
+        </section>
+        <section id="large-messages.streaming.over.jms">
+            <title>在JMS中使用流</title>
+            <para>使用JMS时,HornetQ根据定义的属性值调用对应的核心接口(参见 <xref
+                    linkend="large-messages.ClientMessageAPI"/>)来使用流。你只需要用
+                  <literal>Message.setObjectProperty</literal>方法设置适当的输入/输出流即可。</para>
+            <para>输入流<literal>InputStream</literal>可以通过JMS属性JMS_HQ_InputStream来定义:</para>
+            <programlisting>
+BytesMessage message = session.createBytesMessage();
+
+FileInputStream fileInputStream = new FileInputStream(fileInput);
+
+BufferedInputStream bufferedInput = new BufferedInputStream(fileInputStream);
+
+message.setObjectProperty("JMS_HQ_InputStream", bufferedInput);
+
+someProducer.send(message);</programlisting>
+            <para>输出流<literal>OutputStream</literal>可以通过JMS属性JMS_HQ_SaveStream来定义。下面是阻塞式方法:</para>
+            <programlisting>
+BytesMessage messageReceived = (BytesMessage)messageConsumer.receive(120000);
+                
+File outputFile = new File("huge_message_received.dat");
+                
+FileOutputStream fileOutputStream = new FileOutputStream(outputFile);
+                
+BufferedOutputStream bufferedOutput = new BufferedOutputStream(fileOutputStream);
+                
+// This will block until the entire content is saved on disk
+messageReceived.setObjectProperty("JMS_HQ_SaveStream", bufferedOutput);
+            </programlisting>
+            <para>也可以使用JMS_HQ_OutputStream属性以非阻塞式(异步)方法来定义输出流<literal>OutputStream</literal>:</para>
+            <programlisting>
+// This won't wait the stream to finish. You need to keep the consumer active.
+messageReceived.setObjectProperty("JMS_HQ_OutputStream", bufferedOutput);
+            </programlisting>
+            <note>
+                <para>使用JMS时,只有<literal>StreamMessage</literal>和<literal>BytesMessage</literal>才支持大消息的传送。</para>
+            </note>
+        </section>
+    </section>
+    <section>
+        <title>不使用流的方式</title>
+        <para>如果不想使用输入流与输出流来传送大消息,可以用另外一种方法。</para>
+        <para>使用核心接口时,可以直接从消息中读字节。</para>
+        <programlisting>ClientMessage msg = consumer.receive();
+         
+byte[] bytes = new byte[1024];
+for (int i = 0 ;  i &lt; msg.getBodySize(); i += bytes.length)
+{
+   msg.getBody().readBytes(bytes);
+   // Whatever you want to do with the bytes
+}</programlisting>
+        <para>使用JMS接口时,<literal>BytesMessage</literal>和<literal>StreamMessage</literal>
+            本身提供这样的支持。</para>
+        <programlisting>BytesMessage rm = (BytesMessage)cons.receive(10000);
+
+byte data[] = new byte[1024];
+
+for (int i = 0; i &lt; rm.getBodyLength(); i += 1024)
+{
+   int numberOfBytes = rm.readBytes(data);
+   // Do whatever you want with the data
+}        </programlisting>
+    </section>
+    <section id="large-messages.cache.client">
+        <title>在客户端缓存大消息</title>
+        <para>大消息通过流在服务器和客户端之间传输。每个大消息被分割成很多小的数据包传递。因此大消息只能被
+            读取一次。这样一个大消息在收到后就不能再被再次传送。例如,JMS Bridge在发送大消息时如果在出现故障,
+            将不能把它重新发送。</para>
+        <para>要解决这个问题,可以在连接工厂上设置<literal>cache-large-message-client</literal>属性。
+            这个属性可以使客户端接收者创建一个临时的文件保存收到的大消息,这样就可以在需要时能够重新发送该消息。</para>
+        <note>如果JMS Bridge用来发送大消息,可以在它使用的连接工厂上使用它。</note>
+    </section>
+    <section id="large-messages.example">
+        <title>大消息例子</title>
+        <para>我们在<xref linkend="examples.large-message"/>提供了一个在JMS中配置和使用大消息的例子。</para>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/last-value-queues.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/last-value-queues.xml b/docs/user-manual/zh/last-value-queues.xml
new file mode 100644
index 0000000..cd80899
--- /dev/null
+++ b/docs/user-manual/zh/last-value-queues.xml
@@ -0,0 +1,66 @@
+<?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="last-value-queues">
+   <title>最新值队列(Last-Value Queues)</title>
+   <para>最新值队列是一种特殊的队列。当一个新消息到达一个最新值队列时,它会将所有与该消息定义的Last-Value相同的旧消息
+      抛弃。换句话说,只有最新的消息被保留下来。</para>
+   <para>一个典型的用例是股价信息,通常你只关心一支股票的最新价格。</para>
+   <section>
+      <title>最新值队列的配置</title>
+      <para>最新值队列的配置在address-setting内:</para>
+      <programlisting>
+&lt;address-setting match="jms.queue.lastValueQueue"&gt;
+    &lt;last-value-queue&gt;true&lt;/last-value-queue&gt;
+&lt;/address-setting&gt;
+            </programlisting>
+      <para>默认的<literal>last-value-queue</literal>值是false。可以使用通配符来匹配地址。
+            (参见 <xref linkend="wildcard-syntax"/>)。</para>
+   </section>
+   <section>
+      <title>使用Last-Value参数</title>
+      <para>用来标识最新值的参数名是<literal>"_HQ_LVQ_NAME"</literal>
+         (相当于核心API中定义的常量<literal>Message.HDR_LAST_VALUE_NAME</literal>)。</para>
+      <para>如果两个消息具有相同的Last-Value值,那么较新的消息就会保留,另外一个被丢弃:</para>
+      <programlisting>
+// send 1st message with Last-Value property set to STOCK_NAME
+TextMessage message = 
+  session.createTextMessage("1st message with Last-Value property set");
+message.setStringProperty("_HQ_LVQ_NAME", "STOCK_NAME");
+producer.send(message);
+
+// send 2nd message with Last-Value property set to STOCK_NAME             
+message = 
+  session.createTextMessage("2nd message with Last-Value property set");
+message.setStringProperty("_HQ_LVQ_NAME", "STOCK_NAME");
+producer.send(message);
+       
+...
+       
+// only the 2nd message will be received: it is the latest with 
+// the Last-Value property set
+TextMessage messageReceived = (TextMessage)messageConsumer.receive(5000);
+System.out.format("Received message: %s\n", messageReceived.getText());             
+            </programlisting>
+   </section>
+   <section>
+      <title>例子</title>
+      <para>参见<xref linkend="examples.last-value-queue"/>。它展示的是在JMS应用中来配置和使用
+         最新值队列。</para>
+   </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/libaio.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/libaio.xml b/docs/user-manual/zh/libaio.xml
new file mode 100644
index 0000000..c31d4bd
--- /dev/null
+++ b/docs/user-manual/zh/libaio.xml
@@ -0,0 +1,114 @@
+<?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="libaio">
+    <title>Libaio平台专有库</title>
+    <para>HornetQ发布包中包括一个平台专有的库,它可以使HornetQ使用Linux操作系统的libaio。</para>
+    <para><literal>libaio</literal>是Linux项目的一个库。它将用户提交的写操作用异步的方式执行。通过
+        回调用户的代码来通知写操作的完成。</para>
+    <para>通过配置,HornetQ可以使用这个库来访问高性能的日志,具体请参见 <xref
+            linkend="persistence"/>。</para>
+    <para>下面列出了HornetQ所带的平台专有库文件:</para>
+    <itemizedlist>
+        <listitem>
+            <para>libHornetQAIO32.so - x86 32 位平台</para>
+        </listitem>
+        <listitem>
+            <para>libHornetQAIO64.so - x86 64 位平台</para>
+        </listitem>
+    </itemizedlist>
+    <para>当使用libaio时,HornetQ会在<link linkend="using-server.library.path">库路径</link>中寻找并装
+           载这些文件。</para>
+    <section>
+        <title>库文件的编译</title>
+        <para>如果你的Linux平台不是x86_32或x86_64(比如Itanium 64或IBM Power),你需要自己编译相应的库文件,
+            因为HornetQ不提供这些平台的库文件。</para>
+        <section>
+            <title>安装要求</title>
+            <note>
+                <para>目前libaio只在Linux上有。所以它不可能在其它操作系统上编译。</para>
+            </note>
+            <para>编译需要<ulink url="http://en.wikipedia.org/wiki/Autoconf"
+                    >autoconf</ulink>工具,它用来简化编译过程。除此之外还需要一些安装包:</para>
+            <itemizedlist>
+                <listitem>
+                    <para>gcc - C 编译器</para>
+                </listitem>
+                <listitem>
+                    <para>gcc-c++ or g++ - gcc的c++编译工具扩展</para>
+                </listitem>
+                <listitem>
+                    <para>autoconf - 自动编译工具</para>
+                </listitem>
+                <listitem>
+                    <para>make - make 工具</para>
+                </listitem>
+                <listitem>
+                    <para>automake - make文件自动生成工具</para>
+                </listitem>
+                <listitem>
+                    <para>libtool - 库连接工具</para>
+                </listitem>
+                <listitem>
+                    <para>libaio - 磁盘异步IO库</para>
+                </listitem>
+                <listitem>
+                    <para>libaio-dev - libaio的编译支持</para>
+                </listitem>
+                <listitem>
+                    <para>完整的JDK,JAVA_HOME要指向正确的位置</para>
+                </listitem>
+            </itemizedlist>
+            <para>如果在RHEL或Fedora上进行安装,输入以下命令:</para>
+            <programlisting>sudo yum install automake libtool autoconf gcc-g++ gcc libaio libaio-dev make</programlisting>
+            <para>如果是 debian系统,则:</para>
+            <programlisting>sudo apt-get install automake libtool autoconf gcc-g++ gcc libaio libaio-dev make</programlisting>
+            <note>
+                <para>在有些Linux的版本中上述的安装包名可能有一些差别。(例如Fedora中的gcc-c++在Debian系统中
+                    的名称为g++)</para>
+            </note>
+        </section>
+        <section>
+            <title>开始编译</title>
+            <para>在HornetQ发布包的<literal>native-src</literal>目录下,执行shell脚本
+                <literal>bootstrap</literal>。这个脚本会调用 <literal
+                    >automake</literal>以及<literal>make</literal>来创建所有的make文件和专有库。</para>
+            <programlisting>someUser@someBox:/messaging-distribution/native-src$ ./bootstrap 
+checking for a BSD-compatible install... /usr/bin/install -c
+checking whether build environment is sane... yes
+checking for a thread-safe mkdir -p... /bin/mkdir -p
+
+...
+
+configure: creating ./config.status
+config.status: creating Makefile
+config.status: creating ./src/Makefile
+config.status: creating config.h
+config.status: config.h is unchanged
+config.status: executing depfiles commands
+config.status: executing libtool commands
+
+...</programlisting>
+            <para>编译好的库文件在<literal
+                    >./native-src/src/.libs/libHornetQAIO.so</literal>。将该文件移到发布包的
+                    <literal>bin</literal>目录下,或者你的<link linkend="using-server.library.path">库目录</link>
+                    所指向的目录即可。</para>
+            <para>如果你修改了HornetQ的libaio代码,只需要在<literal>native-src</literal>目录下直挂运行make即可完成编译。</para>
+        </section>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/logging.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/logging.xml b/docs/user-manual/zh/logging.xml
new file mode 100644
index 0000000..519d972
--- /dev/null
+++ b/docs/user-manual/zh/logging.xml
@@ -0,0 +1,46 @@
+<?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="logging">
+    <title>日志(Logging)</title>
+    <para>HornetQ有自己的独立的日志系统,不依赖于任何其它的日志框架。在默认情况下所有HornetQ的日志将输入到
+        标准的<ulink
+            url="http://java.sun.com/j2se/1.4.2/docs/guide/util/logging/">JDK日志系统</ulink>,
+        (即JUL-Java Util Logging)。服务器在默认条件下读取config目录下的
+        <literal>logging.properties</literal>文件做为JUL的配置文件。它配置了使用HornetQ自己的格式化
+        方法,将日志输出到屏幕终端(Console)及文件中。请访问Sun公司的相关网址来进一步了解如何配置使用JUL。</para>
+    <para>你可以通过编程或定义系统变量的方法来配置不同的日志代理(Logging Delegate)。</para>
+    <para>采用编程方法,只需要调用方法:
+        <programlisting>org.hornetq.core.logging.Logger.setDelegateFactory(new Log4jLogDelegateFactory())</programlisting></para>
+    <para>其中<literal>Log4jLogDelegateFactory</literal>实现了<literal
+            >org.hornetq.spi.core.logging.LogDelegateFactory </literal>接口。</para>
+    <para>如果要使用系统变量方法,则需要设置变量<literal
+            >org.hornetq.logger-delegate-factory-class-name</literal>为相应的代理工厂,即
+        <programlisting>-Dorg.hornetq.logger-delegate-factory-class-name=org.hornetq.integration.logging.Log4jLogDelegateFactory</programlisting></para>
+    <para>上面的例子可以看出HornetQ提供了一些代理工厂以方便用户使用,它们是:<orderedlist
+                    ><listitem><para>org.hornetq.core.logging.impl.JULLogDelegateFactory - 默认的JUL日志代理工厂。</para>
+                </listitem><listitem><para>org.hornetq.integration.logging.Log4jLogDelegateFactory
+                    - Log4J的日志代理工厂。</para></listitem></orderedlist></para>
+    <para>如果在客户端使用JUL代理,注意要提供<literal>logging.properties</literal>文件,并且在客户端启动之前设置<literal
+            >java.util.logging.config.file</literal>属性。</para>
+    <section>
+        <title>与JBoss应用服务器日志的关系</title>
+        <para>当HornetQ部署到JBoss应用服务器版本5.x或以上时,虽然HornetQ仍然使用JUL,但是所有的日志输出被重定向到
+            JBoss logger。请参阅相关的JBoss文档来了解更多的信息。如果是以前版本的JBoss,则必需指定你所需要的日志代理。</para>
+    </section>
+</chapter>


Mime
View raw message