activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbert...@apache.org
Subject [04/15] activemq-6 git commit: Remove references to HornetQ in doc and Comments
Date Wed, 19 Nov 2014 15:38:26 GMT
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/docs/user-manual/zh/preface.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/preface.xml b/docs/user-manual/zh/preface.xml
index fe25e7f..2d07b55 100644
--- a/docs/user-manual/zh/preface.xml
+++ b/docs/user-manual/zh/preface.xml
@@ -18,26 +18,26 @@
 <!-- ============================================================================= -->
 <chapter id="preface">
     <title>前言</title>
-    <para>什么是HornetQ?</para>
+    <para>什么是ActiveMQ?</para>
     <itemizedlist>
         <listitem>
-            <para>HornetQ 是一个开源的软件项目。它的目标是一个多协议、可嵌入、高性能、可集群的异步消息系统。</para>
+            <para>ActiveMQ 是一个开源的软件项目。它的目标是一个多协议、可嵌入、高性能、可集群的异步消息系统。</para>
         </listitem>
         <listitem>
-            <para>HornetQ 是一个消息中间件(MoM)。有关MoM和其它消息相关的概念解释请参见 <xref linkend="messaging-concepts"
+            <para>ActiveMQ 是一个消息中间件(MoM)。有关MoM和其它消息相关的概念解释请参见 <xref linkend="messaging-concepts"
                 />。</para>
         </listitem>
         <listitem>
-            <para>要了解有关HornetQ的更多信息请访问 <ulink url="http://www.jboss.org/community/wiki/HornetQGeneralFAQs"></ulink>。</para>
+            <para>要了解有关ActiveMQ的更多信息请访问 <ulink url="http://www.jboss.org/community/wiki/ActiveMQGeneralFAQs"></ulink>。</para>
         </listitem>
     </itemizedlist>
-    <para>为什么要使用HornetQ? 以下给出了几个理由:</para>
+    <para>为什么要使用ActiveMQ? 以下给出了几个理由:</para>
     <itemizedlist>
         <listitem>
-            <para>HornetQ是100%的开源软件。 HornetQ 采用 Apache v 2.0开源协议,对用户的限制最小。</para>
+            <para>ActiveMQ是100%的开源软件。 ActiveMQ 采用 Apache v 2.0开源协议,对用户的限制最小。</para>
         </listitem>
         <listitem>
-            <para>HornetQ的设计强调可用性。</para>
+            <para>ActiveMQ的设计强调可用性。</para>
         </listitem>
         <listitem>
             <para>采用Java语言编写。可以在任何Java 6+ 的平台上运行。这几乎包括了从Windows到IBM mainframes的每个平台。</para>
@@ -49,11 +49,11 @@
             <para>功能全面。不仅拥有其它成熟消息产品所具有的全部功能,而且还有很多独特的功能。</para>
         </listitem>
         <listitem>
-            <para>HornetQ的设计遵从了简约的原则。对第三方软件的依赖极少。根据不同的需要,
-                  HornetQ可以单独运行,也可以运行于JEE应用服务器中。它还可以嵌入到你自己的应用程序中。</para>
+            <para>ActiveMQ的设计遵从了简约的原则。对第三方软件的依赖极少。根据不同的需要,
+                  ActiveMQ可以单独运行,也可以运行于JEE应用服务器中。它还可以嵌入到你自己的应用程序中。</para>
         </listitem>
         <listitem>
-            <para>完美的可获得性。HornetQ提供自动客户端失效备援(automatic client failover)功能,能保证在服务器故障时没有消息丢失或消息重复。</para>
+            <para>完美的可获得性。ActiveMQ提供自动客户端失效备援(automatic client failover)功能,能保证在服务器故障时没有消息丢失或消息重复。</para>
         </listitem>
         <listitem>
             <para>超级灵活的集群方案。可以控制集群进行消息负载均衡的方式。分布在不同地理位置的各个集群间可以通过非可靠的网络连接形成一个全球网络。
@@ -61,8 +61,8 @@
         </listitem>
         <listitem>
             <para>请访问 <ulink
-                    url="http://www.jboss.org/community/wiki/HornetQFeatures">wiki
-                    </ulink>来全面了解HornetQ的所有功能介绍。</para>
+                    url="http://www.jboss.org/community/wiki/ActiveMQFeatures">wiki
+                    </ulink>来全面了解ActiveMQ的所有功能介绍。</para>
         </listitem>
     </itemizedlist>
 </chapter>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/docs/user-manual/zh/project-info.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/project-info.xml b/docs/user-manual/zh/project-info.xml
index d318795..cdfba07 100644
--- a/docs/user-manual/zh/project-info.xml
+++ b/docs/user-manual/zh/project-info.xml
@@ -18,11 +18,11 @@
 <!-- ============================================================================= -->
 <chapter id="project-info">
    <title>项目信息</title>
-   <para>HornetQ的官方网址是 <ulink url="http://hornetq.org/"
+   <para>ActiveMQ的官方网址是 <ulink url="http://hornetq.org/"
          >http://hornetq.org/</ulink>.</para>
    <section id="download.software">
       <title>软件下载</title>
-      <para>HornetQ的下载地址为:<ulink
+      <para>ActiveMQ的下载地址为:<ulink
             url="http://hornetq.org/downloads.html">http://hornetq.org/downloads.html</ulink></para>
    </section>
    <section id="download.git">
@@ -30,11 +30,11 @@
       <para>
          <itemizedlist>
             <listitem>
-               <para>HornetQ的 <ulink
-                     url="http://www.jboss.org/community/wiki/HornetQ">wiki</ulink></para>
+               <para>ActiveMQ的 <ulink
+                     url="http://www.jboss.org/community/wiki/ActiveMQ">wiki</ulink></para>
             </listitem>
             <listitem>
-               <para>如果在使用HornetQ中发生任何问题,可以去我们的 <ulink
+               <para>如果在使用ActiveMQ中发生任何问题,可以去我们的 <ulink
                      url="http://www.jboss.org/index.html?module=bb&amp;op=viewforum&amp;f=312">用户论坛
                      </ulink></para>
             </listitem>
@@ -54,7 +54,7 @@
                <para>还可以跟踪我们的<ulink url="http://twitter.com/hornetq">twitter</ulink></para>
             </listitem>
             <listitem>
-               <para>HornetQ的Git代码库地址 <ulink
+               <para>ActiveMQ的Git代码库地址 <ulink
                      url="https://github.com/hornetq/hornetq"
                      >https://github.com/hornetq/hornetq</ulink></para>
             </listitem>
@@ -65,7 +65,7 @@
             </listitem>
          </itemizedlist>
       </para>
-      <para>Red Hat 公司聘请全职工程师进行HornetQ项目的开发工作,他们是: <itemizedlist>
+      <para>Red Hat 公司聘请全职工程师进行ActiveMQ项目的开发工作,他们是: <itemizedlist>
             <listitem>
                <para>
                   <ulink url="http://jbossfox.blogspot.com">Tim Fox</ulink> (项目主管)</para>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/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
index ca9697c..8aac0f4 100644
--- a/docs/user-manual/zh/queue-attributes.xml
+++ b/docs/user-manual/zh/queue-attributes.xml
@@ -98,7 +98,7 @@
         <para><literal>max-delivery-attempts</literal>定义了最大重传递的次数。一个消息如果反复传递超过
             了这个值将会被发往死信地址<literal>dead-letter-address</literal>。相关的完整的解释在
             <link linkend="undelivered-messages.configuring">这里</link>。</para>
-        <para><literal>redelivery-delay</literal>定义了重新传递的延迟。它控制HornetQ在重新
+        <para><literal>redelivery-delay</literal>定义了重新传递的延迟。它控制ActiveMQ在重新
             传递一个被取消的消息时要等待的时间。参见<link linkend="undelivered-messages.delay"
                 >这里</link>。</para>
         <para><literal>expiry-address</literal>定义了过期消息的发送地址。参见<link linkend="message-expiry.configuring">这里</link>。</para>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/docs/user-manual/zh/security.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/security.xml b/docs/user-manual/zh/security.xml
index 200387b..3706d8e 100644
--- a/docs/user-manual/zh/security.xml
+++ b/docs/user-manual/zh/security.xml
@@ -18,17 +18,17 @@
 <!-- ============================================================================= -->
 <chapter id="security">
     <title>安全</title>
-    <para>本章讲述HornetQ的安全机制以及如何配置它。要完全关闭安全,只要将<literal>activemq-configuration.xml</literal>
+    <para>本章讲述ActiveMQ的安全机制以及如何配置它。要完全关闭安全,只要将<literal>activemq-configuration.xml</literal>
         文件中的<literal>security-enabled</literal>参数设为false即可。</para>
-    <para>出于性能的考虑,安全在HornetQ中被缓存一定的时间。要改变这个时间,需要设置参数
+    <para>出于性能的考虑,安全在ActiveMQ中被缓存一定的时间。要改变这个时间,需要设置参数
         <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>ActiveMQ采用了基于角色的安全模型来配置地址的安全以及其队列的安全。</para>
+        <para>正如在<xref linkend="using-core"/>解释的那样,ActiveMQ核心主要由绑定到地址上的队列组成。
             消息被发送到地址后,服务器查找与之绑定的队列,并将消息路由到这些队列中。</para>
-        <para>HornetQ可以基于地址来给队列定义权限。在定义权限时可以使用通配符'<literal>#</literal>'和
+        <para>ActiveMQ可以基于地址来给队列定义权限。在定义权限时可以使用通配符'<literal>#</literal>'和
             '<literal>*</literal>'。</para>
         <para>队列的权限有7种,它们是:</para>
         <itemizedlist>
@@ -75,11 +75,11 @@
               角色的用户可以在以开头的地址上创建临时的队列。</para>
         <para>任何具有<literal>admin</literal>或<literal>europe-users</literal>角色的用户可以向以"globalqueues.europe."开头的地址
             发送消息,并从绑定到相同地址上的队列接收消息。</para>
