Dubbo源码(6)-动态代理技术源码解析

悠悠 2023-03-12 09:10 100阅读 0赞

### 文章目录 ###

*   *   *  一.Dubbo中的动态代理
         *   *  1.1、Dubbo Invoker领域模型
             *  1.2、Invoke在RPC过程中的作用
         *  二.RPC调用流程
         *  三.动态代理相关源码解析
         *   *  3.1、ProxyFactory
             *   *  3.1.1、AbstractProxyFactory
                 *  3.1.2、JavassistProxyFactory
             *  3.2、InvokerInvocationHandler
             *  3.3、AbstractProxyInvoker
             *  3.4、bytecode包

> 本文主要参考自Dubbo官方文档、Dubbo项目源码以及网络文章和相关书籍，并附上自身的一些理解，如有遗漏或错误，还望海涵并指出。谢谢！

\------本文基于Dubbo-2.6.1版本

### 一.Dubbo中的动态代理 ###

#### 1.1、Dubbo Invoker领域模型 ####

在说Dubbo动态代理之前，先来看看Dubbo的Invoker领域模型。

> 任何框架或组件，总会有核心领域模型，比如：Spring 的 Bean，Struts 的 Action，Dubbo 的 Service，Napoli 的 Queue 等等。这个核心领域模型及其组成部分称为实体域，它代表着我们要操作的目标本身。实体域通常是线程安全的，不管是通过不变类，同步状态，或复制的方式。

> 服务域也就是行为域，它是组件的功能集，同时也负责实体域和会话域的生命周期管理， 比如 Spring 的 ApplicationContext，Dubbo 的 ServiceManager 等。服务域的对象通常会比较重，而且是线程安全的，并以单一实例服务于所有调用。

> 什么是会话？就是一次交互过程。会话中重要的概念是上下文，什么是上下文？比如我们说：“老地方见”，这里的“老地方”就是上下文信息。为什么说“老地方”对方会知道，因为我们前面定义了“老地方”的具体内容。所以说，上下文通常持有交互过程中的状态变量等。会话对象通常较轻，每次请求都重新创建实例，请求结束后销毁。

> **简而言之：把元信息交由实体域持有，把一次请求中的临时状态由会话域持有，由服务域贯穿整个 过程。**

百度中关于领域模型的解释：

> 领域模型是对领域内的概念类或现实世界中对象的可视化表示。 又称概念模型、领域对象模型、分析对象模型。 它专注于分析问题领域本身，发掘重要的业务领域概念，并建立业务领域概念之间的关系。

**`Invoker`是Dubbo 领域模型中非常重要的一个概念，很多设计思路都是向它靠拢。这就使得Invoker渗透在整个实现代码里。而`Invoker`的实现是基于动态代理的，这也是本文要讲解的重点。**

#### 1.2、Invoke在RPC过程中的作用 ####

在整个Dubbo关于RPC通信过程的代码中出现了很多个Invoker，Invoker直译为执行器，那么这些Invoker的作用是什么呢？

下面来看一张图，简化了Dubbo RPC过程中的其他组件，来直观地看Invoker在这个过程中的作用：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BicmxvdmVqYXZh_size_16_color_FFFFFF_t_70]

可以看出，在服务提供端中，Invoker封装了具体的实现服务类。

当服务消费端需要通过RPC调用这个服务时，生成proxy调用对应的Invoker，借助网络通知到服务提供端Exporter，然后Exporter调用Invoker执行具体的服务逻辑。

**可以看出，Invoker实质上就是由动态代理生成并封装了网络连接和数据处理的逻辑，以屏蔽底层的实现。这就是DUbbo动态代理技术的实际运用了。**

### 二.RPC调用流程 ###

在看源码之前，先来从宏观的层面了解下整个调用的流程，这里忽略了很多细节，只展示最重要的实现，如下图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BicmxvdmVqYXZh_size_16_color_FFFFFF_t_70 1]

