mq入门

本次我将给出ActiveMQ和Spring结合使用的一个实例，在这个实例中创建了一个队列，服务端向队列中写入一条消息，客户端从队列中读取消息，并输出到控制台。为了简化问题，我们将服务端和客户端放在一个应用程序中，您完全可以将其拆分成两个程序。这种情况，相当于应用程序发送一条消息到ActiveMQ，然后ActiveMQ将消息反馈给应用程序。程序中使用的是内嵌的ActiveMQ，就是说您在使用的时候不必单独开启ActiveMQ，而是程序会在jvm中启动一个内嵌的ActiveMQ。

 

如果您对上述某些概念不是很清楚，请参考我的其他关于ActiveMQ的文章。您也可以直接参考ActiveMQ in Action的教程。（我前段时间对这部教材的关键部分进行了翻译，可直接参考我翻译的内容，翻译文档放在我博客的其他文章中）。

 

在编写应用之前，可以看到整个的文档结构如下：

注意这是一个javase工程，工程需要的包主要来自于spring-framework-3.0.3.RELEASE 和apache-activemq-5.4.2。其他的包，包括日志相关的和spring运行环境需要的可以很容易找到。另外xbean-spring-3.6.jar是ActiveMQ和spring结合必须使用的包，可以参考ActiveMQ官方文档：http://activemq.apache.org/maven/5.3.1/activemq-core/apidocs/overview-summary.html

db-derby-10.6.2.1-bin.zip主要用于ActiveMQ的数据存储，如果您无需持久化数据，将不会使用此包。

 

下面给出ActiveMQ的配置文件，即activemq.xml：

<beans

  xmlns="http://www.springframework.org/schema/beans"

  xmlns:amq="http://activemq.apache.org/schema/core"

  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.0.xsd

 http://activemq.apache.org/schema/corehttp://activemq.apache.org/schema/core/activemq-core.xsd

 http://camel.apache.org/schema/springhttp://camel.apache.org/schema/spring/camel-spring.xsd">

 

 <!—定义了一个Broker，就是一个ActiveMQ的实例—>

  <broker xmlns="http://activemq.apache.org/schema/core"useJmx="false">

 

<!—定义了activemq对数据的存储方式，即使用KahaDB进行存储，并指定了存储目录-->

  <persistenceFactory>

     <journalPersistenceAdapterFactoryjournalLogFiles="5" dataDirectory="../data"/>

   </persistenceFactory>

 

<!—定义了一个传输连接器，应用程序可以使用指定地址和端口与ActiveMQ进行链接，收发消息，这里使用的是TCP连接-->

   <transportConnectors>

     <transportConnector uri="tcp://localhost:61616"/>     

   </transportConnectors>

       

  </broker>

 

</beans>

 

下面给出spring的配置文件，即SpringConfiguration.java：

package com.guan.ActivemqTest;

 

 

import org.apache.activemq.ActiveMQConnectionFactory;

import org.apache.activemq.command.ActiveMQQueue;

import org.apache.activemq.xbean.BrokerFactoryBean;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.io.ClassPathResource;

import org.springframework.jms.connection.SingleConnectionFactory;

import org.springframework.jms.core.JmsTemplate;

 

@Configuration

public class SpringConfiguration {

 

//注入一个连接工厂，这个连接工厂bean是在本类中定义的。

   @Autowired

   private ActiveMQConnectionFactory connectionFactory;

 

//定义activemq代理的一个实例，这里主要是为了启动一个嵌入式的jms代理（vm）

   @Bean(name="brokerFactory")

   public BrokerFactoryBean brokerFactoryBean()

   {

//创建代理时，指定代理分析他的配置文档，就是先前我们配置的那个文档

      BrokerFactoryBean bfb = new BrokerFactoryBean(new ClassPathResource("org/activemq/xbean/activemq.xml"));

//设置程序运行时开启代理

      bfb.setStart(true);

      return bfb;

   }

   

//创建一个连接工厂，用于程序连接到activemq代理。

   @Bean(name="connectionFactory")

   public ActiveMQConnectionFactoryconnectionFactory()

   {

//指定连接到本地vm的那个代理（注意这个vm就是brokerFactory中启动的那个代理）

      ActiveMQConnectionFactory amqf = new ActiveMQConnectionFactory("vm://localhost");

      return amqf;

   }

//创建一个消息队列

   @Bean(name="queue")

   public ActiveMQQueue queue()

