首先我们从服务器端的发布功能开始着手，同样，Spring中的核心还是配置文件，这是所有功能的基础。在服务器端的配置文件中（上篇文章远程服务（RMI）使用示例）我们可以看到，定义了两个bean，其中一个是对接口实现类的发布，另一个则是对RMI服务的发布，使用org.Springframework.remoting.RMI.RmiServiceExporter类进行封装，其中包括了服务类、服务名、服务接口、服务端口等若干属性，因此我们可以断定，org.Springframework.remoting.RMI.RmiServiceExporter应该是发布RMI的关键类。我们可以从此类入手进行分析。
在上一篇文章的示例中，我们看出，启动Spring的RMI服务并没有多余的操作，仅仅是开启Spring的环境：new ClassPathXmlApplicationContext（"spring-config.xml"），仅此一句，于是，我们分析很可能是RmiServiceExporter在初始化的时候做了某些操作完成了端口的发布功能，那么这些操作的入口是在这个类的哪个方法里面呢？先来看一下这个类的类图：
上述是RmiServiceExporter继承了类，实际上RmiServiceExporter还实现了几个Spring中比较敏感的接口：BeanClassLoaderAware、DisposableBean、InitializingBean，其中，DisposableBean接口保证在实现该接口的bean销毁时调用其destroy方法，BeanClassLoaderAware接口保证在实现该接口的bean的初始化时调用其setBeanClassLoader方法，而InitializingBean接口保证在实现给接口的bean初始化时调用其afterPropertiesSet方法，所以我们推断RmiServiceExporter的初始化函数的入口一定在其afterPropertiesSet或者setBeanClassLoader方法中，查看代码，确认afterPropertiesSet为RmiServiceExporter功能的初始化入口。
public void afterPropertiesSet() throws RemoteException { prepare(); }
public void prepare() throws RemoteException { //检查验证service checkService(); if (this.serviceName == null) { throw new IllegalArgumentException("Property 'serviceName' is required"); } //如果用户在配置文件中配置了clientSocketFactory或者serverSocketFactory的处理；如果配置中既配置了clientSocketFactory又配置了serverSocketFactory //那么配置中的serverSocketFactory会被忽略，而使用clientSocketFactory if (this.clientSocketFactory instanceof RMIServerSocketFactory) { this.serverSocketFactory = (RMIServerSocketFactory) this.clientSocketFactory; } //clientSocketFactory和serverSocketFactory要么同时出现，要么同时不出现 if ((this.clientSocketFactory != null && this.serverSocketFactory == null) || (this.clientSocketFactory == null && this.serverSocketFactory != null)) { throw new IllegalArgumentException( "Both RMIClientSocketFactory and RMIServerSocketFactory or none required"); } // 如果配置文件中registryClientSocketFactory同时实现了RMIClientSocketFactory接口，那么会忽略配置中的registryClientSocketFactory而使用RMIClientSocketFactory if (this.registryClientSocketFactory instanceof RMIServerSocketFactory) { this.registryServerSocketFactory = (RMIServerSocketFactory) this.registryClientSocketFactory; } //不允许出现只配置registryClientSocketFactory却没有配置registryServerSocketFactory的情况出现 if (this.registryClientSocketFactory == null && this.registryServerSocketFactory != null) { throw new IllegalArgumentException( "RMIServerSocketFactory without RMIClientSocketFactory for registry not supported"); } this.createdRegistry = false; // 确定RMI registry if (this.registry == null) { this.registry = getRegistry(this.registryHost, this.registryPort, this.registryClientSocketFactory, this.registryServerSocketFactory); this.createdRegistry = true; } //初始化以及缓存导出的Object，此时通常情况下是使用RMIInvocationWrapper封装的JDK代理类，切面为RemoteInvocationTraceInterceptor this.exportedObject = getObjectToExport(); if (logger.isDebugEnabled()) { logger.debug("Binding service '" + this.serviceName + "' to RMI registry: " + this.registry); } // Export RMI object. if (this.clientSocketFactory != null) { //使用由给定的套接字工厂指定的传送方式导出远程对象，以便能够接收传入的调用。 //clientSocketFactory:进行远程对象调用的客户端套接字工厂 //serverSocketFactory：接收远程调用的服务端套接字工厂 UnicastRemoteObject.exportObject( this.exportedObject, this.servicePort, this.clientSocketFactory, this.serverSocketFactory); } else { //导出remote object，以使它能接收特定端口的调用 UnicastRemoteObject.exportObject(this.exportedObject, this.servicePort); } // Bind RMI object to registry. try { if (this.replaceExistingBinding) { this.registry.rebind(this.serviceName, this.exportedObject); } else { //绑定服务名称到remote object，外界调用servicename的时候会被exportedObject this.registry.bind(this.serviceName, this.exportedObject); } } catch (AlreadyBoundException ex) { // Already an RMI object bound for the specified service name... unexportObjectSilently(); throw new IllegalStateException( "Already an RMI object bound for name '" + this.serviceName + "': " + ex.toString()); } catch (RemoteException ex) { // Registry binding failed: let's unexport the RMI object as well. unexportObjectSilently(); throw ex; } }
果然，在afterPropertiesSet函数中将实现委托给了prepare，而在prepare方法中我们找到了RMI服务发布的功能实现，同时，我们也大致清楚了RMI服务发布的流程。
（1）验证service
此处的service对应的是配置中类型为RmiServiceExporter的service属性，它是实现类，并不是接口。尽管后期会对RmiServiceExporter做一系列的封装，但是，无论怎么封装，最终还是会将逻辑引向至RmiServiceExporter来处理，所以，发布 之前需要进行验证。
（2）处理用户自定义的SocketFactory属性
在RmiServiceExporter中提供了4个套接字工厂配置，分别是clientSocketFactory、serverSocketFactory、registryClientSocketFactory和registryServerSocketFactory。那么这两对配置又有什么区别或者说分别应用在什么样不同场景呢？
registryClientSocketFactory和registryServerSocketFactory用于主机和RMI服务器之间连接的创建，也就是当使用LocateRegistry.createRegistry(registryPort,clientSocketFactory,serverSocketFactory)方法创建Registry实例时会在RMI主机使用registryServerSocketFactory创建套接字等待连接，而服务端与RMI主机通信时会使用registryClientSocketFactory创建连接套接字。
serverSocketFactory、clientSocketFactory同样是创建套接字，但是使用的位置不同，serverSocketFactory、clientSocketFactory用于导出远程对象，serverSocketFactory用于在服务端建立套接字等待客户端连接，而clientSocketFactory用于调用端建立套接字发起连接。
（3）根据配置参数获取Registry
（4）构造对外发布的实例
构建对外发布的实例，当外界通过注册的服务名调用响应的方法时，RMI服务会将请求引入此类来处理。
（5）发布实例
在发布RMI服务的流程中，有几个步骤可能是我们比较关心的：
1.获取registry
获取registry实例时非常简单的，只需要使用一个函数LocateRegistry.createRegistry(registryPort,clientSocketFactory,serverSocketFactory)创建registry实例就可以了。但是，Spring并没有这么做，而是考虑得更多，比如RMI注册机与发布的服务并不在一台机器上，那么需要使用LocateRegistry.getRegistry(registryPort,clientSocketFactory,serverSocketFactory)去远程获取registry实例。
protected Registry getRegistry(String registryHost, int registryPort, @Nullable RMIClientSocketFactory clientSocketFactory, @Nullable RMIServerSocketFactory serverSocketFactory) throws RemoteException { if (registryHost != null) { // 远程连接测试 if (logger.isDebugEnabled()) { logger.debug("Looking for RMI registry at port '" + registryPort + "' of host [" + registryHost + "]"); } //如果registryHost不为空则尝试获取对应主机的Registry Registry reg = LocateRegistry.getRegistry(registryHost, registryPort, clientSocketFactory); testRegistry(reg); return reg; } else { //获取本机的registry return getRegistry(registryPort, clientSocketFactory, serverSocketFactory); } }
如果并不是从另外的服务器上获取registry连接，那么就需要在本地创建Rmi的registry实例了。当然，这里有一个关键的参数alwaysCreateRegistry，如果此参数配置为true，那么在获取Registry实例时会首先测试是否建立了对指定端口的连接，如果已经建立则复用已经创建的实例，否则重新创建。
当然，之前也提到过，创建Registry实例时可以使用自定义的连接工厂，而之前的判断也保证了clientSocketFactory与serverSocketFactory要么同时出现，要么同时不出现，所以这里只对clientSocketFactory是否为空进行了判断。
Registry reg = LocateRegistry.getRegistry(null, registryPort, clientSocketFactory);
如果创建的Registry实例时不需要使用自定义的套接字工厂，那么就可以直接使用 LocateRegistry.createRegistry(registryPort,clientSocketFactory,serverSocketFactory)方法来创建了，当然复用检查还是必要的。
2.初始化将要导出的实体对象
之前有提到过，当请求某个RMI服务的时候，RMI会根据注册的服务名称，将请求引导至远程对象处理类中，这个处理类便是使用getObjectToExport()进行创建。
protected Remote getObjectToExport() { //如果配置的service属性对应的类实现了Remote接口且没有配置serviceInterface属性 if (getService() instanceof Remote && (getServiceInterface() == null || Remote.class.isAssignableFrom(getServiceInterface()))) { // conventional RMI service return (Remote) getService(); } else { // RMI invoker if (logger.isDebugEnabled()) { logger.debug("RMI service [" + getService() + "] is an RMI invoker"); } //对service进行封装 return new RmiInvocationWrapper(getProxyForService(), this); } }
请求处理类的初始化主要处理规则为：如果配置的service属性对应的类实现了Remote接口且没有配置serviceInterface属性，那么直接使用service作为处理类；否则，使用RMIInvocationWrapper对service的代理类和当前类也就是RMIServiceExporter进行封装。
经过这样的封装，客户端与服务端便可以达成一致协议，当客户端检测到RMIInvocationWrapper类型的stub的时候便会直接调用其invoke方法，使得调用端与服务端很好的连接在了一起。而RMIInvocationWrapper封装了用于处理请求的代理类，在invoke中便会使用代理类进行进一步处理。
之前的逻辑已经非常清楚了，当请求RMI服务时会由注册表Registry实例将请求转向之前注册的处理类去处理，也就是之前封装的RMIInvocationWrapper，然后，由RMIInvocationWrapper中的invoke方法进行处理，那么为什么不是在invoke方法中直接使用service，而是通过代理再次将service封装呢？
这其中的一个关键点是，在创建代理时添加了一个增强拦截器RemoteInvocationTraceInterceptor，目的是为了对方法调用进行打印跟踪，但是如果直接在invoke方法中编码这些日志，会使得代码看起来不优雅，而且耦合度很高，使用代理的方式就会解决这样的问题，而且会有很高的可扩展性。
protected Object getProxyForService() { //验证service checkService(); //验证serviceInterface checkServiceInterface(); //使用JDK的方式创建代理 ProxyFactory proxyFactory = new ProxyFactory(); //添加代理接口 proxyFactory.addInterface(getServiceInterface()); if (this.registerTraceInterceptor != null ? this.registerTraceInterceptor : this.interceptors == null) { //加入代理的横切面RemoteInvocationTraceInterceptor并记录Exporter名称 proxyFactory.addAdvice(new RemoteInvocationTraceInterceptor(getExporterName())); } if (this.interceptors != null) { AdvisorAdapterRegistry adapterRegistry = GlobalAdvisorAdapterRegistry.getInstance(); for (Object interceptor : this.interceptors) { proxyFactory.addAdvisor(adapterRegistry.wrap(interceptor)); } } //设置要代理的目标类 proxyFactory.setTarget(getService()); proxyFactory.setOpaque(true); //创建代理 return proxyFactory.getProxy(getBeanClassLoader()); }
3.RMI服务激活调用
由于在之前bean初始化的时候做了服务名称的绑定this.registry.bind(this.serviceName,this.exportedObject)，其中的exportedObject其实是被RMIInvocationWrapper进行封装的，也就是说当其他服务器调用serviceName的RMI服务时，Java会为我们封装其内部操作，而直接会将代码转向RMIInvocationWrapper的invoke方法中。
public Object invoke(RemoteInvocation invocation) throws RemoteException, NoSuchMethodException, IllegalAccessException, InvocationTargetException { return this.rmiExporter.invoke(invocation, this.wrappedObject); }
而此时this.RmiExporter为之前初始化的RmiServiceExporter，invocation为包含着需要激活的方法参数，而wrappedObject则是之前封装的代理类。
protected Object invoke(RemoteInvocation invocation, Object targetObject) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { return super.invoke(invocation, targetObject); }
protected Object invoke(RemoteInvocation invocation, Object targetObject) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { if (logger.isTraceEnabled()) { logger.trace("Executing " + invocation); } try { return getRemoteInvocationExecutor().invoke(invocation, targetObject); } catch (NoSuchMethodException ex) { if (logger.isDebugEnabled()) { logger.debug("Could not find target method for " + invocation, ex); } throw ex; } catch (IllegalAccessException ex) { if (logger.isDebugEnabled()) { logger.debug("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; } }
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"); //通过反射方式激活方法 return invocation.invoke(targetObject); }
public Object invoke(Object targetObject) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { //根据方法名获取代理中对应的方法 Method method = targetObject.getClass().getMethod(this.methodName, this.parameterTypes); //执行代理中的方法 return method.invoke(targetObject, this.arguments); }
至此，RMI服务端已经解析完毕。
参考：《Spring源码深度解析》 郝佳 编著：