常用的RPC框架

Posted 王猴卖瓜

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了常用的RPC框架相关的知识，希望对你有一定的参考价值。

1. 为什么要使用RPC？

RPC（remote procedure call）是指远程过程调用，比如两台服务器A和B，A服务器上部署一个应用，B服务器上部署一个应用，A服务器上的应用想调用B服务器上的应用提供的接口，由于不在一个内存空间，不能直接调用，所以需要通过网络来表达调用的语义和传达调用的数据。

RPC（remote procedure call，远程过程调用）：

  • 首先，要解决通讯的问题，主要是通过客户端和服务器端之间建立TCP连接，远程过程调用的所有交换的数据都在这个连接里传输。连接可以是按需连接，调用结束后就断掉，也可以是长连接，多个远程过程调用共享一个连接。

  • 第三，A服务器上的应用发起远程调用时，方法的参数需要通过底层的网络协议如TCP传递到B服务器，由于网络协议是基于二进制的，内存中的参数需要序列化成二进制形式，然后再通过寻址和传输将序列化的二进制发送给B服务器。

  • 第四：B服务器收到请求后，需要进行反序列化，恢复为内存中的表达方式，然后找到对应的方法进行本地调用并返回，序列化返回值并发送给A服务器。

  • 第五：A服务器收到B服务器的返回值后，进行反序列化，恢复为内存中的表达方式，然后交给A服务器上的应用进行处理。


以上参考： 谁能用通俗的语言解释一下什么是 RPC 框架？


RPC的协议有很多，比如Java RMI、WebService的RPC风格、Hession、Thrift、REST API

2. RPC、RMI、SOAP、REST的区别

RMI(remote method invocation，面向对象的远程方法调用)
RPC（remote procedure call，远程过程调用）
SOAP(simple object access protoal，简单对象访问协议)
REST(representational state transfer，表达性状态转移)

可以都理解为调用远程方法的一些通信技术“风格”：

· RMI就好比它是本地工作，采用tcp/ip协议，客户端直接调用服务端上的一些方法。优点是强类型，编译期可检查错误，缺点是只能基于JAVA语言，客户机与服务器紧耦合。

· RPC是一个泛化的概念，严格来说一切远程过程调用手段都属于rpc范畴，包括rmi、hessian、soap、thrift、protobuf等等。

· SOAP是在XML-RPC基础上，使用标准的XML描述了RPC的请求信息（URI/类/方法/参数/返回值）。因为XML-RPC只能使用有限的数据类型种类和一些简单的数据结构，SOAP能支持更多的类型和数据结构。优点是跨语言，非常适合异步通信和针对松耦合的C/S，缺点是必须做很多运行时检查。

· REST一般用来和SOAP做比较，它采用简单的URL方式来代替一个对象，优点是轻量，可读性较好，不需要其他类库支持，缺点是URL可能会很长，不容易解析。

常用的RPC框架

3. Java RMI

Java RMI（Romote Method Invocation）是一种基于Java的远程方法调用技术，是Java特有的一种RPC实现。它能够部署在不同主机上的Java对象之间进行透明的通信与方法调用。

RMI工作原理：


首先，在一个JVM中启动rmiregistry服务，启动时可以指定服务监听的端口，也可以使用默认的端口。

其次，RMIServer在本地先实例化一个提供服务的实现类，然后通过RMI提供的Naming，Context，Registry等类的bind或rebind方法将刚才实例化好的实现类注册到RMIService上并对外暴露一个名称。

最后，RMIClient通过本地的接口和一个已知的名称（即RMIServer暴露出的名称）再使用RMI提供的Naming，Context，Registry等类的lookup方法从RMIService那拿到实现类。这样虽然本地没有这个类的实现类，但所有的方法都在接口里了，想怎么调就怎么调。

RMI 采用stubs 和 skeletons 来进行远程对象(remote object)的通讯。stub 充当远程对象的客户端代理，有着和远程对象相同的远程接口，远程对象的调用实际是通过调用该对象的客户端代理对象stub来完成的，通过该机制RMI就好比它是本地工作，采用tcp/ip协议，客户端直接调用服务端上的一些方法。优点是强类型，编译期可检查错误，缺点是只能基于Java语言，客户机与服务器紧耦合。

具体RMI的原理可参考：java RMI原理详解

深入理解rmi原理

RMI使用Demo：