   {

      ActiveMQQueue q = new ActiveMQQueue();

      q.setPhysicalName("com.guan.activemqTest");

      return q;

   }

//创建服务端的jmsTemplate（一般情况下服务端和客户端的jmsTemplate可以设置相同，但为了效率因素，我们将其分开设置，服务端应尽量减少连接数量，所以使用singleConnectionFactory）。

   @Bean(name="serviceJmsTemplate")

   public JmsTemplate jmsTemplate()

   {

      JmsTemplate jt = new JmsTemplate();

      SingleConnectionFactory scf = new SingleConnectionFactory();

      scf.setTargetConnectionFactory(connectionFactory);

      jt.setConnectionFactory(scf);

      return jt;

   }

   //客户端的jmsTemplate

   @Bean(name="customJmsTemplate")

   public JmsTemplate jmsTemplateCustom()

   {

      JmsTemplate jt = new JmsTemplate();

      jt.setConnectionFactory(connectionFactory);

      return jt;

   }

}

 

   服务端的程序代码：

package com.guan.ActivemqTest;

 

import javax.jms.JMSException;

import javax.jms.Message;

import javax.jms.Session;

 

import org.apache.activemq.command.ActiveMQQueue;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.jms.core.JmsTemplate;

import org.springframework.jms.core.MessageCreator;

import org.springframework.stereotype.Component;

 

@Component("serviceSide")

public class JMSServiceSide {

   @Autowired

   @Qualifier("serviceJmsTemplate")

   private JmsTemplate template;

   

   @Autowired

   private ActiveMQQueue queue;

   //发送一条简短的消息

   public void simpleSend()

   {

      template.send(queue,new MessageCreator() {

          

          @Override

          public Message createMessage(Session session)throws JMSException {

             

             return session.createTextMessage("您好，关新全！");

          }

      });

   }

}

 

   接收客户端的代码：

package com.guan.ActivemqTest;

 

import javax.jms.JMSException;

import javax.jms.TextMessage;

 

import org.apache.activemq.command.ActiveMQQueue;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.jms.core.JmsTemplate;

import org.springframework.stereotype.Component;

 

@Component("clientSide")

public class JMSClientSide {

   @Autowired

   @Qualifier("customJmsTemplate")

   private JmsTemplate template;

   @Autowired

   private ActiveMQQueue queue;

 

//接收并输出消息

   public void simpleReceive() throws JMSException

   {

      TextMessage tm = (TextMessage) template.receive(queue);

      System.out.println(tm.getText());

   }

   

}

测试代码：

package com.guan.ActivemqTest;

 

import javax.jms.JMSException;

 

import org.junit.Test;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

 

public class ActivemqTest {

   @Test

   public void startTest() throws JMSException

   {

      AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

      ctx.scan("com.guan");

      ctx.refresh();

 

//注意下面使用了两种方法获取bean

      JMSServiceSide ss = (JMSServiceSide) ctx.getBean("serviceSide");

      JMSClientSide cs = ctx.getBean(JMSClientSide.class);

//发送一条消息，然后接收一条消息     

      ss.simpleSend();

      cs.simpleReceive();

   }

}

 

输出结果：您好，关新全！

   

最后log4j的配置文档：

### direct log messages to stdout###

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.Target=System.out

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

 

### direct messages to file hibernate.log###

#log4j.appender.file=org.apache.log4j.FileAppender

#log4j.appender.file.File=hibernate.log

#log4j.appender.file.layout=org.apache.log4j.PatternLayout

#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE}%5p %c{1}:%L - %m%n

 

### set log levels - for more verbose loggingchange 'info' to 'debug' ###

 

log4j.rootLogger=warn, stdout

 

#log4j.logger.org.hibernate=info

#log4j.logger.org.hibernate=debug

 

### log HQL query parser activity

#log4j.logger.org.hibernate.hql.ast.AST=debug

 

### log just the SQL

#log4j.logger.org.hibernate.SQL=debug

 

### log JDBC bind parameters ###

#log4j.logger.org.hibernate.type=info

#log4j.logger.org.hibernate.type=debug

 

### log schema export/update ###

log4j.logger.org.hibernate.tool.hbm2ddl=debug

 

### log HQL parse trees

#log4j.logger.org.hibernate.hql=debug

 

### log cache activity ###

#log4j.logger.org.hibernate.cache=debug

 

### log transaction activity

#log4j.logger.org.hibernate.transaction=debug

 

### log JDBC resource acquisition

#log4j.logger.org.hibernate.jdbc=debug

 

### enable the following line if you want to trackdown connection ###

### leakages when usingDriverManagerConnectionProvider ###

#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace