Spring RMI

DEMO

服务提供方

  • 服务提供方需要准备接口、接口实现泪
  • 接口
  1. public interface IDemoRmiService {
  2.     int add(int a, int b);
  3. }
  • 接口实现
  1. public class IDemoRmiServiceImpl implements IDemoRmiService {
  2.     @Override
  3.     public int add(int a, int b) {
  4.         return a + b;
  5.     }
  6. }
  • xml 配置文件
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.        xmlns="http://www.springframework.org/schema/beans"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean id="demoRmiService" class="com.huifer.source.spring.rmi.impl.IDemoRmiServiceImpl"/>
  7.     <bean id="demoRmi" class="org.springframework.remoting.rmi.RmiServiceExporter">
  8.         <!--        服务-->
  9.         <property name="service" ref="demoRmiService"/>
  10.         <!--        服务名称-->
  11.         <property name="serviceName" value="springRmi"/>
  12.         <!--        服务接口-->
  13.         <property name="serviceInterface" value="com.huifer.source.spring.rmi.IDemoRmiService"/>
  14.         <!--        注册端口-->
  15.         <property name="registryPort" value="9999"/>
  16.     </bean>
  17. </beans>
  • 运行
  1. public class RMIServerSourceCode {
  2.     public static void main(String[] args) throws Exception {
  3.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("rmi/RMISourceCode.xml");
  4.     }
  5. }

服务调用方

  • xml 配置
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean id="rmiClient" class="org.springframework.remoting.rmi.RmiProxyFactoryBean">
  7.         <property name="serviceUrl" value="rmi://localhost:9999/springRmi"/>
  8.         <property name="serviceInterface" value="com.huifer.source.spring.rmi.IDemoRmiService"/>
  9.     </bean>
  12. </beans>

注意:rmi 使用小写 大写报错信息:

  1. Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'rmiClient' defined in class path resource [rmi/RMIClientSourceCode.xml]: Invocation of init method failed; nested exception is org.springframework.remoting.RemoteLookupFailureException: Service URL [RMI://localhost:9999/springRmi] is invalid; nested exception is java.net.MalformedURLException: invalid URL scheme: RMI://localhost:9999/springRmi
  2.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1795)
  3.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:559)
  4.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:478)
  5.     at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:309)
  6.     at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:272)
  7.     at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:306)
  8.     at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:176)
  9.     at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:877)
  10.     at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:953)
  11.     at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:579)
  12.     at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:163)
  13.     at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:90)
  14.     at com.huifer.source.spring.rmi.RMIClientSourceCode.main(RMIClientSourceCode.java:7)
  15. Caused by: org.springframework.remoting.RemoteLookupFailureException: Service URL [RMI://localhost:9999/springRmi] is invalid; nested exception is java.net.MalformedURLException: invalid URL scheme: RMI://localhost:9999/springRmi
  16.     at org.springframework.remoting.rmi.RmiClientInterceptor.lookupStub(RmiClientInterceptor.java:209)
  17.     at org.springframework.remoting.rmi.RmiClientInterceptor.prepare(RmiClientInterceptor.java:147)
  18.     at org.springframework.remoting.rmi.RmiClientInterceptor.afterPropertiesSet(RmiClientInterceptor.java:134)
  19.     at org.springframework.remoting.rmi.RmiProxyFactoryBean.afterPropertiesSet(RmiProxyFactoryBean.java:68)
  20.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1868)
  21.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1791)
  22.     ... 12 more
  23. Caused by: java.net.MalformedURLException: invalid URL scheme: RMI://localhost:9999/springRmi
  24.     at java.rmi.Naming.intParseURL(Naming.java:290)
  25.     at java.rmi.Naming.parseURL(Naming.java:237)
  26.     at java.rmi.Naming.lookup(Naming.java:96)
  27.     at org.springframework.remoting.rmi.RmiClientInterceptor.lookupStub(RmiClientInterceptor.java:201)
  28.     ... 17 more
  • 运行
  1. public class RMIClientSourceCode {
  2.     public static void main(String[] args) {
  3.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("rmi/RMIClientSourceCode.xml");
  4.         IDemoRmiService rmiClient = context.getBean("rmiClient", IDemoRmiService.class);
  5.         int add = rmiClient.add(1, 2);
  6.         System.out.println(add);
  7.     }
  8. }

服务端初始化

  • org.springframework.remoting.rmi.RmiServiceExporter,该类定义了 spring 的远程服务信息

RmiServiceExporter

  • 基础属性如下
  1.  public class RmiServiceExporter extends RmiBasedExporter implements InitializingBean, DisposableBean {
  2. /**
  3.      * 服务名称,rmi的服务名,在Spring中使用ref指向impl实现类
  4.      */
  5.     private String serviceName;
  7.     /**
  8.      *
  9.      */
  10.     private int servicePort = 0;  // anonymous port
  12.     private RMIClientSocketFactory clientSocketFactory;
  14.     private RMIServerSocketFactory serverSocketFactory;
  16.     private Registry registry;
  18.     /**
  19.      * 注册的IP地址
  20.      */
  21.     private String registryHost;
  23.     /**
  24.      * 注册的端口
  25.      */
  26.     private int registryPort = Registry.REGISTRY_PORT;
  28.     /**
  29.      * 进行远程对象调用的Socket工厂
  30.      */
  31.     private RMIClientSocketFactory clientSocketFactory;
  33.     /**
  34.      * 接收远程调用服务端的Socket工厂
  35.      */
  36.     private RMIServerSocketFactory serverSocketFactory;
  38.     /**
  39.      * true: 该参数在获取{@link Registry}时测试是否建立连接,如果建立连接则直接使用,否则创建新连接
  40.      * 是否总是创建{@link Registry}
  41.      */
  42.     private boolean alwaysCreateRegistry = false;
  44.     /**
  45.      * 设置替换RMI注册表中的绑定关系
  46.      */
  47.     private boolean replaceExistingBinding = true;
  49.     private Remote exportedObject;
  51.     /**
  52.      * 创建{@link Registry}
  53.      */
  54.     private boolean createdRegistry = false;
  55. }
  • 属性设置不说了,看接口实现了那些
    1. InitializingBean: 初始化 bean 调用afterPropertiesSet方法
    2. DisposableBean: 摧毁 bean 调用destroy方法
  2.     @Override
  3.     public void afterPropertiesSet() throws RemoteException {
  4.         prepare();
  5.     }
  9.     public void prepare() throws RemoteException {
  10.         // 校验service
  11.         checkService();
  13.         // 服务名称校验
  14.         if (this.serviceName == null) {
  15.             throw new IllegalArgumentException("Property 'serviceName' is required");
  16.         }
  18.         // Check socket factories for exported object.
  19.         if (this.clientSocketFactory instanceof RMIServerSocketFactory) {
  20.             this.serverSocketFactory = (RMIServerSocketFactory) this.clientSocketFactory;
  21.         }
  22.         if ((this.clientSocketFactory != null && this.serverSocketFactory == null) ||
  23.                 (this.clientSocketFactory == null && this.serverSocketFactory != null)) {
  24.             throw new IllegalArgumentException(
  25.                     "Both RMIClientSocketFactory and RMIServerSocketFactory or none required");
  26.         }
  28.         // Check socket factories for RMI registry.
  29.         if (this.registryClientSocketFactory instanceof RMIServerSocketFactory) {
  30.             this.registryServerSocketFactory = (RMIServerSocketFactory) this.registryClientSocketFactory;
  31.         }
  32.         if (this.registryClientSocketFactory == null && this.registryServerSocketFactory != null) {
  33.             throw new IllegalArgumentException(
  34.                     "RMIServerSocketFactory without RMIClientSocketFactory for registry not supported");
  35.         }
  37.         this.createdRegistry = false;
  39.         // Determine RMI registry to use.
  40.         if (this.registry == null) {
  41.             // registry 获取
  42.             this.registry = getRegistry(this.registryHost, this.registryPort,
  43.                     this.registryClientSocketFactory, this.registryServerSocketFactory);
  44.             this.createdRegistry = true;
  45.         }
  47.         // Initialize and cache exported object.
  48.         // 初始化并且获取缓存的object
  49.         this.exportedObject = getObjectToExport();
  51.         if (logger.isDebugEnabled()) {
  52.             logger.debug("Binding service '" + this.serviceName + "' to RMI registry: " + this.registry);
  53.         }
  55.         // Export RMI object.
  56.         // 导出RMI object
  57.         if (this.clientSocketFactory != null) {
  58.             UnicastRemoteObject.exportObject(
  59.                     this.exportedObject, this.servicePort, this.clientSocketFactory, this.serverSocketFactory);
  60.         }
  61.         else {
  62.             UnicastRemoteObject.exportObject(this.exportedObject, this.servicePort);
  63.         }
  65.         // Bind RMI object to registry.
  66.         // 对象绑定,把serviceName 和 到处的RMI对象进行绑定,JDK实现
  67.         try {
  68.             if (this.replaceExistingBinding) {
  69.                 this.registry.rebind(this.serviceName, this.exportedObject);
  70.             }
  71.             else {
  72.                 this.registry.bind(this.serviceName, this.exportedObject);
  73.             }
  74.         }
  75.         catch (AlreadyBoundException ex) {
  76.             // Already an RMI object bound for the specified service name...
  77.             unexportObjectSilently();
  78.             throw new IllegalStateException(
  79.                     "Already an RMI object bound for name '" + this.serviceName + "': " + ex.toString());
  80.         }
  81.         catch (RemoteException ex) {
  82.             // Registry binding failed: let's unexport the RMI object as well.
  83.             unexportObjectSilently();
  84.             throw ex;
  85.         }
  86.     }