定义RMI对外服务接口：RMI接口方法定义必须显示声明抛出RemoteException异常。


  
    
    
  
     
   
  1. package com.yyy.RMIDemo.java.server;
    2.  
   
  2. import java.rmi.Remote;
    3.  
   
  3. import java.rmi.RemoteException;
    4.  
   
  4. /
    5.  
   
  5.  * RMI对外服务接口
    6.  
   
  6.  * @author
    7.  
   
  7.  *
    8.  
   
  8.  */
    9.  
   
  9. public interface HelloService extends Remote{
    10.  
   
  10.  public String sayHello(String someone) throws RemoteException;
    11.  
   
  11. }
    12.

服务端接口实现：服务端方法实现必须继承UnicastRemoteObject类，该类定义了服务调用方与服务提供方对象实例，并建立一对一的连接。


  
    
    
  
     
   
  1. package com.yyy.RMIDemo.java.server;
    2.  
   
  2. import java.rmi.RemoteException;
    3.  
   
  3. import java.rmi.server.UnicastRemoteObject;
    4.  
   


  4. /
    5.  
   
  5. * 服务器端接口实现
    6.  
   
  6. * @author
    7.  
   
  7. *
    8.  
   
  8. /
    9.  
   
  9. public class HelloServiceImpl extends UnicastRemoteObject implements HelloService {
    10.  
   
  10.  
    11.  
   
  11.  private static final long serialVersionUID = 4176511759435216154L;
    12.  
   
  12.  
    13.  
   
  13.  protected HelloServiceImpl() throws RemoteException {
    14.  
   
  14.  super();
    15.  
   
  15.  // TODO Auto-generated constructor stub
    16.  
   
  16.  }
    17.  
   
  17.  
    18.  
   
  18.  @Override
    19.  
   
  19.  public String sayHello(String someone) throws RemoteException {
    20.  
   
  20.  // TODO Auto- generated method stub
    21.  
   
  21.  return "Hello" + someone;
    22.  
   
  22.  }
    23.  
   
  23.  
    24.  
   
  24. }
    25.


RMI的通信端口是随机产生的，因此有可能被防火墙拦截，为了防止被防火墙拦截，需要强制指定RMI的通信端口。一般通过自定义一个RMISocketFactory类来实现，代码如下：


 
   
     
    
  1. package com.yyy.RMIDemo.java.server;
    2.  
    
  2. import java.io.IOException;
    3.  
    
  3. import java.net.ServerSocket;
    4.  
    
  4. import java.net.Socket;
    5.  
    
  5. import java.rmi.server.RMISocketFactory;
    6.  
    
  6. public class CustomerSocketFactory extends RMISocketFactory{
    7.  
    
  7. @Override
    8.  
    
  8. public ServerSocket createServerSocket(int port) throws IOException {
    9.  
    
  9. // TODO Auto-generated method stub
    10.  
    
  10. if (port == 0) {
    11.  
    
  11. port = 8051;
    12.  
    
  12. }
    13.  
    
  13. System.out.println("rmi notify port : " + port);
    14.  
    
  14. return new ServerSocket(port);
    15.  
    
  15. }
    16.  
    
  16. //指定通信端口，防止被防火墙拦截
    17.  
    
  17. @Override
    18.  
    
  18. public Socket createSocket(String host, int port) throws IOException {
    19.  
    
  19. // TODO Auto-generated method stub
    20.  
    
  20. return new Socket(host, port);
    21.  
    
  21. }
    22.  
    
  22. }
    23.

服务端RMI服务启动：

 
   
     
    
  1. package com.yyy.RMIDemo.java.server;
    2.  
    
  2. import java.rmi.Naming;
    3.  
    
  3. import java.rmi.registry.LocateRegistry;
    4.  
    
  4. import java.rmi.server.RMISocketFactory;
    5.  
    
  5. public class ServerMain {
    6.  
    
  6. public static void main(String[] args) throws Exception {
    7.  
    
  7. //创建服务
    8.  
    
  8. HelloService helloService = new HelloServiceImpl();
    9.  
    
  9. //注册服务
    10.  
    
  10. LocateRegistry.createRegistry(8801);
    11.  
    
  11. //指定通信端口，防止被防火墙拦截
    12.  
    
  12. RMISocketFactory.setSocketFactory(new CustomerSocketFactory());
    13.  
    
  13. Naming.bind("rmi://localhost:8801/helloService", helloService);
    14.  
    
  14. System.out.println("ServceMain provide service now");
    15.  
    
  15. }
    16.  
    
  16. }
    17.

