JMS自身没有提供异步发送消息的机制，只能同步发送消息。这带来一个问题，比如外部（远端）的JMS服务器因为各种原因无法工作，那么发送消息的应用可能也连带的无法工作，这时消息会丢失。

可以使用activemq的嵌入式的服务，先同步发送消息到本地（嵌入式activemq服务），然后再用一个接收线程接收本地消息，发送到远端的JMS服务，这样即使远端JMS服务失效，消息也不会丢失，当远端服务器恢复后还能继续收到消息。

spring文件的头部要求有：

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
   xmlns:amq="http://activemq.apache.org/schema/core" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core-5.3.0.xsd">

对xmlns:amq的schema声明，分两部分：

xmlns:amq="http://activemq.apache.org/schema/core" xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance

和：

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

另外，因为使用到了xbean的功能，需要引入包，比如maven下：

<dependency>
    <groupId>org.apache.xbean</groupId>
    <artifactId>xbean-spring</artifactId>
    <version>3.7</version>
</dependency>

在spring中和ConnectionFactory相关的配置：

<amq:broker useJmx="false" persistent="true" brokerName="localhost">
    <amq:persistenceAdapter>
        <amq:amqPersistenceAdapter directory="activemq-data"
            indexPageSize="64kb" indexBinSize="4096" maxFileLength="2147483647" />
    </amq:persistenceAdapter>
    <amq:transportConnectors>
        <amq:transportConnector name="vm" uri="vm://localhost" />
    </amq:transportConnectors>
</amq:broker>
<amq:connectionFactory id="embeddedConnectionFactory"
    brokerURL="vm://localhost" />

 

这里使用了amq的persistent adapter，文件最大值是int型的，最大值被限制在int.MAX_VALUE，只能到2147483647，这里使用了这个最大值，不到2GB。

如果需要加大文件值，需要使用比如kapa persistent adapter，它的最大值是long型的。

可以自己实现这样的生产者消费者模式，实现一个队列机制，然后启动线程阻塞在空队列上，有生产者放到队列里一条消息，比如转换test.mov为test.mp4，然后线程得到通知消费这个消息，并从队列中删除消息。

这个思路是好的，但是不需要自己写这些代码，可以借助第三方API，使用JMS，这里用到的是JMS的开源免费实现ActiveMQ。具体安装参见tomcat下部署activemq。

好处是省去了自己写底层代码和相关的测试维护工作。而且，activemq自带web管理界面，我们可以先实现消费者（也就是转换视频功能），而通过web管理界面手工生成消息。

生成一条消息，消息正文很简单：

test.mov;test.mp4

分号隔开，前者是需要转换的视频文件路径，后者是转换的文件路径。

在activemq的web console中填写并发送这条消息。

然后，启动VideoConvertor.groovy，可以看到这样的日志：

marshal@ubuntu-desktop:~/workspace/vp/vp-backend/bin$ ./VideoConvertor.groovy
09-11-25 11:37:29  INFO (Convertor:?) – 启动视频转换器…
09-11-25 11:37:29  INFO (Convertor:?) – 视频转换器启动完毕。
09-11-25 11:37:52 DEBUG (Convertor:?) – 收到消息，正文是：test.mov;test.mp4
09-11-25 11:38:18 DEBUG (Convertor:?) – 生成test.mp4成功，耗时25905毫秒。
09-11-25 11:38:18 DEBUG (Convertor:?) – 提交会话。

 

如果再发送一条jms消息，会有类似的日志，VideoConvertor也不再是执行一次，而是一直监控jms队列，接收消息，转换视频。如果需要将VideoConvertor程序设置为后台应用，可以参照简化groovy原型的jms消费者部分中的做法。

VideoConvertor.groovy源代码：

#!/usr/bin/env groovy

import groovy.lang.Grab;
import org.apache.log4j.*
import javax.jms.*
import org.apache.activemq.ActiveMQConnectionFactory