checkService

  • 校验 service 是否为空
  1.     /**
  2.      * Check whether the service reference has been set.
  3.      *
  4.      * 校验service
  5.      * @see #setService
  6.      */
  7.     protected void checkService() throws IllegalArgumentException {
  8.         Assert.notNull(getService(), "Property 'service' is required");
  9.     }

getRegistry

  • 获取 Registry 实例
    • 简单说就是通过 host 和 port 创建 socket
  1.     protected Registry getRegistry(String registryHost, int registryPort,
  2.                                    @Nullable RMIClientSocketFactory clientSocketFactory, @Nullable RMIServerSocketFactory serverSocketFactory)
  3.             throws RemoteException {
  5.         if (registryHost != null) {
  6.             // Host explicitly specified: only lookup possible.
  7.             if (logger.isDebugEnabled()) {
  8.                 logger.debug("Looking for RMI registry at port '" + registryPort + "' of host [" + registryHost + "]");
  9.             }
  10.             // 通过 host port socket创建
  11.             Registry reg = LocateRegistry.getRegistry(registryHost, registryPort, clientSocketFactory);
  12.             testRegistry(reg);
  13.             return reg;
  14.         }
  16.         else {
  17.             return getRegistry(registryPort, clientSocketFactory, serverSocketFactory);
  18.         }
  19.     }

getObjectToExport

  • 初始化并且获取缓存的 object
  1.     protected Remote getObjectToExport() {
  2.         // determine remote object
  3.         if (getService() instanceof Remote &&
  4.                 (getServiceInterface() == null || Remote.class.isAssignableFrom(getServiceInterface()))) {
  5.             // conventional RMI service
  6.             // 获取service
  7.             return (Remote) getService();
  8.         }
  9.         else {
  10.             // RMI invoker
  11.             if (logger.isDebugEnabled()) {
  12.                 logger.debug("RMI service [" + getService() + "] is an RMI invoker");
  13.             }
  14.             // RMI 包装类
  15.             /**
  16.              * 1. getProxyForService() 获取代理的接口
  17.              * 2. 创建RMI包装对象 RmiInvocationWrapper
  18.              */
  19.             return new RmiInvocationWrapper(getProxyForService(), this);
  20.         }
  21.     }

