Dubbo动态代理机制解析：Javassist、JDK与CGLIB对比

飞鱼格格

1. 危险品物流运输的核心挑战与行业现状

危险品运输作为物流行业的特殊分支，其复杂性和专业性远超普通货运。根据我国《危险化学品安全管理条例》的定义，危险品主要包括爆炸品、压缩气体、易燃液体、氧化剂、毒害品等九大类。这类货物的运输需要同时满足安全监管、技术规范和应急处置三重标准。

天津作为北方重要的化工产业基地，拥有大港石化、渤海化工等大型企业集群，每年产生数百万吨的危险化学品运输需求。而开封作为中原城市群的重要节点，其精细化工产业对原料输入和产品输出的物流通道有着刚性需求。两地间的危险品物流链路，面临着几个典型痛点：

资质壁垒：从事危险品运输必须取得《道路运输经营许可证》和《道路危险货物运输许可证》，车辆需配备相应的危险品运输标志和消防设备。据行业统计，天津地区具备完整资质的危化品运输企业不足普通物流公司的5%。
路线限制：危险品运输车辆禁止通行城市主干道和人口密集区，天津至开封的G2京沪高速、G45大广高速等主要通道对危化品车辆有严格的时段管制。2022年新修订的《危险货物道路运输安全管理办法》更明确规定运输路径需提前备案。
仓储瓶颈：危险化学品对储存环境有严格要求，普通仓库无法满足防火防爆需求。天津港危化品堆场长期处于满负荷状态，中转仓储能力不足导致运输效率低下。

2. 专线直达模式的价值与实施要点

"天津-开封"危化品专线的核心价值在于打破传统分段运输的桎梏。与普通物流不同，危险品运输的每次中转都意味着风险指数的几何级增长。专线直达方案通过固定车辆、固定路线、固定人员的"三固定"管理，能显著降低运输风险。

2.1 车辆配置标准

专线车队必须符合JT/T 617-2018《汽车运输危险货物规则》的硬性要求：

车辆总质量≥12吨的牵引车配备ABS防抱死系统
罐体材质需与运输货物相容（如硝酸运输需用铝制罐体）
随车携带不少于2具4kg干粉灭火器
安装符合GB 13392标准的危险品标志灯和标牌

我们采用的VOLVO FMX 440牵引车+不锈钢罐式半挂车组合，特别针对酸类、碱类化学品做了内壁防腐处理。实测数据显示，这种配置在京津塘# 1. 概述

本文分享 Protocol 层。对应项目为 dubbo-rpc/dubbo-rpc-api 部分。

dubbo-rpc-api 项目，主要提供了动态代理相关。为什么是动态代理相关呢？因为一个服务接口，需要被调用时，需要通过动态代理，创建远程调用的代理对象。目前，Dubbo 支持如下动态代理方式：

Javassist
JDK
CGLIB

友情提示：本文不会分享动态代理的具体代码实现，有需要的胖友可以自己去看。

2. ProxyFactory

com.alibaba.dubbo.rpc.ProxyFactory ，代理工厂接口。代码如下：

code复制@SPI("javassist")
public interface ProxyFactory {

    /**
     * create proxy.
     *
     * 创建服务消费者 Proxy 对象
     *
     * @param invoker Invoker 对象
     * @return proxy 代理对象
     */
    @Adaptive({Constants.PROXY_KEY})
    <T> T getProxy(Invoker<T> invoker) throws RpcException;

    /**
     * create invoker.
     *
     * 创建服务提供者 Invoker 对象
     *
     * @param <T>
     * @param proxy Service 对象，一般是服务实现类
     * @param type Service 接口
     * @param url URL 对象
     * @return invoker Invoker 对象
     */
    @Adaptive({Constants.PROXY_KEY})
    <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) throws RpcException;

}

@SPI("javassist") 注解，Dubbo SPI 拓展点，默认为 "javassist" ，即使用 Javassist 生成代理。
@Adaptive({Constants.PROXY_KEY}) 注解，基于 Dubbo SPI Adaptive 机制，加载对应的 ProxyFactory 实现，使用 URL.proxy 属性。
#getProxy(invoker) 接口方法，创建服务消费者 Proxy 对象。在《精尽 Dubbo 源码分析 —— 服务引用》中，我们会看到，Invoker#refer(interfaceClass) 会调用该方法，创建 Proxy 对象，从而消费者，可以像调用本地方法一样，调用远程方法。
#getInvoker(proxy, type, url) 接口方法，创建服务提供者 Invoker 对象。在《精尽 Dubbo 源码分析 —— 服务暴露》中，我们会看到，远程暴露的 Dubbo 服务，通过该 Proxy 对象，调用 Invoker#invoke(Invocation) 方法，从而调用 Service 对象的具体的方法。