整体的流程如下：

1.  客户端通过RPC调用Service接口的方法
2.  通过动态代理生成一个Proxy代理对象，该对象实现了Service接口，内容大致如下：

public class proxy0 implements ClassGenerator.DC, EchoService, Service { 
        public static Method[] methods;
        private InvocationHandler handler
        public void bye(Object paramObject) { 
           Object[] arrayOfObject = new Object[1];
           arrayOfObject[0] = paramObject;
           Object localObject = this.handler.invoke(this, methods[0], arrayOfObject);
        }
        public String hello(String paramString){  Object[] arrayOfObject = new Object[1];
           arrayOfObject[0] = paramString;
           Object localObject = this.handler.invoke(this, methods[1], arrayOfObject);
           return (String)localObject;
        }
        public Object $echo(Object paramObject) { 
           Object[] arrayOfObject = new Object[1];
           arrayOfObject[0] = paramObject;
           Object localObject = this.handler.invoke(this, methods[2], arrayOfObject);
           return (Object)localObject;
        }
        public proxy0() { 
            public proxy0(InvocationHandler paramInvocationHandler) { 
                this.handler = paramInvocationHandler; 
            } 
        }

该类通过`dubbo-common`模块的`bytecode`模块的 Proxy类使用Javassis动态代理技术生成。

代理类首先实现了`Service`接口，然后所有的重写方法调用都是集中在了`InvocationHandler`的`invoke`方法中执行，这里实质上就是调用了代理对象（封装了许多RPC细节）。

1.  服务端接的`Protocol`收到了这个RPC调用。
2.  `Protocol`获取到被调用的`Exporter`对象
3.  `Exporter`对象获取到`Invoker`代理对象
4.  `Invoker`代理对象执行`Wrapper`包装类对象中对应的方法。实质上`Wrapper`对象内含有`Service`实现对象，如以下代码：

public class Wrapper1 extends Wrapper implements ClassGenerator.DC
    { 
           public static String[] pns;
           public static Map pts;
           public static String[] mns;
           public static String[] dmns;
           public static Class[] mts0;
           public static Class[] mts1;
           public static Class[] mts2;
    
           public String[] getPropertyNames()
           { 
             return pns;
           }
    
           public boolean hasProperty(String paramString)
           { 
             return pts.containsKey(paramString);
           }
    
           public Class getPropertyType(String paramString)
           { 
             return (Class)pts.get(paramString);
           }
    
           public String[] getMethodNames()
           { 
             return mns;
           }
    
           public String[] getDeclaredMethodNames()
           { 
             return dmns;
           }
    
           public void setPropertyValue(Object paramObject1, String paramString, Object paramObject2)
           { 
             ServiceImpl w;
             try
             { 
               w = (ServiceImpl)paramObject1;
             }
             catch (Throwable localThrowable)
             { 
               throw new IllegalArgumentException(localThrowable);
             }
             if (paramString.equals("test01"))
             { 
               w.test01 = ((String)paramObject2);
               return;
             }
             if (paramString.equals("demoDAO"))
             { 
               localServiceImpl.setDemoDAO((DemoDAO)paramObject2);
               return;
             }
             throw new NoSuchPropertyException("Not found property \"" + paramString + "\" filed or setter method in class com.alibaba.dubbo.demo.provider.ServiceImpl.");
           }
    