客户端远程调用RMI服务代码：



  
    
    
  
     
   
  1. package com.yyy.RMIDemo.java.client;
    2.  
   
  2. import java.rmi.Naming;
    3.  
   
  3. import com.yyy.RMIDemo.java.server.HelloService;
    4.  
   
  4. public class ClientMain {
    5.  
   
  5. public static void main(String[] args) throws Exception {
    6.  
   
  6. HelloService helloService =
    7.  
   
  7. (HelloService)Naming.lookup("rmi://localhost:8801/helloService");
    8.  
   
  8. System.out.println("RMI 客户端接收到的结果是:" + helloService.sayHello("RMI"));
    9.  
   
  9. }
    10.  
   
  10. }
    11.

先运行服务器端程序ServerMain，然后运行ClinetMain，运行结果如下：

RMI 客户端接收到的结果是:HelloRMI

4. Hessian 

Hessian 是由 caucho 提供的一个基于 binary-RPC 实现的远程通讯 library 。Hessian基于Http协议进行传输。

Binary-RPC 是一种和 RMI 类似的远程调用的协议，它和 RMI 的不同之处在于它以标准的二进制格式来定义请求的信息 ( 请求的对象、方法、参数等 ) ，这样的好处是什么呢，就是在跨语言通讯的时候也可以使用。传输协议基于TCP。

Hessian可通过Servlet提供远程服务，需要将匹配某个模式的请求映射到Hessian服务。也可Spring框架整合，通过它的DispatcherServlet可以完成该功能，DispatcherServlet可将匹配模式的请求转发到Hessian服务。Hessian的server端提供一个servlet基类, 用来处理发送的请求，而Hessian的这个远程过程调用，完全使用动态代理来实现的,，建议采用面向接口编程，Hessian服务通过接口暴露。

Hessian处理过程示意图：

客户端——>序列化写到输出流——>远程方法(服务器端)——>序列化写到输出流 ——>客户端读取输入流——>输出结果

Spring + Hessian实现服务器端的demo：

在工程中导入hessian的jar包


在web.xml中，我们配置SpringMVC的DispatcherServlet：


  
    
    
  
     
   
  1. <!-- Spring hessian servlet -->
    2.  
   
  2. <servlet>
    3.  
   
  3. <servlet-name>hessian</servlet-name>
    4.  
   
  4. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    5.  
   
  5. <init-param>
    6.  
   
  6. <param-name>contextConfigLocation</param-name>
    7.  
   
  7. <param-value>classpath:spring-hessian.xml</param-value>
    8.  
   
  8. </init-param>
    9.  
   
  9. <load-on-startup>1</load-on-startup>
    10.  
   
  10. <async-supported>true</async-supported>
    11.  
   
  11. </servlet>
    12.  
   
  12. <servlet-mapping>
    13.  
   
  13. <servlet-name>hessian</servlet-name>
    14.  
   


  14.  <url-pattern>/pubservice/</url-pattern>
    15.  
   
  15. </servlet-mapping>
    16.

spring-hessian.xml的配置：


  
    
    
  
     
   
  1. <bean id="/testService" class="com.example.platform.hession.MyHessianServiceExporter">
    2.  
   
  2. <property name="service" ref="testServiceImpl" />
    3.  
   
  3. <property name="serviceInterface" value="com.xinwei.platform.pubservice.TestService" />
    4.  
   
  4. </bean>
    5.