-        <para>安全管理器处理一个用户和它的角色的对应关系。HornetQ本身自带一个用户管理器,能从文件中读取用户的身份信息。
-            另外HornetQ还可以使用JAAS或JBoss应用服务器的安全管理机制。</para>
+        <para>安全管理器处理一个用户和它的角色的对应关系。ActiveMQ本身自带一个用户管理器,能从文件中读取用户的身份信息。
+            另外ActiveMQ还可以使用JAAS或JBoss应用服务器的安全管理机制。</para>
         <para>有关安全管理器的配置信息,请参见<xref linkend="change-security-manager"/>。</para>
         <para>在每个xml文件中可以有零个或多个 <literal>security-setting</literal>。当一组地址有多个这样的设置时,
-              HornetQ总是选取<emphasis>更具体的</emphasis>匹配。</para>
+              ActiveMQ总是选取<emphasis>更具体的</emphasis>匹配。</para>
         <para>让我们来看一个实例,下面是另一个<literal>security-setting</literal>:</para>
         <programlisting>
 &lt;security-setting match="globalqueues.europe.orders.#"&gt;
@@ -101,13 +101,13 @@
     </section>
     <section>
         <title>安全套接字层(SSL)传输</title>
-        <para>当消息客户端与服务器端,或服务器之间(比如使用桥的情况)通过一个不信任的网络相互通信时,HornetQ
+        <para>当消息客户端与服务器端,或服务器之间(比如使用桥的情况)通过一个不信任的网络相互通信时,ActiveMQ
             支持使用加密的安全套接字(SSL)传输数据。</para>
         <para>关于SSL的详细配置信息,请参见<xref linkend="configuring-transports"/>。</para>
     </section>
     <section>
         <title>基本用户身份信息(Credentials)</title>
-        <para>HornetQ自带一个安全管理器(security manager)可以从xml文件中读取用户身份信息,即用户名、
+        <para>ActiveMQ自带一个安全管理器(security manager)可以从xml文件中读取用户身份信息,即用户名、
             密码、角色信息。该xml文件名为<literal>activemq-users.xml</literal>,它必须要在classpath中。</para>
         <para>如果你要使用这个安全管理器,就将用户名,密码,角色等信息加入到这个文件中。</para>
         <para>让我们看一个例子:</para>
@@ -149,18 +149,18 @@
         <para>如果你不想用默认的安全管理器,可以通过修改配置文件<literal>hornetq-beans.xml</literal>
             (或者在运行JBoss应用服务器情况下<literal
                 >hornetq-jboss-beans.xml</literal>文件)来更换。同时要更换
-            <literal>HornetQSecurityManager</literal> bean 的类。</para>
+            <literal>ActiveMQSecurityManager</literal> bean 的类。</para>
         <para>让我们看一段默认bean文件的内容:</para>
         <programlisting>           
-&lt;bean name="HornetQSecurityManager" 
-      class="org.apache.activemq.spi.core.security.HornetQSecurityManagerImpl"&gt;
+&lt;bean name="ActiveMQSecurityManager" 
+      class="org.apache.activemq.spi.core.security.ActiveMQSecurityManagerImpl"&gt;
     &lt;start ignored="true"/&gt;
     &lt;stop ignored="true"/&gt;
 &lt;/bean&gt;            
         </programlisting>
