原文： https://howtodoinjava.com/hornetq/spring-3-hornetq-standalone-integration-example/

    HornetQ 是一个开放源代码项目，旨在构建多协议，可嵌入，非常高性能的集群异步消息传递系统。 到目前为止，我们已经了解了配置 hornetq 独立服务器和设置基本消息传递功能的示例。 HornetQ 具有很大的灵活性，可以通过一些现有的应用框架进行配置。 在此序列中，我将展示 HornetQ 在 Spring3 中的用法。

    让我们逐步进行所有设置。

    步骤 1）创建一个 Maven 项目并将其转换为 Eclipse Java 项目。

    步骤 2）使用 Spring3 和 hornetq 依赖项更新 maven 仓库。

    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    3.   <modelVersion>4.0.0</modelVersion>
    4.   <groupId>com.howtodoinjava.app</groupId>
    5.   <artifactId>Spring3HornetQStandaloneIntegration</artifactId>
    6.   <packaging>jar</packaging>
    7.   <version>1.0-SNAPSHOT</version>
    8.   <name>Spring3HornetQStandaloneIntegration</name>
    9.   <url>http://maven.apache.org</url>
    10.    <properties>
    11.     <org.springframework.version>3.0.5.RELEASE</org.springframework.version>
    12.   </properties>
    13.   <dependencies>
    15.     <!-- User Application Lib -->
    16.         <dependency>
    17.             <groupId>commons-logging</groupId>
    18.             <artifactId>commons-logging</artifactId>
    19.             <version>1.1.1</version>
    20.         </dependency>
    21.         <dependency>
    22.             <groupId>log4j</groupId>
    23.             <artifactId>log4j</artifactId>
    24.             <version>1.2.14</version>
    25.         </dependency>
    27.         <dependency>
    28.             <groupId>junit</groupId>
    29.             <artifactId>junit</artifactId>
    30.             <version>4.7</version>
    31.             <scope>test</scope>
    32.         </dependency>
    34.         <!-- HornetQ Embedded Server -->
    35.          <dependency>
    36.              <groupId>org.hornetq</groupId>
    37.              <artifactId>hornetq-core</artifactId>
    38.              <version>2.0.0.GA</version>
    39.              <scope>compile</scope>
    40.           </dependency>
    41.           <dependency>
    42.              <groupId>org.hornetq</groupId>
    43.              <artifactId>hornetq-jms</artifactId>
    44.              <version>2.0.0.GA</version>
    45.              <scope>compile</scope>
    46.           </dependency>
    47.           <dependency>
    48.              <groupId>org.hornetq</groupId>
    49.              <artifactId>hornetq-logging</artifactId>
    50.              <version>2.0.0.GA</version>
    51.              <scope>compile</scope>
    52.           </dependency>
    53.           <dependency>
    54.              <groupId>org.hornetq</groupId>
    55.              <artifactId>hornetq-transports</artifactId>
    56.              <version>2.0.0.GA</version>
    57.              <scope>compile</scope>
    58.           </dependency>
    59.           <dependency>
    60.              <groupId>org.jboss.netty</groupId>
    61.              <artifactId>netty</artifactId>
    62.              <version>3.1.0.GA</version>
    63.           </dependency>
    64.           <dependency>
    65.              <groupId>org.jboss.javaee</groupId>
    66.              <artifactId>jboss-jms-api</artifactId>
    67.              <version>1.1.0.GA</version>
    68.              <scope>compile</scope>
    69.           </dependency>
    71.          <dependency>
    72.             <groupId>org.jboss</groupId>
    73.             <artifactId>jboss-common-core</artifactId>
    74.             <version>2.2.10.GA</version>
    75.         </dependency>
    76.         <dependency>
    77.             <groupId>org.jboss.logging</groupId>
    78.             <artifactId>jboss-logging-spi</artifactId>
    79.             <version>2.0.5.GA</version>
    80.         </dependency>
    82.         <!--
    83.         Core utilities used by other modules.
    84.         Define this if you use Spring Utility APIs (org.springframework.core.*/org.springframework.util.*)
    85.     -->
    86.     <dependency>
    87.       <groupId>org.springframework</groupId>
    88.       <artifactId>spring-core</artifactId>
    89.       <version>${org.springframework.version}</version>
    90.     </dependency>
    92.     <!--
    93.         Expression Language (depends on spring-core)
    94.         Define this if you use Spring Expression APIs (org.springframework.expression.*)
    95.     -->
    96.     <dependency>
    97.       <groupId>org.springframework</groupId>
    98.       <artifactId>spring-expression</artifactId>
    99.       <version>${org.springframework.version}</version>
    100.     </dependency>
    102.     <!--
    103.         Bean Factory and JavaBeans utilities (depends on spring-core)
    104.         Define this if you use Spring Bean APIs (org.springframework.beans.*)
    105.     -->
    106.     <dependency>
    107.       <groupId>org.springframework</groupId>
    108.       <artifactId>spring-beans</artifactId>
    109.       <version>${org.springframework.version}</version>
    110.     </dependency>
    112.     <!--
    113.         Aspect Oriented Programming (AOP) Framework (depends on spring-core, spring-beans)
    114.         Define this if you use Spring AOP APIs (org.springframework.aop.*)
    115.     -->
    116.     <dependency>
    117.       <groupId>org.springframework</groupId>
    118.       <artifactId>spring-aop</artifactId>
    119.       <version>${org.springframework.version}</version>
    120.     </dependency>
    122.     <!--
    123.         Application Context (depends on spring-core, spring-expression, spring-aop, spring-beans)
    124.         This is the central artifact for Spring's Dependency Injection Container and is generally always defined
    125.     -->
    126.     <dependency>
    127.       <groupId>org.springframework</groupId>
    128.       <artifactId>spring-context</artifactId>
    129.       <version>${org.springframework.version}</version>
    130.     </dependency>
    132.     <!--
    133.         Various Application Context utilities, including EhCache, JavaMail, Quartz, and Freemarker integration
    134.         Define this if you need any of these integrations
    135.     -->
    136.     <dependency>
    137.       <groupId>org.springframework</groupId>
    138.       <artifactId>spring-context-support</artifactId>
    139.       <version>${org.springframework.version}</version>
    140.     </dependency>
    142.     <!--
    143.         Transaction Management Abstraction (depends on spring-core, spring-beans, spring-aop, spring-context)
    144.         Define this if you use Spring Transactions or DAO Exception Hierarchy
    145.         (org.springframework.transaction.*/org.springframework.dao.*)
    146.     -->
    147.     <dependency>
    148.       <groupId>org.springframework</groupId>
    149.       <artifactId>spring-tx</artifactId>
    150.       <version>${org.springframework.version}</version>
    151.     </dependency>
    153.     <!--
    154.         JDBC Data Access Library (depends on spring-core, spring-beans, spring-context, spring-tx)
    155.         Define this if you use Spring's JdbcTemplate API (org.springframework.jdbc.*)
    156.     -->
    157.     <dependency>
    158.       <groupId>org.springframework</groupId>
    159.       <artifactId>spring-jdbc</artifactId>
    160.       <version>${org.springframework.version}</version>
    161.     </dependency>
    163.     <!--
    164.         Object-to-Relation-Mapping (ORM) integration with Hibernate, JPA, and iBatis.
    165.         (depends on spring-core, spring-beans, spring-context, spring-tx)
    166.         Define this if you need ORM (org.springframework.orm.*)
    167.     -->
    168.     <dependency>
    169.       <groupId>org.springframework</groupId>
    170.       <artifactId>spring-orm</artifactId>
    171.       <version>${org.springframework.version}</version>
    172.     </dependency>
    174.     <!--
    175.         Object-to-XML Mapping (OXM) abstraction and integration with JAXB, JiBX, Castor, XStream, and XML Beans.
    176.         (depends on spring-core, spring-beans, spring-context)
    177.         Define this if you need OXM (org.springframework.oxm.*)
    178.     -->
    179.     <dependency>
    180.       <groupId>org.springframework</groupId>
    181.       <artifactId>spring-oxm</artifactId>
    182.       <version>${org.springframework.version}</version>
    183.     </dependency>
    185.     <!--
    186.         Web application development utilities applicable to both Servlet and Portlet Environments
    187.         (depends on spring-core, spring-beans, spring-context)
    188.         Define this if you use Spring MVC, or wish to use Struts, JSF, or another web framework with Spring (org.springframework.web.*)
    189.     -->
    190.     <dependency>
    191.       <groupId>org.springframework</groupId>
    192.       <artifactId>spring-web</artifactId>
    193.       <version>${org.springframework.version}</version>
    194.     </dependency>
    196.     <!--
    197.         Spring MVC for Servlet Environments (depends on spring-core, spring-beans, spring-context, spring-web)
    198.         Define this if you use Spring MVC with a Servlet Container such as Apache Tomcat (org.springframework.web.servlet.*)
    199.     -->
    200.     <dependency>
    201.       <groupId>org.springframework</groupId>
    202.       <artifactId>spring-webmvc</artifactId>
    203.       <version>${org.springframework.version}</version>
    204.     </dependency>
    206.     <!--
    207.         Spring MVC for Portlet Environments (depends on spring-core, spring-beans, spring-context, spring-web)
    208.         Define this if you use Spring MVC with a Portlet Container (org.springframework.web.portlet.*)
    209.     -->
    210.     <dependency>
    211.       <groupId>org.springframework</groupId>
    212.       <artifactId>spring-webmvc-portlet</artifactId>
    213.       <version>${org.springframework.version}</version>
    214.     </dependency>
    216.     <!--
    217.         Support for testing Spring applications with tools such as JUnit and TestNG
    218.         This artifact is generally always defined with a 'test' scope for the integration testing framework and unit testing stubs
    219.     -->
    220.     <dependency>
    221.       <groupId>org.springframework</groupId>
    222.       <artifactId>spring-test</artifactId>
    223.       <version>${org.springframework.version}</version>
    224.       <scope>test</scope>
    225.     </dependency>
    226.   </dependencies>
    227. </project>

    步骤 3）在lib文件夹中添加两个其他 jar。 如果时间允许，请找到它们的 Maven 依赖项并添加pom.xml。

    • jnpserver-5.0.3.GA.jar
    • org.springframework.jms-3.0.5.RELEASE.jar

    步骤 4）从 jboss 发行版复制以下文件，并将其放在类路径中。 或者，只需复制下面给出的文件。

    hornetq-configuration.xml

    1. <configuration xmlns="urn:hornetq"
    2.                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.                xsi:schemaLocation="urn:hornetq /schema/hornetq-configuration.xsd">
    5.    <connectors>
    6.       <connector name="netty">
    7.          <factory-class>org.hornetq.integration.transports.netty.NettyConnectorFactory</factory-class>
    8.          <param key="host"  value="${hornetq.remoting.netty.host:localhost}"/>
    9.          <param key="port"  value="${hornetq.remoting.netty.port:5445}"/>
    10.       </connector>
    11.    </connectors>
    13.    <acceptors>
    14.       <acceptor name="netty">
    15.          <factory-class>org.hornetq.integration.transports.netty.NettyAcceptorFactory</factory-class>
    16.          <param key="host"  value="${hornetq.remoting.netty.host:localhost}"/>
    17.          <param key="port"  value="${hornetq.remoting.netty.port:5445}"/>
    18.       </acceptor>
    19.    </acceptors>
    21.    <security-settings>
    22.       <security-setting match="#">
    23.          <permission type="createTempQueue" roles="guest"/>
    24.          <permission type="deleteTempQueue" roles="guest"/>
    25.          <permission type="consume" roles="guest"/>
    26.          <permission type="send" roles="guest"/>
    27.       </security-setting>
    28.    </security-settings>
    30.    <address-settings>
    31.       <!--default for catch all-->
    32.       <address-setting match="#">
    33.          <dead-letter-address>jms.queue.DLQ</dead-letter-address>
    34.          <expiry-address>jms.queue.ExpiryQueue</expiry-address>
    35.          <redelivery-delay>0</redelivery-delay>
    36.          <max-size-bytes>-1</max-size-bytes>
    37.          <page-size-bytes>10485760</page-size-bytes>         
    38.          <message-counter-history-day-limit>10</message-counter-history-day-limit>
    39.       </address-setting>
    40.    </address-settings>
    42.    <paging-directory>${hornetq.data.dir}/paging</paging-directory>
    43.    <bindings-directory>${hornetq.data.dir}/bindings</bindings-directory>
    44.    <journal-directory>${hornetq.data.dir}/journal</journal-directory>
    45.    <large-messages-directory>${hornetq.data.dir}/large-messages</large-messages-directory>
    46. </configuration>

    hornetq-jms.xml

    1. <configuration xmlns="urn:hornetq"
    2.            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.            xsi:schemaLocation="urn:hornetq /schema/hornetq-jms.xsd">
    5.     <connection-factory name="NettyConnectionFactory">
    6.        <connectors>
    7.          <connector-ref connector-name="netty"/>
    8.        </connectors>
    9.         <entries>
    10.             <entry name="/ConnectionFactory"/>
    11.             <entry name="/XAConnectionFactory"/>
    12.         </entries>
    13.     </connection-factory>
    15.     <queue name="ExampleQueue">
    16.         <entry name="/queue/ExampleQueue"/>
    17.     </queue>
    19.     <topic name="ExampleTopic">
    20.         <entry name="/topic/ExampleTopic"/>
    21.     </topic>    
    22. </configuration>

    hornetq-users.xml

    1. <configuration xmlns="urn:hornetq" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.             xsi:schemaLocation="urn:hornetq /schema/hornetq-users.xsd">
    3.    <!-- the default user.  this is used where username is null-->
    4.    <defaultuser name="guest" password="guest">
    5.       <role name="guest"/>
    6.    </defaultuser>
    7. </configuration>

    步骤 5）在类路径中复制jndi.properties。

    1. java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
    2. java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces

    步骤 6）配置记录器，以更好地捕获信息。

    1. # Create a STDOUT appender
    2. log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
    3. log4j.appender.STDOUT.layout=org.apache.log4j.PatternLayout
    4. log4j.appender.STDOUT.layout.ConversionPattern=%05p | %m%n
    6. # Default everything to WARN
    7. log4j.rootCategory=WARN, STDOUT
    9. # Enable this application log level to the lowest.
    10. log4j.category.com.howtodoinjava=TRACE
    11. log4j.category.org.jnp.server=INFO
    12. log4j.category.org.hornetq=INFO
    13. log4j.category.org.springframework=INFO

    步骤 7）到目前为止，已经配置了 hornetq 服务器和 jndi。 现在，将它们插入spring.xml和spring.properties中的 spring 框架。

    spring.xml

    1. <?xml version="1.0" encoding="UTF-8" standalone="no"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    5.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
    7.     <context:annotation-config />
    8.     <context:property-placeholder location="classpath:config/server/spring.properties" />
    10.     <bean name ="namingServerImpl" class="org.jnp.server.NamingBeanImpl" init-method="start" destroy-method="stop">
    11.     </bean>
    13.     <!-- JNDI server. Disable this if you don't want JNDI -->
    14.     <bean name="namingServer" class="org.jnp.server.Main" init-method="start" destroy-method="stop">
    15.         <property name="namingInfo" ref="namingServerImpl"></property>
    16.         <property name="port" value="1099"></property>
    17.         <property name="bindAddress" value="localhost"></property>
    18.         <property name="rmiPort" value="1098"></property>
    19.         <property name="rmiBindAddress" value="localhost"></property>
    20.     </bean>
    22.     <!-- MBean server -->
    23.     <bean name="mbeanServer" class="java.lang.management.ManagementFactory" factory-method="getPlatformMBeanServer">
    24.     </bean>
    26.     <!-- The core configuration -->
    27.     <bean name="fileConfiguration" class="org.hornetq.core.config.impl.FileConfiguration" init-method="start" destroy-method="stop">
    28.     </bean>
    30.     <!-- The security manager -->
    31.     <bean name="hornetQSecurityManagerImpl" class="org.hornetq.spi.core.security.HornetQSecurityManagerImpl">
    32.     </bean>
    34.     <!-- The core server -->
    35.     <bean name="hornetQServerImpl" class="org.hornetq.core.server.impl.HornetQServerImpl">
    36.         <constructor-arg ref="fileConfiguration" />
    37.         <constructor-arg ref="mbeanServer" />
    38.         <constructor-arg ref="hornetQSecurityManagerImpl" />
    39.     </bean>
    41.     <!-- The JMS server -->
    42.     <bean name="jmsServerManagerImpl" class="org.hornetq.jms.server.impl.JMSServerManagerImpl" init-method="start" destroy-method="stop">
    43.         <constructor-arg ref="hornetQServerImpl" />
    44.     </bean>       
    46.     <bean name="connectionFactory" class="org.hornetq.jms.client.HornetQConnectionFactory" >
    47.         <constructor-arg>
    48.             <bean class="org.hornetq.api.core.TransportConfiguration">
    49.                 <constructor-arg value="org.hornetq.integration.transports.netty.NettyConnectorFactory" />
    50.                 <constructor-arg>
    51.                     <map key-type="java.lang.String" value-type="java.lang.Object">
    52.                         <entry key="port" value="5445"></entry>
    53.                     </map>
    54.                 </constructor-arg>
    55.             </bean>
    56.         </constructor-arg>
    57.     </bean>
    59.     <bean name="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
    60.         <property name="connectionFactory" ref="connectionFactory"></property>
    61.     </bean>
    63.     <bean name="messageProducerClient" class="com.howtodoinjava.hornetq.demo.MessageProducerClient">
    64.         <property name="jmsTemplate" ref="jmsTemplate"></property>
    65.     </bean>
    67.     <bean name="messageConsumerClient" class="com.howtodoinjava.hornetq.demo.MessageConsumerClient">
    68.         <property name="jmsTemplate" ref="jmsTemplate"></property>
    69.     </bean>
    71. </beans>

    spring.properties

    1. hornetq.data.dir=${hornetq.spring.examples.home}/hornetq-data
    2. org.hornetq.logger-delegate-factory-class-name=org.hornetq.integration.logging.Log4jLogDelegateFactory

    步骤 8）首先加载 Spring 容器。 它还将验证我们所有的配置文件。

    SpringContainerLoader.java

    1. package com.howtodoinjava.hornetq.demo;
    3. import org.springframework.context.support.FileSystemXmlApplicationContext;
    5. public class SpringContainerLoader
    6. {
    7.     public static FileSystemXmlApplicationContext loadEnvironment()
    8.     {
    9.         final FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("classpath:config/server/spring.xml");
    10.         context.registerShutdownHook();
    11.         context.start();
    13.         return context;
    14.     }
    15. }

    步骤 8）现在，我将编写消息生产者和消息使用者客户端。

    MessageProducerClient.java

    1. package com.howtodoinjava.hornetq.demo;
    3. import javax.jms.JMSException;
    4. import javax.jms.MessageProducer;
    5. import javax.jms.Session;
    6. import javax.jms.TextMessage;
    8. import org.apache.commons.logging.Log;
    9. import org.apache.commons.logging.LogFactory;
    10. import org.springframework.jms.core.JmsTemplate;
    11. import org.springframework.jms.core.ProducerCallback;
    13. public class MessageProducerClient implements Runnable {
    15.     private static Log log = LogFactory.getLog(MessageProducerClient.class);
    17.     private static int counter = 1;
    19.     private JmsTemplate jmsTemplate;
    21.     public void setJmsTemplate(JmsTemplate jmsTemplate) {
    22.         this.jmsTemplate = jmsTemplate;
    23.     }
    25.     @Override
    26.     public void run() {
    27.         jmsTemplate.execute("ExampleQueue", new ProducerCallback<Object>() {
    28.             @Override
    29.             public Object doInJms(Session session, MessageProducer producer)
    30.                     throws JMSException {
    31.                 while (true) {
    32.                     TextMessage msg = session.createTextMessage("Message number : " + counter++);
    33.                     log.trace("Sending msg: " + msg);
    34.                     producer.send(msg);
    36.                     try {
    37.                         Thread.sleep(2000);
    38.                     } catch (InterruptedException e) {
    39.                         e.printStackTrace();
    40.                     }
    41.                 }
    42.             }
    43.         });
    45.     }
    46. }

    MessageConsumerClient.java

    1. package com.howtodoinjava.hornetq.demo;
    3. import javax.jms.JMSException;
    4. import javax.jms.Message;
    5. import javax.jms.MessageConsumer;
    6. import javax.jms.Queue;
    7. import javax.jms.Session;
    9. import org.apache.commons.logging.Log;
    10. import org.apache.commons.logging.LogFactory;
    11. import org.springframework.jms.core.JmsTemplate;
    12. import org.springframework.jms.core.SessionCallback;
    14. public class MessageConsumerClient implements Runnable {
    16.     private static Log log = LogFactory.getLog(MessageConsumerClient.class);
    18.     private JmsTemplate jmsTemplate;
    20.     public void setJmsTemplate(JmsTemplate jmsTemplate) {
    21.         this.jmsTemplate = jmsTemplate;
    22.     }
    24.     @Override
    25.     public void run()
    26.     {
    27.         log.info("Message Consumer is just started !!");
    29.         boolean startConn = true;
    30.         jmsTemplate.execute(new SessionCallback<Object>() {
    31.             @Override
    32.             public Object doInJms(Session session) throws JMSException {
    33.                 Queue queue = session.createQueue("ExampleQueue");
    34.                 MessageConsumer consumer = session.createConsumer(queue);
    35.                 while (true) {
    36.                     Message msg = consumer.receive();
    37.                     log.trace("Received msg: " + msg);
    38.                 }
    39.             }
    40.         }, startConn);
    41.     }
    42. }

    步骤 9）现在该测试整个代码和消息传递功能了。

    HornetQMessagingTest.java

    1. package com.howtodoinjava.hornetq.demo;
    3. import org.springframework.context.ApplicationContext;
    5. public class HornetQMessagingTest
    6. {
    7.     public static void main(String[] args) throws InterruptedException
    8.     {
    9.         //Load configurations
    10.         ApplicationContext context = SpringContainerLoader.loadEnvironment();
    12.         //Start the message producer
    13.         new Thread((Runnable)context.getBean("messageProducerClient")).start();
    15.         //Start the message consumer
    16.         new Thread((Runnable)context.getBean("messageConsumerClient")).start();
    18.     }
    19. }

    在测试类之上运行会在下面生成日志，以验证 Spring3 和 hornetq 集成成功。

    1.  INFO | Refreshing org.springframework.context.support.FileSystemXmlApplicationContext@aa9835: startup date [Mon Mar 25 09:23:26 IST 2013]; root of context hierarchy
    2.  INFO | Loading XML bean definitions from class path resource [config/server/spring.xml]
    3.  INFO | Loading properties file from class path resource [config/server/spring.properties]
    4.  INFO | Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@1b4fad5: defining beans [org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.beans.factory.config.PropertyPlaceholderConfigurer#0,namingServerImpl,namingServer,mbeanServer,fileConfiguration,hornetQSecurityManagerImpl,hornetQServerImpl,jmsServerManagerImpl,connectionFactory,jmsTemplate,messageProducerClient,messageConsumerClient]; root of factory hierarchy
    5. 25 Mar, 2013 9:23:28 AM org.hornetq.core.logging.impl.JULLogDelegate info
    6. INFO: live server is starting..
    7. 25 Mar, 2013 9:23:28 AM org.hornetq.core.logging.impl.JULLogDelegate warn
    8. WARNING: AIO wasn't located on this platform, it will fall back to using pure Java NIO. If your platform is Linux, install LibAIO to enable the AIO journal
    9. 25 Mar, 2013 9:23:28 AM org.hornetq.core.logging.impl.JULLogDelegate info
    10. INFO: Using NIO Journal
    11. 25 Mar, 2013 9:23:28 AM org.hornetq.core.logging.impl.JULLogDelegate warn
    12. WARNING: Security risk! It has been detected that the cluster admin user and password have not been changed from the installation default. Please see the HornetQ user guide, cluster chapter, for instructions on how to do this.
    13. 25 Mar, 2013 9:23:30 AM org.hornetq.core.logging.impl.JULLogDelegate info
    14. INFO: Started Netty Acceptor version 3.1.5.GA-r1772
    15. 25 Mar, 2013 9:23:30 AM org.hornetq.core.logging.impl.JULLogDelegate info
    16. INFO: HornetQ Server version 2.0.0.GA (Hornet Queen, 113) started
    17.  INFO | Message Consumer is just started !!
    18. TRACE | Sending msg: HornetQMessage[null]:PERSISTENT
    19. TRACE | Received msg: HornetQMessage[ID:8e74da0e-94ff-11e2-bbba-002564ac1704:0000000000000000]:PERSISTENT
    20. TRACE | Sending msg: HornetQMessage[null]:PERSISTENT
    21. TRACE | Received msg: HornetQMessage[ID:8e74da0e-94ff-11e2-bbba-002564ac1704:1000000000000000]:PERSISTENT
    22. TRACE | Sending msg: HornetQMessage[null]:PERSISTENT
    23. TRACE | Received msg: HornetQMessage[ID:8e74da0e-94ff-11e2-bbba-002564ac1704:2000000000000000]:PERSISTENT
    24. TRACE | Sending msg: HornetQMessage[null]:PERSISTENT
    25. TRACE | Received msg: HornetQMessage[ID:8e74da0e-94ff-11e2-bbba-002564ac1704:3000000000000000]:PERSISTENT

    如有任何问题，请先确认以下几点：

    • 所有配置文件都在类路径中。
    • lib 文件夹中存在的两个 jar 文件包含在类路径中。

    作为参考，我给出了目录结构的快照。

    Spring3 Hornetq 独立集成示例 - 图1

    源代码下载

    祝您学习愉快！