2.1 AbstractProxyFactory

com.alibaba.dubbo.rpc.proxy.AbstractProxyFactory ，实现 ProxyFactory 接口，代理工厂抽象类。代码如下：

code复制public abstract class AbstractProxyFactory implements ProxyFactory {

    @Override
    public <T> T getProxy(Invoker<T> invoker) throws RpcException {
        Class<?>[] interfaces = null;
        // 获得接口集合
        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) {
                interfaces = new Class<?>[types.length + 2];
                interfaces[0] = invoker.getInterface(); // 添加服务接口
                interfaces[1] = EchoService.class; // 添加 EchoService 接口，用于服务回声测试
                for (int i = 0; i < types.length; i++) {
                    interfaces[i + 1] = ReflectUtils.forName(types[i]);
                }
            }
        }
        if (interfaces == null) {
            interfaces = new Class<?>[]{invoker.getInterface(), EchoService.class};
        }
        // 创建 Proxy 对象
        return getProxy(invoker, interfaces);
    }

    /**
     * 创建 Proxy 对象
     *
     * @param invoker Invoker 对象
     * @param types 接口数组
     * @param <T> 泛型
     * @return Proxy 对象
     */
    public abstract <T> T getProxy(Invoker<T> invoker, Class<?>[] types);

    @Override
    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) throws RpcException {
        // 创建 Wrapper 对象
        final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
        // 创建 AbstractProxyInvoker 对象
        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);
            }
        };
    }

}

#getProxy(invoker) 方法
- 获得接口集合。一般情况下，只有服务接口 + com.alibaba.dubbo.rpc.service.EchoService 接口。
- 调用 #getProxy(invoker, types) 抽象方法，创建 Proxy 对象。
#getInvoker(proxy, type, url) 方法
- 调用 Wrapper#getWrapper(Class<?>) 方法，创建 Wrapper 对象。因为创建 Wrapper 对象的过程，会存在缓存的逻辑，所以已经写过一次，这里不再重复。😈 如果没看过的胖友，可以点击《精尽 Dubbo 源码分析 —— 服务暴露（一）之本地暴露（Injvm）》的「4. Wrapper」查看。
- 创建 AbstractProxyInvoker 对象，实现 #doInvoker(...) 方法，调用 Wrapper#invokeMethod(...) 方法，进行服务调用。

3. StubProxyFactoryWrapper

com.alibaba.dubbo.rpc.proxy.wrapper.StubProxyFactoryWrapper ，实现 ProxyFactory 接口，存根代理工厂包装器实现类。

用途：在服务引用时，设置服务消费者的本地存根。在《Dubbo 用户指南 —— 本地存根》中，已经详细分享。

3.1 构造方法

code复制/**
 * ProxyFactory$Adaptive 对象
 */
private final ProxyFactory proxyFactory;
/**
 * Protocol$Adaptive 对象
 */
private Protocol protocol;

public StubProxyFactoryWrapper(ProxyFactory proxyFactory) {
    this.proxyFactory = proxyFactory;
}

public void setProtocol(Protocol protocol) {
    this.protocol = protocol;
}

3.2 getProxy

