Spring Rmi远程方法调用

http://blog.youkuaiyun.com/java2000_wl/article/details/7407073

http://zcjl.iteye.com/blog/36336

一： 服务端  暴露服务

[java] view plain copy print ?

1. package com.xx.service;  
2.   
3. /** 
4.  * 定义远程服务接口  
5.  * 1.可以不继承java.rmi.Remote接口 
6.  * 2.方法可以不抛出java.rmi.RemoteException异常 
7.  *  
8.  */  
9. public interface ISayHelloService {  
10.       
11.     public String doSayHello(String name);  
12. }  

package com.xx.service;

/**
 * 定义远程服务接口 
 * 1.可以不继承java.rmi.Remote接口
 * 2.方法可以不抛出java.rmi.RemoteException异常
 * 
 */
public interface ISayHelloService {
	
	public String doSayHello(String name);
}

 

[java] view plain copy print ?

1. package com.xx.service.impl;  
2.   
3. import com.xx.service.ISayHelloService;  
4.   
5. /** 
6.  * 远程接口实现 
7.  */  
8. public class ChinaSayHelloServiceImpl implements ISayHelloService {  
9.   
10.     public String doSayHello(String name) {  
11.         return "hello " + name;  
12.     }  
13. }  

package com.xx.service.impl;

import com.xx.service.ISayHelloService;

/**
 * 远程接口实现
 */
public class ChinaSayHelloServiceImpl implements ISayHelloService {

	public String doSayHello(String name) {
		return "hello " + name;
	}
}

[java] view plain copy print ?

1. package com.xx.service;  
2.   
3. import org.springframework.context.ApplicationContext;  
4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
5.   
6. /** 
7.  * 服务端   
8.  * 暴露远程服务 
9.  */  
10. public class ServerMain {  
11.       
12.     public static void main(String[] args) {  
13.         ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"classpath:applicationContext-server.xml"}, true);  
14.         System.out.println("==============服务启动成功 ==============");  
15.     }  
16. }  

package com.xx.service;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 服务端  
 * 暴露远程服务
 */
public class ServerMain {
	
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"classpath:applicationContext-server.xml"}, true);
		System.out.println("==============服务启动成功 ==============");
	}
}

[html] view plain copy print ?

1. spring配置文件 applicationContext-server.xml  
2.   
3. <?xml version="1.0" encoding="UTF-8"?>  
4. <beans xmlns="http://www.springframework.org/schema/beans"  
5.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
6.     xmlns:context="http://www.springframework.org/schema/context"  
7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
8.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
9.           
10.         <bean id="chinaSayHelloService" class="com.xx.service.impl.ChinaSayHelloServiceImpl" />  
11.           
12.         <bean id="chinaSayHelloServiceRmi" class="org.springframework.remoting.rmi.RmiServiceExporter" >  
13.             <property name="serviceName"         value="chinaSayHelloService" />  
14.             <property name="service"             ref="chinaSayHelloService"/>  
15.             <property name="serviceInterface"    value="com.xx.service.ISayHelloService"/>  
16.             <property name="registryPort"        value="9999"/>  
17.         </bean>  
18. </beans>  

spring配置文件 applicationContext-server.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
		
		<bean id="chinaSayHelloService" class="com.xx.service.impl.ChinaSayHelloServiceImpl" />
		
		<bean id="chinaSayHelloServiceRmi" class="org.springframework.remoting.rmi.RmiServiceExporter" >
			<property name="serviceName" 		value="chinaSayHelloService" />
			<property name="service" 			ref="chinaSayHelloService"/>
			<property name="serviceInterface" 	value="com.xx.service.ISayHelloService"/>
			<property name="registryPort" 		value="9999"/>
		</bean>
</beans>

二：客户端  远程方法调用

[java] view plain copy print ?

1. package com.xx.service;  
2.   
3. import java.net.UnknownHostException;  
4.   
5. import org.springframework.context.ApplicationContext;  
6. import org.springframework.context.support.ClassPathXmlApplicationContext;  
7.   
8. /** 
9.  *  客户端 
10.  */  
11. public class ClientMain {  
12.       
13.     public static void main(String[] args) throws UnknownHostException {  
14.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext-client.xml");  
15.         ISayHelloService object = applicationContext.getBean("chinaSayHelloServiceRmi", ISayHelloService.class);  
16.         System.out.println(object.doSayHello("张三"));  
17.     }  
18. }  

