分布式服务框架远程服务通讯简单实现

转自：http://staratsky.iteye.com/blog/345593

  在分布式服务框架中，一个最基础的问题就是远程服务是怎么通讯的，在Java底层领域中有很多可实现远程通讯的技术，例如：RMI、MINA、ESB、Burlap、SOAP、EJB和JMS 等，在j2ee中,对java底层远程通讯的技术进行了封装,形成了 Hessian 、 HttpInvoker 、 XFire 、 Axis 等多种形式的远程调用技术。 但对高级程序员而言仍需要掌握Java底层领域中远程通讯的技术,尤其是rmi,xml-rpc,JMS。 

1.远程服务基本原理 
1)底层协议 
　　要实现网络机器间的通讯，首先得来看看计算机系统网络通信的基本原理，在底层层面去看，网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络IO来实现，其中传输协议比较出名的有http、tcp、udp等等，http、tcp、udp都是在基于Socket概念上为某类应用场景而扩展出的传输协议，网络IO，主要有bio、nio、aio三种方式，所有的分布式应用通讯都基于这个原理而实现，只是为了应用的易用，各种语言通常都会提供一些更为贴近应用易用的应用层协议。 
2)应用级协议 
　　远程服务通讯，需要达到的目标是在一台计算机发起请求，另外一台机器在接收到请求后进行相应的处理并将结果返回给请求端，这其中又会有诸如one way request、同步请求、异步请求等等请求方式，按照网络通信原理，需要实现这个需要做的就是将请求转换成流，通过传输协议传输至远端，远端计算机在接收到请求的流后进行处理，处理完毕后将结果转化为流，并通过传输协议返回给调用端。 
   在java领域中知名的远程通信的应用级协议有：RMI、XML-RPC、Binary-RPC、SOAP、JMS 
　　 
2.RMI 
2.1RMI原理 
    RMI，即Java RMI（Java Remote Method Invocation）,Java远程方法调用.是Java编程语言里，一种用于实现远程过程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。远程方法调用特性使Java编程人员能够在网络环境中分布操作。 
　　RMI是个典型的为java定制的远程通信协议，RMI全部的宗旨就是尽可能简化远程接口对象的使用。 
    RMI的基础是接口，RMI构架基于一个重要的原理：定义接口和定义接口的具体实现是分开的。 
　　来看下基于RMI的一次完整的远程通信过程的原理： 
　　1)客户端发起请求，请求转交至RMI客户端的stub类; 
　　2)stub类将请求的接口、方法、参数等信息进行序列化; 
　　3)基于socket将序列化后的流传输至服务器端; 
　　4)服务器端接收到流后转发至相应的skelton类; 
　　5)skelton类将请求的信息反序列化后调用实际的处理类; 
　　6)处理类处理完毕后将结果返回给skelton类; 
　　7)Skelton类将结果序列化，通过socket将流传送给客户端的stub; 
　　8)stub在接收到流后反序列化，将反序列化后的Java Object返回给调用者。 
2.2JAVA对RMI的支持 
    java.rmi是JAVA提供 RMI 包。RMI是一种机制，能够让在某个 Java 虚拟机上的对象调用另一个 Java 虚拟机中的对象上的方法。可以用此方法调用的任何对象必须实现该远程接口。调用这样一个对象时，其参数为 "marshalled" 并将其从本地虚拟机发送到远程虚拟机（该远程虚拟机的参数为 "unmarshalled"）上。该方法终止时，将编组来自远程机的结果并将结果发送到调用方的虚拟机。如果方法调用导致抛出异常，则该异常将指示给调用方. 
    Remote 接口用于标识其方法可以从非本地虚拟机上调用的接口。 
2.3rmi在java中的应用 
    要使用RMI，必须构建四个主要的类：远程对象的本地接口、远程对象实现、RMI客户机和RMI服务器。RMI服务器生成远程对象实现的一个实例，并用一个专有的URL注册。RMI客户机在远程RMI服务器上查找服务对象，并将它转换成本地接口类型，然后像对待一个本地对象一样使用 