           public Object getPropertyValue(Object paramObject, String paramString)
           { 
             ServiceImpl w;
             try
             { 
               w = (ServiceImpl)paramObject;
        }
        catch (Throwable localThrowable)
            { throw new IllegalArgumentException(localThrowable);
            }
            if (paramString.equals("test01")) { return localServiceImpl.test01;
            }
            throw new NoSuchPropertyException("Not found property \"" + paramString + "\" filed or setter method in class com.alibaba.dubbo.demo.provider.ServiceImpl.");
        }
        public Object invokeMethod(Object paramObject, String paramString, Class[] paramArrayOfClass, Object[] paramArrayOfObject)
        throws InvocationTargetException
          { ServiceImpl w;
          try
        { 
            w = (ServiceImpl)paramObject;
        }
          catch (Throwable localThrowable1)
          { 
            throw new IllegalArgumentException(localThrowable1);
          }
          try
        { 
            if ("hello".equals(paramString) && paramArrayOfClass.length == 1) { 
                return w.hello((String)paramArrayOfObject[0]);
            }
            if ("bye".equals(paramString) && paramArrayOfClass.length == 1)
            { w.bye((Object)paramArrayOfObject[0]);
            return null;
            }
            if ("setDemoDAO".equals(paramString) && paramArrayOfClass.length == 1)
            { w.setDemoDAO((DemoDAO)paramArrayOfObject[0]);
            return null;
            }
        }
          catch (Throwable localThrowable2)
        { 
            throw new InvocationTargetException(localThrowable2);
        }
          throw new NoSuchMethodException("Not found method \"" + paramString + "\" in class com.alibaba.dubbo.demo.provider.ServiceImpl.");
        }
    }

该包装类由`dubbo-common`模块的`bytecode`模块的`Wrapper`类使用`Javassist`动态代理技术生成。

可以看到到了这一步，其实就是在调用包装类中包装的实现类的具体方法了。

### 三.动态代理相关源码解析 ###

关于Dubbo的动态代理技术的使用，相关的源码集中在`dubbo-rpc`模块以及`dubbo-common`模块下的`bytecode`包。

**`dubbo-rpc`远程调用模块包含了各种协议的抽象，以及动态代理，只包含一对一的调用，不关心集群的管理。**

#### 3.1、ProxyFactory ####

ProxyFactory接口位于`dubbo-rpc`模块下的`dubbo-rpc-api`子模块，定义了获取Proxy的方法，以SPI机制做动态拓展，默认使用的是`JavassistProxyFactory`作为拓展实现类（Javassist做底层的动态代理技术，性能优于Jdk动态代理）。

*  ProxyFactory

@SPI("javassist")
    public interface ProxyFactory { 
    
        /** * 获取指定的proxy * * @param invoker * @return proxy */
        @Adaptive({ Constants.PROXY_KEY})
        <T> T getProxy(Invoker<T> invoker) throws RpcException;
    
        /** * 获取指定的Invoker * * @param <T> * @param proxy * @param type * @param url * @return invoker */
        @Adaptive({ Constants.PROXY_KEY})
        <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) throws RpcException;
    }

*  实现关系图  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BicmxvdmVqYXZh_size_16_color_FFFFFF_t_70 2]

##### 3.1.1、AbstractProxyFactory #####

*  AbstractProxyFactory

public abstract class AbstractProxyFactory implements ProxyFactory { 
    
        /* * 传入invoker获取proxy */
        public <T> T getProxy(Invoker<T> invoker) throws RpcException { 
            // 接口数组
            Class<?>[] interfaces = null;
            // 获取invoker的url，再获取url中的interfaces配置
            String config = invoker.getUrl().getParameter("interfaces");
            // 解析接口配置
            if (config != null && config.length() > 0) { 
                // 获取到接口全限定名数组
                String[] types = Constants.COMMA_SPLIT_PATTERN.split(config);
                if (types != null && types.length > 0) { 
                    // 额外申请接口数组长度+2
                    interfaces = new Class<?>[types.length + 2];
                    // 第一个位置放置invoker自身实现的接口
                    interfaces[0] = invoker.getInterface();
                    // EchoService接口用于回声测试
                    interfaces[1] = EchoService.class;
                    for (int i = 0; i < types.length; i++) { 
                        // 使用反射生成接口class
                        interfaces[i + 1] = ReflectUtils.forName(types[i]);
                    }
                }
            }
            if (interfaces == null) { 
                interfaces = new Class<?>[]{ invoker.getInterface(), EchoService.class};
            }
            // 模板方法模式，让具体实现类实现getProxy(invoker, interfaces)的逻辑
            return getProxy(invoker, interfaces);
        }
    