package com.xx.service;

import java.net.UnknownHostException;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 *  客户端
 */
public class ClientMain {
	
	public static void main(String[] args) throws UnknownHostException {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext-client.xml");
		ISayHelloService object = applicationContext.getBean("chinaSayHelloServiceRmi", ISayHelloService.class);
		System.out.println(object.doSayHello("张三"));
	}
}

[java] view plain copy print ?

1. spring配置文件 applicationContext-client.xml  
2.   
3. <?xml version="1.0" encoding="UTF-8"?>  
4. <beans xmlns="http://www.springframework.org/schema/beans"  
5.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
6.     xmlns:context="http://www.springframework.org/schema/context"  
7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd   
8.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">   
9.           
10.         <bean id="chinaSayHelloServiceRmi" class="org.springframework.remoting.rmi.RmiProxyFactoryBean" >  
11.             <property name="serviceUrl" value="rmi://192.168.3.104:9999/chinaSayHelloService" />  
12.             <property name="serviceInterface"    value="com.xx.service.ISayHelloService"/>  
13.         </bean>  
14. </beans>  

 

 

看了《J2EE without EJB》的remote章节，忍不住写点代码试试，看看Spring的实现到底多巧妙。

1.先测试RMI服务的发布，测试代码如下：

java 代码

1. //MyService.java: remote interface for RMI   
2. package test.spring.remote.rmi;   
3.   
4. public interface MyService extends java.rmi.Remot {   
5.     public void doSomething() throws java.rmi.RemoteException;   
6. }   
7.   
8.   
9. //MyBusinessInterface.java: My own business interface, must has the same methods as MyService   
10. package test.spring.remote.rmi;   
11.   
12. public interface MyBusinessInterface {   
13.     public void doSomething();   
14. }   
15.   
16.   
17. //MyServiceImpl.java: the service implement class   
18. package test.spring.remote.rmi;   
19.   
20. public class MyServiceImpl implements MyService, MyBusinessInterface {   
21.     public void doSomething() {   
22.         System.out.println("MyServiceImpl.doSomething()");   
23.     }   
24. }  

Spring的context配置文件如下：

xml 代码

1. //spring-remote.xml   
2. <?xml version="1.0" encoding="UTF-8"?>  
3. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"   
4.     "http://www.springframework.org/dtd/spring-beans.dtd">  
5.   
6. <beans>  
7.     <bean id="myService" class="test.spring.remote.rmi.MyServiceImpl" />  
8.     <bean id="serviceExporter" class="org.springframework.remoting.rmi.RmiServiceExporter">  
9.         <property name="serviceName">  
10.             <value>myService</value>  
11.         </property>  
12.         <property name="service">  
13.             <ref bean="myService" />  
14.         </property>  
15.         <property name="serviceInterface">  
16.             <value>test.spring.remote.rmi.MyService</value>  
17.         </property>  
18.         <property name="registryPort">  
19.             <value>1199</value>  
20.         </property>  
21.     </bean>  
22. </beans>  

再写一个测试程序，如下：

java 代码

1. //TestSpringRmi.java   
2. package test.spring.remote.rmi;   
3.   
4. import org.springframework.context.ApplicationContext;   
5. import org.springframework.context.support.ClassPathXmlApplicationContext;   
6.   
7. public class TestSpringRmi {   
8.     public static void main(String[] args) {   
9.         ApplicationContext context = new ClassPathXmlApplicationContext("spring-remote.xml");   
10.     }   
11. }  

运行TestSpringRmi，报错如下：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'serviceExporter' defined in class path resource [spring-remote.xml]: Initialization of bean failed; nested exception is java.rmi.StubNotFoundException: Stub class not found: test.spring.remote.rmi.MyServiceImpl_Stub; nested exception is:
 java.lang.ClassNotFoundException: test.spring.remote.rmi.MyServiceImpl_Stub