@Grab(group="log4j",module="log4j",version="1.2.12")
@Grab(group="org.apache.activemq",module="activemq-core",version="5.3.0")
class Convertor implements MessageListener{
    private static Logger logger=Logger.getLogger(Convertor.class)
    static{
        PropertyConfigurator.configure("log4j.properties");               
    }
    def connection
    def session
    def start(){
        logger.info("启动视频转换器…")
        def connectionFactory=new ActiveMQConnectionFactory("tcp://localhost:61616")
        connection=connectionFactory.createConnection()
        connection.start()
        session=connection.createSession(true,Session.AUTO_ACKNOWLEDGE)
        def destination=session.createQueue("video_convert")
        def consumer=session.createConsumer(destination)
        consumer.setMessageListener(this)
        logger.info("视频转换器启动完毕。")
    }

    public void onMessage(Message message){
        logger.debug("收到消息，正文是：${message.text}")
        def parameters=message.text.split(";")
        convert(parameters[0],parameters[1])
        session.commit()
        logger.debug("提交会话。")
    }
    def convert(input,output){
        def time=new Date().time
        def file=new File(output)
        if(file.exists()){
            file.delete()
            logger.debug("删除已经存在的输出文件 ${output}。")
        }
        def process="ffmpeg -i ${input} ${output}".execute()
        process.waitFor()
        logger.debug("生成${output}成功，耗时${new Date().time-time}毫秒。")
    }
}

new Convertor().start()

 

可以在这里下载源代码：

http://easymorse.googlecode.com/svn/tags/vp_m0_2/

代码见：

http://easymorse.googlecode.com/svn/tags/sms-service_1.1/

http://easymorse.googlecode.com/svn/tags/groovy.proto.1.4/

主要修改的是两部分代码：

• 通过hello.gsp增加发送xml文本消息的代码，具体写法可参见groovy生成xml；
• 主要部分，修改TestScript.groovy文件。

TestScript代码主要修改的代码片段：

     public void onMessage(Message message) {
        if(message.destination.equals(destination)){
            println """
收到消息：${message.text}
            """
            sendMessageToQueue(‘receive.confirm’,'–’,'ok.’)
            session.commit()
        }else if (message.destination.equals(shutdownDestination)){
            print (‘shutdown …’)
            session.commit()
            connection.close()
            println (‘ok.’)
        }
     }

     def sendMessageToQueue(queueName,tag,text){
        def destination=session.createQueue(queueName)
        def producer=session.createProducer(destination)
        producer.setDeliveryMode(javax.jms.DeliveryMode.PERSISTENT)

        def out=new StringWriter()
        def xmlResults=new MarkupBuilder(out)
        xmlResults.messages{
            message text
        }
        def message=session.createTextMessage(out.toString())
        message.setStringProperty(‘tag’,tag)
        producer.send(message)
    }

这里收到消息和发送确认消息是在一个事务当中。

示例运行效果：

消息服务器使用了activemq，需要提前部署一个activemq-web-console的war文件到tomcat中，这样不但可以提供activemq消息服务器，还带一个web界面的监控应用。类似这样：

消息正文如果是中文，会是问号，实际上没有问题，是该web应用显示的编码问题。

activemq-web-console的安装过程见tomcat下部署activemq。

涉及groovy发送消息的文件有两个。第一个，配置activemq信息和获取ConnectionFactory方法，实现类似sql部分。见JMSService.groovy：

import org.apache.activemq.ActiveMQConnectionFactory;

class JMSService{
    private static connectionFactory
    def url="tcp://localhost:61616"
    def username=""
    def password=""
    def initConnectionFactory(){
        connectionFactory=new ActiveMQConnectionFactory(url)
    }
    def getConnectionFactory(){
        if(!connectionFactory){
            initConnectionFactory()
        }
        connectionFactory
    }
}

 

另外一个，就是hello.gsp中的调用：

def connectionFactory=classloader.parseClass(new File("${realpath}/WEB-INF/groovy/JMSService.groovy")).newInstance().connectionFactory

…

