java框架简介4----Spring+Hessian 远程过程调用

Spring+Hessian简介：
Hessian能够完成RMI就是远程过程调用，实际上Hessian自己就可以完成这个功能，但是我的目的是将与Spring相关的框架与Spring结合起来，一起完成任务，所有不单独拿出一个章节来讲Hessian。不够，使用方式都是相通的。
 
这次需要完成的任务是这样的，假设在远程有一个作业需要执行，我们写一个客户端，并将这个客户端安装到远程主机上，然后再本机上远程调用客户端的服务，让客户端执行远程主机的作业任务。
 
从上面的分析可知，我们需要完成两个服务，一个是远程执行主机的服务，一个是本地的调用服务。整个程序的结构如下：
远程执行主机服务：



需要用到的jar包：



 
本地执行主机目录：



 
需要的jar包：
 


 
第一步：编写远程主机服务：
要在远程主机上执行作业必然需要对需要执行的作业进行描述，这里对作业的描述如下：
package com.guan.springHessianClientTest.logicModel;
 
import java.io.File;
import java.io.Serializable;
 
public class Job implements Serializable{
    /**
     * 注意作业必须要实现Serializable接口，很明显，作业作为参数在两个主机间传递，必然要进行串行化。Hessian是以二进制的形式进行传输的。
     */
    private static final long serialVersionUID = 1L;
    private String executable;//可执行文件的名字
    private File directory;//执行目录
    private String stdOutFile;//标准输出文档
    private String stdErrFile;//标准错误输出文档
    private String[] args;//程序执行参数
   
 
    public File getDirectory() {
       return directory;
    }
 
    public void setDirectory(File directory) {
       this.directory = directory;
    }
 
    public String getExecutable() {
       return executable;
    }
 
    public void setExecutable(String executable) {
       this.executable = executable;
    }
 
    public String[] getArgs() {
       return args;
    }
 
    public void setArgs(String[] args) {
       this.args = args;
    }
 
    public String getStdOutFile() {
       return stdOutFile;
    }
 
    public void setStdOutFile(String stdOutFile) {
       this.stdOutFile = stdOutFile;
    }
 
    public String getStdErrFile() {
       return stdErrFile;
    }
 
    public void setStdErrFile(String stdErrFile) {
       this.stdErrFile = stdErrFile;
    }
}
上面这个类是个实体类，不多说，大家都明白。
然后实现一个ServiceDao就是服务接口，对应Hessian来说，这个接口是必须的，因为Hessian建立的远程调用，在远程不能过直接对服务的实现调用，而是对服务的接口进行调用，后面还会分析其原因。
package com.guan.springHessianClientTest.ServiceDao;
 
import java.io.IOException;
 
import com.guan.springHessianClientTest.logicModel.Job;
 
public interface ExecuteServiceDao {
    public void submintJob(Job job) throws IOException;
}
 
这个接口很简单，就是提交作业到远程执行。
 
下面给出上面接口的实现：
package com.guan.springHessianClientTest.ServiceImpl;
 
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
 
import com.guan.springHessianClientTest.ServiceDao.ExecuteServiceDao;
import com.guan.springHessianClientTest.logicModel.Job;
 
public class ExecuteServiceDaoImpl implements ExecuteServiceDao{
 
    public void submintJob(Job job) throws IOException {
       Runtime runtime = Runtime.getRuntime();//执行时环境
       Process process = runtime.exec(job.getExecutable(),job.getArgs(),job.getDirectory());
       //开启一个进程来执行提交过来的程序
       BufferedInputStream in = new BufferedInputStream(process.getInputStream());//获得可执行程序的标准输出
       BufferedReader br = new BufferedReader(new InputStreamReader(in));//创建一个reader读取标准输出
      
       BufferedInputStream err = new BufferedInputStream(process.getErrorStream());/*获得可执行程序标准错误输出*/
       BufferedReader berr = new BufferedReader(new InputStreamReader(err));
      
       PrintStream myout = new PrintStream(new FileOutputStream(new File(job.getStdOutFile()))); /*打开标准输出文件*/
       PrintStream myerr = new PrintStream(new FileOutputStream(new File(job.getStdErrFile())));/*打开标准错误输出文件*/
 
       String s;
       while ((s = br.readLine()) != null)
           myout.println(s);/*读取，然后输出到文件*/
       while ((s = berr.readLine()) != null)
           myerr.println(s);
    }
   
}
 
在执行程序的过程中，服务先开启一个进程来执行这个程序，然后将执行的结果输出到文件中。
 
