Spring Rmi远程方法调用

最新推荐文章于 2022-03-28 10:06:44 发布
最新推荐文章于 2022-03-28 10:06:44 发布
阅读量1.9k 收藏 3
点赞数
分类专栏： Spring

http://blog.csdn.net/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接口

 

feiyu8607
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring RMI 远程接口调用
08-25
spring RMI 远程接口调用 包含服务端客户端程序，可完整运行
java.lang.ClassNotFoundException: org.springframework.remoting.rmi.RmiInvocationWrapper_Stub
weixin_30821731的博客
05-05 656
org.springframework.remoting.RemoteLookupFailureException: Lookup of RMI stub failed; nested exception is java.rmi.UnmarshalException: error unmarshalling return; nested exception is: java.lang.Class...
java.lang.ClassNotFoundException异常问题原因总结
热门推荐
u011017880的专栏
03-28 5万+
常会遇到报找不到类的问题，有时是没有引入相关类，但很多时候明明是有的，现把原因简单总结如下： 1、java.lang.ClassNotFoundException: com.alibaba.nacos.client.logging.NacosLogging 调试spring cloud alibaba总报这个错，查到对应包nacos-client-2.0.3有此类，双击无法打开，果断判断是包下载问题，去仓库删除下载包，maven重新下载，搞定！ 2、还有一种常见的报错原因是引入了不同版本的包，两个包都
@java.lang.ClassNotFoundException:org.springframework.web.context.ContextLoaderListener错误解决方法[TOC](t
wu274899434的博客
10-25 490
@java.lang.ClassNotFoundException:org.springframework.web.context.ContextLoaderListener错误解决方法TOC 12-Mar-2018 12:08:02.345 严重 [RMI TCP Connection(2)-127.0.0.1] org.apache.catalina.core.StandardContext....
Maven构建SpringMVC环境报错“java.lang.ClassNotFoundException: org.springframework.web.servlet. DispatcherSe
Hitvz的博客
08-28 1万+
今天朋友发了个maven项目给我看，问我为什么启动不了。说实话，一直用Jfinal都快不会用spring了… 还是决定看看。接收了文件，是maven构建的，打开eclipse，导入maven项目，然后部署到tomcat，启动tomcat，就报错了：“java.lang.ClassNotFoundException: org.springframework.web. servlet.Dispatche
springboot启动报错： java.lang.ClassNotFoundException: org.springframework.beans.factory.ObjectProvider
lujx_1024的博客
11-15 1万+
使用springboot时遇到报错，报错信息如下 java.lang.IllegalStateException: Cannot load configuration class: org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration at org.springframework.context.annotation.C...
Spring 实现远程访问详解——rmi
04-18
1. 远程调用RMI(Remote Method Invocation): 通过使用 RmiProxyFactoryBean 和 RmiServiceExporter，并且，Spring支持两个传统的RMI（使用 java.rmi.Remote接口和java.rmi.RemoteException）和通过RMI调用器实现的...
RMI远程调用
04-25
RMI远程调用，之前做的Demo希望对大家有所帮助！
spring rmi 源码
07-11
spring rmi 远程调用服务端和客户端源码，eclipse环境，jdk1.7.
java spring+rmi 的远程调用例子
10-31
一个基于Spring的rmi实现，测试成功，可以远程调用。
IDEA调试SpringMvc, 出现：java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderL
阳光大男孩！！！的博客
07-18 1804
转自：https://www.cnblogs.com/feiyujun/p/6537510.html 原因：没有将jar导出到lib中 有时，使用idea开发SpringMvc发现调试时出现以下错误： 12-Mar-2017 12:08:02.345 严重 [RMI TCP Connection(2)-127.0.0.1] org.apache.catalina.core.StandardCont...
java rmi stub cannot be cast to_java RMI java.rmi.StubNotFoundException 错误的解决
weixin_39827798的博客
03-01 146
在设计小型分布式系统的时候，可以利用java的rmi 接口来方便程序设计。第一次设计hello world， 可以参考很好的tutorial我在linux下跑一个类似的程序，也是server 以及client 两部分。 和简单的helloworld不同的是server和client之间要有交互，没有问题。但是在windows以及mac的系统下跑同样的程序，报错 stub class not fou...
Spring-remoting使用心得1－RMI
zcjl的专栏
03-02 4153
看了《J2EE without EJB》的remote章节，忍不住写点代码试试，看看Spring的实现到底多巧妙。1.先测试RMI服务的发布，测试代码如下：//MyService.java: remote interface for RMIpackage test.spring.remote.rmi;public interface MyService extends java.rmi.R
SpringRMI解析3-RmiServiceExporter逻辑细节
weixin_34354173的博客
11-21 140
在发布RMI服务的流程中，有几个步骤可能是我们比较关心的。 获取registry 由于底层的封装，获取Registry实例是非常简单的，只需要使用一个函数LocateRegistry.createRegistry(...)创建Registry实例就可以了。但是，Spring中并没有这么做，而是考虑得更多，比如RMI注册主机与发布的服务并不在一台机器上，那...
Java 远程调用 RMI 与Spring的整合实例
xwh9004的博客
08-06 3528
spring 与java rmi整合
rmi 找不到stub问题
sun_cat的专栏
05-16 476
转自http://bbs.cjsdn.net/post/view?bid=2&amp;id=35316&amp;sty=3 今天，又看了一回JBUILDER关于RMI的帮助，终于解决了些重要的疑问。看过这阵子贴子的人应该都知道这段时间关于RMI有很多问题出现，我也看了那些贴子，有的问题没有解决，有的“解决”了，但根本就没有用正确的方法。以下是我的经验（但是这不是RMI入门教程，没有基础的请暂时收藏...
spring zuul网关过滤和spring远程方法调用
最新发布
04-26
Spring远程方法调用可以通过RMI、Hessian、Burlap、HTTP等协议来实现，通过Spring框架提供的远程调用模块可以方便地实现远程方法调用。其中最常用的是HTTP协议调用RESTful API，实现微服务之间的相互调用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值