它。 
　1)远程对象的本地接口 
package test.rmi; 

import java.rmi.Remote; 
import java.rmi.RemoteException; 
public interface HelloRMI extends Remote {   
   
    /**  
     * 简单的返回“Hello World！"字样  
     * @return 返回“Hello World！"字样  
     * @throws java.rmi.RemoteException  
     */  
    public String helloWorld() throws RemoteException;   
  
    /**  
     * @param someBodyName   
     * @return 返回相应的问候语  
     * @throws java.rmi.RemoteException  
     */  
    public String sayHelloToSomeBody(String someBodyName) throws RemoteException;   
       
} 
2)远程对象实现 

Java代码  

1. package test.rmi;  
2.   
3. import java.rmi.RemoteException;     
4. import java.rmi.server.UnicastRemoteObject;     
5.     
6. /**   
7. * User: staratsky   
8. * Date: 2008-8-7 21:56:47   
9. * 远程的接口的实现   
10. */    
11. public class HelloRMIImpl extends UnicastRemoteObject implements HelloRMI {     
12.     private static final long serialVersionUID = -5464145481720553926L;     
13.     
14.     /**   
15.      * 因为UnicastRemoteObject的构造方法抛出了RemoteException异常，因此这里默认的构造方法必须写，必须声明抛出RemoteException 
16.  
17. 异常   
18.      *   
19.      * @throws RemoteException   
20.      */    
21.     public HelloRMIImpl() throws RemoteException {     
22.              
23.     }     
24.     
25.     /**   
26.      * 简单的返回“Hello World！"字样   
27.      *   
28.      * @return 返回“Hello World！"字样   
29.      * @throws java.rmi.RemoteException   
30.      */    
31.     public String helloWorld() throws RemoteException {     
32.         return "Hello World!";     
33.     }     
34.     
35.     /**   
36.      * @param someBodyName  
37.      * @return 返回问候语   
38.      * @throws java.rmi.RemoteException   
39.      */    
40.     public String sayHelloToSomeBody(String someBodyName) throws RemoteException {     
41.         return "你好，" + someBodyName + "!";     
42.     }     
43. }   

3)RMI服务器 

Java代码  

1. package test.rmi;  
2.   
3. import java.net.MalformedURLException;     
4. import java.rmi.AlreadyBoundException;     
5. import java.rmi.Naming;     
6. import java.rmi.RemoteException;     
7. import java.rmi.registry.LocateRegistry;     
8.     
9. /**   
10. * User: staratsky   
11. * Date: 2008-8-7 22:03:35   
12. * 创建RMI注册表，启动RMI服务，并将远程对象注册到RMI注册表中。   
13. */    
14. public class HelloRMIServer {     
15.     public static void main(String args[]) {     
16.         try {     
17.             //创建一个远程对象     
18.             HelloRMI rhello = new HelloRMIImpl();     
19.             //本地主机上的远程对象注册表Registry的实例，并指定端口为8888，这一步必不可少（Java默认端口是1099），必不可缺的一  
20.   
21. 步，缺少注册表创建，则无法绑定对象到远程注册表上     
22.             LocateRegistry.createRegistry(8888);     
23.     
24.             //把远程对象注册到RMI注册服务器上，并命名为RHello     
25.             //绑定的URL标准格式为：rmi://host:port/name(其中协议名可以省略，下面两种写法都是正确的）     
26.             Naming.bind("rmi://localhost:8888/RHello", rhello);     
27.             // Naming.bind("//localhost:8888/RHello",rhello);     
28.     
29.             System.out.println(">>>>>INFO:远程IHello对象绑定成功！");     
30.         } catch (RemoteException e) {     
31.             System.out.println("创建远程对象发生异常！");     
32.             e.printStackTrace();     
33.         } catch (AlreadyBoundException e) {     
34.             System.out.println("发生重复绑定对象异常！");     
35.             e.printStackTrace();     
36.         } catch (MalformedURLException e) {     
37.             System.out.println("发生URL畸形异常！");     
38.             e.printStackTrace();     
39.         }     
40.     }     
41. }  

  
4)RMI客户机 