def sendMessageToQueue(connectionFactory,queueName,tag,text){
    def connection=connectionFactory.createConnection()
    connection.start()
    def session=connection.createSession(true,javax.jms.Session.AUTO_ACKNOWLEDGE)
    def destination=session.createQueue(queueName)
    def producer=session.createProducer(destination)
    producer.setDeliveryMode(javax.jms.DeliveryMode.PERSISTENT)
    def message=session.createTextMessage(text)
    message.setStringProperty(‘tag’,tag)
    producer.send(message)
    session.commit()
    connection.close()
    ‘sucess.’
}

 

…

println """
<div>
发送消息到队列  … ${sendMessageToQueue(connectionFactory,’myqueue’,’15201234567′,’你好’)}
</div>
"""

 

源代码见：

http://easymorse.googlecode.com/svn/tags/groovy.proto.1.2/

官方文档上有一个针对这种需求的文档：

http://activemq.apache.org/web-console.html

根据文档，使用tomcat 6.0.20，activemq 5.2.0。实现了上述需求。首先需要下载：

• activemq-web-console
• activemq-all

前者直接复制到tomcat的webapps目录下即可。后者复制到tomcat/lib目录下。

文档中没有提到的但是tomcat6.0.20中需要增加的类库是有关jstl支持的：

• jstl-1.1.0.jar
• standard-1.1.0.jar

然后启动tomcat，就可以通过如下链接访问：

http://localhost:8080/activemq-web-console-5.2.0

和上述官方文档不同的是，不需要设置这个内容：

set JAVA_OPTS=”-Dwebconsole.type=properties -Dwebconsole.jms.url=tcp://localhost:61616 -Dwebconsole.jmx.url=service:jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi -Dwebconsole.jmx.role= -Dwebconsole.jmx.password=”

设置了反而报错。如果不设置的话，activemq默认启动61616端口。并且能顺利执行。

<networkConnectors>
    <!-- by default just auto discover the other brokers -->
    <networkConnector name="default-nc" uri="multicast://default"/>

这样可以让JMS客户端不需要指定url就可以在广播可到达的网络范围内自动找到服务器：

<bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<!--        <property name="brokerURL">-->
<!--            <value>failover:tcp://localhost:61616</value>-->
<!--        </property>-->

比如把brokerURL属性设置屏蔽掉，程序一样可以运行，参见通过spring开发ActiveMQ简单应用。

这样带来一个问题，安全问题。可以使用activemq简单的安全机制，为activemq设置用户和密码，并作简单的授权。如在conf/activemq.xml中加入：

<plugins>
    <simpleAuthenticationPlugin>
        <users>
          <authenticationUser username="system" password="manager" groups="users,admins"/>
          <authenticationUser username="user" password="password" groups="users"/>
          <authenticationUser username="guest" password="password" groups="guests"/>
        </users>
     </simpleAuthenticationPlugin>
</plugins>

然后在客户端程序中配置用户和密码，以下是在通过spring开发ActiveMQ简单应用示例基础上增加用户和密码的配置：

<bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<!--        <property name="brokerURL">-->
<!--            <value>failover:tcp://localhost:61616</value>-->
<!--        </property>-->
    <property name="userName" value="system"/>
    <property name="password" value="manager"/>
</bean>

首先需要确保如下类库，这里使用maven的pom：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jms</artifactId>
    <version>2.5.6</version>
</dependency>
<dependency>
    <groupId>org.apache.xbean</groupId>
    <artifactId>xbean-spring</artifactId>
    <version>3.5</version>
</dependency>
<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-core</artifactId>
    <version>5.2.0</version>
</dependency>

编写消息生产者的代码：

@Component
public class MyMessageProducer {
    @Resource(name = "Queue")
    private Destination destination;

    @Autowired
    private JmsTemplate jmsTemplate;

    public void sendMessage(final String message) {
        this.jmsTemplate.send(this.destination, new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                TextMessage textMessage = session.createTextMessage();
                textMessage.setText(message);
                return textMessage;
            }
        });
    }
}

有关生产者部分spring的配置文件内容：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:amq="http://activemq.apache.org/schema/core" xmlns:lang="http://www.springframework.org/schema/lang"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
     http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.5.xsd
     http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd">

    <context:annotation-config />
    <context:component-scan base-package="activemq.demo.spring" />

    <bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL">
            <value>tcp://localhost:61616</value>
        </property>
    </bean>

    <bean id="myJmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="jmsFactory" />
    </bean>
    <amq:queue name="Queue" physicalName="example.D" />