getProxyForService

  • 获取代理服务
  1.     protected Object getProxyForService() {
  2.         //  service 校验
  3.         checkService();
  4.         // 校验接口
  5.         checkServiceInterface();
  7.         // 代理工厂
  8.         ProxyFactory proxyFactory = new ProxyFactory();
  9.         // 添加代理接口
  10.         proxyFactory.addInterface(getServiceInterface());
  12.         if (this.registerTraceInterceptor != null ? this.registerTraceInterceptor : this.interceptors == null) {
  13.             // 添加切面
  14.             proxyFactory.addAdvice(new RemoteInvocationTraceInterceptor(getExporterName()));
  15.         }
  16.         if (this.interceptors != null) {
  17.             AdvisorAdapterRegistry adapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();
  18.             for (Object interceptor : this.interceptors) {
  19.                 proxyFactory.addAdvisor(adapterRegistry.wrap(interceptor));
  20.             }
  21.         }
  22.         // 设置代理类
  23.         proxyFactory.setTarget(getService());
  25.         proxyFactory.setOpaque(true);
  27.         // 获取代理对象
  28.         return proxyFactory.getProxy(getBeanClassLoader());
  29.     }
  • 这里要注意,切片方法的invoke调用
  • RmiInvocationWrapper的invoke方法会在调用方调用接口时候触发

rebind 和 bind

  • 绑定和重新绑定
  • 这部分源码在: sun.rmi.registry.RegistryImpl
  1.     public void rebind(String var1, Remote var2) throws RemoteException, AccessException {
  2.         checkAccess("Registry.rebind");
  3.         this.bindings.put(var1, var2);
  4.     }
  1.     public void bind(String var1, Remote var2) throws RemoteException, AlreadyBoundException, AccessException {
  2.         checkAccess("Registry.bind");
  3.         synchronized(this.bindings) {
  4.             Remote var4 = (Remote)this.bindings.get(var1);
  5.             if (var4 != null) {
  6.                 throw new AlreadyBoundException(var1);
  7.             } else {
  8.                 this.bindings.put(var1, var2);
  9.             }
  10.         }
  11.     }
  • 共同维护private Hashtable<String, Remote> bindings = new Hashtable(101);这个对象

unexportObjectSilently

  • 出现异常时候调用方法
  2.     private void unexportObjectSilently() {
  3.         try {
  4.             UnicastRemoteObject.unexportObject(this.exportedObject, true);
  5.         }
  6.         catch (NoSuchObjectException ex) {
  7.             if (logger.isInfoEnabled()) {
  8.                 logger.info("RMI object for service '" + this.serviceName + "' is not exported anymore", ex);
  9.             }
  10.         }
  11.     }

客户端初始化

RmiProxyFactoryBean

image-20200225104850528

  • 该类实现了InitializingBean接口直接看afterPropertiesSet方法

  • org.springframework.remoting.rmi.RmiProxyFactoryBean

      1.     @Override
      2.     public void afterPropertiesSet() {
      3.         super.afterPropertiesSet();
      4.         Class<?> ifc = getServiceInterface();
      5.         Assert.notNull(ifc, "Property 'serviceInterface' is required");
      6.         this.serviceProxy = new ProxyFactory(ifc, this).getProxy(getBeanClassLoader());
      7.     }

    • org.springframework.remoting.rmi.RmiClientInterceptor#afterPropertiesSet

        1.     @Override
        2.     public void afterPropertiesSet() {
        3.         super.afterPropertiesSet();
        4.         prepare();
        5.     }

      • org.springframework.remoting.support.UrlBasedRemoteAccessor#afterPropertiesSet

          1.     @Override
          2.     public void afterPropertiesSet() {
          3.         if (getServiceUrl() == null) {
          4.             throw new IllegalArgumentException("Property 'serviceUrl' is required");
          5.         }
          6.     }