Java代码  

1. package test.rmi;  
2.   
3. import java.net.MalformedURLException;     
4. import java.rmi.Naming;     
5. import java.rmi.NotBoundException;     
6. import java.rmi.RemoteException;     
7.     
8. /**   
9. * User: staratsky 
10. * Date: 2008-8-7 22:21:07   
11. * 客户端测试，在客户端调用远程对象上的远程方法，并返回结果。   
12. */    
13. public class HelloRMIClient {     
14.     public static void main(String args[]){     
15.         try {     
16.             //在RMI服务注册表中查找名称为RHello的对象，并调用其上的方法     
17.             HelloRMI rhello =(HelloRMI) Naming.lookup("rmi://localhost:8888/RHello");     
18.             System.out.println(rhello.helloWorld());     
19.             System.out.println(rhello.sayHelloToSomeBody("staratsky"));     
20.         } catch (NotBoundException e) {     
21.             e.printStackTrace();     
22.         } catch (MalformedURLException e) {     
23.             e.printStackTrace();     
24.         } catch (RemoteException e) {     
25.             e.printStackTrace();       
26.         }     
27.     }     
28. }   

总结：从上面的过程来看，RMI对服务器的IP地址和端口依赖很紧密，但是在开发的时候不知道将来的服务器IP和端口如何，但是客户端程序依赖这个IP和端口。 
    这也是RMI的局限性之一。这个问题有两种解决途径：一是通过DNS来解决，二是通过封装将IP暴露到程序代码之外。 
    RMI的局限性之二是RMI是Java语言的远程调用，两端的程序语言必须是Java实现，对于不同语言间的通讯可以考虑用Web Service来实现。 


3.XML-RPC 
3.1原理 
   XML-RPC 网站是这样描述的： 
   它是允许运行在不同操作系统、不同环境中的软件进行基于 Internet 过程调用的规范和一组实现。这种远程过程调用使用 HTTP 作为传输协议，XML 作为编码格式。XML-RPC 的定义尽可能简单，但能够传送、处理和返回复杂的数据结构。 
    XML-RPC消息都是HTTP-POST请求。请求的主要部分的XML。服务器端执行后的返回结果同样也是XML格式。函数调用的参数可以是scalars, numbers, strings, dates等等；也可以是混合型的记录和结构体。 
    所以,要完成XML-RPC,需要完成3部分工作: 
1)接口实现 

Java代码  

1. package test.xmlrpc;  
2.   
3. ublic class HelloHandler implements ServicesHandler {  
4.    public String execute(String str){  
5.          return "Hello," + str + "!";  
6.    }  

2)远程调用 

Java代码  

1. package test.xmlrpc;  
2.   
3. import java.io.IOException;  
4. import java.net.MalformedURLException;  
5. import java.util.Vector;  
6. import java.net.URL;  
7. import org.apache.xmlrpc.XmlRpcException;  
8. import org.apache.xmlrpc.client.XmlRpcClient;  
9. import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;  
10.   
11. public class TestClient {  
12.       public static void main(String [] args) throws Exception {  
13.        try {  
14.   
15.               // config client  
16.               XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();  
17.               config.setServerURL(new URL("http://localhost:8080/yizhu/HelloHandler"));      // should be modified according   
18.   
19. to your configuration of jsp container  
20.               // create a new XmlRpcClient object and bind above config object with it  
21.               XmlRpcClient client = new XmlRpcClient();  
22.               client.setConfig(config);  
23.               // create parameter list  
24.               Vector<String> params = new Vector<String>();  
25.               params.addElement("MY");  
26.               // execute XML-RPC call  
27.               String result = (String) client.execute("HelloHandler.execute", params);                    
28.               System.out.println(result);  
29.         } catch (MalformedURLException e) {  
30.               System.out.println(e.toString());  
31.         } catch (XmlRpcException e) {  
32.               System.out.println(e.toString());  
33.         } catch (IOException e) {  
34.               e.printStackTrace();  
35.         }  
36.   }  
37. }  