        public abstract <T> T getProxy(Invoker<T> invoker, Class<?>[] types);
    }

##### 3.1.2、JavassistProxyFactory #####

`com.alibaba.dubbo.rpc.proxy.javassist.JavassistProxyFactory`是`ProxyFactory`的默认拓展实现类：

*  JavassistProxyFactory

/** * JavaassistRpcProxyFactory,ProxyFactory默认拓展实现类 */
    public class JavassistProxyFactory extends AbstractProxyFactory { 
    
        @SuppressWarnings("unchecked")
        /* * 获取proxy，这里需要看Proxy类和InvokerInvocationHandler的源码 */
        public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) { 
            return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
        }
    
        /* * 获取invoker，不能够获取类名含有$的proxy */
        public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) { 
            // TODO Wrapper cannot handle this scenario correctly: the classname contains '$'
            final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
            return new AbstractProxyInvoker<T>(proxy, type, url) { 
                @Override
                protected Object doInvoke(T proxy, String methodName,
                                          Class<?>[] parameterTypes,
                                          Object[] arguments) throws Throwable { 
                    return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
                }
            };
        }
    
    }

#### 3.2、InvokerInvocationHandler ####

`com.alibaba.dubbo.rpc.proxy.InvokerInvocationHandler`基于Jdk的`InvocationHandler`做了一层封装实现：

*  InvokerInvocationHandler

public class InvokerInvocationHandler implements InvocationHandler { 
    
        private final Invoker<?> invoker;
    
        public InvokerInvocationHandler(Invoker<?> handler) { 
            this.invoker = handler;
        }
    
        /* * 执行proxy的方法 */
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            // 获取方法名
            String methodName = method.getName();
            // 获取方法参数
            Class<?>[] parameterTypes = method.getParameterTypes();
            // 如果proxy为Object，则直接使用method执行
            if (method.getDeclaringClass() == Object.class) { 
                return method.invoke(invoker, args);
            }
            // 下面三个方法统一使用invoker直接调用
            if ("toString".equals(methodName) && parameterTypes.length == 0) { 
                return invoker.toString();
            }
            if ("hashCode".equals(methodName) && parameterTypes.length == 0) { 
                return invoker.hashCode();
            }
            if ("equals".equals(methodName) && parameterTypes.length == 1) { 
                return invoker.equals(args[0]);
            }
            // 除此之外的其他用户方法，采用invoker.invoke的方式来执行
            return invoker.invoke(new RpcInvocation(method, args)).recreate();
        }
    
    }

#### 3.3、AbstractProxyInvoker ####

`com.alibaba.dubbo.rpc.proxy.AbstractProxyInvoker`实现了`Invoker`，可以获取到RPC调用的执行结果：

*  AbstractProxyInvoker

public abstract class AbstractProxyInvoker<T> implements Invoker<T> { 
    
        // 被代理的接口实现类
        private final T proxy;
        // 被代理的接口
        private final Class<T> type;
        // 传入URL对象
        private final URL url;
    
        /* * 构造方法 */
        public AbstractProxyInvoker(T proxy, Class<T> type, URL url) { 
            if (proxy == null) { 
                throw new IllegalArgumentException("proxy == null");
            }
            if (type == null) { 
                throw new IllegalArgumentException("interface == null");
            }
            if (!type.isInstance(proxy)) { 
                throw new IllegalArgumentException(proxy.getClass().getName() + " not implement interface " + type);
            }
            this.proxy = proxy;
            this.type = type;
            this.url = url;
        }
    
        public Class<T> getInterface() { 
            return type;
        }
    
        public URL getUrl() { 
            return url;
        }
    
