1. 为什么要使用RPC？
RPC（remote procedure call）是指远程过程调用，比如两台服务器A和B，A服务器上部署一个应用，B服务器上部署一个应用，A服务器上的应用想调用B服务器上的应用提供的接口，由于不在一个内存空间，不能直接调用，所以需要通过网络来表达调用的语义和传达调用的数据。
RPC（remote procedure call，远程过程调用）：
- 首先，要解决通讯的问题，主要是通过客户端和服务器端之间建立TCP连接，远程过程调用的所有交换的数据都在这个连接里传输。连接可以是按需连接，调用结束后就断掉，也可以是长连接，多个远程过程调用共享一个连接。
- 第二，要解决寻址的问题，A服务器上的应用要调用B服务器上的应用，A服务器上的应用需要通过底层RPC框架得知：如何连接到B服务器（主机或IP地址）以及特定的端口，方法的名称等信息，这样才能完成调用。
- 第三，A服务器上的应用发起远程调用时，方法的参数需要通过底层的网络协议如TCP传递到B服务器，由于网络协议是基于二进制的，内存中的参数需要序列化成二进制形式，然后再通过寻址和传输将序列化的二进制发送给B服务器。
- 第四：B服务器收到请求后，需要进行反序列化，恢复为内存中的表达方式，然后找到对应的方法进行本地调用并返回，序列化返回值并发送给A服务器。
- 第五：A服务器收到B服务器的返回值后，进行反序列化，恢复为内存中的表达方式，然后交给A服务器上的应用进行处理。
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可能会很长，不容易解析。
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使用Demo：定义RMI对外服务接口：RMI接口方法定义必须显示声明抛出RemoteException异常。
package com.yyy.RMIDemo.java.server;
import java.rmi.Remote;
import java.rmi.RemoteException;
/**
* RMI对外服务接口
* @author
*
*/
public interface HelloService extends Remote{
public String sayHello(String someone) throws RemoteException;
}
package com.yyy.RMIDemo.java.server;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
/**
* 服务器端接口实现
* @author
*
*/
public class HelloServiceImpl extends UnicastRemoteObject implements HelloService {
private static final long serialVersionUID = 4176511759435216154L;
protected HelloServiceImpl() throws RemoteException {
super();
// TODO Auto-generated constructor stub
}
@Override
public String sayHello(String someone) throws RemoteException {
// TODO Auto- generated method stub
return "Hello" + someone;
}
}
RMI的通信端口是随机产生的，因此有可能被防火墙拦截，为了防止被防火墙拦截，需要强制指定RMI的通信端口。一般通过自定义一个RMISocketFactory类来实现，代码如下：
package com.yyy.RMIDemo.java.server;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.rmi.server.RMISocketFactory;
public class CustomerSocketFactory extends RMISocketFactory{
@Override
public ServerSocket createServerSocket(int port) throws IOException {
// TODO Auto-generated method stub
if (port == 0) {
port = 8051;
}
System.out.println("rmi notify port : " + port);
return new ServerSocket(port);
}
//指定通信端口，防止被防火墙拦截
@Override
public Socket createSocket(String host, int port) throws IOException {
// TODO Auto-generated method stub
return new Socket(host, port);
}
}
服务端RMI服务启动：
package com.yyy.RMIDemo.java.server;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.RMISocketFactory;
public class ServerMain {
public static void main(String[] args) throws Exception {
//创建服务
HelloService helloService = new HelloServiceImpl();
//注册服务
LocateRegistry.createRegistry(8801);
//指定通信端口，防止被防火墙拦截
RMISocketFactory.setSocketFactory(new CustomerSocketFactory());
Naming.bind("rmi://localhost:8801/helloService", helloService);
System.out.println("ServceMain provide service now");
}
}
客户端远程调用RMI服务代码：
package com.yyy.RMIDemo.java.client;
import java.rmi.Naming;
import com.yyy.RMIDemo.java.server.HelloService;
public class ClientMain {
public static void main(String[] args) throws Exception {
HelloService helloService =
(HelloService)Naming.lookup("rmi://localhost:8801/helloService");
System.out.println("RMI 客户端接收到的结果是:" + helloService.sayHello("RMI"));
}
}
RMI 客户端接收到的结果是:HelloRMIHessian 是由 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：
<!-- Spring hessian servlet -->
<servlet>
<servlet-name>hessian</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-hessian.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
<async-supported>true</async-supported>
</servlet>
<servlet-mapping>
<servlet-name>hessian</servlet-name>
<url-pattern>/pubservice/*</url-pattern>
</servlet-mapping>
<bean id="/testService" class="com.example.platform.hession.MyHessianServiceExporter">
<property name="service" ref="testServiceImpl" />
<property name="serviceInterface" value="com.xinwei.platform.pubservice.TestService" />
</bean>使用了org.springframework.remoting.caucho.HessianServiceExporter来发布服务。将程序部署在tomcat中。如果我们想从HessianServiceExporter的handleRequest方法中可以获得客户端request，那我们就会有很多种方法得到此request；Aop方式或重写方法，我们采用重写的方式：
/**
*
*/
package com.example.platform.hession;
import javax.servlet.ServletRequest;
/**
* Hession service线程上下文，用以线程安全地保存客户端request
* @author yangyunyun
*
*/
public class HessionContext {
private ServletRequest request;
private static final ThreadLocal<HessionContext> localContext
= new ThreadLocal<HessionContext>(){
@Override
public HessionContext initialValue(){
return new HessionContext();
}
};
private HessionContext(){
}
public static ServletRequest getRequest() {
return localContext.get().request;
}
public static void setRequest(ServletRequest request) {
localContext.get().request = request;
}
public static void clear() {
localContext.get().request = null;
}
}
/**
*
*/
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.remoting.caucho.HessianExporter;
import org.springframework.web.HttpRequestHandler;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.util.NestedServletException;
/**
* @author
*
*/
public class MyHessianServiceExporter extends HessianExporter implements HttpRequestHandler {
private static final Logger logger = LoggerFactory.getLogger(InmpServiceExporter.class);
@Override
public void handleRequest(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
// TODO Auto-generated method stub
if (!"POST".equals(request.getMethod())){
throw new HttpRequestMethodNotSupportedException(
request.getMethod(), new String[]{"POST"},
"HessionSeriviceExporter only supports POST requests");
}
response.setContentType(CONTENT_TYPE_HESSIAN);
try {
//保存request到Hession线程上下文
HessionContext.setRequest(request);
invoke(request.getInputStream(), response.getOutputStream());
} catch (Throwable ex) {
// TODO: handle exception
logger.error("Hession skeleton invocation failed");
throw new NestedServletException("Hession skeleton invocation failed", ex);
} finally{
HessionContext.clear();
}
}
}
服务器端服务接口：
package com.example.platform.pubservice;
public interface TestService {
public String sayHello(String datas);
}
package com.example.platform.pubservice.impl;
import com.example.platform.pubservice.TestService;
public class TestServiceImpl extends InmpHessianHandle implements TestService{
@Override
public String sayHello(String datas) {
// TODO Auto-generated method stub
return "Hello " + datas;
}
}
public class TestClient {
public static void main(String[] args) {
try {
String url = "http://localhost:8080/HessianDemo/pubservice/testService";
HessianProxyFactory factory = new HessianProxyFactory();
factory.setOverloadEnabled(true);
TestService testService = (TestService) factory.create(TestService.class, url);
System.out.println(basic.sayHello("SW"));
}catch (Exception e){
e.printStackTrace();
}
}
}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-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之前就有了。
RESTful架构风格参考：RESTful 架构风格概述
410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