org.springframework.remoting.support.UrlBasedRemoteAccessor#afterPropertiesSet

  • 该方法对 serviceUrl进行空判断，如果是空的抛出异常
  1.     /**
  2.      * 判断服务地址是否为空
  3.      */
  4.     @Override
  5.     public void afterPropertiesSet() {
  6.         if (getServiceUrl() == null) {
  7.             throw new IllegalArgumentException("Property 'serviceUrl' is required");
  8.         }
  9.     }

org.springframework.remoting.rmi.RmiClientInterceptor#afterPropertiesSet

  1.     @Override
  2.     public void afterPropertiesSet() {
  3.         super.afterPropertiesSet();
  4.         prepare();
  5.     }
  1. 调用父类的afterPropertiesSet方法判断serviceUrl是否为空
  2. 执行prepare()方法
  1.     public void prepare() throws RemoteLookupFailureException {
  2.         // Cache RMI stub on initialization?
  3.         if (this.lookupStubOnStartup) {
  4.             // 获取remote对象
  5.             Remote remoteObj = lookupStub();
  6.             if (logger.isDebugEnabled()) {
  7.                 if (remoteObj instanceof RmiInvocationHandler) {
  8.                     logger.debug("RMI stub [" + getServiceUrl() + "] is an RMI invoker");
  9.                 }
  10.                 else if (getServiceInterface() != null) {
  11.                     // 是否接口
  12.                     boolean isImpl = getServiceInterface().isInstance(remoteObj);
  13.                     logger.debug("Using service interface [" + getServiceInterface().getName() +
  14.                             "] for RMI stub [" + getServiceUrl() + "] - " +
  15.                             (!isImpl ? "not " : "") + "directly implemented");
  16.                 }
  17.             }
  18.             if (this.cacheStub) {
  19.                 this.cachedStub = remoteObj;
  20.             }
  21.         }
  22.     }

org.springframework.remoting.rmi.RmiClientInterceptor#lookupStub

  1. protected Remote lookupStub() throws RemoteLookupFailureException {
  2.         try {
  3.             Remote stub = null;
  4.             if (this.registryClientSocketFactory != null) {
  5.                 // RMIClientSocketFactory specified for registry access.
  6.                 // Unfortunately, due to RMI API limitations, this means
  7.                 // that we need to parse the RMI URL ourselves and perform
  8.                 // straight LocateRegistry.getRegistry/Registry.lookup calls.
  9.                 // 通过 serviceUrl 创建 URL
  10.                 URL url = new URL(null, getServiceUrl(), new DummyURLStreamHandler());
  11.                 // url 的协议
  12.                 String protocol = url.getProtocol();
  13.                 if (protocol != null && !"rmi".equals(protocol)) {
  14.                     throw new MalformedURLException("Invalid URL scheme '" + protocol + "'");
  15.                 }
  16.                 // 获取host
  17.                 String host = url.getHost();
  18.                 // 获取port
  19.                 int port = url.getPort();
  20.                 // 获取serviceName
  21.                 String name = url.getPath();
  22.                 if (name != null && name.startsWith("/")) {
  23.                     name = name.substring(1);
  24.                 }
  25.                 // 创建 Registry
  26.                 Registry registry = LocateRegistry.getRegistry(host, port, this.registryClientSocketFactory);
  27.                 // 获取Remote
  28.                 stub = registry.lookup(name);
  29.             }
  30.             else {
  31.                 // Can proceed with standard RMI lookup API...
  32.                 stub = Naming.lookup(getServiceUrl());
  33.             }
  34.             if (logger.isDebugEnabled()) {
  35.                 logger.debug("Located RMI stub with URL [" + getServiceUrl() + "]");
  36.             }
  37.             return stub;
  38.         }
  39.         catch (MalformedURLException ex) {
  40.             throw new RemoteLookupFailureException("Service URL [" + getServiceUrl() + "] is invalid", ex);
  41.         }
  42.         catch (NotBoundException ex) {
  43.             throw new RemoteLookupFailureException(
  44.                     "Could not find RMI service [" + getServiceUrl() + "] in RMI registry", ex);
  45.         }
  46.         catch (RemoteException ex) {
  47.             throw new RemoteLookupFailureException("Lookup of RMI stub failed", ex);
  48.         }
  49.     }