接下来，需要配置远程调用的接口，首先要在web.xml中配置Spring的过滤器，这个可以参考我前面的Spring+Hibernate那篇文章。
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">   <servlet>
           <servlet-name>remoting</servlet-name>
           <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
           <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
           <servlet-name>remoting</servlet-name>
           <url-pattern>/remoting/*</url-pattern>
    </servlet-mapping>
</web-app>
 
通过这个配置，很容易看到，凡是以/remoting开始的请求，都会被传递给Spring来处理。
下面要配置Spring：
Remoting-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
      
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-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/tx            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd            http://www.springframework.org/schema/context            http://www.springframework.org/schema/context/spring-context-2.5.xsd">              <bean id="excuteServiceDaoImpl" class="com.guan.springHessianClientTest.ServiceImpl.ExecuteServiceDaoImpl"/>
        <bean name="/executeManagerService" class="org.springframework.remoting.caucho.HessianServiceExporter">
               <property name="service" ref="excuteServiceDaoImpl"/>
               <property name="serviceInterface" value="com.guan.springHessianClientTest.ServiceDao.ExecuteServiceDao"/>
       </bean>
</beans>
首先创建了一个ExecuteServiceDaoImpl的实现，然后创建了一个远程调用的服务，这个服务中注入了ExecuteServiceDaoImpl的实现。并且说明了接口是ExecuteServiceDao。在远程需要获得这个远程调用的服务（/executeManagerService，注意呀，这个名字前有个/），然后使用接口来完成服务的访问。
 
第二部分 服务端本地调用的编写：
本地调用只写了个测试程序，需要直接从执行服务端拷贝model和dao。然后需要写一个Spring的配置文件，bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
      
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-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/tx            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd            http://www.springframework.org/schema/context            http://www.springframework.org/schema/context/spring-context-2.5.xsd">                     
       <bean id="myServiceClient" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">
       <property name="serviceUrl">
          <value>http://localhost:8080/SpringHessianClientTest/remoting/executeManagerService</value>
       </property>
       <property name="serviceInterface">
           <value>com.guan.springHessianClientTest.ServiceDao.ExecuteServiceDao</value>
       </property>
       </bean>
</beans>
先创建一个Service的bean，并指明这个Service的url是刚才我们配置那个服务的url，注意我是本机测试，所以使用localHost，并且我的tomcat配置的是8080端口，如果执行服务放在远程主机上，那么要将localHost更换成其ip地址。然后指明要使用的接口是什么。
 
注意在提交端，并没有拷贝服务的实现，只是拷贝了服务的接口。
最后的测试部分代码如下：
package com.guan.springHessianClientTest.RomoteService;
 
import java.io.File;
import java.io.IOException;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.guan.springHessianClientTest.ServiceDao.ExecuteServiceDao;
import com.guan.springHessianClientTest.logicModel.Job;
 
public class RMIServiceTest {
    @Test
    public void remoteTest() throws IOException
    {
        ApplicationContext appContext = new ClassPathXmlApplicationContext("beans.xml");//分析Spring配置文档
        ExecuteServiceDao studentService = (ExecuteServiceDao) appContext.getBean("myServiceClient");//获取配置的bean
        Job job = new Job();//新创建一个job，并进行配置
        job.setExecutable("F://programs//vs6.0//redirectionTest//Debug//redirectionTest.exe");
        job.setDirectory(new File("F://programs//NFSWorkSpace"));
        job.setStdErrFile("F://test.err");
        job.setStdOutFile("F://test.out");
        studentService.submintJob(job);//直接调用完成执行
    }
}
 
从上面的例子我们可以看出，整个执行过程就像在本机执行一样，是不是很方便呀！！
测试的程序redirectionTest是用c++写的，代码如下：
#include <iostream>
 
using std::cin;
using std::cout;
using std::endl;
using std::cerr;
 
void main()
{
         cout<<"hello world!!"<<endl;
         cout<<"您好！！！"<<endl;
         cout<<"good good "<<endl;
         cerr<<"err message"<<endl;
         cout<<"after err message"<<endl;
         cerr<<"second errmessage"<<endl;
}
 
最后结果是：在F盘生成两个文件
Test.err
err message
second errmessage
 
和
Test.out
hello world!!
您好！！！
good good
after err message
 
实际上这已经是个小的网格的概念，作业调度系统在远程调度作业到执行主机去执行作业。
 
远程过程调用就像您在本地调用方法一样轻松的完成您的任务，这是一个好方法。
 
如果您在提交端不想使用Spring，可以用下面的方法，似乎更简练些：
      
        String url = " http://localhost:8080/SpringHessianClientTest/remoting/executeManagerService ";
        HessianProxyFactory factory = new HessianProxyFactory();
        ExecuteServiceDao executeServiceDao= (ExecuteServiceDao) factory.create(ExecuteServiceDao.class, url);