Spring基于JMS实现远程访问

使用JMS作为底层通信协议，Spring提供了很好的支持。我们可以基于JMS将服务暴露给外部，这一切对于外部完全透明。这里我们基于开源消息中间件ActiveMQ作为中间代理，通过在服务端将服务以消息的形式发布到代理服务器上，然后客户端通过代理服务器实现对服务的远程调用。

ActiveMQ的BrokerService可以非常容易地实现服务端与客户端进行通信的中间代理，Spring配置broker.xml内容如下所示：

1. xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
5.   
6.     <bean id="broker" class="org.apache.activemq.broker.BrokerService" />  
7.   
8. beans>  

通过Spring的IOC容器来管理BrokerService。实现一个基于ActiveMQ的消息代理服务，如下所示：

1. package org.shirdrn.spring.remote.jms;  
2.   
3. import org.apache.activemq.broker.BrokerService;  
4. import org.apache.log4j.Logger;  
5. import org.springframework.context.ApplicationContext;  
6. import org.springframework.context.support.ClassPathXmlApplicationContext;  
7.   
8. public class Broker {  
9.       
10.     private static final Logger LOG = Logger.getLogger(Broker.class);  
11.     private static final String CONNECTOR_ADDRESS = "tcp://192.168.1.103:61616";  
12.       
13.     public static void main(String[] args) {  
14.         ApplicationContext ctx = new ClassPathXmlApplicationContext(  
15.                 new String[] { "org/shirdrn/spring/remote/jms/broker.xml" });  
16.         BrokerService broker = (BrokerService) ctx.getBean("broker");  
17.         try {  
18.             broker.setBrokerName("myBroker");  
19.             broker.setUseJmx(true);  
20.             broker.addConnector(CONNECTOR_ADDRESS);  
21.             broker.start();  
22.             LOG.info("Broker service started.");  
23.               
24.             Object lock = new Object();  
25.             synchronized (lock) {  
26.                 lock.wait();  
27.             }  
28.         } catch (InterruptedException e) {  
29.             e.printStackTrace();  
30.         } catch (Exception e) {  
31.             e.printStackTrace();  
32.         }  
33.     }  
34. }  

启动后，代理监听61616，等待服务端发布服务，以及远程客户端调用服务。

看一下，服务端如何进行实现。

定义服务接口和服务实现。服务接口，代码如下所示：

1. package org.shirdrn.spring.remote.jms;  
2.   
3. public interface AccountService {  
4.     int queryBalance(String mobileNo);  
5.     String shoopingPayment(String mobileNo, byte protocol);  
6. }  

实现上述接口，示例代码如下所示：

1. package org.shirdrn.spring.remote.jms;  
2.   
3. import org.apache.log4j.Logger;  
4.   
5. public class MobileAccountServiceImpl implements AccountService {  
6.   
7.     private static final Logger LOG = Logger.getLogger(MobileAccountServiceImpl.class);  
8.   
9.     public int queryBalance(String mobileNo) {  
10.         if (mobileNo != null)  
11.             return 100;  
12.         return 0;  
13.     }  
14.   
15.     public String shoopingPayment(String mobileNo, byte protocol) {  
16.         StringBuffer sb = new StringBuffer().append("Your mobile number is /"")  
17.                 .append(mobileNo).append("/", protocol type is /"").append(  
18.                         protocol).append("/".");  
19.         LOG.info(sb.toString());  
20.         return sb.toString();  
21.     }  
22. }  

然后，服务端的配置server.xml，内容如下所示：

1. xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
5.   
6.     <bean class="org.springframework.jms.listener.SimpleMessageListenerContainer">  
7.         <property name="connectionFactory" ref="connectionFactory" />  
8.         <property name="destination" ref="myQueue" />  
9.         <property name="concurrentConsumers" value="3" />  
10.         <property name="messageListener" ref="myAccountService" />  
11.         <property name="taskExecutor" ref="threadPool" />  
12.     bean>  
13.       
14.     <bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
15.         <property name="brokerURL" value="tcp://192.168.1.103:61616" />  
16.     bean>  
17.   
18.     <bean id="myQueue" class="org.apache.activemq.command.ActiveMQQueue">  
19.         <constructor-arg value="shirdrnQ" />  
20.     bean>  
21.   
22.     <bean id="myAccountService"  
23.         class="org.springframework.jms.remoting.JmsInvokerServiceExporter">  
24.         <property name="serviceInterface" value="org.shirdrn.spring.remote.jms.AccountService" />  
25.         <property name="service">  
26.             <bean class="org.shirdrn.spring.remote.jms.MobileAccountServiceImpl" />  
27.         property>  
28.     bean>  
29.       
30.     <bean id="threadPool" class="org.springframework.core.task.SimpleAsyncTaskExecutor">  
31.         <property name="daemon" value="true" />  
32.         <property name="concurrencyLimit" value="300" />  
33.         <property name="threadNamePrefix" value="SERVICE" />  
34.     bean>  
35.   
36. beans>  

通过Spring的org.springframework.jms.listener.SimpleMessageListenerContainer实现服务的发布，可以配置的属性有：

connectionFactory         连接工厂

destination                    消息目的地，基于ActiveMQ则是一个消息队列

concurrentConsumers   并发消息消费者数量

messageListener           消息监听器

taskExecutor                 线程池

通过上面配置可以看到，连接工厂指定了代理监听服务的端口，我们通过服务端发布服务，作为消息生产者将服务以消息的形式发布，然后客户端作为服务的消费者，通过代理来实现对远程发布服务的调用。

服务端启动的实现，如下所示：

1. package org.shirdrn.spring.remote.jms;  
2.   
3. import org.apache.log4j.Logger;  
4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
5.   
6. public class Server {  
7.   
8.     private static final Logger LOG = Logger.getLogger(Server.class);  
9.       
10.     public static void main(String[] args) throws Exception {  
11.         new ClassPathXmlApplicationContext(  
12.                 new String[] { "org/shirdrn/spring/remote/jms/server.xml" });  
13.         LOG.info("Server started.");  
14.     }  
15. }