java.rmi.StubNotFoundException: Stub class not found: test.spring.remote.rmi.MyServiceImpl_Stub; nested exception is:
 java.lang.ClassNotFoundException: test.spring.remote.rmi.MyServiceImpl_Stub

咦？Spring不是号称不需要自己生成stub么？怎么会出现“Stub class not found”呢？
祭出google，从spring官方论坛搜到一个帖子：http://forum.springframework.org/showthread.php?t=19185，里面有条回复是：

I found the answer:
The class org.springframework.remoting.rmi.RmiInvocationWrap per_Stub is present in spring.jar, but not in the source tree as a Java file. Since I was running against the compiled Spring Java files, rather than the jar, it did not find it.

晕倒，Spring不会这么弱智吧，难道我以后使用的时候还得把jar包解压到class目录下？
不甘心，再搜，找到这个帖子：http://forum.springframework.org/showthread.php?t=12685

在Juergen Hoeller的回复提示下，我再去看了jpetstore的配置文件，原来用以发布rmi的接口应该是pojo形式的MyBusinessInterface，而不是那个继承自Remote的MyService，修改自己的context配置文件：

xml 代码

1. //spring-remote.xml   
2. <?xml version="1.0" encoding="UTF-8"?>  
3. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"   
4.     "http://www.springframework.org/dtd/spring-beans.dtd">  
5.   
6. <beans>  
7.     <bean id="myService" class="test.spring.remote.rmi.MyServiceImpl" />  
8.     <bean id="serviceExporter" class="org.springframework.remoting.rmi.RmiServiceExporter">  
9.         <property name="serviceName">  
10.             <value>myService</value>  
11.         </property>  
12.         <property name="service">  
13.             <ref bean="myService" />  
14.         </property>  
15.         <property name="serviceInterface">  
16.             <!-- <value>test.spring.remote.rmi.MyService</value> -->  
17.             <value>test.spring.remote.rmi.MyBusinessInterface</value>  
18.         </property>  
19.         <property name="registryPort">  
20.             <value>1199</value>  
21.         </property>  
22.     </bean>  
23. </beans>  

再运行TestSpringRmi，成功了。console打印：
03-02 14:51:56 INFO  [RmiServiceExporter.java:236] Binding RMI service 'myService' to registry at port '1199'

2.再继续测试客户端调用，先修改context配置如下：

xml 代码

1. //spring-remote.xml   
2. <?xml version="1.0" encoding="UTF-8"?>  
3. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"   
4.     "http://www.springframework.org/dtd/spring-beans.dtd">  
5.   
6. <beans>  
7.     <bean id="rmiService"  
8.         class="org.springframework.remoting.rmi.RmiProxyFactoryBean">  
9.         <property name="serviceInterface">  
10.             <value>test.spring.remote.rmi.MyBusinessInterface</value>  
11.         </property>  
12.         <property name="serviceUrl">  
13.             <value>rmi://localhost:1199/myService</value>  
14.         </property>  
15.     </bean>  
16.     <bean id="myService" class="test.spring.remote.rmi.MyServiceImpl" />  
17.     <bean id="serviceExporter" class="org.springframework.remoting.rmi.RmiServiceExporter">  
18.         <property name="serviceName">  
19.             <value>myService</value>  
20.         </property>  
21.         <property name="service">  
22.             <ref bean="myService" />  
23.         </property>  
24.         <property name="serviceInterface">  
25.             <!-- <value>test.spring.remote.rmi.MyService</value> -->  
26.             <value>test.spring.remote.rmi.MyBusinessInterface</value>  
27.         </property>  
28.         <property name="registryPort">  
29.             <value>1199</value>  
30.         </property>  
31.     </bean>  
32. </beans>  

再修改测试代码，添加客户端调用：

java 代码

1. //TestSpringRmi.java   
2. package test.spring.remote.rmi;   
3.   
4. import org.springframework.context.ApplicationContext;   
5. import org.springframework.context.support.ClassPathXmlApplicationContext;   
6.   
7. public class TestSpringRmi {   
8.     public static void main(String[] args) {   
9.         ApplicationContext context = new ClassPathXmlApplicationContext("spring-remote.xml");   
10.         MyBusinessInterface service = (MyBusinessInterface) context.getBean("rmiService");   
11.         service.doSomething();   
12.     }   
13. }  

