activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbert...@apache.org
Subject [22/51] [partial] activemq-6 git commit: ACTIVEMQ6-1 - Initial HornetQ Donation Commit
Date Mon, 10 Nov 2014 16:32:33 GMT
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/queue-attributes.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/queue-attributes.xml b/docs/user-manual/zh/queue-attributes.xml
new file mode 100644
index 0000000..33ae46b
--- /dev/null
+++ b/docs/user-manual/zh/queue-attributes.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="queue-attributes">
+    <title>队列属性</title>
+    <para>有两种方法可以设置队列的属性。一种使用配置文件,另一种使用核心接口(core API)。
+        本章讲述这些属性的配置以及这些属性的作用。</para>
+    <section id="predefined.queues">
+        <title>预定义的队列</title>
+        <para>通过配置可以定义队列。队列的定义可以在核心层定义,也可以在JMS层来定义。首先我们看一下JMS层。</para>
+        <para>下面就是一个在<literal>hornetq-jms.xml</literal>中定义的一个队列的例子:</para>
+        <programlisting>&lt;queue name="selectorQueue">
+      &lt;entry name="/queue/selectorQueue"/>
+      &lt;selector string="color='red'"/>
+      &lt;durable>true&lt;/durable>
+&lt;/queue></programlisting>
+        <para>这个队列的name属性定义了队列的名字。例子中我们采用了一种命名的惯例,因些对应的核心队列的名字是
+            <literal>jms.queue.selectorQueue</literal>。</para>
+        <para>在entry单元内定义的名字用来将队列绑定于JNDI。这是必不可少的。一个队列可以有多个entry定义,每个
+            定义中的名字都绑定到同一个队列。</para>
+        <para>selector单元定义的是队列的选择器。定义了选择器后,只有与选择器相匹配的消息才能被加到队列中。
+            这是一个可选项。如果没有定义选择器,队列将默认没有选择器。</para>
+        <para>durable定义了队列是否是一个可持久的队列。这也是一个可选项,默认值是true。</para>
+        <para>如果在核心层定义队列,则使用<literal>hornetq-configuration.xml</literal>文件。
+            下面是一个例子:</para>
+        <programlisting>&lt;queues>     
+   	&lt;queue name="jms.queue.selectorQueue">
+   	    &lt;address>jms.queue.selectorQueue&lt;/address>
+   	    &lt;filter string="color='red'"/>
+       &lt;durable>true&lt;/durable>
+   	&lt;/queue>
+&lt;/queues></programlisting>
+        <para>它的配置与JMS的配置很相似,但有三个不同之处:</para>
+        <orderedlist>
+            <listitem>
+                <para>队列的name属性是队列的真正名字,不是JMS中的名字。</para>
+            </listitem>
+            <listitem>
+                <para>address一项定义了消息路由的地址。</para>
+            </listitem>
+            <listitem>
+                <para>没有entry单元。</para>
+            </listitem>
+            <listitem>
+                <para>filter的定义使用<emphasis>核心过滤器语法</emphasis> (在
+                        <xref linkend="filter-expressions"/>中描述),不是JMS的选择器语法。</para>
+            </listitem>
+        </orderedlist>
+    </section>
+    <section>
+        <title>使用接口(API)创建队列</title>
+        <para>队列还可以使用核心接口或管理接口来创建。</para>
+        <para>核心接口的<literal>org.hornetq.api.core.client.ClientSession</literal>接口可以用来
+              创建队列。它有几个<literal>createQueue</literal>方法,可以在创建队列时对上述的属性进行设置。
+              除此之外,还有一个额外的属性<literal>temporary</literal>可以设置。如果将其设为true,
+              那么队列在会话断开时将被删除。</para>
+        <para>在<xref linkend="management"/>中讲述了如何用管理接口来创建队列。</para>
+    </section>
+    <section id="queue-attributes.address-settings">
+        <title>通过地址设置来配置队列属性</title>
+        <para>有些属性的定义中地址可以使用通配符。下面是<literal>hornetq-configuration.xml</literal>
+            文件中的一个<literal>address-setting</literal>的配置例子。</para>
+        <programlisting>&lt;address-settings>
+    &lt;address-setting match="jms.queue.exampleQueue">
+        &lt;dead-letter-address>jms.queue.deadLetterQueue&lt;/dead-letter-address>
+        &lt;max-delivery-attempts>3&lt;/max-delivery-attempts>
+        &lt;redelivery-delay>5000&lt;/redelivery-delay>
+        &lt;expiry-address>jms.queue.expiryQueue&lt;/expiry-address>
+        &lt;last-value-queue>true&lt;/last-value-queue>        
+        &lt;max-size-bytes>100000&lt;/max-size-bytes>
+        &lt;page-size-bytes>20000&lt;/page-size-bytes>
+        &lt;redistribution-delay>0&lt;/redistribution-delay>
+        &lt;send-to-dla-on-no-route>true&lt;/send-to-dla-on-no-route>
+        &lt;address-full-policy>PAGE&lt;/address-full-policy>
+     &lt;/address-setting>
+&lt;/address-settings></programlisting>
+        <para>通过上述的地址设定可以将多个属性应用于所有与<literal>match</literal>属性相匹配的地址。
+            上面例子中所定义的属性应用于<literal>jms.queue.exampleQueue</literal>的地址。如果使用
+            通配符,就可以将这些属性应用于一组匹配的地址。通配符的详细说明在<link linkend="wildcard-syntax">这里</link>。</para>
+        <para>例如在<literal>match</literal>中定义字符串<literal>jms.queue.#</literal>,那么
+        定义的属性就会应用于所有以<literal>jms.queue.</literal>开头的地址--即所有的JMS队列。</para>
+        <para>这些属性在本手册的各个地方有相应的介绍。在此处给出了简单的解释各它所在章的连接。</para>
+        <para><literal>max-delivery-attempts</literal>定义了最大重传递的次数。一个消息如果反复传递超过
+            了这个值将会被发往死信地址<literal>dead-letter-address</literal>。相关的完整的解释在
+            <link linkend="undelivered-messages.configuring">这里</link>。</para>
+        <para><literal>redelivery-delay</literal>定义了重新传递的延迟。它控制HornetQ在重新
+            传递一个被取消的消息时要等待的时间。参见<link linkend="undelivered-messages.delay"
+                >这里</link>。</para>
+        <para><literal>expiry-address</literal>定义了过期消息的发送地址。参见<link linkend="message-expiry.configuring">这里</link>。</para>
+        <para><literal>last-value-queue</literal> 定义一个队列是否使用最新值。参见<link linkend="last-value-queues">这里</link>。</para>
+        <para><literal>max-size-bytes</literal>和<literal>page-size-bytes</literal>用来设置地址的分页转存功能。
+            它们在<link linkend="paging">这里</link>有详细的解释。</para>
+        <para><literal>redistribution-delay</literal>定义了当最后一个接收者关闭时重新分配队列消息前所等待的时间。
+            参见<link linkend="clusters.message-redistribution">这里</link>。</para>
+        <para><literal>send-to-dla-on-no-route</literal>。当一个消息被送到某个地址时,可能不会被路由到任何一个队列。
+            例如该地址没有绑定任何队列的情况,或者它所有的队列的选择器与该消息不匹配时。这样的消息通常情况下会被丢弃。这时
+            如果将这个参数设为true,则如果这个地址配置了死信地址的话,这样的消息就会被发送到该地址的死信地址(DLA)。</para>
+        <para><literal>address-full-policy</literal>。这个属性有三个可能的值:PAGE、 DROP 或 BLOCK。它决定了
+            如果地址的消息所占用的内存达到了<literal>max-size-bytes</literal>所定义的值时,如何处理后继到来的消息。
+            默认值是PAGE,就是将后续的消息分页转存到磁盘上。DROP则表示丢弃后续的消息。BLOCK表示阻塞消息的发送方发送后续
+            的消息。参见<xref linkend="flow-control"/>和<xref linkend="paging"/>。
+        </para>
+
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/scheduled-messages.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/scheduled-messages.xml b/docs/user-manual/zh/scheduled-messages.xml
new file mode 100644
index 0000000..9504ecf
--- /dev/null
+++ b/docs/user-manual/zh/scheduled-messages.xml
@@ -0,0 +1,47 @@
+<?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="scheduled-messages">
+   <title>定期消息</title>
+   <para>与普通消息不同,定期消息是在未来某个指定时间发送的消息。</para>
+   <para>为了创建定期消息,需要设定一个特殊的参数.</para>
+   <section>
+      <title>定期传递参数</title>
+      <para>用来标识一个定期消息的参数是<literal
+            >"_HQ_SCHED_DELIVERY"</literal> (相当于常量<literal
+            >Message.HDR_SCHEDULED_DELIVERY_TIME</literal>)。</para>
+      <para>这个参数的值必须是一个大于零的长整型,单位是毫秒。下面例子给出了使用JMS接口创建定期消息的方法:</para>
+      <programlisting>
+  TextMessage message = 
+   session.createTextMessage("This is a scheduled message message which will be delivered
+     in 5 sec.");
+  message.setLongProperty("_HQ_SCHED_DELIVERY", System.currentTimeMillis() + 5000);
+  producer.send(message);
+
+  ...
+         
+  // message will not be received immediately but 5 seconds later
+  TextMessage messageReceived = (TextMessage) consumer.receive();
+      </programlisting>
+      <para>也可以使用核心接口来发送定期消息。它只需要将同样的参数设定到核心消息上即可。</para>
+   </section>
+   <section>
+      <title>例子</title>
+      <para>参见<xref linkend="examples.scheduled-message"/>,它是一个JMS使用定期消息的例子。</para>
+   </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/security.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/security.xml b/docs/user-manual/zh/security.xml
new file mode 100644
index 0000000..e973586
--- /dev/null
+++ b/docs/user-manual/zh/security.xml
@@ -0,0 +1,235 @@
+<?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="security">
+    <title>安全</title>
+    <para>本章讲述HornetQ的安全机制以及如何配置它。要完全关闭安全,只要将<literal>hornetq-configuration.xml</literal>
+        文件中的<literal>security-enabled</literal>参数设为false即可。</para>
+    <para>出于性能的考虑,安全在HornetQ中被缓存一定的时间。要改变这个时间,需要设置参数
+        <literal>security-invalidation-interval</literal>,单位是毫秒。默认值是
+        <literal>10000</literal>毫秒。</para>
+    <section id="security.settings.roles">
+        <title>基于角色的地址安全</title>
+        <para>HornetQ采用了基于角色的安全模型来配置地址的安全以及其队列的安全。</para>
+        <para>正如在<xref linkend="using-core"/>解释的那样,HornetQ核心主要由绑定到地址上的队列组成。
+            消息被发送到地址后,服务器查找与之绑定的队列,并将消息路由到这些队列中。</para>
+        <para>HornetQ可以基于地址来给队列定义权限。在定义权限时可以使用通配符'<literal>#</literal>'和
+            '<literal>*</literal>'。</para>
+        <para>队列的权限有7种,它们是:</para>
+        <itemizedlist>
+            <listitem>
+                <para><literal>createDurableQueue</literal>。允许用户在相应的地址上创建持久的队列。</para>
+            </listitem>
+            <listitem>
+                <para><literal>deleteDurableQueue</literal>。允许用户在相应的地址上删除相应的持久的队列。</para>
+            </listitem>
+            <listitem>
+                <para><literal>createNonDurableQueue</literal>。允许用户在相应地址上创建非持久的队列。</para>
+            </listitem>
+            <listitem>
+                <para><literal>deleteNonDurableQueue</literal>。允许用户在相应地址上删除非持久队列。</para>
+            </listitem>
+            <listitem>
+                <para><literal>send</literal>。允许用户向相应地址发送消息。</para>
+            </listitem>
+            <listitem>
+                <para><literal>consume</literal>。允许用户从相应地址上的队列接收消息。</para>
+            </listitem>
+            <listitem>
+                <para><literal>manage</literal>。允许用户调用管理操作,即向管理地址发关管理消息。</para>
+            </listitem>
+        </itemizedlist>
+        <para>每个权限有一个角色表。如果用户的角色在这个表中,那么它将拥有这个权限。</para>
+        <para>让我们看个简单的例子。下面是从<literal>hornetq-configuration.xml</literal>文件或
+              <literal>hornetq-queues.xml</literal>文件中提取的安全设置:</para>
+        <programlisting>
+&lt;security-setting match="globalqueues.europe.#"&gt;
+    &lt;permission type="createDurableQueue" roles="admin"/&gt;
+    &lt;permission type="deleteDurableQueue" roles="admin"/&gt;
+    &lt;permission type="createNonDurableQueue" roles="admin, guest, europe-users"/&gt;
+    &lt;permission type="deleteNonDurableQueue" roles="admin, guest, europe-users"/&gt;
+    &lt;permission type="send" roles="admin, europe-users"/&gt;
+    &lt;permission type="consume" roles="admin, europe-users"/&gt;
+&lt;/security-setting&gt;            
+        </programlisting>
+        <para>在配置中字符'<literal>#</literal>'代表"任何单词序列“。单词由'<literal>.</literal>'字符分隔。
+            有关通配符的语法的完整说明请参见<xref linkend="wildcard-syntax"/>。上面的安全配置对以
+            "globalqueues.europe."开始的地址有效:</para>
+        <para>只有具有<literal>admin</literal>角色的用户才可以创建和删除绑定到以"globalqueues.europe."开始的地址的持久化队列。</para>
+        <para>具有<literal>admin</literal>、<literal>guest</literal>或<literal>europe-users</literal>
+              角色的用户可以在以开头的地址上创建临时的队列。</para>
+        <para>任何具有<literal>admin</literal>或<literal>europe-users</literal>角色的用户可以向以"globalqueues.europe."开头的地址
+            发送消息,并从绑定到相同地址上的队列接收消息。</para>
+        <para>安全管理器处理一个用户和它的角色的对应关系。HornetQ本身自带一个用户管理器,能从文件中读取用户的身份信息。
+            另外HornetQ还可以使用JAAS或JBoss应用服务器的安全管理机制。</para>
+        <para>有关安全管理器的配置信息,请参见<xref linkend="change-security-manager"/>。</para>
+        <para>在每个xml文件中可以有零个或多个 <literal>security-setting</literal>。当一组地址有多个这样的设置时,
+              HornetQ总是选取<emphasis>更具体的</emphasis>匹配。</para>
+        <para>让我们来看一个实例,下面是另一个<literal>security-setting</literal>:</para>
+        <programlisting>
+&lt;security-setting match="globalqueues.europe.orders.#"&gt;
+    &lt;permission type="send" roles="europe-users"/&gt;
+    &lt;permission type="consume" roles="europe-users"/&gt;
+&lt;/security-setting&gt;            
+        </programlisting>
+        <para>在这个<literal>security-setting</literal>块中,字符串
+            'globalqueues.europe.orders.#' 要比它之前的字符串'globalqueues.europe.#'更具体。
+            因此当一个地址与'globalqueues.europe.orders.#'匹配时,它<emphasis>只</emphasis>选择这个安全配置。</para>
+        <para>注意安全设置没有继承性。对于像'globalqueues.europe.orders.plastics'的地址,只要上面的设置
+            能被采用。即角色europe-users有<literal
+                >send</literal>和<literal>consume</literal>权限。权限
+            <literal>createDurableQueue</literal>、 <literal
+            >deleteDurableQueue</literal>、<literal>createNonDurableQueue</literal>、<literal
+                >deleteNonDurableQueue</literal>不会从先前的设置中继承。</para>
+        <para>由于权限的不可继承,如果我们不在更具体的security-setting设置中给出一个权限,这个权限就是没有的,不会因为继承而带来
+            麻烦。否则就不可能对一组地址中的部分地址进行如此的设置。</para>
+    </section>
+    <section>
+        <title>安全套接字层(SSL)传输</title>
+        <para>当消息客户端与服务器端,或服务器之间(比如使用桥的情况)通过一个不信任的网络相互通信时,HornetQ
+            支持使用加密的安全套接字(SSL)传输数据。</para>
+        <para>关于SSL的详细配置信息,请参见<xref linkend="configuring-transports"/>。</para>
+    </section>
+    <section>
+        <title>基本用户身份信息(Credentials)</title>
+        <para>HornetQ自带一个安全管理器(security manager)可以从xml文件中读取用户身份信息,即用户名、
+            密码、角色信息。该xml文件名为<literal>hornetq-users.xml</literal>,它必须要在classpath中。</para>
+        <para>如果你要使用这个安全管理器,就将用户名,密码,角色等信息加入到这个文件中。</para>
+        <para>让我们看一个例子:</para>
+        <programlisting>
+&lt;configuration xmlns="urn:hornetq" 
+               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="urn:hornetq ../schemas/hornetq-users.xsd "&gt;
+    
+    &lt;defaultuser name="guest" password="guest"&gt;
+        &lt;role name="guest"/&gt;
+    &lt;/defaultuser&gt;
+    
+    &lt;user name="tim" password="marmite"&gt;
+        &lt;role name="admin"/&gt;      
+    &lt;/user&gt;
+    
+    &lt;user name="andy" password="doner_kebab"&gt;
+        &lt;role name="admin"/&gt;
+        &lt;role name="guest"/&gt;
+    &lt;/user&gt;
+    
+    &lt;user name="jeff" password="camembert"&gt;
+        &lt;role name="europe-users"/&gt;
+        &lt;role name="guest"/&gt;
+    &lt;/user&gt;
+    
+&lt;/configuration&gt;
+        </programlisting>
+        <para>首先要注意的是<literal>defaultuser</literal>,它定义的是默认的用户。当客户端创建会话时
+            没有提供用户名/密码时,就会使用这个用户。根据上述配置,这个默认用户是<literal>guest</literal>
+            并且他的角色是<literal>guest</literal>。一个默认用户可以有多个角色。</para>
+        <para>另外三个用户中,用户<literal>tim</literal>具有角色<literal
+                >admin</literal>。用户<literal>andy</literal>具有角色<literal
+                >admin</literal>和<literal>guest</literal>,用户<literal>jeff</literal>
+             具有角色<literal>europe-users</literal>和<literal>guest</literal>。</para>
+    </section>
+    <section id="change-security-manager">
+        <title>更换安全管理器</title>
+        <para>如果你不想用默认的安全管理器,可以通过修改配置文件<literal>hornetq-beans.xml</literal>
+            (或者在运行JBoss应用服务器情况下<literal
+                >hornetq-jboss-beans.xml</literal>文件)来更换。同时要更换
+            <literal>HornetQSecurityManager</literal> bean 的类。</para>
+        <para>让我们看一段默认bean文件的内容:</para>
+        <programlisting>           
+&lt;bean name="HornetQSecurityManager" 
+      class="org.hornetq.spi.core.security.HornetQSecurityManagerImpl"&gt;
+    &lt;start ignored="true"/&gt;
+    &lt;stop ignored="true"/&gt;
+&lt;/bean&gt;            
+        </programlisting>
+        <para><literal>org.hornetq.spi.core.security.HornetQSecurityManagerImpl</literal>
+            类就是HornetQ服务器的在独立运行时的默认的安全管理器。</para>
+        <para>HornetQ自带有另外两个安全管理器可供使用。一个是JAAS安全管理器,另一个是用来与JBoss应用服务
+            器集成的安全管理器。此外,你还可以编写实现你自己的安全管理器。首先要实现
+            <literal>org.hornetq.core.security.SecurityManager</literal>接口,再将你的实现
+            类定义到<literal>hornetq-beans.xml</literal>文件中即可(或者在JBoss应用服务器中
+            使用<literal>hornetq-jboss-beans.xml</literal>文件)。</para>
+        <para>以下分别介绍这两咱安全管理器</para>
+    </section>
+    <section>
+        <title>JAAS安全管理器</title>
+        <para>JAAS表示“Java认证与授权服务“。它是Java平台标准的一部分。它提供了进行安全认证与授权的通用接口。
+            它允许你插入自己的安全管理模块。</para>
+        <para>要配置使用你自己的JAAS安全实现,需要在bean文件中定义<literal>JAASSecurityManager</literal>。
+            下面是一个例子:</para>
+        <programlisting><![CDATA[
+&lt;bean name="HornetQSecurityManager"
+      class="org.hornetq.integration.jboss.security.JAASSecurityManager"&gt;
+    &lt;start ignored="true"/&gt;
+    &lt;stop ignored="true"/&gt;
+
+    &lt;property name="ConfigurationName"&gt;org.hornetq.jms.example.ExampleLoginModule&lt;/property&gt;
+    &lt;property name="Configuration"&gt;
+       &lt;inject bean="ExampleConfiguration"/&gt;
+    &lt;/property&gt;
+    &lt;property name="CallbackHandler"&gt;
+       &lt;inject bean="ExampleCallbackHandler"/&gt;
+    &lt;/property&gt;
+&lt;/bean&gt;
+        ]]></programlisting>
+        <para>注意你需要为JAAS安全管理器提供三个参数:</para>
+        <itemizedlist>
+            <listitem>
+                <para>ConfigurationName: <literal>LoginModule</literal>的名字。</para>
+            </listitem>
+            <listitem>
+                <para>Configuration: <literal>Configuration</literal>的实现。</para>
+            </listitem>
+            <listitem>
+                <para>CallbackHandler: <literal>CallbackHandler</literal>实现,用于用户交互。</para>
+            </listitem>
+        </itemizedlist>
+        <section>
+            <title>例子</title>
+            <para>参见<xref linkend="examples.jaas"/>。这个例子展示了怎样在HornetQ中配置使用JAAS。</para>
+        </section>
+    </section>
+    <section>
+        <title>JBoss 应用服务器安全管理器</title>
+        <para>JBoss 应用服务器安全管理器适用于当HornetQ运行于JBoss应用服务器内时。它可以与JBoss应用服务器
+            的安全模型紧密集成。</para>
+        <para>此安全管理器的类是 <literal
+                >org.hornetq.integration.jboss.security.JBossASSecurityManager</literal>。</para>
+        <para>要了解如何配置JBoss安全管理器,可以看一眼HornetQ发布包中相关例子中的
+            <literal>hornetq-jboss-beans.xml</literal>文件。</para>
+       <section>
+          <title>配置客户端登录</title>
+          <para>JBoss可以配置使用客户登录。JEE的模块如servlet或EJB可以将安全认证信息设置到安全上下文(security context)中,
+             用于整个调用过程。如果想在HornetQ在发送和接收消息时使用这些认证(credential)信息,需要将参数
+             <literal>allowClientLogin</literal>设为true。它会越过HornetQ的身份验证过程并会传播安全上下文(security
+             context)。如果你想要HornetQ使用传播的安全信息进行身份验证,需要同时将参数<literal>authoriseOnClientLogin</literal>
+             设为true。</para>
+          <para>关于客户端登录的详细信息请访问<ulink
+                url="http://community.jboss.org/wiki/ClientLoginModule">这里</ulink>。 </para>
+          <note><para>如果消息是以非阻塞方式发送的,那么有可能在消息到达服务器时,调用线程已经结束,安全上下文也被清除了。
+          所以如果使用安全上下文,需要采用阻塞方式发送消息。</para></note>
+       </section>
+    </section>
+    <section>
+        <title>集群用户名/密码的配置</title>
+        <para>为了使集群连接正常工作,每个节点都必须与其它节点相连接。它们连接所使用的默认用户名和密码在正式使用时
+            一定要做相应的更改,以防止安全隐患。</para>
+        <para>请参见<xref linkend="management"/>了解怎样去做。</para>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/send-guarantees.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/send-guarantees.xml b/docs/user-manual/zh/send-guarantees.xml
new file mode 100644
index 0000000..ab3a041
--- /dev/null
+++ b/docs/user-manual/zh/send-guarantees.xml
@@ -0,0 +1,102 @@
+<?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="send-guarantees">
+    <title>发送与提交的保证</title>
+    <section>
+        <title>事务保证</title>
+        <para>在提交或回滚事务时,HornetQ将提交或回滚的请求发送到服务器,客户端阻塞等待服务器的响应。</para>
+        <para>当服务器端收到提交或回滚的请求时,它将事务信息记录到日志(journal)中。然后向客户端发回
+              响应。参数<literal>journal-sync-transactional</literal>控制着如何向客户端发回响应。
+            如果它的值是<literal>false</literal>,服务器向客户端发回响应时事务的处理結果不一定已经被
+            保存到磁盘中。可能会在之后的某个时间保存。如果期间服务器发生故障那么事务的处理信息可能丢失。
+            当它的值是<literal>true</literal>时,服务器将保证在向客户端发回响应时,事务的处理信息
+            已经被保存到了磁盘中。默认值是<literal>true</literal>。</para>
+        <para>显然将这个参数设为<literal>false</literal>可以提高性能,但是要以牺牲事务的持久性为代价。</para>
+        <para>这个参数在 <literal>hornetq-configuration.xml</literal>文件中。</para>
+    </section>
+    <section id="non-transactional-sends">
+        <title>非事务性消息发送的保证</title>
+        <para>使用非事务性会话发送消息时,经过适当配置HornetQ,客户端在发送后以阻塞的方式等待,直到确认发出
+            的消息已经到达服务器后再返回。可以对持久化或非持久化的消息分别配置,具体参数如下:</para>
+        <itemizedlist>
+            <listitem>
+                <para><literal>BlockOnDurableSend</literal>。如果设为<literal>true</literal>则通过
+                    非事务性会话发送持久消息时,每次发送都将阻塞直到消息到达服务器并返回通知为止。默认值是
+                     <literal>true</literal>。
+                </para>
+            </listitem>
+            <listitem>
+                <para><literal>BlockOnNonDurableSend</literal>。如果设为<literal>true</literal>,
+                    则通过非事务性会话发送非持久消息时,每次发送都将阻塞直到消息到达服务器并返回通知为止。默认值是
+                    <literal>false</literal>。</para>
+            </listitem>
+        </itemizedlist>
+        <para>将发送设置为阻塞方式会降低程序的效率。因为每次发送都需要一次网络往返的过程,然后才可以进行下次发送。
+            这样发送消息的速度将受网络往返时间(RTT)的限制。这样你的网络带宽就可能没有被充分利用。为了提高效率,我们
+            建议采用事务来批量发送消息。因为在事务中,只有在提交或回滚时阻塞。另外你还可以利用HornetQ高级的
+            <emphasis>异步发送通知功能</emphasis>。这一功能在<xref linkend="asynchronous-send-acknowledgements"/>
+            进行了描述。</para>
+        <para>使用JMS时,如果JMS的连接工厂是在服务器端被注册到JNDI服务,你需要配置
+                <literal>hornetq-jms.xml</literal>文件中的<literal>block-on-durable-send</literal>
+                和<literal>block-on-non-durable-send</literal>。如果不使用JNDI,可以调用
+                <literal>HornetQConnectionFactory</literal>相应的设置方法进行配置。</para>
+        <para>如果你使用的是内核服务,你可以直接在<literal
+                >ClientSessionFactory</literal>上用相关的方法设置相应的参数。</para>
+        <para>当服务器从一个非事务性的会话收到一个消息时,如果这个消息是持久的并且此消息被路由到至少一个持久的队列中,
+            则该消息会被持久化到永久存贮介质中。如果日志(journal)的参数<literal
+                >journal-sync-non-transactional</literal>设为<literal>true</literal>,服务器在向客户
+            发送响应时,它能保证消息已经被持久化到磁盘中。默认值是<literal>true</literal>。</para>
+    </section>
+    <section id="send-guarantees.nontrans.acks">
+        <title>非事务性通知的保证</title>
+        <para>当客户端使用非事务性会话向服务器通知消息收到时,可以配置HornetQ使得客户端的通知阻塞直到服务器收到
+            了通知并返回为止。其相应的配置参数是<literal>BlockOnAcknowledge</literal>。如果该参数设为
+            <literal>true</literal>则所有的通过非事务会话的消息通知都是阻塞式的。如果你想要的消息传递策略是
+            <emphasis>最多一次</emphasis>的话,那么你需要将此参数设为。默认值是<literal>false</literal>。</para>
+    </section>
+    <section id="asynchronous-send-acknowledgements">
+        <title>异步发送通知</title>
+        <para>如果你使用的是非事务会话来发送消息,并且希望保证每个发送出去的消息都到达服务器的话,你可以将HornetQ配置
+            成阻塞的方式,如<xref linkend="non-transactional-sends"/>讨论的那样。这样做的一个缺点是性能的降低。
+            因为这样每发送一个消息就需要一次网络的往返通信。如果网络时延越长,消息发送的效率就越低。同时网络的带宽对消息
+            的发送没有影响。</para>
+        <para>我们来做一个简单的计算。假设有一个1Gib的网络,客户端与服务器间往返时间为0.25ms。</para>
+        <para>这样,在阻塞方式的情况下,客户端<emphasis>最大</emphasis>的消息发送速度为 1000/ 0.25 =
+            4000 消息每秒。</para>
+        <para>如果每个消息的大小&lt; 1500字节,而且网络的最大传输单元(MTU)是1500字节。那么理论上1GiB的网络
+            最大的传输速率是 (1024 * 1024 * 1024 / 8) / 1500 = 89478 消息每秒!尽管这不是一个精确的工程计算但
+            你可以看出阻塞式的发送对性能的影响会有多大。</para>
+        <para>为了解决这个问题,HornetQ提供了一种新的功能,称为<emphasis>异步发送通知</emphasis>。
+            它允许消息以非阻塞的方式发送,同时从另一个连接流中异步地接收服务器的通知。这样就使得消息的发送与通知分开来,
+            避免了阻塞方式带来的缺点。在保证消息可行发送到服务器的同时提高了呑吐量。</para>
+        <para>参数用来定义消息发送通知的窗口大小。它属于连接工厂或客户会话工厂。参见<xref linkend="client-reconnection"/>
+            以获取更多的相关信息。</para>
+        <section>
+            <title>异步发送通知</title>
+            <para>如果使用核心API,你需要实现<literal
+                    >org.hornetq.api.core.client.SendAcknowledgementHandler</literal>接口并将一个实例设置到
+                    <literal>ClientSession</literal>中。</para>
+            <para>然后使用这个<literal>ClientSession</literal>发送消息。当消息到达服务器后,服务器向客户端异步地发送通知,
+                并在客户端调用你的SendAcknowledgementHandler实例的<literal
+                    >sendAcknowledged(ClientMessage message)</literal>方法。其中传入的参数就是发送的消息的引用。</para>
+            <para>为了使异步发送通知正常工作你必须确保<literal>confirmation-window-size</literal>的值为一个正整数,例如 10MiB</para>
+            <para>相关的例子请参见 <xref linkend="asynchronous-send-acknowledgements-example"/>。</para>
+        </section>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/thread-pooling.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/thread-pooling.xml b/docs/user-manual/zh/thread-pooling.xml
new file mode 100644
index 0000000..8c21b18
--- /dev/null
+++ b/docs/user-manual/zh/thread-pooling.xml
@@ -0,0 +1,108 @@
+<?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="thread-pooling">
+    <title>线程管理</title>
+    <para>本章讲述HornetQ如何使用线程池以及如何管理线程。</para>
+    <para>首先我们讨论在服务器端线程是如何被管理的,然后我们再讨论客户端的情况。</para>
+    <section>
+        <title>服务器端线程的管理</title>
+        <para>每个HornetQ服务器都有一个线程池作为一般线程使用,另外还有一个可计划线程池。Java的可计划线程池不能作为
+            标准的线程池使用,因此我们采用了两个单独的线程池。</para>
+        <para>当使用旧的(阻塞)IO时,使用了一个单独的线程池来处理连接。但是旧的IO要求一个线程配一个连接,所以如果你
+            的应用有很多并发的连接,这个线程池会很快用光所有的线程,造成服务器出现“挂起”现象。因此,对于大量并发连接
+            的应用,一定要使用NIO。</para>
+        <para>如果使用NIO,默认情况下HornetQ会使用系统中处理器内核(或超线程)数量三倍的线程来处理接收的数据包。
+            内核的数量是通过调用<literal>Runtime.getRuntime().availableProcessors()</literal>来得到
+            的。如果你想改变这个数量,可以设置传输层配置参数<literal>nio-remoting-threads</literal>。
+            参见<xref linkend="configuring-transports"/>。</para>
+        <para>另外在其它一些地方直接使用了线程,没有用线程池。我们将对这些线程作出解释。</para>
+        <section id="server.scheduled.thread.pool">
+            <title>服务器端可计划线程池</title>
+            <para>服务器可计划线程池可以定期地或延迟地执行所交给的任务,它用来完成HornetQ中绝大部分这样的任务。
+                  它内部使用的是一个 <literal
+                    >java.util.concurrent.ScheduledThreadPoolExecutor</literal>实例。</para>
+            <para>最大线程数可以在<literal
+                    >hornetq-configuration.xml</literal>文件中进行配置,参数名是<literal
+                    >scheduled-thread-pool-max-size</literal>。默认值是<literal>5</literal>。
+                    通常这个线程池不需要很大数量的线程。</para>
+        </section>
+        <section>
+            <title>服务器通用线程池</title>
+            <para>服务器端绝大部分的异步操作都是由这个线程池来完成的。在它的内部使用了一个<literal
+                    >java.util.concurrent.ThreadPoolExecutor</literal>的实例。</para>
+            <para>这个线程池的最大线程数在<literal>hornetq-configuration.xml</literal>文件中配置,相应的参数名为<literal
+                    >thread-pool-max-size</literal>。</para>
+            <para>如果将参数设为<literal>-1</literal>则表示该线程池没有线程限制。也就是说当线程不够用时,线程池就
+                会创建新的线程。当任务不多时,空闲的线程将会超时并被关闭。</para>
+            <para>如果这个参数的值是一个大于零的整数<literal>n</literal>,则该线程池的线程数是有限的。当所有线程都
+                处于忙的状态并且线程数已经达到n时,任何新的请求都将被阻塞直到有线程空闲为止。在设置线程上限时,我们建议
+                要非常谨慎。因为如何线程数量过低会造成死锁情况的发生。</para>
+            <para><literal>thread-pool-max-size</literal>的默认值是<literal
+                    >30</literal>。</para>
+            <para>参见<ulink
+                    url="http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/ThreadPoolExecutor.html"
+                    >J2SE javadoc</ulink>有关无边界(缓存)和有边界(固定)线程池的解释。</para>
+        </section>
+        <section>
+            <title>过期回收线程</title>
+            <para>HornetQ使用一个单独的线程来扫描队列中过期的消息。由于这个线程需要自己的优先级配置,所以不能使用上述的
+                任何一个线程池。</para>
+            <para>关于回收线程的配置请参阅<xref linkend="message-expiry"/>。</para>
+        </section>
+        <section>
+            <title>异步IO</title>
+            <para>HornetQ使用一个线程池来进行异步IO的操作,包括事件的接收和发送。这些线程的名字都是以
+                HornetQ-AIO-poller-pool为开头。每个打开的日志文件都对应有一个线程为其服务(通常只有
+                一个)。</para>
+            <para>还有一个单独的线程用于向libaio发送写请求。这样做是为了避免上下文转换带来的性能下降。该
+                线程的名字以HornetQ-AIO-writer-pool开头。</para>
+        </section>
+    </section>
+    <section id="thread-pooling.client.side">
+        <title>客户端线程管理</title>
+        <para>在客户端HornetQ有一个静态的可计划线程池和一个静态的通用线程池,它们在一个JVM中由同一个classloader装载的所有客户端
+            共同使用。</para>
+        <para>静态的可计划的线程池的最大线程数为 <literal>5</literal>,通用线程池则没有线程数限制。</para>
+        <para>如果需要还可以配置一个<literal
+                >ClientSessionFactory</literal>实例以使它拥有自己的可计划与通用线程池。通过这个工厂创建的会话都
+            将使用这些线程池。</para>
+        <para>要想配置<literal>ClientSessionFactory</literal>使用自己的线程池,只要调用它相应的方法取出可,如:</para>
+        <programlisting>ClientSessionFactory myFactory = HornetQClient.createClientSessionFactory(...);
+myFactory.setUseGlobalPools(false);
+myFactory.setScheduledThreadPoolMaxSize(10);
+myFactory.setThreadPoolMaxSize(-1);   </programlisting>
+        <para>如果使用JMS,你可以先用同样的参数设置ClientSessionFactory,然后再用这样工厂创建<literal
+                >ConnectionFactory</literal>的实例。如:</para>
+        <programlisting>ConnectionFactory myConnectionFactory = HornetQJMSClient.createConnectionFactory(myFactory);     </programlisting>
+        <para>如果你使用JNDI来创建<literal>HornetQConnectionFactory</literal>
+            实例,你还可以在<literal>hornetq-jms.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;use-global-pools&gt;false&lt;/use-global-pools&gt;
+    &lt;scheduled-thread-pool-max-size&gt;10&lt;/scheduled-thread-pool-max-size&gt;
+    &lt;thread-pool-max-size&gt;-1&lt;/thread-pool-max-size&gt;
+&lt;/connection-factory&gt;</programlisting>
+    </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/transaction-config.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/transaction-config.xml b/docs/user-manual/zh/transaction-config.xml
new file mode 100644
index 0000000..232d35c
--- /dev/null
+++ b/docs/user-manual/zh/transaction-config.xml
@@ -0,0 +1,29 @@
+<?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="transaction-config">
+    <title>配置资源管理器(Resource Manager)</title>
+    <para>HornetQ有自己的资源管理器来管理JTA事务。当一个事务开始时,资源管理器就得到通知并记录下该事务和它的状态。
+        有的时候一个事务开始后,最終被忘记。有时客户端崩溃并且再也不能恢复,这样的话该事务就一直存在下去。</para>
+    <para>为了解决这个问题,可以配置HornetQ来扫描过期的事务,并且将它们回滚。默认值是3000000毫秒(5分钟)。
+        它表示任何超过5分钟的事务都将被删除。这个超时对应的参数是<literal
+            >transaction-timeout</literal>,它在配置文件<literal>hornetq-configuration.xml</literal>中(单位毫秒)。
+        参数<literal>transaction-timeout-scan-period</literal>定义了HornetQ扫描过期事务的间隔。</para>
+    <para>注意HornetQ不会单方面回滚一个已经处于准备状态的XA事务。如果你认为这些事务永远不会被事务管理器(transaction manager)
+        来处理的话,你必须通过管理接口来进行回滚。</para>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/undelivered-messages.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/undelivered-messages.xml b/docs/user-manual/zh/undelivered-messages.xml
new file mode 100644
index 0000000..a5fb827
--- /dev/null
+++ b/docs/user-manual/zh/undelivered-messages.xml
@@ -0,0 +1,118 @@
+<?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="undelivered-messages">
+   <title>消息再传递及未传递的消息</title>
+   <para>消息有可能传递失败(比如相关的事务发生回滚)。失败的消息将退回到队列中准备重新传递。这样就会出现
+      一种情况,就是同一个消息会被反复的传递而总不成功,以至于使系统处于忙的状态。</para>
+   <para>对于这样的消息我们有两种处理方法:</para>
+   <itemizedlist>
+      <listitem>
+         <para>延迟再传递</para>
+         <para>这种方法是让消息再次传递时有一定的时间延迟,这样客户端就有机会从故障中恢复,同时网络连接和CPU资源
+            也不致于被过度占用。</para>
+      </listitem>
+      <listitem>
+         <para>死信(Dead Letter)地址</para>
+         <para>这种方法是规定一个死信地址,如果消息再被反复传递达到一定次数时,就会从原有队列中删除,转到这个
+            死信地址中。这样消息就不会永远地重复传递了。</para>
+      </listitem>
+   </itemizedlist>
+   <para>以上两种方法可以合理搭配使用,使解决方案更加灵活。</para>
+   <section>
+      <title>延迟再传递</title>
+      <para>延迟再传递对于时常出现故障或回滚的客户端十分有用。如果没有延迟,整个系统可能会处于一种”疯狂“的状态。
+         就是消息被传递、回滚、再传递,这样反复不间断地进行着,将宝贵的CPU和网络资源占用。</para>
+      <section id="undelivered-messages.delay">
+         <title>延迟再传递的配置</title>
+         <para>延迟再传递的配置在地址设定内(address-setting):</para>
+         <programlisting>
+     &lt;!-- delay redelivery of messages for 5s --&gt;
+     &lt;address-setting match="jms.queue.exampleQueue"&gt;
+        &lt;redelivery-delay&gt;5000&lt;/redelivery-delay&gt;
+     &lt;/address-setting&gt;
+             </programlisting>
+         <para>如果定义了<literal>redelivery-delay</literal>,HornetQ在再传递之前等待所定义的时间。</para>
+         <para>默认是没有延时的(即<literal>redelivery-delay</literal>的值是0)。</para>
+         <para>可以使用通配符为一组地址定义再传递的延迟(参见<xref linkend="wildcard-syntax"/>)。
+               </para>
+      </section>
+      <section>
+         <title>例子</title>
+         <para>参见 <xref linkend="examples.delayed-redelivery"/>。这是一个JMS应用中配置延迟再传递的例子。</para>
+      </section>
+   </section>
+   <section>
+      <title>死信地址</title>
+      <para>通过定义一个<emphasis role="italic">死信地址</emphasis>也可以防止同一个消息被无休止地传递:
+         当一个消息被重复传递一定次数后,就会从队列中删除并传递到定义好的死信地址中。</para>
+      <para>这些死信中的消息之后可以转发到某个队列中,以供系统管理员分析处理。</para>
+      <para>每个HornetQ的地址可以有一个死信地址。当一个消息被反复传递达一定次数时,它就会被从队列中删除并送到
+         死信地址。这些<emphasis>死信</emphasis>消息可以被接收进行分析处理。</para>
+      <section id="undelivered-messages.configuring">
+         <title>配置死信地址</title>
+         <para>死信地址定义在地址设定中(address-setting):</para>
+         <programlisting>
+     &lt;!-- undelivered messages in exampleQueue will be sent to the dead letter address 
+        deadLetterQueue after 3 unsuccessful delivery attempts
+      --&gt;
+     &lt;address-setting match="jms.queue.exampleQueue"&gt;
+        &lt;dead-letter-address&gt;jms.queue.deadLetterQueue&lt;/dead-letter-address&gt;
+        &lt;max-delivery-attempts&gt;3&lt;/max-delivery-attempts&gt;
+     &lt;/address-setting&gt;
+             </programlisting>
+         <para>如果没有定义<literal>dead-letter-address</literal>,消息在经过
+               <literal>max-delivery-attempts</literal>次重复传递后被删除。</para>
+         <para>默认的重复传递次数为10。将<literal>max-delivery-attempts</literal>设定为-1
+               表示无限次重复传递。</para>
+         <para>例如,对一组地址设置了一个通用的死信地址后,再将其中某个地址的<literal>max-delivery-attempts</literal>
+            设定为-1时,那么只有这个地址的再传递次数是无限的。</para>
+         <para>可以使用通配符对一组地址设定死信地址(参见<xref linkend="wildcard-syntax"/>)。</para>
+      </section>
+      <section>
+         <title>死信的属性</title>
+         <para>从死信地址接收到的消息有以下属性:</para>
+         <itemizedlist>
+            <listitem>
+               <para><literal>_HQ_ORIG_ADDRESS</literal></para>
+               <para>这是一个字符串属性,它是该死信消息的<emphasis>原始地址</emphasis>。</para>
+            </listitem>
+         </itemizedlist>
+      </section>
+      <section>
+         <title>例子</title>
+         <para>参见<xref linkend="examples.dead-letter"/>。这个例子给出了在JMS应用中死信的配置与使用。</para>
+      </section>
+   </section>
+   <section id="configuring.delivery.count.persistence">
+      <title>传递计数的持久化</title>
+      <para>通常情况下HornetQ在一个消息被回滚之前并不更新持久的传递计数(即在消息传递到接收者之前不会更新传递计数)。
+         大多数情况下消息被接收、通知、然后被忘掉。这样对<emphasis>每一个消息</emphasis>的传递都要更新一次持久的
+         传递计数,会显著降低系统的性能。</para>
+      <para>介是如果在消息传递之前不进行持久传递计数的更新,服务器一旦发生故障而崩溃,就会造成消息可能被传递出去而传递
+         计数却没有正确反映出传递的結果。在恢复阶段,服务器将错误地将该消息的<literal>redelivered</literal>设为
+         <literal>false</literal>而不是<literal>true</literal>。 </para>
+      <para>这样是不符合严格的JMS要求的。因此HornetQ允许在消息传递前更新传递计数。但是默认不这样做,目的是优先考虑
+         了它对性能的影响。</para>
+      <para>要想打开传递计数更新功能,将<literal>hornetq-configuration.xml</literal>文件中的
+            <literal>persist-delivery-count-before-delivery</literal>设为<literal>true</literal>即可:</para>
+      <programlisting>
+&lt;persist-delivery-count-before-delivery&gt;true&lt;/persist-delivery-count-before-delivery&gt;
+      </programlisting>
+   </section>
+</chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8ecd255f/docs/user-manual/zh/using-core.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/using-core.xml b/docs/user-manual/zh/using-core.xml
new file mode 100644
index 0000000..53172e6
--- /dev/null
+++ b/docs/user-manual/zh/using-core.xml
@@ -0,0 +1,163 @@
+<?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="using-core">
+    <title>使用HornetQ内核</title>
+    <para>HornetQ内核是一个与JMS无关的消息系统,它有一套自己的API。我们称它为<emphasis>内核API</emphasis>.</para>
+    <para>你可以直接使用内核API。使用内核API可以完成JMS同样的功能,只是比起JMS API使用更加简单方便。另外,内核API
+        还提供了JMS不具有的额外的功能。</para>
+    <section>
+        <title>内核消息系统的相关概念</title>
+        <para>内核消息系统中有许多概念是与JMS相似的,但有些方面是不同的。总的来说内核消息系统的接口相对简单。这是因为
+            在内核中没有队列(queue)、话题(topic)和订阅(subscription)的概念。下面我们就内核消息中的概念作逐一介绍。
+            但是每个API的详细说明还是要参见相应的javadoc。</para>
+        <section>
+            <title>消息</title>
+            <itemizedlist>
+                <listitem>
+                    <para>一个消息就是客户端与服务器传递信息的单位数据。</para>
+                </listitem>
+                <listitem>
+                    <para>一个消息有一个消息体(body),即一个缓存用以写入数据或从中读取数据。</para>
+                </listitem>
+                <listitem>
+                    <para>一个消息有一个属性集,这个属性集实际上包含的是主键-值的集合。每个属性的主键是一个字符串,值可
+                         以是一个整数(integer)、长整数(long)、短整数(short)、字节(byte)、字节数组(byte[])、
+                         字符串(String),双精度值(double)、浮点数(float)或是布尔值(boolean)。</para>
+                </listitem>
+                <listitem>
+                    <para>每个消息都有一个<emphasis>地址(address)</emphasis>做为它的目的地。当一个消息被发到
+                        服务器上时,它会被路由到与该地址绑定的所有队列中(queue)。如果queue配置了过滤器(filter),
+                        那么只有与过滤器相匹配的消息才会被路由到该queue。一个地址可以绑定多个queue,也可以一个也不
+                        绑定。注意这里所说的queue是内核的概念,不是JMS的queue。除了queue之外,还有其它一些实体可以
+                        绑定到某一地址上。比如<emphasis role="italic">divert(转发器)</emphasis>。</para>
+                </listitem>
+                <listitem>
+                    <para>消息可以是持久的(durable)或非持久的(non-durable)。持久的消息不会因为服务器故障或重启而丢失。
+                        非持久消息则会因为服务器的故障或重启而丢失。</para>
+                </listitem>
+                <listitem>
+                    <para>消息具有优先级。优先级的值为从0到9的整数。0代表最低优先级,9代表最高优先级。HornetQ总
+                        会尝试先传送优先级高的消息。</para>
+                </listitem>
+                <listitem>
+                    <para>消息还有一个可选的失效时间。如果一个消息过了失效时间,HornetQ将不再传送它。</para>
+                </listitem>
+                <listitem>
+                    <para>消息还有一个可选的时间戳(timestamp)。这个时间戳表示的是消息被发送的时间。</para>
+                </listitem>
+                <listitem>
+                    <para>HornetQ还支持大消息的发送。它可以处理大到内存装不下的超大消息。</para>
+                </listitem>
+            </itemizedlist>
+        </section>
+        <section>
+            <title>地址(Address)</title>
+            <para>HornetQ服务器保存有地址和queue的映射集。一个地址对应零个或多个queue。每个queue还可以拥有消息
+                过滤器(filter)。当一个消息在服务器内进行路由时,它将会被送往与其地址相绑定的所有的queue中。但是
+                如果其中某个queue有过滤器,那么只有与其过滤器相匹配的消息才会被发到这个queue中。</para>
+            <para>其它的实体如<emphasis role="italic">diverts</emphasis>也可以与一地址进行绑定,消息也会被同样
+                  路由到相应的实体中。</para>
+            <note>
+                <para>在内核中,没有Topic的概念。只有<emphasis>地址(address)</emphasis> 和
+                        <emphasis>queue</emphasis>。</para>
+                <para>假如想在内核实现JMS topic的功能,只要将一地址绑定到多个queue即可。其中的每一个queue就相当
+                    于一个订阅(subscription)。类似地,一个JMS queue则可以通过一个地址与一个queue的绑定来实现。</para>
+            </note>
+        </section>
+        <section>
+            <title>Queue</title>
+            <para>Queue可以的持久的。意思是如果queue中的消息是持久的,那么当发生服务器故障或重启时,这些消息不会丢失。
+                Queue也可是非持久的,这意谓着如果服务器发的故障或重启,queue中的消息将会丢失,不管消息是不是持久的。</para>
+            <para>Queue也可以是临时的,意思是临时的queue在客户端断开连接时,它将会被删除。</para>
+            <para>Queue可以有一个过滤器表达式。服务器在向这样的queue路由消息时,先判定消息是否与过滤器表达式相匹配,
+                只有匹配的消息才会被发到该queue。</para>
+            <para>一个地址可以绑定多个queue、。但是一个queue只能被绑定到一个地址上。</para>
+        </section>
+        <section>
+            <title>ClientSessionFactory</title>
+            <para>客户端使用 <literal>ClientSessionFactory</literal> 类的实例创建 <literal
+                    >ClientSession</literal> 实例。 <literal>ClientSessionFactory</literal>
+                知道如何连接到服务器并创建会话(session)。它是可以根据不同需要灵活配置的。</para>
+            <para><literal>ClientSessionFactory</literal>实例是通过 <literal
+                    >HornetQClient</literal> 工厂类创建的。</para>
+        </section>
+        <section>
+            <title>ClientSession</title>
+            <para>客户端使用ClientSession来发送和接收消息,并控制事务的使用。ClientSession可以支持事务性
+                和非事务性的应用。它还提供了一个 <literal
+                    >XAResource</literal> 接口,因些它可以加入到一个<ulink url="http://java.sun.com/javaee/technologies/jta/index.jsp">JTA</ulink>
+                交易中。</para>
+            <para>ClientSession 管理着ClientConsumers和ClientProducers。</para>
+            <para>ClientSession 实例可以注册一个可选的 <literal
+                    >SendAcknowledgementHandler</literal>。每当消息被送达HornetQ服务器中时,
+                   HornetQ就用它来异步地发出通知。有了这个独特的功能,客户可以不必阻塞在每次消息的发送操作上来保证
+                   消息安全到达服务器。如果采用阻塞的方法,那么每一个消息的发送都要包括往返两次的网络传递操作,开销
+                   是很大的。有了这个异步方式就可以避免这种开销,建立真正的异步的端到端间的系统。这是标准的JMS接口
+                   无法做到的。参见 <xref linkend="send-guarantees"/>了解相关的更详细的信息。</para>
+        </section>
+        <section>
+            <title>ClientConsumer</title>
+            <para>客户端使用 <literal>ClientConsumer</literal> 实例来接收来自queue的消息。HornetQ的内核同时支持
+                同步与异步的消息接收。<literal>ClientConsumer</literal> 实例可以配置有可选的过滤器。它只接收与过滤
+                器相匹配的消息。</para>
+        </section>
+        <section>
+            <title>ClientProducer</title>
+            <para>客户端使用<literal>ClientSession</literal>创建 <literal>ClientProducer</literal> 实例
+                来向服务器发送消息。ClientProducer可以指定一个地址,用来向其发送消息。或者不指定地址,消息在发送时
+                再指定地址。</para>
+        </section>
+        <warning>
+            <para>请注意 ClientSession、 ClientProducer和ClientConsumer 实例是可以被
+                <emphasis>重用</emphasis>的。</para>
+            <para>在每次发送或接收一个消息时都创建新的 ClientSession, ClientProducer 和 ClientConsumer是不符合
+                设计模式的要求的。这样做会导致性能低下。在<xref linkend="perf-tuning"/>中我们会做进一步的讨论。</para>
+        </warning>
+    </section>
+    <section>
+        <title>一个内核的应用实例</title>
+        <para>下面是一个非常简单的使用内核API来发送的接收消息的实例:</para>
+        <programlisting>
+ClientSessionFactory factory =  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.getBodyBuffer().writeString("Hello");
+
+producer.send(message);
+
+session.start();
+
+ClientConsumer consumer = session.createConsumer("example");
+
+ClientMessage msgReceived = consumer.receive();
+
+System.out.println("message = " + msgReceived.getBodyBuffer().readString());
+
+session.close();</programlisting>
+    </section>
+</chapter>


Mime
View raw message