3)建立一个web服务器 

Java代码  

1. package test.xmlrpc;  
2.   
3. import javax.servlet.*;  
4. import javax.servlet.http.*;  
5. import java.io.*;  
6. import org.apache.xmlrpc.*;  
7. import org.apache.xmlrpc.server.*;  
8. import org.apache.xmlrpc.webserver.*;  
9.   
10. public class XmlRpcServicesServlet extends HttpServlet {  
11.    
12.  private XmlRpcServletServer server;  
13.   
14.     public void init(ServletConfig pConfig) throws ServletException {  
15.   
16.           super.init(pConfig);  
17.   
18.           try {  
19.                 // create a new XmlRpcServletServer object  
20.                 server = new XmlRpcServletServer();  
21.   
22.                 // set up handler mapping of XmlRpcServletServer object  
23.                 PropertyHandlerMapping phm = new PropertyHandlerMapping();  
24.                 phm.addHandler("HelloHandler", HelloHandler.class);                    
25.                 server.setHandlerMapping(phm);  
26.   
27.                 // more config of XmlRpcServletServer object        
28.                 XmlRpcServerConfigImpl serverConfig = (XmlRpcServerConfigImpl)server.getConfig();  
29.                 serverConfig.setEnabledForExtensions(true);  
30.                 serverConfig.setContentLengthOptional(false);  
31.           } catch (XmlRpcException e) {  
32.                 try {  
33.                       log("Failed to create XmlRpcServer: " + e.getMessage(), e);  
34.   
35.                 } catch (Throwable ignore) {  
36.                    
37.                 }  
38.                 throw new ServletException(e);  
39.           }  
40.     }  
41.   
42.       
43.     public void doPost(HttpServletRequest Request, HttpServletResponse Response)  
44.   
45.           throws IOException, ServletException {  
46.   
47.           server.execute(Request, Response);  
48.     }  
49.       
50.     public void doGet(HttpServletRequest Request, HttpServletResponse Response)  
51.   
52.     throws IOException, ServletException {  
53.   
54.     server.execute(Request, Response);  
55.     }  
56. }  

在web.xml中的配置 

Java代码  

1. <servlet>  
2.     <servlet-name>XmlRpcServer</servlet-name>  
3.     <servlet-class>test.xmlrpc.XmlRpcServicesServlet</servlet-class>  
4.  </servlet>  
5.  <servlet-mapping>  
6.    <servlet-name>XmlRpcServer</servlet-name>  
7.    <url-pattern>/HelloHandler</url-pattern>  
8.  </servlet-mapping>  

3.2RMI和RPC的区别 
　　XML-RPC也是一种和RMI类似的远程调用的协议，它和RMI的不同之处在于它以标准的xml格式来定义请求的信息(请求的对象、方法、参数等).所以, 在RMI和RPC之间最主要的区别在于方法是如何别调用的。 
  在RMI中，远程接口使每个远程方法都具有方法签名。如果一个方法在服务器上执行，但是没有相匹配的签名被添加到这个远程接口上，那么这个新方法就不能被RMI客户方所调用。在RPC中，当一个请求到达RPC服务器时，这个请求就包含了一个参数集和一个文本值，通常形成“classname.methodname”的形式。这就向RPC服务器表明，被请求的方法在为“classname”的类中，名叫“methodname”。然后RPC服务器就去搜索与之相匹配的类和方法，并把它作为那种方法参数类型的输入。这里的参数类型是与RPC请求中的类型是匹配的。一旦匹配成功，这个方法就被调用了，其结果被编码后返回客户方。 