org.springframework.remoting.rmi.RmiProxyFactoryBean#afterPropertiesSet

  1.     @Override
  2.     public void afterPropertiesSet() {
  3.         super.afterPropertiesSet();
  4.         // 获取 服务提供的接口
  5.         Class<?> ifc = getServiceInterface();
  6.         // 如果服务接口不为空
  7.         Assert.notNull(ifc, "Property 'serviceInterface' is required");
  8.         // 创建服务代理
  9.         this.serviceProxy = new ProxyFactory(ifc, this).getProxy(getBeanClassLoader());
  10.     }

增强调用

  • 通过类图我们可以知道RmiProxyFactoryBean实现了MethodInterceptor,具体实现方法在org.springframework.remoting.rmi.RmiClientInterceptor#invoke
  1.     @Override
  2.     public Object invoke(MethodInvocation invocation) throws Throwable {
  3.         // 获取remote
  4.         Remote stub = getStub();
  5.         try {
  6.             // 真正的invoke调用
  7.             return doInvoke(invocation, stub);
  8.         }
  9.         catch (RemoteConnectFailureException ex) {
  10.             return handleRemoteConnectFailure(invocation, ex);
  11.         }
  12.         catch (RemoteException ex) {
  13.             if (isConnectFailure(ex)) {
  14.                 return handleRemoteConnectFailure(invocation, ex);
  15.             }
  16.             else {
  17.                 throw ex;
  18.             }
  19.         }
  20.     }
  1.     protected Remote getStub() throws RemoteLookupFailureException {
  2.         if (!this.cacheStub || (this.lookupStubOnStartup && !this.refreshStubOnConnectFailure)) {
  3.             // 如果缓存stub存在直接获取,否则创建
  4.             return (this.cachedStub != null ? this.cachedStub : lookupStub());
  5.         }
  6.         else {
  7.             synchronized (this.stubMonitor) {
  8.                 if (this.cachedStub == null) {
  9.                     this.cachedStub = lookupStub();
  10.                 }
  11.                 return this.cachedStub;
  12.             }
  13.         }
  14.     }
  • org.springframework.remoting.rmi.RmiClientInterceptor#doInvoke(org.aopalliance.intercept.MethodInvocation, org.springframework.remoting.rmi.RmiInvocationHandler)
  1.     @Nullable
  2.     protected Object doInvoke(MethodInvocation methodInvocation, RmiInvocationHandler invocationHandler)
  3.             throws RemoteException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
  5.         if (AopUtils.isToStringMethod(methodInvocation.getMethod())) {
  6.             return "RMI invoker proxy for service URL [" + getServiceUrl() + "]";
  7.         }
  9.         /**
  10.          * 1. 参数组装成对象{@link RemoteInvocationBasedAccessor#createRemoteInvocation(org.aopalliance.intercept.MethodInvocation)}
  11.          * 2. invoke 执行 简单来说就是调用{@link RmiInvocationHandler#invoke(RemoteInvocation)}方法
  12.          */
  13.         return invocationHandler.invoke(createRemoteInvocation(methodInvocation));
  14.     }
  • RmiInvocationHandler类图

image-20200226082614312