        public boolean isAvailable() { 
            return true;
        }
    
        public void destroy() { 
        }
    
        /* * 执行代理方法，获取到RPC调用结果 */
        public Result invoke(Invocation invocation) throws RpcException { 
            try { 
                return new RpcResult(doInvoke(proxy, invocation.getMethodName(), invocation.getParameterTypes(), invocation.getArguments()));
            } catch (InvocationTargetException e) { 
                return new RpcResult(e.getTargetException());
            } catch (Throwable e) { 
                throw new RpcException("Failed to invoke remote proxy method " + invocation.getMethodName() + " to " + getUrl() + ", cause: " + e.getMessage(), e);
            }
        }
    
        protected abstract Object doInvoke(T proxy, String methodName, Class<?>[] parameterTypes, Object[] arguments) throws Throwable;
    
        @Override
        public String toString() { 
            return getInterface() + " -> " + (getUrl() == null ? " " : getUrl().toString());
        }
    
    
    }

*  RpcResult

public class RpcResult implements Result, Serializable { 
    
        private static final long serialVersionUID = -6925924956850004727L;
        // RPC调用结果
        private Object result;
    
        private Throwable exception;
        // 额外附加信息
        private Map<String, String> attachments = new HashMap<String, String>();
    
        public RpcResult() { 
        }
    
        public RpcResult(Object result) { 
            this.result = result;
        }
    
        public RpcResult(Throwable exception) { 
            this.exception = exception;
        }
    
        public Object recreate() throws Throwable { 
            if (exception != null) { 
                throw exception;
            }
            return result;
        }
    
        /** * @see com.alibaba.dubbo.rpc.RpcResult#getValue() * @deprecated Replace to getValue() */
        @Deprecated
        public Object getResult() { 
            return getValue();
        }
    
        /** * @see com.alibaba.dubbo.rpc.RpcResult#setValue(Object) * @deprecated Replace to setValue() */
        @Deprecated
        public void setResult(Object result) { 
            setValue(result);
        }
    
        public Object getValue() { 
            return result;
        }
    
        public void setValue(Object value) { 
            this.result = value;
        }
    
        public Throwable getException() { 
            return exception;
        }
    
        public void setException(Throwable e) { 
            this.exception = e;
        }
    
        public boolean hasException() { 
            return exception != null;
        }
    
        public Map<String, String> getAttachments() { 
            return attachments;
        }
    
        /** * Append all items from the map into the attachment, if map is empty then nothing happens * * @param map contains all key-value pairs to append */
        public void setAttachments(Map<String, String> map) { 
            if (map != null && map.size() > 0) { 
                attachments.putAll(map);
            }
        }
    
        public String getAttachment(String key) { 
            return attachments.get(key);
        }
    
        public String getAttachment(String key, String defaultValue) { 
            String result = attachments.get(key);
            if (result == null || result.length() == 0) { 
                result = defaultValue;
            }
            return result;
        }
    
        public void setAttachment(String key, String value) { 
            attachments.put(key, value);
        }
    
        @Override
        public String toString() { 
            return "RpcResult [result=" + result + ", exception=" + exception + "]";
        }
    }

#### 3.4、bytecode包 ####

上述的代码都基于`dubbo-rpc-api`子模块进行分析，下面基于`dubbo-common`模块的`bytecode`包，基于Javassit动态编译技术做了高性能的动态代理实现，用以生成`wrapper`与`proxy`的代码。

// TODO

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BicmxvdmVqYXZh_size_16_color_FFFFFF_t_70]: /images/20230312/53b515b5993b4d25abd87f36fe9838a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BicmxvdmVqYXZh_size_16_color_FFFFFF_t_70 1]: /images/20230312/57f8ab2dd67a443292a689ea76f119d3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BicmxvdmVqYXZh_size_16_color_FFFFFF_t_70 2]: /images/20230312/905da4c991064422b571795d22bc6583.png