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定义
public class RmiServiceExporter extends RmiBasedExporter implements InitializingBean, DisposableBean {
}
实现了 InitializingBean接口 Spring会在bean的实例化阶段 调用 InitializingBean 的afterPropertiesSet 方法
bean的实例化 会在什么时候触发 取决于配置 例如lazy-init
RmiServiceExporter afterPropertiesSet 方法实现
public void afterPropertiesSet() throws RemoteException {
prepare();
}
prepare方法
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方法
protected void checkService() throws IllegalArgumentException {
if (getService() == null) {
throw new IllegalArgumentException("Property 'service' is required");
}
}
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 接口
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
public interface RmiInvocationHandler extends Remote {
}
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接口