Dubbo Adaptive机制1 - 动态扩展加载、$Adap

Dubbo的Adaptive机制是什么？

在回答这个问题之前，我们先说说扩展和Dubbo的SPI机制。

评价一个软件扩展性好不好，说的是软件本身有没有预留足够的扩展点，让用户去自定义软件的功能，让软件调用你的代码，运行你的代码逻辑。比如在Web开发中，常常会自定义一些Filter，在一个请求的前后做一些额外的处理。用Java的语言来讲，扩展点就是接口（Interface），扩展就是接口实现（implement）。

那Dubbo的SPI是什么？Dubbo的SPI机制，就是扩展点加载机制。Dubbo允许用户在配置文件中配置扩展，形式为：key=value，key为扩展的名称，value是扩展类的全限定名。例如，一个扩展点是Animal，有3个实现，分别是Dog、Cat、Tiger，在配置文件中做如下配置：
dog=com.xxx.Dog
然后在代码中调用：
Animal dog = ExtensionLoader.getExtensionLoader(Animal.class).getExtension("dog");
即可获取到Dog的实例。但是扩展名（dog）是写死的，如果我想换成cat，需要写成：
Animal cat = ExtensionLoader.getExtensionLoader(Animal.class).getExtension("cat");
写死名称很不灵活，在有些场景下，需要动态的获取扩展，有时想要cat实例，有时需要dog实例。那怎么做呢，很简单只要扩展名是一个变量，就可以实现动态获取扩展了:
Animal animal = ExtensionLoader.getExtensionLoader(Animal.class).getExtension(animal);

Dubbo的Adaptive机制，正是利用URL这个参数，在运行过程中动态的加载扩展。具体为，@Adaptive注解定义从URL取哪个key，对应的value就是扩展的名称：

URL url = arg.getUrl();
String extName = url.getParameter( "animal_type", "cat");
Animal extension = ExtensionLoader
                      .getExtensionLoader( Animal.class )
                      .getExtension( extName );

其中，animal_type是在注解@Adaptive中定义的，cat是默认的扩展名

Dubbo会为方法上标注有@Adaptive的扩展点，自动生成一个$Adaptive后缀的包装类，包装类中的逻辑，就是上述所说的从URL中获取扩展名，再获取扩展的过程。

最终，获取adaptive扩展的代码为：
Animal animal = ExtensionLoader.getExtensionLoader(Animal.class).getAdaptiveExtension();

下面具体看下Dubbo为我们生成的包装类的代码长什么样？
以ProxyFactory为例，生成的ProxyFactory$Adaptive类的代码如下：

@SPI("javassist")
public interface ProxyFactory {
    
    @Adaptive({Constants.PROXY_KEY})
    <T> T getProxy(Invoker<T> invoker) throws RpcException;
    
    @Adaptive({Constants.PROXY_KEY})
    <T> T getProxy(Invoker<T> invoker, boolean generic) throws RpcException;
    
    @Adaptive({Constants.PROXY_KEY})
    <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) throws RpcException;

}

public class ProxyFactory$Adaptive implements com.alibaba.dubbo.rpc.ProxyFactory {

    public java.lang.Object getProxy( com.alibaba.dubbo.rpc.Invoker arg0 ) throws com.alibaba.dubbo.rpc.RpcException
    {
        if ( arg0 == null )
            throw new IllegalArgumentException( "com.alibaba.dubbo.rpc.Invoker argument == null" );

        if ( arg0.getUrl() == null )
            throw new IllegalArgumentException( "com.alibaba.dubbo.rpc.Invoker argument getUrl() == null" );

        com.alibaba.dubbo.common.URL url    = arg0.getUrl();
        String extName = url.getParameter( "proxy", "javassist" );
        if ( extName == null )
            throw new IllegalStateException( "Fail to get extension(com.alibaba.dubbo.rpc.ProxyFactory) name from url(" + url.toString() + ") use keys([proxy])" );

        com.alibaba.dubbo.rpc.ProxyFactory extension = (com.alibaba.dubbo.rpc.ProxyFactory)ExtensionLoader
                .getExtensionLoader( com.alibaba.dubbo.rpc.ProxyFactory.class )
                .getExtension( extName );

        return (extension.getProxy( arg0 ) );
    }

    // 省略其他2个方法
}

在这里打个断点，就能看到动态拼接的adaptive包装类的代码：com.alibaba.dubbo.common.extension.ExtensionLoader#createAdaptiveExtensionClass

private Class<?> createAdaptiveExtensionClass() {
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        return compiler.compile(code, classLoader);
    }

下一篇，我们将从源码的角度，分析Adaptive机制。