运行TestSpringRmi，报错如下：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'rmiService' defined in class path resource [spring-remote.xml]: Initialization of bean failed; nested exception is java.rmi.ConnectException: Connection refused to host: localhost; nested exception is:
 java.net.ConnectException: Connection refused: connect
java.rmi.ConnectException: Connection refused to host: localhost; nested exception is:
 java.net.ConnectException: Connection refused: connect

仔细检查，原来自己把生成rmi客户端的bean映射放到了发布rmi服务的serviceExporter之前了，调换一下顺序：

    xml 代码

1. //spring-remote.xml   
2. <?xml version="1.0" encoding="UTF-8"?>  
3. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"   
4.     "http://www.springframework.org/dtd/spring-beans.dtd">  
5.   
6. <beans>  
7.     <bean id="myService" class="test.spring.remote.rmi.MyServiceImpl" />  
8.     <bean id="serviceExporter" class="org.springframework.remoting.rmi.RmiServiceExporter">  
9.         <property name="serviceName">  
10.             <value>myService</value>  
11.         </property>  
12.         <property name="service">  
13.             <ref bean="myService" />  
14.         </property>  
15.         <property name="serviceInterface">  
16.             <!-- <value>test.spring.remote.rmi.MyService</value> -->  
17.             <value>test.spring.remote.rmi.MyBusinessInterface</value>  
18.         </property>  
19.         <property name="registryPort">  
20.             <value>1199</value>  
21.         </property>  
22.     </bean>  
23.     <bean id="rmiService"  
24.         class="org.springframework.remoting.rmi.RmiProxyFactoryBean">  
25.         <property name="serviceInterface">  
26.             <value>test.spring.remote.rmi.MyBusinessInterface</value>  
27.         </property>  
28.         <property name="serviceUrl">  
29.             <value>rmi://localhost:1199/myService</value>  
30.         </property>  
31.     </bean>  
32. </beans>  