使用了org.springframework.remoting.caucho.HessianServiceExporter来发布服务。将程序部署在tomcat中。如果我们想从HessianServiceExporter的handleRequest方法中可以获得客户端request，那我们就会有很多种方法得到此request；Aop方式或重写方法，我们采用重写的方式：


  
    
    
  
     
   
  1. /
    2.  
   
  2.  *
    3.  
   
  3.  */
    4.  
   
  4. package com.example.platform.hession;
    5.  
   
  5.  
    6.  
   
  6. import javax.servlet.ServletRequest;
    7.  
   
  7.  
    8.  
   
  8. /
    9.  
   
  9. * Hession service线程上下文，用以线程安全地保存客户端request
    10.  
   
  10. * @author yangyunyun
    11.  
   
  11. *
    12.  
   
  12. /
    13.  
   
  13. public class HessionContext {
    14.  
   
  14.  private ServletRequest request;
    15.  
   
  15.  private static final ThreadLocal<HessionContext> localContext
    16.  
   
  16.  = new ThreadLocal<HessionContext>(){
    17.  
   
  17.  @Override
    18.  
   
  18.  public HessionContext initialValue(){
    19.  
   
  19.  return new HessionContext();
    20.  
   
  20.  }
    21.  
   
  21.  };
    22.  
   
  22.  
    23.  
   
  23.  private HessionContext(){
    24.  
   
  24.  
    25.  
   
  25.  }
    26.  
   
  26.  
    27.  
   
  27.  
    28.  
   
  28.  public static ServletRequest getRequest() {
    29.  
   
  29.  return localContext.get().request;
    30.  
   
  30.  }
    31.  
   
  31.  
    32.  
   
  32.  
    33.  
   
  33.  public static void setRequest(ServletRequest request) {
    34.  
   
  34.  localContext.get().request = request;
    35.  
   
  35.  }
    36.  
   
  36.  
    37.  
   
  37.  public static void clear() {
    38.  
   
  38.  localContext.get().request = null;
    39.  
   
  39.  }
    40.  
   
  40.  
    41.  
   
  41.  
    42.  
   
  42.  
    43.  
   
  43.  
    44.  
   
  44. }
    45.

自定义类:


  
    
    
  
     
   


  1. /*
    2.  
   
  2. *
    3.  
   
  3. /
    4.  
   
  4.  
    5.  
   
  5. import java.io.IOException;
    6.  
   
  6.  
    7.  
   
  7. import javax.servlet.ServletException;
    8.  
   
  8. import javax.servlet.http.HttpServletRequest;
    9.  
   
  9. import javax.servlet.http.HttpServletResponse;
    10.  
   
  10.  
    11.  
   
  11. import org.slf4j.Logger;
    12.  
   
  12. import org.slf4j.LoggerFactory;
    13.  
   
  13. import org.springframework.remoting.caucho.HessianExporter;
    14.  
   
  14. import org.springframework.web.HttpRequestHandler;
    15.  
   
  15. import org.springframework.web.HttpRequestMethodNotSupportedException;
    16.  
   
  16. import org.springframework.web.util.NestedServletException;
    17.  
   
  17.  
    18.  
   
  18. /*
    19.  
   
  19. * @author
    20.  
   
  20. *
    21.  
   
  21. */
    22.  
   
  22. public class MyHessianServiceExporter extends HessianExporter implements HttpRequestHandler {
    23.  
   
  23. private static final Logger logger = LoggerFactory.getLogger(InmpServiceExporter.class);
    24.  
   
  24. @Override
    25.  
   
  25. public void handleRequest(HttpServletRequest request,
    26.  
   
  26. HttpServletResponse response)
    27.  
   
  27. throws ServletException, IOException {
    28.  
   
  28. // TODO Auto-generated method stub
    29.  
   
  29. if (!"POST".equals(request.getMethod())){
    30.  
   
  30. throw new HttpRequestMethodNotSupportedException(
    31.  
   
  31. request.getMethod(), new String[]{"POST"},
    32.  
   
  32. "HessionSeriviceExporter only supports POST requests");
    33.  
   
  33. }
    34.  
   
  34. response.setContentType(CONTENTTYPEHESSIAN);
    35.  
   
  35. try {
    36.  
   
  36. //保存request到Hession线程上下文
    37.  
   
  37. HessionContext.setRequest(request);
    38.  
   
  38. invoke(request.getInputStream(), response.getOutputStream());
    39.  
   
  39. } catch (Throwable ex) {
    40.  
   
  40. // TODO: handle exception
    41.  
   
  41. logger.error("Hession skeleton invocation failed");
    42.  
   
  42. throw new NestedServletException("Hession skeleton invocation failed", ex);
    43.  
   
  43. } finally{
    44.  
   
  44. HessionContext.clear();
    45.  
   
  45. }
    46.  
   
  46. }
    47.  
   
  47. }
    48.

Service开发中就可以直接使用  HessianContext.getRequest(); 来获得客户端的request了，所有的客户端信息随你所用了，而且是线程安全的。

服务器端服务接口：


  
    
    
  
     
   
  1. package com.example.platform.pubservice;
    2.  
   
  2. public interface TestService {
    3.  
   
  3. public String sayHello(String datas);
    4.  
   
  4. }
    5.

