可以自己实现这样的生产者消费者模式，实现一个队列机制，然后启动线程阻塞在空队列上，有生产者放到队列里一条消息，比如转换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/

增加的代码见sms_send.gsp：

import org.apache.log4j.Logger;

def log=Logger.getLogger(this.getClass())
log.debug(‘sms send …’)

def message

if(request.parameters.phone){
    log.debug("phone number: ${request.parameters.phone}")
    message=receiveMessage(request.parameters.phone)
    if(!message){
        message=’–’
    }else{
        message=message.text
    }
}

println "收到消息，内容是：${message}"

log.debug(‘sms finished.’)

def receiveMessage(phone){
    def connectionFactory=new GroovyClassLoader().parseClass(new File("${application.getRealPath(”)}/WEB-INF/groovy/JMSService.groovy")).newInstance().connectionFactory
    def connection=connectionFactory.createConnection()
    connection.start()
    def session=connection.createSession(true,javax.jms.Session.AUTO_ACKNOWLEDGE)
    def destination=session.createQueue("outbound-${phone}")
    def consumer=session.createConsumer(destination)
    def message=consumer.receiveNoWait()
    session.commit()
    connection.close()
    message
}

源代码见：

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

代码见：

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

基本思路就是消费者还是单起进程处理，并且可以通过操作系统普通的方式杀掉这个进程。和web应用部分没有直接的耦合关系。

由于这两个应用程序，分别扮演着生产者和消费者的角色，即独立又有关联，比如类库依赖基本一样。因此考虑使用maven的多模块方式，即在一个maven项目中包含多个子项目，父项目包含子项目都需要的类库依赖关系和其他共享信息。

在本示例中，有一个父项目，两个子项目，分别是front-end，用于web应用，back-end，用于消费者部分。

有关多模块maven项目的创建和配置，可参见创建支持eclipse的多模块maven项目。

本文示例源代码见：

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

下载这个代码：

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

然后进入项目目录：

cd sms-service_1.0

生成eclipse项目：

mvn eclipse:eclipse

注意，两个子项目都会级联生成eclipse项目文件。然后，可以通过eclipse的导入已存在项目的功能一次导入进来。

导入的两个项目会共享相同的类库依赖，很方便。但是，要想运行back-end中的脚本，需要在sms-service_1.0目录下执行：

mvn dependency:copy-dependencies

然后，将target/dependency目录设置到groovy的类库加载配置文件中，和groovy原型增加接收消息示例中的配置类似。

执行脚本需要进入back-end/bin目录下再执行，因为脚本中使用了相对路径。执行前需要给脚本文件增加可执行权限：

chmod +x ./ConsumerService.groovy

然后，可以直接Ctrl+c关闭该脚本。可以看到会执行释放资源的代码并有日志提示。

marshal@ubuntu-desktop:~/workspace/sms-service/back-end/bin$ ./ConsumerService.groovy
09-11-20 23:20:22 DEBUG (JMSConsumer:?) – start consumer…
09-11-20 23:20:23 DEBUG (JMSConsumer:?) – start ok.
^C09-11-20 23:21:29 DEBUG (ShutdownThread:?) – shutdown consumer…
09-11-20 23:21:29 DEBUG (ShutdownThread:?) – shutdown succesful.

 

这是因为脚本中使用了钩子线程，当进程关闭的时候会被执行。

Runtime.runtime.addShutdownHook(new ShutdownThread(consumer))

class ShutdownThread extends Thread{
    private static final Logger logger=Logger.getLogger(ShutdownThread.class)
    def consumer
    ShutdownThread(consumer){
        this.consumer=consumer
    }
    public void run(){
        logger.debug("shutdown consumer…")
        this.consumer.connection.close()
        logger.debug("shutdown succesful.")
    }
}

 

如果想后台执行代码，可以这样：

nohup ./ConsumerService.groovy &

关闭这个脚本进程，需要先找到进程号：

ps -ef|grep groovy

然后，这样杀掉进程：

kill -15 your_pid

这样，进程会调用shutdown线程正常释放和关闭进程。这里不能使用-9参数杀进程，这会立即杀掉进程，不能执行shutdown线程释放资源。

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)
    }

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

使用groovy脚本，类似sh脚本，在操作系统下可直接启动运行，实现这些，需要：

• 在操作系统中安装groovy，比如在ubuntu下手工安装groovy
• 编写脚本文件，参考ubuntu建立简单的groovy环境的编写groovy脚本部分

异步接收进程会在后台启动，一直监听队列的消息，收到消息后做后续处理。那么如何关闭该进程呢？这里采用一个简单的办法，创建一个shutdown主题（topic），该进程订阅这个主题，如果从主题收到消息，就立即关闭进程。

主要源代码见：TestScript.groovy

#!/usr/bin/env groovy

import groovy.sql.Sql;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

class MyBiz implements MessageListener{
    def classloader=new GroovyClassLoader()
    def connectionFactory=classloader.parseClass(new File("JMSService.groovy")).newInstance().connectionFactory
    def sql=classloader.parseClass(new File("DBService.groovy")).newInstance().sql
    def connection
    def session
    def consumer
    def destination
    def shutdownDestination
    def shutdownConsumer
    def runConsume(){
        println "启动监听器"
        connection=connectionFactory.createConnection()
        connection.start()
        session=connection.createSession(true,javax.jms.Session.AUTO_ACKNOWLEDGE)

        destination=session.createQueue("myqueue")
        consumer=session.createConsumer(destination)
        consumer.setMessageListener(this)

        shutdownDestination=session.createTopic("shutdownTopic")
        shutdownConsumer=session.createConsumer(shutdownDestination)
        shutdownConsumer.setMessageListener(this)
    }

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

def biz=new MyBiz()
def time=new Date().time

println """
获取到sql连接对象：${biz.sql}，数据库正常。
获取到消息服务器工厂对象：${biz.connectionFactory}，消息服务器正常。
"""

biz.runConsume()

println """
耗时：${new Date().time-time}       
"""

 

使用这个代码，需要先设置为可执行权限：

chmod +x ./TestScript.groovy

然后，需要在该目录下执行，因为代码内部使用的是相对路径：

./TestScript.groovy

执行效果类似这样：

当向shutdown topic发送任意消息，该进程关闭。

这里还碰到一个问题，就是类加载问题。独立的进程，无法享受到Servlet容器提供的类加载支持。需要自行解决。groovy在这方面有一些方法，但都不是很方便。比如有自动加载的脚本，见:

http://groovy.codehaus.org/Auto+setup+and+download+dependencies+jars

在这个原型中，本身已经使用了maven，所以打算直接利用maven的自动类库依赖加载机制，执行命令：

mvn dependency:copy-dependencies

在项目的target/dependency目录下，将生成所有依赖类库的拷贝。然后，根据groovy脚本的类加载，将该目录设置到groovy类加载配置文件中即可。

源代码见：

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

示例运行效果：

消息服务器使用了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端口。并且能顺利执行。

首先需要确保如下类库，这里使用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();
        }
    }
});