1.RMI简单介绍
Spring除了使用基于HTTP协议的远程调用方案，还为开发者提供了基于RMI机制的远程调用方法，RMI远程调用网络通信实现是基于TCP/IP协议完成的，而不是通过HTTP协议。
在Spring RMI实现中，集成了标准的RMI-JRIM解决方案，该方案是java虚拟机实现的一部分，它使用java序列化来完成对象的传输，是一个java到java环境的分布式处理技术，不涉及异构平台的处理。
2.RMI客户端配置：
和基于HTTP协议的远程调用类似，RMI远程调用客户端也需要进行类似如下的配置：
<bean id=”rmiProxy” class=”org.springframework.remoting.rmi.RmiProxyFactoryBean”>
<property name=”serviceUrl”>
<value>rmi://hostAddress:1099/serviceUrl</value>
</property>
<property name=”serviceInterface”>
<value>远程调用接口</value>
</property>
</bean>
<bean id=”rmiClient” class=”RMI远程调用客户端类全路径”>
<property name=”serviceInterface”>
<ref bean=”rmiProxy”/>
</property>
</bean>注意：上面的配置中serviceUrl必须和服务端的远程调用提供者的id一致，另外，serviceUrl中使用的是rmi协议，默认端口是1099.
3.RmiProxyFactoryBean
RmiProxyFactoryBean的主要功能是对RMI客户端封装，生成代理对象，查询得到RMI的stub对象，并通过这个stub对象发起相应的RMI远程调用请求。其源码如下：
public class RmiProxyFactoryBean extends RmiClientInterceptor implements FactoryBean<Object>, BeanClassLoaderAware {
//远程调用代理对象
private Object serviceProxy;
//Spring IoC容器完成依赖注入后的回调方法
public void afterPropertiesSet() {
//调用父类RmiClientInterceptor的回调方法
super.afterPropertiesSet();
//获取客户端配置的远程调用接口
if (getServiceInterface() == null) {
throw new IllegalArgumentException("Property 'serviceInterface' is required");
}
//创建远程调用代理对象并为代理对象设置拦截器。注意第二个参数this,因为
//RmiProxyFactoryBean继承RmiClientInterceptor，因此其也是拦截器
this.serviceProxy = new ProxyFactory(getServiceInterface(), this).getProxy(getBeanClassLoader());
}
//Spring IoC容器获取被管理对象的接口方法，获取远程调用代理
public Object getObject() {
return this.serviceProxy;
}
public Class<?> getObjectType() {
return getServiceInterface();
}
public boolean isSingleton() {
return true;
}
}
通过对上面RmiProxyFactoryBean源码分析中，我们看到在创建远程调用代理对象的时候需要设置拦截器，因为我们继续分析远程调用客户端拦截器RmiClientInterceptor。
4.RmiClientInterceptor封装RMI客户端：
RmiClientInterceptor对客户端的远程调用进行拦截，具体的生成远程调用代理对象、查找远程调用stub、以及通过RMI stub向服务端发起远程调用请求的具体实现都由RMI客户端拦截器实现，其源码如下：
public class RmiClientInterceptor extends RemoteInvocationBasedAccessor
implements MethodInterceptor {
//在Spring启动时查找远程调用stub
private boolean lookupStubOnStartup = true;
//对查找到或使用过的远程调用stub进行缓存
private boolean cacheStub = true;
//当连接失败是是否刷新远程调用stub
private boolean refreshStubOnConnectFailure = false;
//RMI客户端socket工厂
private RMIClientSocketFactory registryClientSocketFactory;
//缓存的远程调用stub
private Remote cachedStub;
//创建远程调用stub监控器
private final Object stubMonitor = new Object();
//设置是否启动时查找RMI stub
public void setLookupStubOnStartup(boolean lookupStubOnStartup) {
this.lookupStubOnStartup = lookupStubOnStartup;
}
//设置是否缓存以查找的RMI stub
public void setCacheStub(boolean cacheStub) {
this.cacheStub = cacheStub;
}
//设置当连接失败时，是否刷新RMI stub
public void setRefreshStubOnConnectFailure(boolean refreshStubOnConnectFailure) {
this.refreshStubOnConnectFailure = refreshStubOnConnectFailure;
}
//设置客户端socket工厂
public void setRegistryClientSocketFactory(RMIClientSocketFactory registryClientSocketFactory) {
this.registryClientSocketFactory = registryClientSocketFactory;
}
//Spring IoC容器回调方法，由子类RmiProxyFactoryBean回调方法调用
public void afterPropertiesSet() {
//调用父类RemoteInvocationBasedAccessor的回调方法
super.afterPropertiesSet();
prepare();
}
//初始化RMI客户端
public void prepare() throws RemoteLookupFailureException {
//如果设置了启动时查找RMI stub
if (this.lookupStubOnStartup) {
//查找RMI stub
Remote remoteObj = lookupStub();
if (logger.isDebugEnabled()) {
//如果查找到的RMI stub是RmiInvocationHandler类型
if (remoteObj instanceof RmiInvocationHandler) {
logger.debug("RMI stub [" + getServiceUrl() + "] is an RMI invoker");
}
//如果获取到客户端配置的serviceInterface不为null
else if (getServiceInterface() != null) {
//判断客户端配置的serviceInterface是否是RMI stub实例
boolean isImpl = getServiceInterface().isInstance(remoteObj);
logger.debug("Using service interface [" + getServiceInterface().getName() +
"] for RMI stub [" + getServiceUrl() + "] - " +
(!isImpl ? "not " : "") + "directly implemented");
}
}
//如果设置了缓存RMI stub，将缓存的stub设置为查找到的RMI stub
if (this.cacheStub) {
this.cachedStub = remoteObj;
}
}
}
//查找RMI stub
protected Remote lookupStub() throws RemoteLookupFailureException {
try {
Remote stub = null;
//如果设置了客户端socket工厂
if (this.registryClientSocketFactory != null) {
//获取并解析客户端配置的serviceUrl
URL url = new URL(null, getServiceUrl(), new DummyURLStreamHandler());
//获取客户端配置的serviceUrl协议
String protocol = url.getProtocol();
//如果客户端配置的serviceUrl中协议不为null且不是rmi
if (protocol != null && !"rmi".equals(protocol)) {
throw new MalformedURLException("Invalid URL scheme '" + protocol + "'");
}
//获取客户端配置的serviceUrl中的主机地址
String host = url.getHost();
//获取客户端配置的serviceUrl中的端口
int port = url.getPort();
//获取客户端配置的serviceUrl中请求路径
String name = url.getPath();
//如果请求路径不为null，且请求路径以”/”开头，则去掉”/”
if (name != null && name.startsWith("/")) {
name = name.substring(1);
}
//根据客户端配置的serviceUrl信息和客户端socket工厂创建远程对
//象引用
Registry registry = LocateRegistry.getRegistry(host, port, this.registryClientSocketFactory);
//通过远程对象引用查找指定RMI请求的RMI stub
stub = registry.lookup(name);
}
//如果客户端配置的serviceUrl中协议为null或者是rmi
else {
//直接通过RMI标准API查找客户端配置的serviceUrl的RMI stub
stub = Naming.lookup(getServiceUrl());
}
if (logger.isDebugEnabled()) {
logger.debug("Located RMI stub with URL [" + getServiceUrl() + "]");
}
return stub;
}
//对查找RMI stub过程中异常处理
catch (MalformedURLException ex) {
throw new RemoteLookupFailureException("Service URL [" + getServiceUrl() + "] is invalid", ex);
}
catch (NotBoundException ex) {
throw new RemoteLookupFailureException(
"Could not find RMI service [" + getServiceUrl() + "] in RMI registry", ex);
}
catch (RemoteException ex) {
throw new RemoteLookupFailureException("Lookup of RMI stub failed", ex);
}
}
//获取RMI stub
protected Remote getStub() throws RemoteLookupFailureException {
//如果没有配置缓存RMI stub，或者设置了启动时查找RMI stub或当连接失败时
//不刷新RMI stub
if (!this.cacheStub || (this.lookupStubOnStartup && !this.refreshStubOnConnectFailure)) {
//如果缓存的RMI stub不为null，则直接返回，否则，查找RMI stub
return (this.cachedStub != null ? this.cachedStub : lookupStub());
}
//如果设置了缓存RMI stub，且设置了启动时查找RMI stub或者当连接失败时刷新
//RMI stub
else {
//线程同步
synchronized (this.stubMonitor) {
//如果缓存的RMI stub为null
if (this.cachedStub == null) {
//则将查找的RMI stub缓存
this.cachedStub = lookupStub();
}
//返回缓存的RMI stub
return this.cachedStub;
}
}
}
//拦截器对客户端远程调用方法的拦截入口
public Object invoke(MethodInvocation invocation) throws Throwable {
//获取RMI stub
Remote stub = getStub();
try {
//拦截客户端远程调用方法
return doInvoke(invocation, stub);
}
catch (RemoteConnectFailureException ex) {
return handleRemoteConnectFailure(invocation, ex);
}
catch (RemoteException ex) {
if (isConnectFailure(ex)) {
return handleRemoteConnectFailure(invocation, ex);
}
else {
throw ex;
}
}
}
//判断是否连接失败
protected boolean isConnectFailure(RemoteException ex) {
return RmiClientInterceptorUtils.isConnectFailure(ex);
}
//处理远程连接失败
private Object handleRemoteConnectFailure(MethodInvocation invocation, Exception ex) throws Throwable {
//如果设置了当连接失败时，刷新RMI stub
if (this.refreshStubOnConnectFailure) {
String msg = "Could not connect to RMI service [" + getServiceUrl() + "] - retrying";
if (logger.isDebugEnabled()) {
logger.warn(msg, ex);
}
else if (logger.isWarnEnabled()) {
logger.warn(msg);
}
//刷新查找远程调用stub
return refreshAndRetry(invocation);
}
else {
throw ex;
}
}
//刷新RMI stub
protected Object refreshAndRetry(MethodInvocation invocation) throws Throwable {
Remote freshStub = null;
//线程同步
synchronized (this.stubMonitor) {
this.cachedStub = null;
//查找RMI stub
freshStub = lookupStub();
//如果设置了缓存RMI stub
if (this.cacheStub) {
//将刷新查找的RMI stub缓存
this.cachedStub = freshStub;
}
}
return doInvoke(invocation, freshStub);
}
//具体RMI调用的地方
protected Object doInvoke(MethodInvocation invocation, Remote stub) throws Throwable {
//如果RMI stub是RmiInvocationHandler类型
if (stub instanceof RmiInvocationHandler) {
//调用RmiInvocationHandler的RMI
try {
return doInvoke(invocation, (RmiInvocationHandler) stub);
}
catch (RemoteException ex) {
throw RmiClientInterceptorUtils.convertRmiAccessException(
invocation.getMethod(), ex, isConnectFailure(ex), getServiceUrl());
}
catch (InvocationTargetException ex) {
Throwable exToThrow = ex.getTargetException();
RemoteInvocationUtils.fillInClientStackTraceIfPossible(exToThrow);
throw exToThrow;
}
catch (Throwable ex) {
throw new RemoteInvocationFailureException("Invocation of method [" + invocation.getMethod() +
"] failed in RMI service [" + getServiceUrl() + "]", ex);
}
}
//如果RMI stub不是RmiInvocationHandler类型
else {
//使用传统的RMI调用方式
try {
return RmiClientInterceptorUtils.invokeRemoteMethod(invocation, stub);
}
catch (InvocationTargetException ex) {
Throwable targetEx = ex.getTargetException();
if (targetEx instanceof RemoteException) {
RemoteException rex = (RemoteException) targetEx;
throw RmiClientInterceptorUtils.convertRmiAccessException(
invocation.getMethod(), rex, isConnectFailure(rex), getServiceUrl());
}
else {
throw targetEx;
}
}
}
}
//调用RmiInvocationHandler的RMI
protected Object doInvoke(MethodInvocation methodInvocation, RmiInvocationHandler invocationHandler)
throws RemoteException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
//如果客户端远程调用请求是toString()方法
if (AopUtils.isToStringMethod(methodInvocation.getMethod())) {
return "RMI invoker proxy for service URL [" + getServiceUrl() + "]";
}
//使用RmiInvocationHandler处理RMI调用
return invocationHandler.invoke(createRemoteInvocation(methodInvocation));
}
}
通过上面对RmiClientInterceptor源码分析，我们看到Spring对RMI远程调用使用以下两种方式：
(1).RMI调用器方式：
这种方式和Spring HTTP调用器非常类似，即使用RemoteInvocation来封装调用目标对象、目标方法、参数类型等信息，RMI服务器端接收到RMI请求之后直接调用目标对象的匹配方法。
(2).传统RMI调用方式：
使用JDK的反射机制，直接调用远程调用stub的方法。
5.RMI的服务端配置：
在Spring RMI服务端需要进行类似如下的配置：
<bean id=”rmiService” class=”org.springframework.remoting.rmi.RmiServiceExporter”>
<property name=”service”>
<ref bean=”RMI服务端对象”/>
</property>
<property name=”serviceInterface”>
<value>RMI服务接口</value>
</property>
<property name=”serviceName”>
<value>RMI服务导出名称</value>
</property>
<property name=”registerPort”>
<value>1099</value>
</property>
</bean>
RMI中，基于TCP/IP协议，而不是HTTP协议来实现底层网络通信，由于RMI的网络通信已由Java RMI实现，所以这里不再使用Spring MVC的DispatcherServlet来转发客户端配置的远程调用请求URL，只需要指定RMI的TCP/.IP监听端口和服务导出的名称即可。
6.RmiServiceExporter导出RMI远程调用对象：
RmiServiceExporter主要功能是将服务端远程对象提供的服务导出供客户端请求调用，同时将导出的远程对象和注册器绑定起来供客户端查询，其主要源码如下：
public class RmiServiceExporter extends RmiBasedExporter implements InitializingBean, DisposableBean {
//导出的RMI服务名称
private String serviceName;
//RMI服务端口
private int servicePort = 0;
//RMI客户端socket工厂
private RMIClientSocketFactory clientSocketFactory;
//RMI服务端socket工厂
private RMIServerSocketFactory serverSocketFactory;
//注册器
private Registry registry;
//注册主机
private String registryHost;
//注册端口
private int registryPort = Registry.REGISTRY_PORT;
//客户端注册socket工厂
private RMIClientSocketFactory registryClientSocketFactory;
//服务端注册socket工厂
private RMIServerSocketFactory registryServerSocketFactory;
//总是创建时注册
private boolean alwaysCreateRegistry = false;
//替换已有的绑定
private boolean replaceExistingBinding = true;
//导出的远程对象
private Remote exportedObject;
//创建注册
private boolean createdRegistry = false;
//注入服务端配置的RMI导出服务名称，格式为：“rmi://host:post/NAME”
public void setServiceName(String serviceName) {
this.serviceName = serviceName;
}
//设置服务端口
public void setServicePort(int servicePort) {
this.servicePort = servicePort;
}
//设置RMI客户端socket工厂
public void setClientSocketFactory(RMIClientSocketFactory clientSocketFactory) {
this.clientSocketFactory = clientSocketFactory;
}
//设置RMI服务端socket工厂
public void setServerSocketFactory(RMIServerSocketFactory serverSocketFactory) {
this.serverSocketFactory = serverSocketFactory;
}
//设置RMI注册器
public void setRegistry(Registry registry) {
this.registry = registry;
}
//设置RMI注册主机
public void setRegistryHost(String registryHost) {
this.registryHost = registryHost;
}
//设置RMI注册端口
public void setRegistryPort(int registryPort) {
this.registryPort = registryPort;
}
//设置用于注册的RMI客户端socket工厂
public void setRegistryClientSocketFactory(RMIClientSocketFactory registryClientSocketFactory) {
this.registryClientSocketFactory = registryClientSocketFactory;
}
//设置用于注册的RMI服务端socket工厂
public void setRegistryServerSocketFactory(RMIServerSocketFactory registryServerSocketFactory) {
this.registryServerSocketFactory = registryServerSocketFactory;
}
//设置是否总是创建注册，而不是试图查找指定端口上已有的注册
public void setAlwaysCreateRegistry(boolean alwaysCreateRegistry) {
this.alwaysCreateRegistry = alwaysCreateRegistry;
}
//设置是否提供已绑定的RMI注册
public void setReplaceExistingBinding(boolean replaceExistingBinding) {
this.replaceExistingBinding = replaceExistingBinding;
}
//IoC容器依赖注入完成之后的回调方法
public void afterPropertiesSet() throws RemoteException {
prepare();
}
//初始化RMI服务导出器
public void prepare() throws RemoteException {
//调用其父类RmiBasedExporter的方法，检查服务引用是否被设置
checkService();
//如果服务导出名称为null
if (this.serviceName == null) {
throw new IllegalArgumentException("Property 'serviceName' is required");
}
//检查socket工厂
if (this.clientSocketFactory instanceof RMIServerSocketFactory) {
this.serverSocketFactory = (RMIServerSocketFactory) this.clientSocketFactory;
}
if ((this.clientSocketFactory != null && this.serverSocketFactory == null) ||
(this.clientSocketFactory == null && this.serverSocketFactory != null)) {
throw new IllegalArgumentException(
"Both RMIClientSocketFactory and RMIServerSocketFactory or none required");
}
//检查RMI注册的socket工厂
if (this.registryClientSocketFactory instanceof RMIServerSocketFactory) {
this.registryServerSocketFactory = (RMIServerSocketFactory) this.registryClientSocketFactory;
}
if (this.registryClientSocketFactory == null && this.registryServerSocketFactory != null) {
throw new IllegalArgumentException(
"RMIServerSocketFactory without RMIClientSocketFactory for registry not supported");
}
this.createdRegistry = false;
//获取RMI注册器
if (this.registry == null) {
this.registry = getRegistry(this.registryHost, this.registryPort,
this.registryClientSocketFactory, this.registryServerSocketFactory);
this.createdRegistry = true;
}
//获取要被导出的服务端远程对象
this.exportedObject = getObjectToExport();
if (logger.isInfoEnabled()) {
logger.info("Binding service '" + this.serviceName + "' to RMI registry: " + this.registry);
}
//导出远程服务对象
if (this.clientSocketFactory != null) {
UnicastRemoteObject.exportObject(
this.exportedObject, this.servicePort, this.clientSocketFactory, this.serverSocketFactory);
}
else {
UnicastRemoteObject.exportObject(this.exportedObject, this.servicePort);
}
//将RMI对象绑定到注册器
try {
if (this.replaceExistingBinding) {
this.registry.rebind(this.serviceName, this.exportedObject);
}
else {
this.registry.bind(this.serviceName, this.exportedObject);
}
}
//异常处理
catch (AlreadyBoundException ex) {
unexportObjectSilently();
throw new IllegalStateException(
"Already an RMI object bound for name '" + this.serviceName + "': " + ex.toString());
}
catch (RemoteException ex) {
unexportObjectSilently();
throw ex;
}
}
……
}
7.RemoteInvocationBasedExporter处理RMI远程调用请求：
RmiServiceExporter的父类RmiBasedExporter的父类RemoteInvocationBasedExporter负责对RMI远程调用请求进行处理，并将处理的结果封装返回，其源码如下：
public abstract class RemoteInvocationBasedExporter extends RemoteExporter {
//RMI远程调用处理器，RMI远程调用请求是由DefaultRemoteInvocationExecutor处理
private RemoteInvocationExecutor remoteInvocationExecutor = new DefaultRemoteInvocationExecutor();
//设置RMI远程调用处理器
public void setRemoteInvocationExecutor(RemoteInvocationExecutor remoteInvocationExecutor) {
this.remoteInvocationExecutor = remoteInvocationExecutor;
}
//获取RMI远程调用处理器
public RemoteInvocationExecutor getRemoteInvocationExecutor() {
return this.remoteInvocationExecutor;
}
//对RMI远程调用请求进行处理的地方
protected Object invoke(RemoteInvocation invocation, Object targetObject)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
if (logger.isTraceEnabled()) {
logger.trace("Executing " + invocation);
}
try {
//调用DefaultRemoteInvocationExecutor对RMI远程调用请求进行处理
return getRemoteInvocationExecutor().invoke(invocation, targetObject);
}
catch (NoSuchMethodException ex) {
if (logger.isDebugEnabled()) {
logger.warn("Could not find target method for " + invocation, ex);
}
throw ex;
}
catch (IllegalAccessException ex) {
if (logger.isDebugEnabled()) {
logger.warn("Could not access target method for " + invocation, ex);
}
throw ex;
}
catch (InvocationTargetException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Target method failed for " + invocation, ex.getTargetException());
}
throw ex;
}
}
//获取RMI远程调用请求的处理结果
protected RemoteInvocationResult invokeAndCreateResult(RemoteInvocation invocation, Object targetObject) {
try {
Object value = invoke(invocation, targetObject);
return new RemoteInvocationResult(value);
}
catch (Throwable ex) {
return new RemoteInvocationResult(ex);
}
}
}
RMI远程调用请求最终由DefaultRemoteInvocationExecutor处理。
8.DefaultRemoteInvocationExecutor处理RMI远程调用请求：
DefaultRemoteInvocationExecutor用于处理RMI远程调用请求，并返回处理后的结果，其源码如下：
public class DefaultRemoteInvocationExecutor implements RemoteInvocationExecutor {
//处理RMI远程调用请求
public Object invoke(RemoteInvocation invocation, Object targetObject)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException{
Assert.notNull(invocation, "RemoteInvocation must not be null");
Assert.notNull(targetObject, "Target object must not be null");
//调用RemoteInvocation处理RMI远程调用请求
return invocation.invoke(targetObject);
}
}
9.RemoteInvocation处理RMI远程调用请求：
RemoteInvocation的invoke方法处理RMI远程调用请求，并返回远程调用处理后的结果，其源码如下：
public Object invoke(Object targetObject)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
//使用JDK反射机制获取远程调用服务端目标对象的方法
Method method = targetObject.getClass().getMethod(this.methodName, this.parameterTypes);
//使用JDK反射机制调用目标对象的方法
return method.invoke(targetObject, this.arguments);
}