code复制 1: @Override
 2: @SuppressWarnings({"unchecked", "rawtypes"})
 3: public <T> T getProxy(Invoker<T> invoker) throws RpcException {
 4:     // 获得 Service Proxy 对象
 5:     T proxy = proxyFactory.getProxy(invoker);
 6:     if (GenericService.class != invoker.getInterface()) { // 非泛化引用
 7:         // 获得 `stub` 配置项
 8:         String stub = invoker.getUrl().getParameter(Constants.STUB_KEY, invoker.getUrl().getParameter(Constants.LOCAL_KEY));
 9:         if (ConfigUtils.isNotEmpty(stub)) {
10:             Class<?> serviceType = invoker.getInterface();
11:             // `stub = true` 的情况，使用接口 + `Stub` 字符串
12:             if (ConfigUtils.isDefault(stub)) {
13:                 if (invoker.getUrl().hasParameter(Constants.STUB_KEY)) {
14:                     stub = serviceType.getName() + "Stub";
15:                 } else {
16:                     stub = serviceType.getName() + "Local";
17:                 }
18:             }
19:             try {
20:                 // 加载 Stub 类
21:                 Class<?> stubClass = ReflectUtils.forName(stub);
22:                 if (!serviceType.isAssignableFrom(stubClass)) {
23:                     throw new IllegalStateException("The stub implementation class " + stubClass.getName() + " not implement interface " + serviceType.getName());
24:                 }
25:                 try {
26:                     // 创建 Stub 对象，使用带 Service Proxy 对象的构造方法
27:                     Constructor<?> constructor = ReflectUtils.findConstructor(stubClass, serviceType);
28:                     proxy = (T) constructor.newInstance(new Object[]{proxy});
29:                     // 【TODO 8033】参数回调
30:                     //export stub service
31:                     URL url = invoker.getUrl();
32:                     if (url.getParameter(Constants.STUB_EVENT_KEY, Constants.DEFAULT_STUB_EVENT)) {
33:                         url = url.addParameter(Constants.STUB_EVENT_METHODS_KEY, StringUtils.join(Wrapper.getWrapper(proxy.getClass()).getDeclaredMethodNames(), ","));
34:                         url = url.addParameter(Constants.IS_SERVER_KEY, Boolean.FALSE.toString());
35:                         try {
36:                             export(proxy, (Class) invoker.getInterface(), url);
37:                         } catch (Exception e) {
38:                             LOGGER.error("export a stub service error.", e);
39:                         }
40:                     }
41:                 } catch (NoSuchMethodException e) {
42:                     throw new IllegalStateException("No such constructor \"public " + stubClass.getSimpleName() + "(" + serviceType.getName() + ")\" in stub implementation class " + stubClass.getName(), e);
43:                 }
44:             } catch (Throwable t) {
45:                 LOGGER.error("Failed to create stub implementation class " + stub + " in consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion() + ", cause: " + t.getMessage(), t);
46:                 // ignore
47:             }
48:         }
49:     }
50:     return proxy;
51: }

第 5 行：调用 proxyFactory#getProxy(invoker) 方法，获得 Service Proxy 对象。
第 6 行：若是非泛化引用，进行本地存根的逻辑。
第 8 行：获得 stub 配置项。
第 11 至 18 行：处理 stub = true 的情况，获得对应的 Stub 类名。例如：com.alibaba.dubbo.demo.DemoService 接口，为 com.alibaba.dubbo.demo.DemoServiceStub 类名。
第 21 行：加载 Stub 类。
第 22 至 24 行：校验 Stub 类，必须实现服务接口。
第 26 至 28 行：创建 Stub 对象，使用带 Service Proxy 对象的构造方法。例如：public DemoServiceStub(DemoService demoService) 。
第 29 至 40 行：【TODO 8033】参数回调
第 50 行：返回最终的 proxy 。

3.3 getInvoker

code复制@Override
public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) throws RpcException {
    return proxyFactory.getInvoker(proxy, type, url);
}

直接委托 proxyFactory ，进行创建 Invoker 对象。

4. JavassistProxyFactory

com.alibaba.dubbo.rpc.proxy.javassist.JavassistProxyFactory ，实现 AbstractProxyFactory 抽象类，基于 Javassist 的代理工厂实现类。

4.1 getProxy

code复制@Override
public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
    // 生成 Proxy 子类（Proxy 是抽象类）。并调用 Proxy 子类的 newInstance 方法，创建 Proxy 对象
    return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
}

调用 Proxy#getProxy(Class<?>[]) 方法，生成 Proxy 子类（Proxy 是抽象类）。
调用 Proxy#newInstance(InvocationHandler) 方法，创建 Proxy 对象。传入 InvokerInvocationHandler 对象。在《精尽 Dubbo 源码分析 —— 动态代理（二）之 JDK》中，我们会看到具体的代码实现。

4.2 getInvoker

code复制@Override
public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
    // TODO Wrapper cannot handle this scenario correctly: the classname contains '$'
    // 创建 Wrapper 对象
    final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
    // 创建 AbstractProxyInvoker 对象
    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);
        }
    };
}

和父类 AbstractProxyFactory 的 #getInvoker(proxy, type, url) 方法，一样的代码。

5. JDK 实现

在 dubbo-rpc-default 项目中，com.alibaba.dubbo.rpc.proxy.jdk 包，基于 JDK 的代理工厂实现类。

因为代码和 JavassistProxyFactory 基本一致，所以，直接看《精尽 Dubbo 源码分析 —— 动态代理（二）之 JDK》文章。

6. CGLIB 实现

在 dubbo-rpc-default 项目中，com.alibaba.dubbo.rpc.proxy.cglib 包，基于 CGLIB 的代理工厂实现类。

因为代码和 JavassistProxyFactory 基本一致，所以，直接看《精尽 Dubbo 源码分析 —— 动态代理（三）之 CGLIB》文章。