3.3xml-rpc的缺点 
1)XML-RPC的消息系统过于简单,没有完整意义上的消息模型 
2)XML-RPC调用服务的方式要求直接指定对象和方法,称不上完整的面向服务的体系 
3)XML-RPC服务器端提供的服务实际上是特定对象的某个方法,限制了服务器端的开发 

　　 
4.Binary-RPC 
　　Binary-RPC看名字就知道和XML-RPC是差不多的了，不同之处仅在于传输的标准格式由XML转为了二进制的格式。 
    Hessian是由caucho提供的一个基于binary-RPC实现的远程通讯library。 
1)写一个接口： 

Java代码  

1. package test.hassian;  
2. public interface SayHello {     
3.     public String sayHello(String name);     
4.     public Student getStudent();     
5.     
6. }   

2)编写一个实现： 

Java代码  

1. package test.hassian;  
2. import com.caucho.hessian.server.HessianServlet;     
3. public class SayHelloImpl extends HessianServlet implements SayHello {     
4.      public String sayHello(String name) {     
5.         return "hello "+name;     
6.     }     
7.     public Student getStudent(){     
8.             Student  s=new Student();     
9.             s.setName("staratsky");     
10.             s.setSchool("ustc");     
11.             return s;            
12.     }     
13.     
14. }   

3)bean类 

Java代码  

1. package test.hassian;  
2. import java.io.Serializable;     
3.   
4. public class Student implements Serializable {     
5.     /**   
6.      *    
7.      */    
8.     private static final long serialVersionUID = -9006571629757493042L;     
9.     private String name;     
10.     private String school;     
11.     public String getName() {     
12.         return name;     
13.     }     
14.     public void setName(String name) {     
15.         this.name = name;     
16.     }     
17.     public String getSchool() {     
18.         return school;     
19.     }     
20.     public void setSchool(String school) {     
21.         this.school = school;     
22.     }     
23.     public String toString() {     
24.         return name+"  "+school;     
25.     }     
26.           
27. }    

4)远程调用类 

Java代码  

1. package test.hassian;  
2. import java.net.MalformedURLException;     
3. import com.caucho.hessian.client.HessianProxyFactory;     
4. public class HessianClientTest {     
5.     public static void main(String[] args) {     
6.         String url="http://127.0.0.1:8080/yizhu/hassiantest";     
7.         HessianProxyFactory factory=new HessianProxyFactory();     
8.         try {     
9.             SayHello say=(SayHello) factory.create(SayHello.class, url);     
10.             System.out.println(say.sayHello("abc"));     
11.             System.out.println(say.getStudent());     
12.         } catch (MalformedURLException e) {     
13.             e.printStackTrace();     
14.         }     
15.     }   

服务器端的配置 
在web.xml中,加入下面两段代码: 

Java代码  

1. <servlet>    
2.        <servlet-name>hassiantest</servlet-name>    
3.        <servlet-class>    
4.            test.hassian.SayHelloImpl     
5.        </servlet-class>    
6. </servlet>  
7.   
8. <servlet-mapping>    
9.        <servlet-name>hassiantest</servlet-name>    
10.        <url-pattern>/hassiantest</url-pattern>    
11.    </servlet-mapping>    

5.JMS 
　　JMS呢，是实现java领域远程通信的一种手段和方法，基于JMS实现远程通信时和RPC是不同的，虽然可以做到RPC的效果，但因为不是从协议级别定义的，因此我们不认为JMS是个RPC协议，但它确实是个远程通信协议，在其他的语言体系中也存在着类似JMS的东西，可以统一的将这类机制称为消息机制，而消息机制呢，通常是高并发、分布式领域推荐的一种通信机制，这里的主要一个问题是容错。 
　　来看JMS中的一次远程通信的过程：  
　　客户端将请求转化为符合JMS规定的Message; 
　　通过JMS API将Message放入JMS Queue或Topic中; 
　　如为JMS Queue，则发送中相应的目标Queue中，如为Topic，则发送给订阅了此Topic的JMS Queue。 
　　处理端则通过轮训JMS Queue，来获取消息，接收到消息后根据JMS协议来解析Message并处理。 
详看<实战activeMQ(http://staratsky.iteye.com/blog/275045) >