-        <para><literal>org.apache.activemq.spi.core.security.HornetQSecurityManagerImpl</literal>
-            类就是HornetQ服务器的在独立运行时的默认的安全管理器。</para>
-        <para>HornetQ自带有另外两个安全管理器可供使用。一个是JAAS安全管理器,另一个是用来与JBoss应用服务
+        <para><literal>org.apache.activemq.spi.core.security.ActiveMQSecurityManagerImpl</literal>
+            类就是ActiveMQ服务器的在独立运行时的默认的安全管理器。</para>
+        <para>ActiveMQ自带有另外两个安全管理器可供使用。一个是JAAS安全管理器,另一个是用来与JBoss应用服务
             器集成的安全管理器。此外,你还可以编写实现你自己的安全管理器。首先要实现
             <literal>org.apache.activemq.core.security.SecurityManager</literal>接口,再将你的实现
             类定义到<literal>hornetq-beans.xml</literal>文件中即可(或者在JBoss应用服务器中
@@ -174,7 +174,7 @@
         <para>要配置使用你自己的JAAS安全实现,需要在bean文件中定义<literal>JAASSecurityManager</literal>。
             下面是一个例子:</para>
         <programlisting><![CDATA[
-&lt;bean name="HornetQSecurityManager"
+&lt;bean name="ActiveMQSecurityManager"
       class="org.apache.activemq.integration.jboss.security.JAASSecurityManager"&gt;
     &lt;start ignored="true"/&gt;
     &lt;stop ignored="true"/&gt;
@@ -202,23 +202,23 @@
         </itemizedlist>
         <section>
             <title>例子</title>
-            <para>参见<xref linkend="examples.jaas"/>。这个例子展示了怎样在HornetQ中配置使用JAAS。</para>
+            <para>参见<xref linkend="examples.jaas"/>。这个例子展示了怎样在ActiveMQ中配置使用JAAS。</para>
         </section>
     </section>
     <section>
         <title>JBoss 应用服务器安全管理器</title>
-        <para>JBoss 应用服务器安全管理器适用于当HornetQ运行于JBoss应用服务器内时。它可以与JBoss应用服务器
+        <para>JBoss 应用服务器安全管理器适用于当ActiveMQ运行于JBoss应用服务器内时。它可以与JBoss应用服务器
             的安全模型紧密集成。</para>
         <para>此安全管理器的类是 <literal
                 >org.apache.activemq.integration.jboss.security.JBossASSecurityManager</literal>。</para>
-        <para>要了解如何配置JBoss安全管理器,可以看一眼HornetQ发布包中相关例子中的
+        <para>要了解如何配置JBoss安全管理器,可以看一眼ActiveMQ发布包中相关例子中的
             <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>
+             用于整个调用过程。如果想在ActiveMQ在发送和接收消息时使用这些认证(credential)信息,需要将参数
+             <literal>allowClientLogin</literal>设为true。它会越过ActiveMQ的身份验证过程并会传播安全上下文(security
+             context)。如果你想要ActiveMQ使用传播的安全信息进行身份验证,需要同时将参数<literal>authoriseOnClientLogin</literal>
              设为true。</para>
           <para>关于客户端登录的详细信息请访问<ulink
                 url="http://community.jboss.org/wiki/ClientLoginModule">这里</ulink>。 </para>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/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
index 0c034c9..b16180e 100644
--- a/docs/user-manual/zh/send-guarantees.xml
+++ b/docs/user-manual/zh/send-guarantees.xml
@@ -20,7 +20,7 @@
     <title>发送与提交的保证</title>
     <section>
         <title>事务保证</title>
-        <para>在提交或回滚事务时,HornetQ将提交或回滚的请求发送到服务器,客户端阻塞等待服务器的响应。</para>
+        <para>在提交或回滚事务时,ActiveMQ将提交或回滚的请求发送到服务器,客户端阻塞等待服务器的响应。</para>
         <para>当服务器端收到提交或回滚的请求时,它将事务信息记录到日志(journal)中。然后向客户端发回
               响应。参数<literal>journal-sync-transactional</literal>控制着如何向客户端发回响应。
             如果它的值是<literal>false</literal>,服务器向客户端发回响应时事务的处理結果不一定已经被
@@ -32,7 +32,7 @@
     </section>
     <section id="non-transactional-sends">
         <title>非事务性消息发送的保证</title>
-        <para>使用非事务性会话发送消息时,经过适当配置HornetQ,客户端在发送后以阻塞的方式等待,直到确认发出
+        <para>使用非事务性会话发送消息时,经过适当配置ActiveMQ,客户端在发送后以阻塞的方式等待,直到确认发出
             的消息已经到达服务器后再返回。可以对持久化或非持久化的消息分别配置,具体参数如下:</para>
         <itemizedlist>
             <listitem>
@@ -49,13 +49,13 @@
         </itemizedlist>
         <para>将发送设置为阻塞方式会降低程序的效率。因为每次发送都需要一次网络往返的过程,然后才可以进行下次发送。
             这样发送消息的速度将受网络往返时间(RTT)的限制。这样你的网络带宽就可能没有被充分利用。为了提高效率,我们
-            建议采用事务来批量发送消息。因为在事务中,只有在提交或回滚时阻塞。另外你还可以利用HornetQ高级的
+            建议采用事务来批量发送消息。因为在事务中,只有在提交或回滚时阻塞。另外你还可以利用ActiveMQ高级的
             <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>
+                <literal>ActiveMQConnectionFactory</literal>相应的设置方法进行配置。</para>
         <para>如果你使用的是内核服务,你可以直接在<literal
                 >ClientSessionFactory</literal>上用相关的方法设置相应的参数。</para>
         <para>当服务器从一个非事务性的会话收到一个消息时,如果这个消息是持久的并且此消息被路由到至少一个持久的队列中,
@@ -65,14 +65,14 @@
     </section>
     <section id="send-guarantees.nontrans.acks">
         <title>非事务性通知的保证</title>
-        <para>当客户端使用非事务性会话向服务器通知消息收到时,可以配置HornetQ使得客户端的通知阻塞直到服务器收到
+        <para>当客户端使用非事务性会话向服务器通知消息收到时,可以配置ActiveMQ使得客户端的通知阻塞直到服务器收到
             了通知并返回为止。其相应的配置参数是<literal>BlockOnAcknowledge</literal>。如果该参数设为
             <literal>true</literal>则所有的通过非事务会话的消息通知都是阻塞式的。如果你想要的消息传递策略是
             <emphasis>最多一次</emphasis>的话,那么你需要将此参数设为。默认值是<literal>false</literal>。</para>
     </section>
     <section id="asynchronous-send-acknowledgements">
         <title>异步发送通知</title>
-        <para>如果你使用的是非事务会话来发送消息,并且希望保证每个发送出去的消息都到达服务器的话,你可以将HornetQ配置
+        <para>如果你使用的是非事务会话来发送消息,并且希望保证每个发送出去的消息都到达服务器的话,你可以将ActiveMQ配置
             成阻塞的方式,如<xref linkend="non-transactional-sends"/>讨论的那样。这样做的一个缺点是性能的降低。
             因为这样每发送一个消息就需要一次网络的往返通信。如果网络时延越长,消息发送的效率就越低。同时网络的带宽对消息
             的发送没有影响。</para>
@@ -82,7 +82,7 @@
         <para>如果每个消息的大小&lt; 1500字节,而且网络的最大传输单元(MTU)是1500字节。那么理论上1GiB的网络
             最大的传输速率是 (1024 * 1024 * 1024 / 8) / 1500 = 89478 消息每秒!尽管这不是一个精确的工程计算但
             你可以看出阻塞式的发送对性能的影响会有多大。</para>
-        <para>为了解决这个问题,HornetQ提供了一种新的功能,称为<emphasis>异步发送通知</emphasis>。
+        <para>为了解决这个问题,ActiveMQ提供了一种新的功能,称为<emphasis>异步发送通知</emphasis>。
             它允许消息以非阻塞的方式发送,同时从另一个连接流中异步地接收服务器的通知。这样就使得消息的发送与通知分开来,
             避免了阻塞方式带来的缺点。在保证消息可行发送到服务器的同时提高了呑吐量。</para>
         <para>参数用来定义消息发送通知的窗口大小。它属于连接工厂或客户会话工厂。参见<xref linkend="client-reconnection"/>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/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
index 7f38bf9..98e565b 100644
--- a/docs/user-manual/zh/thread-pooling.xml
+++ b/docs/user-manual/zh/thread-pooling.xml
@@ -18,23 +18,23 @@
 <!-- ============================================================================= -->
 <chapter id="thread-pooling">
     <title>线程管理</title>
-    <para>本章讲述HornetQ如何使用线程池以及如何管理线程。</para>
+    <para>本章讲述ActiveMQ如何使用线程池以及如何管理线程。</para>
     <para>首先我们讨论在服务器端线程是如何被管理的,然后我们再讨论客户端的情况。</para>
     <section>
         <title>服务器端线程的管理</title>
-        <para>每个HornetQ服务器都有一个线程池作为一般线程使用,另外还有一个可计划线程池。Java的可计划线程池不能作为
+        <para>每个ActiveMQ服务器都有一个线程池作为一般线程使用,另外还有一个可计划线程池。Java的可计划线程池不能作为
             标准的线程池使用,因此我们采用了两个单独的线程池。</para>
         <para>当使用旧的(阻塞)IO时,使用了一个单独的线程池来处理连接。但是旧的IO要求一个线程配一个连接,所以如果你
             的应用有很多并发的连接,这个线程池会很快用光所有的线程,造成服务器出现“挂起”现象。因此,对于大量并发连接
             的应用,一定要使用NIO。</para>
-        <para>如果使用NIO,默认情况下HornetQ会使用系统中处理器内核(或超线程)数量三倍的线程来处理接收的数据包。
+        <para>如果使用NIO,默认情况下ActiveMQ会使用系统中处理器内核(或超线程)数量三倍的线程来处理接收的数据包。
             内核的数量是通过调用<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中绝大部分这样的任务。
+            <para>服务器可计划线程池可以定期地或延迟地执行所交给的任务,它用来完成ActiveMQ中绝大部分这样的任务。
                   它内部使用的是一个 <literal
                     >java.util.concurrent.ScheduledThreadPoolExecutor</literal>实例。</para>
             <para>最大线程数可以在<literal
@@ -61,36 +61,36 @@
         </section>
         <section>
             <title>过期回收线程</title>
-            <para>HornetQ使用一个单独的线程来扫描队列中过期的消息。由于这个线程需要自己的优先级配置,所以不能使用上述的
+            <para>ActiveMQ使用一个单独的线程来扫描队列中过期的消息。由于这个线程需要自己的优先级配置,所以不能使用上述的
                 任何一个线程池。</para>
             <para>关于回收线程的配置请参阅<xref linkend="message-expiry"/>。</para>
         </section>
         <section>
             <title>异步IO</title>
-            <para>HornetQ使用一个线程池来进行异步IO的操作,包括事件的接收和发送。这些线程的名字都是以
-                HornetQ-AIO-poller-pool为开头。每个打开的日志文件都对应有一个线程为其服务(通常只有
+            <para>ActiveMQ使用一个线程池来进行异步IO的操作,包括事件的接收和发送。这些线程的名字都是以
+                ActiveMQ-AIO-poller-pool为开头。每个打开的日志文件都对应有一个线程为其服务(通常只有
                 一个)。</para>
             <para>还有一个单独的线程用于向libaio发送写请求。这样做是为了避免上下文转换带来的性能下降。该
-                线程的名字以HornetQ-AIO-writer-pool开头。</para>
+                线程的名字以ActiveMQ-AIO-writer-pool开头。</para>
         </section>
     </section>
     <section id="thread-pooling.client.side">
         <title>客户端线程管理</title>
-        <para>在客户端HornetQ有一个静态的可计划线程池和一个静态的通用线程池,它们在一个JVM中由同一个classloader装载的所有客户端
+        <para>在客户端ActiveMQ有一个静态的可计划线程池和一个静态的通用线程池,它们在一个JVM中由同一个classloader装载的所有客户端
             共同使用。</para>
         <para>静态的可计划的线程池的最大线程数为 <literal>5</literal>,通用线程池则没有线程数限制。</para>
         <para>如果需要还可以配置一个<literal
                 >ClientSessionFactory</literal>实例以使它拥有自己的可计划与通用线程池。通过这个工厂创建的会话都
             将使用这些线程池。</para>
         <para>要想配置<literal>ClientSessionFactory</literal>使用自己的线程池,只要调用它相应的方法取出可,如:</para>
-        <programlisting>ClientSessionFactory myFactory = HornetQClient.createClientSessionFactory(...);
+        <programlisting>ClientSessionFactory myFactory = ActiveMQClient.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>
+        <programlisting>ConnectionFactory myConnectionFactory = ActiveMQJMSClient.createConnectionFactory(myFactory);     </programlisting>
+        <para>如果你使用JNDI来创建<literal>ActiveMQConnectionFactory</literal>
             实例,你还可以在<literal>hornetq-jms.xml</literal>文件中进行配置。如:</para>
         <programlisting>&lt;connection-factory name="ConnectionFactory"&gt;
     &lt;connectors>

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

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/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
index d099f92..0e43e8c 100644
--- a/docs/user-manual/zh/undelivered-messages.xml
+++ b/docs/user-manual/zh/undelivered-messages.xml
@@ -47,7 +47,7 @@
         &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>,ActiveMQ在再传递之前等待所定义的时间。</para>
          <para>默认是没有延时的(即<literal>redelivery-delay</literal>的值是0)。</para>
          <para>可以使用通配符为一组地址定义再传递的延迟(参见<xref linkend="wildcard-syntax"/>)。
                </para>
@@ -62,7 +62,7 @@
       <para>通过定义一个<emphasis role="italic">死信地址</emphasis>也可以防止同一个消息被无休止地传递:
          当一个消息被重复传递一定次数后,就会从队列中删除并传递到定义好的死信地址中。</para>
       <para>这些死信中的消息之后可以转发到某个队列中,以供系统管理员分析处理。</para>
-      <para>每个HornetQ的地址可以有一个死信地址。当一个消息被反复传递达一定次数时,它就会被从队列中删除并送到
+      <para>每个ActiveMQ的地址可以有一个死信地址。当一个消息被反复传递达一定次数时,它就会被从队列中删除并送到
          死信地址。这些<emphasis>死信</emphasis>消息可以被接收进行分析处理。</para>
       <section id="undelivered-messages.configuring">
          <title>配置死信地址</title>
@@ -101,13 +101,13 @@
    </section>
    <section id="configuring.delivery.count.persistence">
       <title>传递计数的持久化</title>
-      <para>通常情况下HornetQ在一个消息被回滚之前并不更新持久的传递计数(即在消息传递到接收者之前不会更新传递计数)。
+      <para>通常情况下ActiveMQ在一个消息被回滚之前并不更新持久的传递计数(即在消息传递到接收者之前不会更新传递计数)。
          大多数情况下消息被接收、通知、然后被忘掉。这样对<emphasis>每一个消息</emphasis>的传递都要更新一次持久的
          传递计数,会显著降低系统的性能。</para>
       <para>介是如果在消息传递之前不进行持久传递计数的更新,服务器一旦发生故障而崩溃,就会造成消息可能被传递出去而传递
          计数却没有正确反映出传递的結果。在恢复阶段,服务器将错误地将该消息的<literal>redelivered</literal>设为
          <literal>false</literal>而不是<literal>true</literal>。 </para>
-      <para>这样是不符合严格的JMS要求的。因此HornetQ允许在消息传递前更新传递计数。但是默认不这样做,目的是优先考虑
+      <para>这样是不符合严格的JMS要求的。因此ActiveMQ允许在消息传递前更新传递计数。但是默认不这样做,目的是优先考虑
          了它对性能的影响。</para>
       <para>要想打开传递计数更新功能,将<literal>activemq-configuration.xml</literal>文件中的
             <literal>persist-delivery-count-before-delivery</literal>设为<literal>true</literal>即可:</para>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/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
index 53172e6..4d19a9e 100644
--- a/docs/user-manual/zh/using-core.xml
+++ b/docs/user-manual/zh/using-core.xml
@@ -17,8 +17,8 @@
 <!-- permitted by applicable law.                                                  -->
 <!-- ============================================================================= -->
 <chapter id="using-core">
-    <title>使用HornetQ内核</title>
-    <para>HornetQ内核是一个与JMS无关的消息系统,它有一套自己的API。我们称它为<emphasis>内核API</emphasis>.</para>
+    <title>使用ActiveMQ内核</title>
+    <para>ActiveMQ内核是一个与JMS无关的消息系统,它有一套自己的API。我们称它为<emphasis>内核API</emphasis>.</para>
     <para>你可以直接使用内核API。使用内核API可以完成JMS同样的功能,只是比起JMS API使用更加简单方便。另外,内核API
         还提供了JMS不具有的额外的功能。</para>
     <section>
@@ -52,23 +52,23 @@
                         非持久消息则会因为服务器的故障或重启而丢失。</para>
                 </listitem>
                 <listitem>
-                    <para>消息具有优先级。优先级的值为从0到9的整数。0代表最低优先级,9代表最高优先级。HornetQ总
+                    <para>消息具有优先级。优先级的值为从0到9的整数。0代表最低优先级,9代表最高优先级。ActiveMQ总
                         会尝试先传送优先级高的消息。</para>
                 </listitem>
                 <listitem>
-                    <para>消息还有一个可选的失效时间。如果一个消息过了失效时间,HornetQ将不再传送它。</para>
+                    <para>消息还有一个可选的失效时间。如果一个消息过了失效时间,ActiveMQ将不再传送它。</para>
                 </listitem>
                 <listitem>
                     <para>消息还有一个可选的时间戳(timestamp)。这个时间戳表示的是消息被发送的时间。</para>
                 </listitem>
                 <listitem>
-                    <para>HornetQ还支持大消息的发送。它可以处理大到内存装不下的超大消息。</para>
+                    <para>ActiveMQ还支持大消息的发送。它可以处理大到内存装不下的超大消息。</para>
                 </listitem>
             </itemizedlist>
         </section>
         <section>
             <title>地址(Address)</title>
-            <para>HornetQ服务器保存有地址和queue的映射集。一个地址对应零个或多个queue。每个queue还可以拥有消息
+            <para>ActiveMQ服务器保存有地址和queue的映射集。一个地址对应零个或多个queue。每个queue还可以拥有消息
                 过滤器(filter)。当一个消息在服务器内进行路由时,它将会被送往与其地址相绑定的所有的queue中。但是
                 如果其中某个queue有过滤器,那么只有与其过滤器相匹配的消息才会被发到这个queue中。</para>
             <para>其它的实体如<emphasis role="italic">diverts</emphasis>也可以与一地址进行绑定,消息也会被同样
@@ -95,7 +95,7 @@
                     >ClientSession</literal> 实例。 <literal>ClientSessionFactory</literal>
                 知道如何连接到服务器并创建会话(session)。它是可以根据不同需要灵活配置的。</para>
             <para><literal>ClientSessionFactory</literal>实例是通过 <literal
-                    >HornetQClient</literal> 工厂类创建的。</para>
+                    >ActiveMQClient</literal> 工厂类创建的。</para>
         </section>
         <section>
             <title>ClientSession</title>
@@ -105,15 +105,15 @@
                 交易中。</para>
             <para>ClientSession 管理着ClientConsumers和ClientProducers。</para>
             <para>ClientSession 实例可以注册一个可选的 <literal
-                    >SendAcknowledgementHandler</literal>。每当消息被送达HornetQ服务器中时,
-                   HornetQ就用它来异步地发出通知。有了这个独特的功能,客户可以不必阻塞在每次消息的发送操作上来保证
+                    >SendAcknowledgementHandler</literal>。每当消息被送达ActiveMQ服务器中时,
+                   ActiveMQ就用它来异步地发出通知。有了这个独特的功能,客户可以不必阻塞在每次消息的发送操作上来保证
                    消息安全到达服务器。如果采用阻塞的方法,那么每一个消息的发送都要包括往返两次的网络传递操作,开销
                    是很大的。有了这个异步方式就可以避免这种开销,建立真正的异步的端到端间的系统。这是标准的JMS接口
                    无法做到的。参见 <xref linkend="send-guarantees"/>了解相关的更详细的信息。</para>
         </section>
         <section>
             <title>ClientConsumer</title>
-            <para>客户端使用 <literal>ClientConsumer</literal> 实例来接收来自queue的消息。HornetQ的内核同时支持
+            <para>客户端使用 <literal>ClientConsumer</literal> 实例来接收来自queue的消息。ActiveMQ的内核同时支持
                 同步与异步的消息接收。<literal>ClientConsumer</literal> 实例可以配置有可选的过滤器。它只接收与过滤
                 器相匹配的消息。</para>
         </section>
@@ -134,7 +134,7 @@
         <title>一个内核的应用实例</title>
         <para>下面是一个非常简单的使用内核API来发送的接收消息的实例:</para>
         <programlisting>
-ClientSessionFactory factory =  HornetQClient.createClientSessionFactory(
+ClientSessionFactory factory =  ActiveMQClient.createClientSessionFactory(
                                         new TransportConfiguration(
                                            InVMConnectorFactory.class.getName()));
 

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/docs/user-manual/zh/using-jms.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/using-jms.xml b/docs/user-manual/zh/using-jms.xml
index 9075632..a70350a 100644
--- a/docs/user-manual/zh/using-jms.xml
+++ b/docs/user-manual/zh/using-jms.xml
@@ -18,14 +18,14 @@
 <!-- ============================================================================= -->
 <chapter id="using-jms">
     <title>使用JMS</title>
-    <para>很多用户喜欢使JMS,因此HornetQ提供了JMS服务。</para>
+    <para>很多用户喜欢使JMS,因此ActiveMQ提供了JMS服务。</para>
     <para>JMS是一个普遍使用API标准,绝大多数的消息系统都提供JMS接口。如果你对JMS还不熟悉,建议你先参考一下
           Sun的<ulink url="http://java.sun.com/products/jms/tutorial/1_3_1-fcs/doc/jms_tutorialTOC.html">
             JMS 教程</ulink>。</para>
-    <para>HornetQ还提供了许多的JMS的示例程序(examples)。比如简单的JMS Queue和Topic的示例,就很适合初学者做为了
-          解HornetQ JMS的起点。<xref linkend="examples"/>对这些示例作了详细的说明。</para>
-    <para>下面我们将带领读者一步步地配置HornetQ的JMS服务,并创建一个简单的JMS程序。我们还将展示如何在没有JNDI的情况下
-          来使用HornetQ中的JMS。</para>
+    <para>ActiveMQ还提供了许多的JMS的示例程序(examples)。比如简单的JMS Queue和Topic的示例,就很适合初学者做为了
+          解ActiveMQ JMS的起点。<xref linkend="examples"/>对这些示例作了详细的说明。</para>
+    <para>下面我们将带领读者一步步地配置ActiveMQ的JMS服务,并创建一个简单的JMS程序。我们还将展示如何在没有JNDI的情况下
+          来使用ActiveMQ中的JMS。</para>
     <section>
         <title>一个简单的订购系统</title>
         <para>本章我们将用一个简单的订购系统做为一个例子。尽管它十分简单,但是它能够很好地向大家展示JMS的设置和使用。</para>
@@ -68,13 +68,13 @@
               中即可。</para>
         <note>
             <para>在JMS ConnectionFactory的配置中引用了一个名为 <literal>netty</literal>的<literal>connector</literal>。
-                它实际上指向的是HornetQ核心中部署的一个连接器(connector)。它的配置在HornetQ的核心配置文件
+                它实际上指向的是ActiveMQ核心中部署的一个连接器(connector)。它的配置在ActiveMQ的核心配置文件
                  <literal>activemq-configuration.xml</literal> 中。它定义了采用何种传输与服务器连接。</para>
         </note>
     </section>
     <section id="using-jms.configure.factory.types">
         <title>连接工厂的类型</title>
-        <para>在JMS API文档中有几种不同类型的连接工厂供用户使用。HornetQ为用户提供了配置连接工厂类型的参数。用户可以通过
+        <para>在JMS API文档中有几种不同类型的连接工厂供用户使用。ActiveMQ为用户提供了配置连接工厂类型的参数。用户可以通过
               配置连接工厂的”signature"属性和"xa"参数来得到想要的类型。“singature"属性是字符串类型,它有三个可选值:
               <emphasis>generic</emphasis>、<emphasis>queue</emphasis>和<emphasis>topic</emphasis>; 
               <literal>xa</literal>是一个布尔型参数。下表给出了不同类型连接工厂对应的配置值:</para>
@@ -176,8 +176,8 @@ java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
                   千万不能用<literal>localhost</literal>!</para>
         </note>
         <note>
-            <para><emphasis>只有当HornetQ作为独立服务器运行时</emphasis>
-                  才可以配置JNDIServer bean。当HornetQ运行于JBoss应用服务器中时,由于JBOSS服务器已经提供了
+            <para><emphasis>只有当ActiveMQ作为独立服务器运行时</emphasis>
+                  才可以配置JNDIServer bean。当ActiveMQ运行于JBoss应用服务器中时,由于JBOSS服务器已经提供了
                   JNDI服务,所以就不需要再进行配置了。</para>
         </note>
     </section>
@@ -207,7 +207,7 @@ producer.send(message);</programlisting>
         <programlisting>TextMessage receivedMessage = (TextMessage)consumer.receive();
 System.out.println("Got order: " + receivedMessage.getText());
         </programlisting>
-        <para>看起来就是这么简单。 在HornetQ有发布包中有很多各种各样的JMS例子供用户参考。</para>
+        <para>看起来就是这么简单。 在ActiveMQ有发布包中有很多各种各样的JMS例子供用户参考。</para>
         <warning>
             <para>请注意,JMS的连接(connection)、会话(session)、生产者(producer)和消费者(consumer)
                   对象是可以<emphasis>重用</emphasis>的。</para>
@@ -220,19 +220,19 @@ System.out.println("Got order: " + receivedMessage.getText());
         <para>尽管采用JNDI对 JMS 的各种<emphasis>管理对象(Administered
                 Objects)</emphasis> (即JMS Queue, Topic and ConnectionFactory)是很常用的方法,但在有些
             情况时JNDI不可用,或者你不需要用JNDI时,如何还能正常使用JMS呢?</para>
-        <para>HornetQ允许你不通过JNDI也能使用JMS。HornetQ支持直接创建JMS的各种对象而无需JNDI的存在。</para>
+        <para>ActiveMQ允许你不通过JNDI也能使用JMS。ActiveMQ支持直接创建JMS的各种对象而无需JNDI的存在。</para>
         <para>在<xref linkend="examples"/>中包括有这样的例子供读者参考。</para>
         <para>下面我们就将上述那个简单的例子重写,以抛开对JNDI的依赖:</para>
-        <para>我们通过HornetQJMSClient类来方便地创建JMS的ConnectionFactory。注意这里要提供各种连接参数和定义
+        <para>我们通过ActiveMQJMSClient类来方便地创建JMS的ConnectionFactory。注意这里要提供各种连接参数和定义
               所用的传输方式。有关连接器(connector)的信息参见<xref linkend="configuring-transports"
             />。</para>
         <programlisting>              
 TransportConfiguration transportConfiguration = 
                      new TransportConfiguration(NettyConnectorFactory.class.getName());                
-ConnectionFactory cf = HornetQJMSClient.createConnectionFactory(transportConfiguration);
+ConnectionFactory cf = ActiveMQJMSClient.createConnectionFactory(transportConfiguration);
         </programlisting>
-        <para>同样利用HornetQJMSClient类创建JMS Queue对象:</para>
-        <programlisting>Queue orderQueue = HornetQJMSClient.createQueue("OrderQueue");</programlisting>
+        <para>同样利用ActiveMQJMSClient类创建JMS Queue对象:</para>
+        <programlisting>Queue orderQueue = ActiveMQJMSClient.createQueue("OrderQueue");</programlisting>
         <para>然后用连接工厂创建 JMS 连接:</para>
         <programlisting>Connection connection = cf.createConnection();</programlisting>
         <para>还有非事务的\AUTO_ACKNOWLEDGE方式的 JMS 会话(session):</para>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/docs/user-manual/zh/using-server.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/using-server.xml b/docs/user-manual/zh/using-server.xml
index 1f10a26..01835f6 100644
--- a/docs/user-manual/zh/using-server.xml
+++ b/docs/user-manual/zh/using-server.xml
@@ -17,21 +17,21 @@
 <!-- permitted by applicable law.                                                  -->
 <!-- ============================================================================= -->
 <chapter id="using-server">
-    <title>使用HornetQ服务</title>
-    <para>本章将介绍如何使用HornetQ服务。</para>
-    <para>其中的内容包括服务器的位置,如何启动和停止HornetQ服务器。本章还将解释HornetQ的目录结构,其中的文件及其用途。</para>
-    <para>本章中所提到的HornetQ服务器是指HornetQ默认配置的独立服务器,包含JMS服务和JNDI服务。</para>
-    <para>对于运行于JBoss应用服务器中的HornetQ,其基本结构是一样的,只是有一些小的差别。</para>
+    <title>使用ActiveMQ服务</title>
+    <para>本章将介绍如何使用ActiveMQ服务。</para>
+    <para>其中的内容包括服务器的位置,如何启动和停止ActiveMQ服务器。本章还将解释ActiveMQ的目录结构,其中的文件及其用途。</para>
+    <para>本章中所提到的ActiveMQ服务器是指ActiveMQ默认配置的独立服务器,包含JMS服务和JNDI服务。</para>
+    <para>对于运行于JBoss应用服务器中的ActiveMQ,其基本结构是一样的,只是有一些小的差别。</para>
     <section>
         <title>服务的启动和停止</title>
-        <para>在HornetQ的安装目录下<literal>bin</literal>子目录中包含有一个unit/linux脚本run.sh和对应的Windows批处理文件run.bat。</para>
+        <para>在ActiveMQ的安装目录下<literal>bin</literal>子目录中包含有一个unit/linux脚本run.sh和对应的Windows批处理文件run.bat。</para>
         <para>如果你是在Unix/Linux环境,在bin目录下运行<literal>./run.sh</literal>。</para>
         <para>如果是在Windows环境,则在bin目录下运行 <literal>run.bat</literal>。</para>
         <para>这个脚本文件会设置classpath以及各种JVM参数,并启动JBoss Microcontainer。JBoss Microcontainer是一个轻量级的容器。
-              它被用来部署HornetQ的POJO对象。</para>
+              它被用来部署ActiveMQ的POJO对象。</para>
         <para>要停止服务,运行其中的相应脚本:在Unix/Linux环境下,运行 <literal>stop.sh</literal>。
               在Windows环境,运行 <literal>run.bat</literal>。</para>
-        <para>注意HornetQ需要在Java 6及以上版本才能正常运行。</para>
+        <para>注意ActiveMQ需要在Java 6及以上版本才能正常运行。</para>
         <para>启动和停止脚本在默认条件下读取<literal>config/stand-alone/non-clustered</literal>目录下的配置文件。
               如果要指向其他目录,可以在命令行实现,例如: <literal>./run.sh ../config/stand-alone/clustered</literal>。
               这一方法同样适用于Windows批处理文件。</para>
@@ -41,14 +41,14 @@
         <para>在启动脚本<literal>run.sh</literal>和<literal>run.bat</literal>中设置了一些JVM参数,
               这些参数主要是调整Java 6的运行环境及拉圾回收的策略。我们建议采用并行拉圾回收的方法。
               这种方法可以将拉圾回收所造成的延时进行平均分配,有效减少由于拉圾回收引起的长时间暂停的情况。</para>
-        <para>默认条件下HornetQ需要最大1GB的内存空间。通过<literal>-Xms</literal>和<literal>-Xmx</literal>可以调整Java程序内存的使用。</para>
+        <para>默认条件下ActiveMQ需要最大1GB的内存空间。通过<literal>-Xms</literal>和<literal>-Xmx</literal>可以调整Java程序内存的使用。</para>
         <para>你可以向启动脚本中添加其它的参数或修改已有的参数,已满足你的需要。</para>
     </section>
     <section>
         <title>服务器端的classpath</title>
-        <para>HornetQ在其classpath中寻找配置文件。</para>
-        <para>classpath被定义在<literal>run.sh</literal>和<literal>run.bat</literal>脚本中。在HornetQ的发布中,启动脚本将非集群的配置文件目录加进了classpath中。该目录包括了一组配置文件,可以让HornetQ以基本的非集群方式运行。它的具体位置是在HornetQ发布根目录下 config/stand-along/non-clustered/ 子目录。</para>
-        <para>在HornetQ的发布包中包括了一组标准的配置目录,它们是:</para>
+        <para>ActiveMQ在其classpath中寻找配置文件。</para>
+        <para>classpath被定义在<literal>run.sh</literal>和<literal>run.bat</literal>脚本中。在ActiveMQ的发布中,启动脚本将非集群的配置文件目录加进了classpath中。该目录包括了一组配置文件,可以让ActiveMQ以基本的非集群方式运行。它的具体位置是在ActiveMQ发布根目录下 config/stand-along/non-clustered/ 子目录。</para>
+        <para>在ActiveMQ的发布包中包括了一组标准的配置目录,它们是:</para>
         <itemizedlist>
             <listitem>
                 <para>非集群方式的独立服务器配置</para>
@@ -63,7 +63,7 @@
                 <para>集群方式运行于JBoss应用服务器</para>
             </listitem>
         </itemizedlist>
-        <para>当然你可以创建自己定义的配置文件目录。要注意的是将你的目录加到classpath中以便HornetQ能正确找到并加载。</para>
+        <para>当然你可以创建自己定义的配置文件目录。要注意的是将你的目录加到classpath中以便ActiveMQ能正确找到并加载。</para>
     </section>
     <section id="using-server.library.path">
         <title>Library Path</title>
@@ -73,7 +73,7 @@
     </section>
     <section>
         <title>系统变量</title>
-        <para>HornetQ命令行可以接受系统变量来配置日志(logging)。有关logging配置的具体信息参见<xref linkend="logging"/>。</para>
+        <para>ActiveMQ命令行可以接受系统变量来配置日志(logging)。有关logging配置的具体信息参见<xref linkend="logging"/>。</para>
     </section>
     <section id="using-server.configuration">
         <title>配置文件</title>
@@ -81,27 +81,27 @@
         <itemizedlist>
             <listitem>
                 <para><literal>hornetq-beans.xml</literal> (如果是运行在JBoss应用服务器内,则为 <literal
-                        >hornetq-jboss-beans.xml</literal>)。这是JBoss Microcontainer的bean配置文件。其中定义了HornetQ的
-                    各种bean,以及它们之间的依赖关系。HornetQ的bean都是一些POJO。是JBoss Microcontainer保证了这些bean的正确装载和运行。</para>
+                        >hornetq-jboss-beans.xml</literal>)。这是JBoss Microcontainer的bean配置文件。其中定义了ActiveMQ的
+                    各种bean,以及它们之间的依赖关系。ActiveMQ的bean都是一些POJO。是JBoss Microcontainer保证了这些bean的正确装载和运行。</para>
             </listitem>
             <listitem>
-                <para><literal>activemq-configuration.xml</literal>。这个是HornetQ的主要的配置文件。
+                <para><literal>activemq-configuration.xml</literal>。这个是ActiveMQ的主要的配置文件。
                     其中的所有参数在<xref linkend="configuration-index"/>中给出了解释. 在 <xref
                         linkend="usingserver.mainconfig"/> 也有更多的相关信息。</para>
             </listitem>
             <listitem>
                 <para><literal>activemq-queues.xml</literal>。这个文件里包含了预定义的queue以及它们的配置,包括安全设置。
                     这是一个可选的文件,里面所有的内容都可以放在 <literal>activemq-configuration.xml</literal>文件中。
-                    在默认的配置文件目录下并没有这个文件。HornetQ之所以提供这个文件是为了用户便于管理他们的queue。在classpath中
+                    在默认的配置文件目录下并没有这个文件。ActiveMQ之所以提供这个文件是为了用户便于管理他们的queue。在classpath中
                     允许包含多个 <literal>activemq-queues.xml</literal> 文件。所有的这些文件都会被加载。</para>
             </listitem>
             <listitem>
-                <para><literal>activemq-users.xml</literal>。用户信息文件。HornetQ本身实现了一个基本的
+                <para><literal>activemq-users.xml</literal>。用户信息文件。ActiveMQ本身实现了一个基本的
                     安全管理器(security manager),它从这个文件内读取用户的安全信息,如用户名,密码和角色。
                     想了解更多关于安全的信息,参见 <xref linkend="security"/>。</para>
             </listitem>
             <listitem>
-                <para><literal>hornetq-jms.xml</literal>。这个文件包含有JMS对象。HornetQ的默认配置中包含有JMS服务,
+                <para><literal>hornetq-jms.xml</literal>。这个文件包含有JMS对象。ActiveMQ的默认配置中包含有JMS服务,
                     它从这个文件中读取JMS Queue,Topic和ConnectionFactory并将它们部署到JNDI服务中。如果你不使用JMS,
                     或者你不需要部署这些JMS对象,那么你就不需要这个文件。有关JMS的使用详见<xref linkend="using-jms"
                     />。</para>
@@ -116,7 +116,7 @@
         </itemizedlist>
         <note>
             <para>如果在<literal>activemq-configuration.xml</literal>文件中将<literal>file-deployment-enabled</literal> 参数
-                  定义为false,则HornetQ将不会加载其它的配置文件。这个参数的默认值是true。</para>
+                  定义为false,则ActiveMQ将不会加载其它的配置文件。这个参数的默认值是true。</para>
         </note>
         <para>所有配置文件中的参数都可以用系统变量来定义其值。以下用一个connector的配置来说明:</para>
         <programlisting>&lt;connector name="netty">
@@ -133,13 +133,13 @@
     </section>
     <section id="server.microcontainer.configuration">
         <title>JBoss Microcontainer Beans 文件</title>
-        <para>HornetQ的POJO对象是由<ulink url="http://www.jboss.org/jbossmc/"> JBoss Microcontainer
+        <para>ActiveMQ的POJO对象是由<ulink url="http://www.jboss.org/jbossmc/"> JBoss Microcontainer
             </ulink>进行加载和运行的。JBoss Microcontainer是一个轻量级的加载工具。</para>
         <note>
-            <para>如果是在JBoss应用服务器内运行,HornetQ同样需要一个bean的配置文件来将其部署到JBoss中。但是这与单独运行时的配置文件略有不同。
-                这是因为应用服务器内已经部署了一些服务,如安全服务等。所以在HornetQ中这些服务就不需要再部署了。</para>
+            <para>如果是在JBoss应用服务器内运行,ActiveMQ同样需要一个bean的配置文件来将其部署到JBoss中。但是这与单独运行时的配置文件略有不同。
+                这是因为应用服务器内已经部署了一些服务,如安全服务等。所以在ActiveMQ中这些服务就不需要再部署了。</para>
         </note>
-        <para>让我们看一个HornetQ作为单独服务器时的一个配置文件例子:</para>
+        <para>让我们看一个ActiveMQ作为单独服务器时的一个配置文件例子:</para>
         <para>
             <programlisting>&lt;?xml version="1.0" encoding="UTF-8"?&gt;
 
@@ -169,14 +169,14 @@
 &lt;/bean&gt;
 
 &lt;!-- The security manager --&gt;
-&lt;bean name="HornetQSecurityManager" 
-      class="org.apache.activemq.spi.core.security.HornetQSecurityManagerImpl"&gt;
+&lt;bean name="ActiveMQSecurityManager" 
+      class="org.apache.activemq.spi.core.security.ActiveMQSecurityManagerImpl"&gt;
    &lt;start ignored="true"/&gt;
    &lt;stop ignored="true"/&gt;
 &lt;/bean&gt;
 
 &lt;!-- The core server --&gt;
-&lt;bean name="HornetQServer" class="org.apache.activemq.core.server.impl.HornetQServerImpl"&gt;
+&lt;bean name="ActiveMQServer" class="org.apache.activemq.core.server.impl.ActiveMQServerImpl"&gt;
    &lt;start ignored="true"/&gt;
    &lt;stop ignored="true"/&gt;  
    &lt;constructor&gt;
@@ -187,7 +187,7 @@
          &lt;inject bean="MBeanServer"/&gt;
       &lt;/parameter&gt;
       &lt;parameter&gt;
-         &lt;inject bean="HornetQSecurityManager"/&gt;
+         &lt;inject bean="ActiveMQSecurityManager"/&gt;
       &lt;/parameter&gt;        
    &lt;/constructor&gt;         
 &lt;/bean&gt;
@@ -197,14 +197,14 @@
       class="org.apache.activemq.jms.server.impl.JMSServerManagerImpl"&gt;
    &lt;constructor&gt;         
       &lt;parameter&gt;
-         &lt;inject bean="HornetQServer"/&gt;
+         &lt;inject bean="ActiveMQServer"/&gt;
       &lt;/parameter&gt;         
    &lt;/constructor&gt;
 &lt;/bean&gt;
 
 &lt;/deployment&gt;</programlisting>
         </para>
-        <para>我们从上可以看出HornetQ的单独服务器(以及核心服务器)包括了一些POJO对象:</para>
+        <para>我们从上可以看出ActiveMQ的单独服务器(以及核心服务器)包括了一些POJO对象:</para>
         <itemizedlist>
             <listitem>
                 <para>JNDIServer</para>
@@ -218,17 +218,17 @@
             </listitem>
             <listitem>
                 <para>Configuration</para>
-                <para>这是HornetQ的Configuration对象。默认时它是一个FileConfiguration对象。它可以从文件系统中读取
-                    配置信息。有些情况下(如嵌入式HornetQ)你可以将它定义为其它对象,以便用其它方法获得配置信息。</para>
+                <para>这是ActiveMQ的Configuration对象。默认时它是一个FileConfiguration对象。它可以从文件系统中读取
+                    配置信息。有些情况下(如嵌入式ActiveMQ)你可以将它定义为其它对象,以便用其它方法获得配置信息。</para>
             </listitem>
             <listitem>
                 <para>Security Manager. 可配置的安全管理器。默认的安全管理器使用 <literal>activemq-users.xml</literal> 文件中的配置信息。
-                    它也可以配置为一个JAAS的安全管理器。当HornetQ运行于JBoss应用服务器中时,它还可以配置为JBoss的安全管理器,以达到更紧密的集成。
+                    它也可以配置为一个JAAS的安全管理器。当ActiveMQ运行于JBoss应用服务器中时,它还可以配置为JBoss的安全管理器,以达到更紧密的集成。
                     如果不需要安全管理,你也可以将它删除。</para>
             </listitem>
             <listitem>
-                <para>HornetQServer</para>
-                <para>这是HornetQ的核心服务对象,几乎所有的核心功能都在这里。</para>
+                <para>ActiveMQServer</para>
+                <para>这是ActiveMQ的核心服务对象,几乎所有的核心功能都在这里。</para>
             </listitem>
             <listitem id="bean-jmsservermanager">
                 <para>JMSServerManager</para>
@@ -241,45 +241,45 @@
     <section id="server.microkernel.configuration">
         <title>JBoss AS4 MBean 服务</title>
         <note>
-            <para>本节只讨论在JBoss AS 4上配置HornetQ。其与JBoss Microcontainer的配置很相似。</para>
+            <para>本节只讨论在JBoss AS 4上配置ActiveMQ。其与JBoss Microcontainer的配置很相似。</para>
         </note>
         <para>
             <programlisting>&lt;?xml version="1.0" encoding="UTF-8"?&gt;
 &lt;server&gt;
 
-   &lt;mbean code="org.apache.activemq.service.HornetQFileConfigurationService"
-      name="org.apache.activemq:service=HornetQFileConfigurationService"&gt;
+   &lt;mbean code="org.apache.activemq.service.ActiveMQFileConfigurationService"
+      name="org.apache.activemq:service=ActiveMQFileConfigurationService"&gt;
    &lt;/mbean&gt;
 
    &lt;mbean code="org.apache.activemq.service.JBossASSecurityManagerService"
       name="org.apache.activemq:service=JBossASSecurityManagerService"&gt;
    &lt;/mbean&gt;
 
-   &lt;mbean code="org.apache.activemq.service.HornetQStarterService"
-      name="org.apache.activemq:service=HornetQStarterService"&gt;
+   &lt;mbean code="org.apache.activemq.service.ActiveMQStarterService"
+      name="org.apache.activemq:service=ActiveMQStarterService"&gt;
       &lt;!--let's let the JMS Server start us--&gt;
          &lt;attribute name="Start"&gt;false&lt;/attribute&gt;
 
       &lt;depends optional-attribute-name="SecurityManagerService"
          proxy-type="attribute"&gt;org.apache.activemq:service=JBossASSecurityManagerService&lt;/depends&gt;
       &lt;depends optional-attribute-name="ConfigurationService"
-         proxy-type="attribute"&gt;org.apache.activemq:service=HornetQFileConfigurationService&lt;/depends&gt;
+         proxy-type="attribute"&gt;org.apache.activemq:service=ActiveMQFileConfigurationService&lt;/depends&gt;
    &lt;/mbean&gt;
 
-   &lt;mbean code="org.apache.activemq.service.HornetQJMSStarterService"
-      name="org.apache.activemq:service=HornetQJMSStarterService"&gt;
-      &lt;depends optional-attribute-name="HornetQServer"
-         proxy-type="attribute"&gt;org.apache.activemq:service=HornetQStarterService&lt;/depends&gt;
+   &lt;mbean code="org.apache.activemq.service.ActiveMQJMSStarterService"
+      name="org.apache.activemq:service=ActiveMQJMSStarterService"&gt;
+      &lt;depends optional-attribute-name="ActiveMQServer"
+         proxy-type="attribute"&gt;org.apache.activemq:service=ActiveMQStarterService&lt;/depends&gt;
    &lt;/mbean&gt;
    
 &lt;/server&gt;
             </programlisting>
         </para>
-        <para>这个jboss-service.xml包含在hornetq-service.sar文件中,它用来配置AS4中嵌入运行的HornetQ。
+        <para>这个jboss-service.xml包含在hornetq-service.sar文件中,它用来配置AS4中嵌入运行的ActiveMQ。
               在这个配置文件中我们启动了以下几个服务:</para>
         <itemizedlist>
             <listitem>
-                <para>HornetQFileConfigurationService</para>
+                <para>ActiveMQFileConfigurationService</para>
                 <para>这个MBean服务的任务是管理 <literal>FileConfiguration POJO</literal>的生命周期。</para>
             </listitem>
             <listitem>
@@ -287,12 +287,12 @@
                 <para>这个MBean服务管理着 <literal>JBossASSecurityManager</literal> POJO的生命周期。</para>
             </listitem>
             <listitem>
-                <para>HornetQStarterService</para>
-                <para>这个MBean服务管理着<literal>HornetQServer</literal> POJO。它依赖于 JBossASSecurityManagerService 和
-                      HornetQFileConfigurationService 这两个MBean。</para>
+                <para>ActiveMQStarterService</para>
+                <para>这个MBean服务管理着<literal>ActiveMQServer</literal> POJO。它依赖于 JBossASSecurityManagerService 和
+                      ActiveMQFileConfigurationService 这两个MBean。</para>
             </listitem>
             <listitem>
-                <para>HornetQJMSStarterService</para>
+                <para>ActiveMQJMSStarterService</para>
                 <para>这个MBean服务管理着 <literal>JMSServerManagerImpl</literal> POJO对象。如果不需要JMS,可以去掉这个服务。</para>
             </listitem>
             <listitem>
@@ -303,9 +303,9 @@
     </section>
     <section id="usingserver.mainconfig">
         <title>主配置文件</title>
-        <para>HornetQ 核心服务的配置保存在 <literal>activemq-configuration.xml</literal>文件中。
+        <para>ActiveMQ 核心服务的配置保存在 <literal>activemq-configuration.xml</literal>文件中。
          FileConfiguration bean 读取这个文件来对消息服务器进行配置。</para>
-        <para>HornetQ有很多的配置参数。采用默认的配置在绝大多数情况下可以很好的运行。事实上每一个参数都有默认的处理,因此一个只包含有一个空
+        <para>ActiveMQ有很多的配置参数。采用默认的配置在绝大多数情况下可以很好的运行。事实上每一个参数都有默认的处理,因此一个只包含有一个空
               的<literal>configuration</literal>的配置文件是一个有效的文件。对各个参数的解释贯穿于本手册。你还可参参照
                <link linkend="configuration-index">这里</link>来查找你想看的参数。</para>
     </section>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/docs/user-manual/zh/wildcard-routing.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/wildcard-routing.xml b/docs/user-manual/zh/wildcard-routing.xml
index 4e3b4be..91868fe 100644
--- a/docs/user-manual/zh/wildcard-routing.xml
+++ b/docs/user-manual/zh/wildcard-routing.xml
@@ -20,7 +20,7 @@
 
 <chapter id="wildcard-routing">
     <title>使用通配符实现消息路由</title>
-    <para>HornetQ支持使用带通配符的地址对消息路由。</para>
+    <para>ActiveMQ支持使用带通配符的地址对消息路由。</para>
     <para>例如,当创建一个队列时使用了地址<literal>queue.news.#</literal>,那么它就能接收
           所有和这个地址通配符相配的每一个地址的消息。这样的地址如 <literal
             >queue.news.europe</literal> 或 <literal>queue.news.usa</literal> 或 <literal

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/docs/user-manual/zh/wildcard-syntax.xml
----------------------------------------------------------------------
diff --git a/docs/user-manual/zh/wildcard-syntax.xml b/docs/user-manual/zh/wildcard-syntax.xml
index e527d7a..4d6feb4 100644
--- a/docs/user-manual/zh/wildcard-syntax.xml
+++ b/docs/user-manual/zh/wildcard-syntax.xml
@@ -19,10 +19,10 @@
 <!-- ============================================================================= -->
 
 <chapter id="wildcard-syntax">
-    <title>了解 HornetQ 通配符的语法</title>
-    <para>HornetQ使用了一种专门的通配符语法来配置安全、地址及接收者(consumer)的创建。</para>
+    <title>了解 ActiveMQ 通配符的语法</title>
+    <para>ActiveMQ使用了一种专门的通配符语法来配置安全、地址及接收者(consumer)的创建。</para>
     <para>这种语法与 <ulink url="http://www.amqp.org">AMQP</ulink>所用的语法相似。</para>
-    <para>一个HornetQ的通配符表达式是由一些由“<literal
+    <para>一个ActiveMQ的通配符表达式是由一些由“<literal
             >.</literal>”分隔的单词组成。</para>
     <para>特殊字符“<literal>#</literal>”和“<literal>*</literal>”在表达式中可作为一个单词,它们代表
         特殊的意义。</para>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/etc/IDEA-style.jar
----------------------------------------------------------------------
diff --git a/etc/IDEA-style.jar b/etc/IDEA-style.jar
index 06e3baa..037a886 100644
Binary files a/etc/IDEA-style.jar and b/etc/IDEA-style.jar differ

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/etc/findbugs-exclude.xml
----------------------------------------------------------------------
diff --git a/etc/findbugs-exclude.xml b/etc/findbugs-exclude.xml
index 6170bed..fb559ef 100644
--- a/etc/findbugs-exclude.xml
+++ b/etc/findbugs-exclude.xml
@@ -37,7 +37,7 @@
 
   <!-- Comparison is correct within its context -->
   <Match>
-    <Class name="org.apache.activemq.ra.HornetQRaUtils"/>
+    <Class name="org.apache.activemq.ra.ActiveMQRaUtils"/>
     <Or>
       <Method name="compare" params="java.lang.Integer,java.lang.Integer" returns="boolean"/>
       <Method name="compare" params="java.lang.Long,java.lang.Long" returns="boolean"/>
@@ -115,7 +115,7 @@
 
   <Match>
     <!-- Files generated by JBoss Logging are ignored -->
-    <Class name="~org\.hornetq\..*\.HornetQ.*(Logger_\$logger|Bundle_\$bundle)"/>
+    <Class name="~org\.hornetq\..*\.ActiveMQ.*(Logger_\$logger|Bundle_\$bundle)"/>
   </Match>
 
   <!-- Ignore checks on return values, example File.delete(), on samples/examples -->
@@ -130,7 +130,7 @@
   </Match>
 
   <Match>
-    <Class name="org.apache.activemq.core.server.impl.HornetQServerImpl$SharedNothingLiveActivation"/>
+    <Class name="org.apache.activemq.core.server.impl.ActiveMQServerImpl$SharedNothingLiveActivation"/>
     <Method name="isNodeIdUsed"/>
     <Bug pattern="RV_RETURN_VALUE_IGNORED"/>
   </Match>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/etc/org.eclipse.jdt.ui.prefs
----------------------------------------------------------------------
diff --git a/etc/org.eclipse.jdt.ui.prefs b/etc/org.eclipse.jdt.ui.prefs
index f68cb8d..4b2bd25 100644
--- a/etc/org.eclipse.jdt.ui.prefs
+++ b/etc/org.eclipse.jdt.ui.prefs
@@ -49,11 +49,11 @@ cleanup.use_this_for_non_static_field_access=true
 cleanup.use_this_for_non_static_field_access_only_if_necessary=true
 cleanup.use_this_for_non_static_method_access=true
 cleanup.use_this_for_non_static_method_access_only_if_necessary=true
-cleanup_profile=_HornetQ profile
+cleanup_profile=_ActiveMQ profile
 cleanup_settings_version=2
 eclipse.preferences.version=1
 editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
-formatter_profile=_'HornetQ'
+formatter_profile=_'ActiveMQ'
 formatter_settings_version=12
 org.eclipse.jdt.ui.exception.name=e
 org.eclipse.jdt.ui.gettersetter.use.is=true

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/examples/core/embedded-remote/readme.html
----------------------------------------------------------------------
diff --git a/examples/core/embedded-remote/readme.html b/examples/core/embedded-remote/readme.html
index ad25345..5dc0bdb 100644
--- a/examples/core/embedded-remote/readme.html
+++ b/examples/core/embedded-remote/readme.html
@@ -1,21 +1,21 @@
 <html>
   <head>
-    <title>HornetQ Embedded Example</title>
+    <title>ActiveMQ Embedded Example</title>
     <link rel="stylesheet" type="text/css" href="../../common/common.css" />
     <link rel="stylesheet" type="text/css" href="../../common/prettify.css" />
     <script type="text/javascript" src="../../common/prettify.js"></script>
   </head>
   <body onload="prettyPrint()">
      <h1>Embedded Example</h1>
-     <p>This example shows how to setup and run HornetQ embedded with remote clients connecting.</p>
-     <p>HornetQ was designed to use POJOs (Plain Old Java Objects), what makes embedding HornetQ as simple as instantiating a few objects.</p>
+     <p>This example shows how to setup and run ActiveMQ embedded with remote clients connecting.</p>
+     <p>ActiveMQ was designed to use POJOs (Plain Old Java Objects), what makes embedding ActiveMQ as simple as instantiating a few objects.</p>
 
-     <p>HornetQ Embedded could be used from very simple use cases with only InVM support to very complex cases with clustering, persistence and fail over.</p>
+     <p>ActiveMQ Embedded could be used from very simple use cases with only InVM support to very complex cases with clustering, persistence and fail over.</p>
 
 
      <h2>Example step-by-step</h2>     
      <p><i>To run the example, simply type <code>mvn -Pserver</code> from this directory to start the server and <code>mvn -Pclient</code> to run the client example</i></p>
-     <p>In this we don't use any configuration files. (Everything is embedded). We simply instantiate ConfigurationImpl, HornetQServer, start it and operate on JMS regularly</p>
+     <p>In this we don't use any configuration files. (Everything is embedded). We simply instantiate ConfigurationImpl, ActiveMQServer, start it and operate on JMS regularly</p>
      <br/>
      <ol>
         <li>On EmbeddedServer: Create the Configuration, and set the properties accordingly</li>
@@ -27,13 +27,13 @@
          
         <li>On EmbeddedServer: Create and start the server</li>
         <pre class="prettyprint">
-           HornetQServer server = HornetQ.newHornetQServer(configuration);
+           ActiveMQServer server = ActiveMQ.newActiveMQServer(configuration);
            server.start();
         </pre>
 
         <li>As we are not using a JNDI environment we instantiate the objects directly</li>
         <pre class="prettyprint">
-           ServerLocator serverLocator = HornetQClient.createServerLocatorWithoutHA(new TransportConfiguration(NettyConnectorFactory.class.getName()));
+           ServerLocator serverLocator = ActiveMQClient.createServerLocatorWithoutHA(new TransportConfiguration(NettyConnectorFactory.class.getName()));
            ClientSessionFactory sf = serverLocator.createSessionFactory();
         </pre>
 

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/examples/core/embedded/readme.html
----------------------------------------------------------------------
diff --git a/examples/core/embedded/readme.html b/examples/core/embedded/readme.html
index ac41734..d003ffb 100644
--- a/examples/core/embedded/readme.html
+++ b/examples/core/embedded/readme.html
@@ -1,6 +1,6 @@
 <html>
   <head>
-    <title>HornetQ Embedded Example</title>
+    <title>ActiveMQ Embedded Example</title>
     <link rel="stylesheet" type="text/css" href="../../common/common.css" />
     <link rel="stylesheet" type="text/css" href="../../common/prettify.css" />
     <script type="text/javascript" src="../../common/prettify.js"></script>
@@ -8,19 +8,19 @@
   <body onload="prettyPrint()">
      <h1>Embedded Example</h1>
 
-     <p>This example shows how to setup and run HornetQ embedded.</p>
-     <p>HornetQ was designed to use POJOs (Plain Old Java Objects), what makes embedding HornetQ as simple as instantiating a few objects.</p>
+     <p>This example shows how to setup and run ActiveMQ embedded.</p>
+     <p>ActiveMQ was designed to use POJOs (Plain Old Java Objects), what makes embedding ActiveMQ as simple as instantiating a few objects.</p>
      <p>In this example, we are using two jars:</p>
      <ul>
         <li>hornetq-server.jar</li>
         <li>netty.jar</li>
      </ul>
      
-     <p>HornetQ Embedded could be used from very simple use cases with only InVM support to very complex cases with clustering, persistence and fail over.</p>
+     <p>ActiveMQ Embedded could be used from very simple use cases with only InVM support to very complex cases with clustering, persistence and fail over.</p>
 
      <h2>Example step-by-step</h2>     
      <p><i>To run the example, simply type <code>mvn -Pexample</code> from this directory</i></p>
-     <p>In this we don't use any configuration files. (Everything is embedded). We simply instantiate ConfigurationImpl, HornetQServer, start it and operate on JMS regularly</p>
+     <p>In this we don't use any configuration files. (Everything is embedded). We simply instantiate ConfigurationImpl, ActiveMQServer, start it and operate on JMS regularly</p>
 
      <ol>
         <li>Create the Configuration, and set the properties accordingly</li>
@@ -33,13 +33,13 @@
          
         <li>Create and start the server</li>
         <pre class="prettyprint">
-           HornetQServer server = HornetQ.newHornetQServer(configuration);
+           ActiveMQServer server = ActiveMQ.newActiveMQServer(configuration);
            server.start();
         </pre>
 
         <li>As we are not using a JNDI environment we instantiate the objects directly</li>
         <pre class="prettyprint">
-           ServerLocator serverLocator = HornetQClient.createServerLocatorWithoutHA(new TransportConfiguration(InVMConnectorFactory.class.getName()));
+           ServerLocator serverLocator = ActiveMQClient.createServerLocatorWithoutHA(new TransportConfiguration(InVMConnectorFactory.class.getName()));
            ClientSessionFactory sf = serverLocator.createSessionFactory();
         </pre>
 

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/examples/core/twitter-connector/readme.html
----------------------------------------------------------------------
diff --git a/examples/core/twitter-connector/readme.html b/examples/core/twitter-connector/readme.html
index 936c411..bfd8c3f 100644
--- a/examples/core/twitter-connector/readme.html
+++ b/examples/core/twitter-connector/readme.html
@@ -1,6 +1,6 @@
 <html>
   <head>
-    <title>HornetQ Twitter Connector Service Example</title>
+    <title>ActiveMQ Twitter Connector Service Example</title>
     <link rel="stylesheet" type="text/css" href="../../common/common.css" />
     <link rel="stylesheet" type="text/css" href="../../common/prettify.css" />
     <script type="text/javascript" src="../../common/prettify.js"></script>
@@ -8,9 +8,9 @@
   <body onload="prettyPrint()">
      <h1>Twitter Connector Service Example</h1>
 
-     <p>This example shows you how to configure HornetQ to use the Twitter Connector Service.</p>
+     <p>This example shows you how to configure ActiveMQ to use the Twitter Connector Service.</p>
      
-     <p>HornetQ supports 2 types of Twitter connector, incoming and outgoing.
+     <p>ActiveMQ supports 2 types of Twitter connector, incoming and outgoing.
      Incoming connector consumes from twitter and forwards to a configurable address.
      Outgoing connector consumes from a configurable address and forwards to twitter.
      </p>
@@ -28,7 +28,7 @@
      <ol>
         <li>First we need to create a ClientSessionFactory with Netty transport configuration</li>
         <pre class="prettyprint">
-           <code>csf = HornetQClient.createClientSessionFactory(new TransportConfiguration(NettyConnectorFactory.class.getName()));</code>
+           <code>csf = ActiveMQClient.createClientSessionFactory(new TransportConfiguration(NettyConnectorFactory.class.getName()));</code>
         </pre>
 
         <li>We create a core session with auto-commit mode</li>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/examples/core/vertx-connector/readme.html
----------------------------------------------------------------------
diff --git a/examples/core/vertx-connector/readme.html b/examples/core/vertx-connector/readme.html
index ed37cfc..e8e61fa 100644
--- a/examples/core/vertx-connector/readme.html
+++ b/examples/core/vertx-connector/readme.html
@@ -1,6 +1,6 @@
 <html>
   <head>
-    <title>HornetQ Vert.x Connector Service Example</title>
+    <title>ActiveMQ Vert.x Connector Service Example</title>
     <link rel="stylesheet" type="text/css" href="../../common/common.css" />
     <link rel="stylesheet" type="text/css" href="../../common/prettify.css" />
     <script type="text/javascript" src="../../common/prettify.js"></script>
@@ -8,9 +8,9 @@
   <body onload="prettyPrint()">
      <h1>Vert.x Connector Service Example</h1>
 
-     <p>This example shows you how to configure HornetQ to use the Vert.x Connector Service.</p>
+     <p>This example shows you how to configure ActiveMQ to use the Vert.x Connector Service.</p>
      
-     <p>HornetQ supports 2 types of Vert.x connector, incoming and outgoing.
+     <p>ActiveMQ supports 2 types of Vert.x connector, incoming and outgoing.
      Incoming connector consumes from Vert.x event bus and forwards to a configurable address.
      Outgoing connector consumes from a configurable address and forwards to a configurable Vert.x event bus.
      </p>
@@ -18,8 +18,8 @@
      <p>In this example, an incoming connector and an outgoing connector are configured. A simple java Verticle
      is deployed. The verticle registers a message handler on the outgoing connector's address ("outgoing.vertx.address").
      A String message is sent to Vert.x event bus on the incoming connector's address("incoming.vertx.address"). 
-     The message then will be forwarded to a HornetQ queue by the incoming connector. The outgoing connector listens to 
-     the HornetQ queue and forwards the message from HornetQ to Vert.x event bus on the outgoing connector's address.
+     The message then will be forwarded to a ActiveMQ queue by the incoming connector. The outgoing connector listens to 
+     the ActiveMQ queue and forwards the message from ActiveMQ to Vert.x event bus on the outgoing connector's address.
      The verticle finally receives the message from it's event bus.</p>
      
      <p>For more information on Vert.x concept please visit the <a href="http://vertx.io/">Vertx site</a></p>

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/4a6b980f/examples/javaee/ejb-jms-transaction/readme.html
----------------------------------------------------------------------
diff --git a/examples/javaee/ejb-jms-transaction/readme.html b/examples/javaee/ejb-jms-transaction/readme.html
index 57ce0e8..7c950ce 100644
--- a/examples/javaee/ejb-jms-transaction/readme.html
+++ b/examples/javaee/ejb-jms-transaction/readme.html
@@ -1,6 +1,6 @@
 <html>
   <head>
-    <title>HornetQ EJB/JMS Transaction Example</title>
+    <title>ActiveMQ EJB/JMS Transaction Example</title>
     <link rel="stylesheet" type="text/css" href="../../common/common.css" />
     <link rel="stylesheet" type="text/css" href="../../common/prettify.css" />
     <script type="text/javascript" src="../../common/prettify.js"></script>


Mime
View raw message