接口实现类：


  
    
    
  
     
   
  1. package com.example.platform.pubservice.impl;
    2.  
   
  2. import com.example.platform.pubservice.TestService;
    3.  
   
  3. public class TestServiceImpl extends InmpHessianHandle implements TestService{
    4.  
   
  4. @Override
    5.  
   
  5. public String sayHello(String datas) {
    6.  
   
  6. // TODO Auto-generated method stub
    7.  
   
  7. return "Hello " + datas;
    8.  
   
  8. }
    9.  
   
  9. }
    10.

client调用：


  
    
    
  
     
   
  1. public class TestClient {
    2.  
   
  2. public static void main(String[] args) {
    3.  
   
  3. try {
    4.  
   
  4. String url = "http://localhost:8080/HessianDemo/pubservice/testService";
    5.  
   
  5. HessianProxyFactory factory = new HessianProxyFactory();
    6.  
   
  6. factory.setOverloadEnabled(true);
    7.  
   
  7. TestService testService = (TestService) factory.create(TestService.class, url);
    8.  
   
  8. System.out.println(basic.sayHello("SW"));
    9.  
   
  9. }catch (Exception e){
    10.  
   
  10. e.printStackTrace();
    11.  
   
  11. }
    12.  
   
  12. }
    13.  
   
  13. }
    14.

Hessian的原理以及使用请参考：Hessian的使用以及理解

5. WebService

WebService是一种跨平台的RPC技术协议。WebService技术栈由SOAP（简单对象访问协议）、UDDI（统一描述、发现与集成）、WSDL（网络服务描述语言：用来描述Service、以及如何访问WebService）组成。SOAP是一种使用XML进行数据编码的通信协议。独立于平台、独立于语言，简单可扩展。

WebService常用的两种实现：CXF和Axis2

详解见 从零开始写分布式服务框架 1.3小节

目前三种主流的web服务实现方法： 

REST（新型）：表象化状态转变 (软件架构风格）RESTEasy、Wink、CXF、Axis2…….

SOAP（比较成熟）：简单对象访问协议  Xfire、Axis2、CXF、Axis1

XML-RPC（淘汰）：远程过程调用协议（慢慢被soap 所取代）

1、Java开发WebService最重要的两个规范：

JSR-224 (JAX-WS：Java API for XML-Based Web Services ) ，主要使用soap协议，使用wsdl来描述；

JSR-311 (JAX-RS：The Java API for RESTful Web Services)，简化了 web service 的设计，它不再需要 wsdl ，也不再需要 soap 协议，而是通过最简单的 http 协议传输数据 ( 包括 xml 或 json) 。既简化了设计，也减少了网络传输量（因为只传输代表数据的 xml 或 json ，没有额外的 xml 包装）。

JAX-WS是针对WebService。而JAX-RS是针对RESTful HTTP Service。

RESTful HTTP Service相关介绍可以参考：RESTful Service API 设计最佳工程实践和常见问题解决方案

JAX-WS与JAX-RS两者是不同风格的SOA架构。前者以动词为中心，指定的是每次执行函数。而后者以名词为中心，每次执行的时候指的是资源。

JAX-RS是JAVA EE6 引入的一个新技术。是一个Java 编程语言的应用程序接口，支持按照表述性状态转移(REST)架构风格创建Web服务。JAX-RS使用了Java SE5引入的Java标注来简化Web服务的客户端和服务端的开发和部署。

JAX-WS规范是一组XML web services的JAVA API，JAX-WS允许开发者可以选择RPC-oriented或者message-oriented 来实现自己的web services。

支持JAX-WS服务规范的框架有：CXF，Axis，Xfire。结合java语言均可可实现JAX-WS

支持JAX-RS服务规范的框架有： 

1.CXF——XFire和Celtix的合并 

2.Jersey——Sun公司的JAX-RS参考实现。 

3.RESTEasy——JBoss的JAX-RS项目。

4.Restlet——也许是最早的REST框架了，它JAX-RS之前就有了。

在分布式服务框架中，除了实现RPC的特性以外，还包括负载均衡策略以及实现，服务的注册、发布与引入。服务的高可用策略以及服务治理等特性。 

以上是关于常用的RPC框架的主要内容，如果未能解决你的问题，请参考以下文章

常用RPC框架及如何设计一个RPC框架

什么是RPC？RPC好处？常用的RPC框架？

JAVA中几种常用的RPC框架介绍

JAVA中几种常用的RPC框架介绍

JAVA中几种常用的RPC框架介绍

JAVA中几种常用的RPC框架介绍