这样，执行发送代码，在activemq的admin界面中可以观察到发送成功的消息。

异步接收的代码：

public class MyMessageConsumer implements MessageListener {

    @Override
    public void onMessage(Message message) {
        TextMessage textMessage = (TextMessage) message;
        try {
            System.out.println(">>>>>>>"+textMessage.getText());
//            throw new RuntimeException(">>>>>>>>>>test error");
        } catch (JMSException e) {
            throw new RuntimeException(e);
        }
    }

}

有关异步接收代码的spring配置：

    <bean id="myMessageConsumer" class="activemq.demo.spring.MyMessageConsumer" />
    <bean id="jmsContainer"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="jmsFactory" />
        <property name="destination" ref="Queue" />
        <property name="messageListener" ref="myMessageConsumer" />
        <property name="sessionTransacted" value="true"/>
    </bean>

这样，就实现了基于spring和activemq的JMS的同步发送和异步提交。如果将MyMessageConsumer的抛出异常部分取消注释，则接收信息后，spring捕获到该异常并自动回滚事务。通过activemq的admin界面会监控到消息依然留在队列中。

可下载本文中的示例项目：[Download not found]，可通过：

mvn test

执行测试代码。并以测试代码为线索理解本项目。

有一段时间不使用JMS了。现在的项目又有可能需要应用JMS，来提高服务质量和提高系统资源的利用率。

提高服务质量，主要是保证不间断的服务。用JMS服务器接收任务，排成队列。应用服务可以暂停做维护，不影响接收的任务。应用服务运行后，再从队列中获取任务。

提高系统资源的利用率，主要是任务的派发不是24小时平均的，而是高峰时期任务量很多，比如1秒1000多个，有的时候很低，比如十几秒钟才来一个。应用服务通过JMS队列一个一个的取任务，做完一个再领一个，使系统资源的运用趋于平均。而JMS，比如JMS接收消息的效率是很高的，比如ActiveMQ，在赛扬（2.40GHz）机器上能够达到2000/s，消息大小为1-2k。好一些的服务器可以达到2万以上/秒。

ActiveMQ是开源免费的JMS实现，并且有很多扩展功能。地址：

http://activemq.apache.org

安装和运行很简单，下载后解压缩，执行：

activemq.bat

将启动默认配置的activemq。可以通过：

http://localhost:8161/admin

访问activemq的管理界面。查看队列（queue）和主题（topic）下的消息内容。

编写ActiveMQ程序前需要准备类库，如果使用maven就简单了：

<dependency>
  <groupId>org.apache.activemq</groupId>
  <artifactId>activemq-core</artifactId>
  <version>5.2.0</version>
</dependency>

编写最简单的向JMS队列发送文本消息的程序：

ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
        "tcp://localhost:61616");
Connection connection = connectionFactory.createConnection();
connection.start();
System.out.println("start...");

Session session = connection.createSession(true,
        Session.AUTO_ACKNOWLEDGE);
Queue destination = session.createQueue("example.C");

MessageProducer producer = session.createProducer(destination);
producer.setDeliveryMode(DeliveryMode.PERSISTENT);

TextMessage message = session.createTextMessage("中文");
producer.send(message);
session.commit();

connection.close();
System.out.println("send text ok.");

执行程序后可通过上面提到的web界面查看example.C队列中收到的消息。不过中文信息显示的是??。这没有关系，是admin web应用自身的问题（使用的是iso-8859-1编码）。队列里的数据是对的。

异步接收数据的代码如下：

ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
        "tcp://localhost:61616");
Connection connection = connectionFactory.createConnection();
connection.start();
final Session session = connection.createSession(true,
        Session.AUTO_ACKNOWLEDGE);
Queue destination = session.createQueue("example.C");

MessageConsumer consumer = session.createConsumer(destination);
consumer.setMessageListener(new MessageListener(){
    @Override
    public void onMessage(Message message) {
        System.out.println(message);
        try {
            session.commit();
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
});