运行TestSpringRmi，结果如下：
03-02 15:01:24 INFO  [RmiServiceExporter.java:236] Binding RMI service 'myService' to registry at port '1199'
03-02 15:01:24 INFO  [RmiClientInterceptor.java:128] RMI stub [rmi://localhost:1199/myService] is an RMI invoker
MyServiceImpl.doSomething()

经过一番浅尝辄止，初步得出几个结论：
1.Spring对RMI的支持果然很不错，在Cglib等工具的支持下，使用RMI终于可以同Naming、rmic和stub告别了。
2.用以发布RMI的接口不能从java.rmi.Remote继承而来，否则就会出现“Stub class not found”的错误，原因有待深究。
3.Spring的BeanFactory创建bean实例是有序的，向RMI、JNDI、WebService等注册服务性质的应用，同一应用中的客户端要根据其依赖性调整配置顺序。

 

JNDI的使用方式

服务端注册

 	<bean class="org.springframework.remoting.rmi.JndiRmiServiceExporter">
		<property name="service" ref="creditService" />
		<property name="serviceInterface" value="com.common.CreditRemoteService" />
		<property name="jndiName" value="CreditService" />
	</bean>

客户端调用xml配置

	<bean id="creditService" class="org.springframework.remoting.rmi.JndiRmiProxyFactoryBean"
			scope="prototype" lazy-init="true">
		<property name="serviceInterface" value="com.common.CreditRemoteService" />
	    <property name="lookupStubOnStartup" value="false"/>
	    <property name="refreshStubOnConnectFailure" value="true"/>
		<property name="jndiName" value="CreditService" /> 
		<property name="jndiEnvironment">
			<props>
				<prop key="java.naming.provider.url">${com.jndi.creditServiceUrl}</prop>
				<prop key ="java.naming.factory.initial">weblogic.jndi.WLInitialContextFactory</prop>
			</props>
		</property>
	</bean>

 

 

Spring RMI 源码浅析-RmiServiceExporter 导出服务

分类： 源码学习 2012-03-29 17:25 317人阅读 评论(0) 收藏 举报

Java Rmi

1.接口必须继承java.rmi.Remote接口

2.方法必须抛出java.rmi.RemoteException异常

Spring Rmi

1.可以不实现java.rmi.Remote接口 

2.方法可以不抛出异常  

问题：在Spring 内部是怎么实现的？

在Spring中 是通过org.springframework.remoting.rmi.RmiServiceExporte 在服务端导出一个服务

RmiServiceExporter定义

[java] view plain copy print ?

1. public class RmiServiceExporter extends RmiBasedExporter implements InitializingBean, DisposableBean {  
2. }  

public class RmiServiceExporter extends RmiBasedExporter implements InitializingBean, DisposableBean {
}

实现了 InitializingBean接口  Spring会在bean的实例化阶段 调用 InitializingBean 的afterPropertiesSet 方法

bean的实例化 会在什么时候触发 取决于配置 例如lazy-init 

RmiServiceExporter afterPropertiesSet 方法实现

[java] view plain copy print ?

1. public void afterPropertiesSet() throws RemoteException {  
2.     prepare();  
3. }  

	public void afterPropertiesSet() throws RemoteException {
		prepare();
	}

prepare方法

[java] view plain copy print ?

1. public void prepare() throws RemoteException {  
2.     //检查配置中的 service对象   如果为null 抛出异常    
3.     checkService();  
4.     //检查服务名称   
5.     if (this.serviceName == null) {  
6.         throw new IllegalArgumentException("Property 'serviceName' is required");  
7.     }  
8.     // Check socket factories for exported object.   
9.     // 略....   
10.   
11.     // Determine RMI registry to use.   
12.     if (this.registry == null) {  
13.         //获得注册器   
14.         this.registry = getRegistry(this.registryHost, this.registryPort,  
15.             this.registryClientSocketFactory, this.registryServerSocketFactory);  
16.     }  
17.     // 获得要导出的服务对象   
18.     // getObjectToExport方法  在父类RmiBasedExporter中定义    
19.     // 1.如果实现了jdk Remote接口 那就是一个标准的RMI 类型转换后 直接返回   
20.     // 2.没有实现jdk Remote接口  返回spring包装对象RmiInvocationWrapper调用器  RmiInvocationWrapper实现了jdk Remote接口   
21.     // RmiInvocationWrapper 中有两个属性  1.wrappedObject 自己定义的远程对象[service属性]     
22.     // 2.RmiBasedExporter 也就是当前导出对象 this 在客户端调用的时候  会触发invoke方法   
23.     this.exportedObject = getObjectToExport();  
24.   
25.     // 导出服务对象   jdk UnicastRemoteObject实现   
26.     if (this.clientSocketFactory != null) {  
27.         UnicastRemoteObject.exportObject(  
28.                 this.exportedObject, this.servicePort, this.clientSocketFactory, this.serverSocketFactory);  
29.     }  
30.     else {  
31.         UnicastRemoteObject.exportObject(this.exportedObject, this.servicePort);  
32.     }  
33.   
34.     // Bind RMI object to registry.   
35.     // 把RMI远程服务对象和注册器绑定 jdk实现   
36.     try {  
37.         if (this.replaceExistingBinding) {  
38.             //替换指定serviceName的远程对象   
39.             this.registry.rebind(this.serviceName, this.exportedObject);  
40.         }  
41.         else {  
42.             //绑定对象   
43.             this.registry.bind(this.serviceName, this.exportedObject);  
44.         }  
45.     }  
46.     catch (AlreadyBoundException ex) {  
47.         // Already an RMI object bound for the specified service name...   
48.         unexportObjectSilently();  
49.         throw new IllegalStateException(  
50.                 "Already an RMI object bound for name '"  + this.serviceName + "': " + ex.toString());  
51.     }  
52.     catch (RemoteException ex) {  
53.         // Registry binding failed: let's unexport the RMI object as well.   
54.         unexportObjectSilently();  
55.         throw ex;  
56.     }  
57. }  

	public void prepare() throws RemoteException {
		//检查配置中的 service对象   如果为null 抛出异常 
		checkService();
		//检查服务名称
		if (this.serviceName == null) {
			throw new IllegalArgumentException("Property 'serviceName' is required");
		}
		// Check socket factories for exported object.
		// 略....

		// Determine RMI registry to use.
		if (this.registry == null) {
			//获得注册器
			this.registry = getRegistry(this.registryHost, this.registryPort,
				this.registryClientSocketFactory, this.registryServerSocketFactory);
		}
		// 获得要导出的服务对象
		// getObjectToExport方法  在父类RmiBasedExporter中定义 
		// 1.如果实现了jdk Remote接口 那就是一个标准的RMI 类型转换后 直接返回
		// 2.没有实现jdk Remote接口  返回spring包装对象RmiInvocationWrapper调用器  RmiInvocationWrapper实现了jdk Remote接口
		// RmiInvocationWrapper 中有两个属性  1.wrappedObject 自己定义的远程对象[service属性]  
		// 2.RmiBasedExporter 也就是当前导出对象 this 在客户端调用的时候  会触发invoke方法
		this.exportedObject = getObjectToExport();

		// 导出服务对象   jdk UnicastRemoteObject实现
		if (this.clientSocketFactory != null) {
			UnicastRemoteObject.exportObject(
					this.exportedObject, this.servicePort, this.clientSocketFactory, this.serverSocketFactory);
		}
		else {
			UnicastRemoteObject.exportObject(this.exportedObject, this.servicePort);
		}

		// Bind RMI object to registry.
		// 把RMI远程服务对象和注册器绑定 jdk实现
		try {
			if (this.replaceExistingBinding) {
				//替换指定serviceName的远程对象
				this.registry.rebind(this.serviceName, this.exportedObject);
			}
			else {
				//绑定对象
				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;
		}
	}

checkService方法 

[java] view plain copy print ?

1. protected void checkService() throws IllegalArgumentException {  
2.     if (getService() == null) {  
3.         throw new IllegalArgumentException("Property 'service' is required");  
4.     }  
5. }  

	protected void checkService() throws IllegalArgumentException {
		if (getService() == null) {
			throw new IllegalArgumentException("Property 'service' is required");
		}
	}

[java] view plain copy print ?

1. protected Remote getObjectToExport() {  
2.     //自定义的远程对象 实现了 jdk Remote   
3.     if (getService() instanceof Remote &&  
4.             (getServiceInterface() == null || Remote.class.isAssignableFrom(getServiceInterface()))) {              return (Remote) getService();  
5.     }  
6.     else {  
7.         //  没有实现  Remote接口  spring在此处包装了我们自定义的远程服务对象   
8.         // getProxyForService方法 返回一个代理对象   
9.         return new RmiInvocationWrapper(getProxyForService(), this);  
10.     }  
11. }  

	protected Remote getObjectToExport() {
		//自定义的远程对象 实现了 jdk Remote
		if (getService() instanceof Remote &&
				(getServiceInterface() == null || Remote.class.isAssignableFrom(getServiceInterface()))) {				return (Remote) getService();
		}
		else {
			//  没有实现  Remote接口  spring在此处包装了我们自定义的远程服务对象
			// getProxyForService方法 返回一个代理对象
			return new RmiInvocationWrapper(getProxyForService(), this);
		}
	}

RmiInvocationWrapper定义  实现了RmiInvocationHandler接口  而RmiInvocationHandler接口继承了Remote 接口

[java] view plain copy print ?

1. class RmiInvocationWrapper implements RmiInvocationHandler {  
2.   
3.     private final Object wrappedObject;  
4.   
5.     private final RmiBasedExporter rmiExporter;  
6.   
7.     public RmiInvocationWrapper(Object wrappedObject, RmiBasedExporter rmiExporter) {  
8.         Assert.notNull(wrappedObject, "Object to wrap is required");  
9.         Assert.notNull(rmiExporter, "RMI exporter is required");  
10.         this.wrappedObject = wrappedObject;  
11.         this.rmiExporter = rmiExporter;  
12.     }  
13.   
14.   
15.     public String getTargetInterfaceName() {  
16.         Class ifc = this.rmiExporter.getServiceInterface();  
17.         return (ifc != null ? ifc.getName() : null);  
18.     }  
19.   
20.     /*** 
21.      * 非标准的RMI调用远程方法的中转站 
22.      * invocation封装了方法名 参数名 
23.      */  
24.     public Object invoke(RemoteInvocation invocation)  
25.         throws RemoteException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {  
26.         //会在客户端调用远程方法时触发，chuwrappedObject是 我们定义的远程对象    
27.         return this.rmiExporter.invoke(invocation, this.wrappedObject);  
28.     }  
29. }  

class RmiInvocationWrapper implements RmiInvocationHandler {

	private final Object wrappedObject;

	private final RmiBasedExporter rmiExporter;

	public RmiInvocationWrapper(Object wrappedObject, RmiBasedExporter rmiExporter) {
		Assert.notNull(wrappedObject, "Object to wrap is required");
		Assert.notNull(rmiExporter, "RMI exporter is required");
		this.wrappedObject = wrappedObject;
		this.rmiExporter = rmiExporter;
	}


	public String getTargetInterfaceName() {
		Class ifc = this.rmiExporter.getServiceInterface();
		return (ifc != null ? ifc.getName() : null);
	}

	/***
	 * 非标准的RMI调用远程方法的中转站
	 * invocation封装了方法名 参数名
	 */
	public Object invoke(RemoteInvocation invocation)
	    throws RemoteException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
		//会在客户端调用远程方法时触发，chuwrappedObject是 我们定义的远程对象 
		return this.rmiExporter.invoke(invocation, this.wrappedObject);
	}
}

RmiInvocationHandler接口继承了 jdk Remote

[java] view plain copy print ?

1. public interface RmiInvocationHandler extends Remote {  
2. }  

public interface RmiInvocationHandler extends Remote {
}

[java] view plain copy print ?

1. protected Object getProxyForService() {  
2.         //检查配置中的 service对象   如果为null 抛出异常   
3.         checkService();  
4.         //检查serviceInterface属性     
5.         checkServiceInterface();  
6.         ProxyFactory proxyFactory = new ProxyFactory();  
7.         proxyFactory.addInterface(getServiceInterface());  
8.         if (this.registerTraceInterceptor != null ?  
9.                 this.registerTraceInterceptor.booleanValue() : this.interceptors == null) {  
10.             proxyFactory.addAdvice(new RemoteInvocationTraceInterceptor(getExporterName()));  
11.         }  
12.         if (this.interceptors != null) {  
13.             AdvisorAdapterRegistry adapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();  
14.             for (int i = 0; i < this.interceptors.length; i++) {  
15.                 proxyFactory.addAdvisor(adapterRegistry.wrap(this.interceptors[i]));  
16.             }  
17.         }  
18.         proxyFactory.setTarget(getService());  
19.         // 生成代理对象  到底是jdk实现 还是cglib实现  取决于 到底有没有实现接口   
20.         return proxyFactory.getProxy(getBeanClassLoader());  
21.     }  

protected Object getProxyForService() {
		//检查配置中的 service对象   如果为null 抛出异常
		checkService();
		//检查serviceInterface属性  
		checkServiceInterface();
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.addInterface(getServiceInterface());
		if (this.registerTraceInterceptor != null ?
				this.registerTraceInterceptor.booleanValue() : this.interceptors == null) {
			proxyFactory.addAdvice(new RemoteInvocationTraceInterceptor(getExporterName()));
		}
		if (this.interceptors != null) {
			AdvisorAdapterRegistry adapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();
			for (int i = 0; i < this.interceptors.length; i++) {
				proxyFactory.addAdvisor(adapterRegistry.wrap(this.interceptors[i]));
			}
		}
		proxyFactory.setTarget(getService());
		// 生成代理对象  到底是jdk实现 还是cglib实现  取决于 到底有没有实现接口
		return proxyFactory.getProxy(getBeanClassLoader());
	}

总结：1.spring 容器发布一个远程服务 是通过InitializingBean接口驱动起来的

            2.spring 包装了JDK Rmi  也就是说 服务端是spring暴露   客户端也可以用Jdk rmi调用 没有任何问题

            3,spring对没有实现Remote接口的远程服务 用RmiInvocationWrapper做了包装  RmiInvocationWrapper实现了Remote接口