最后的invoke方法

  • org.springframework.remoting.rmi.RmiInvocationWrapper#invoke

    1.     /**
    2.      * Delegates the actual invocation handling to the RMI exporter.
    3.      *
    4.      *
    5.      * 远程调用的时候会执行
    6.      * @see RmiBasedExporter#invoke(org.springframework.remoting.support.RemoteInvocation, Object)
    7.      */
    8.     @Override
    9.     @Nullable
    10.     public Object invoke(RemoteInvocation invocation)
    11.             throws RemoteException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
    13.         return this.rmiExporter.invoke(invocation, this.wrappedObject);
    14.     }

    • 继续跟踪org.springframework.remoting.rmi.RmiBasedExporter#invoke

      1.     @Override
      2.     protected Object invoke(RemoteInvocation invocation, Object targetObject)
      3.             throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
      5.         return super.invoke(invocation, targetObject);
      6.     }

      • 继续跟踪org.springframework.remoting.support.RemoteInvocationBasedExporter#invoke

        1.     protected Object invoke(RemoteInvocation invocation, Object targetObject)
        2.             throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        4.         if (logger.isTraceEnabled()) {
        5.             logger.trace("Executing " + invocation);
        6.         }
        7.         try {
        8.             return getRemoteInvocationExecutor().invoke(invocation, targetObject);
        9.         }
        10.         catch (NoSuchMethodException ex) {
        11.             if (logger.isDebugEnabled()) {
        12.                 logger.debug("Could not find target method for " + invocation, ex);
        13.             }
        14.             throw ex;
        15.         }
        16.         catch (IllegalAccessException ex) {
        17.             if (logger.isDebugEnabled()) {
        18.                 logger.debug("Could not access target method for " + invocation, ex);
        19.             }
        20.             throw ex;
        21.         }
        22.         catch (InvocationTargetException ex) {
        23.             if (logger.isDebugEnabled()) {
        24.                 logger.debug("Target method failed for " + invocation, ex.getTargetException());
        25.             }
        26.             throw ex;
        27.         }
        28.     }

  • 关键语句return getRemoteInvocationExecutor().invoke(invocation, targetObject);

类图

image-20200226083247784

  1. public class DefaultRemoteInvocationExecutor implements RemoteInvocationExecutor {
  3.     @Override
  4.     public Object invoke(RemoteInvocation invocation, Object targetObject)
  5.             throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
  7.         Assert.notNull(invocation, "RemoteInvocation must not be null");
  8.         Assert.notNull(targetObject, "Target object must not be null");
  9.         return invocation.invoke(targetObject);
  10.     }
  12. }
  1.     public Object invoke(Object targetObject)
  2.             throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
  4.         Method method = targetObject.getClass().getMethod(this.methodName, this.parameterTypes);
  5.         return method.invoke(targetObject, this.arguments);
  6.     }
  • 这部分流程相对清晰,从对象中获取函数,调用这个函数

服务端 debug

  • org.springframework.remoting.rmi.RmiServiceExporter#afterPropertiesSet打上断点

image-20200226084056993

可以看到此时的数据字段和我们的 xml 配置中一致

  • org.springframework.remoting.rmi.RmiServiceExporter#prepare断点

    image-20200226084200428

    往下一直走

    image-20200226084400939

    ​ 这一行是 jdk 的就不进去看了

    执行完成就创建出了 Registry

    image-20200226084514795

  • org.springframework.remoting.rmi.RmiBasedExporter#getObjectToExport

    直接看结果对象

    image-20200226084640683

  • 执行 bind

    image-20200226084923783

    image-20200226084914000

  • 此时服务端信息已经成功记录并且启动

客户端 debug

image-20200226085433130

image-20200226085440865

remote 对象

image-20200226085727426

  • 服务提供接口

image-20200226085839496

  • serviceProxy

    image-20200226090042946

  • 方法调用

    • 使用的是 AOP 技术进行的，AOP 相关技术不在此处展开

image-20200226090315865

stub 对象

image-20200226090432052

image-20200226090650154

  • invocation

    image-20200226090719108

  • targetObject

    image-20200226090827849

  • 反射执行method结束整个调用

    image-20200226090945418

    此时得到结果 RMI 调用结束