dubbo SPI设计

SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口加载实现类。其实这有有点像IOC的思想,将装配的控制权移到程序之外

Java SPI 示例

首先定义一个接口:

public interface Robot {

    void sayHello();

}

再定义两个实现类：

public class OptimusPrime implements Robot {

    @Override

    public void sayHello() {

        System.out.println("Hello, I am Optimus Prime.");

    }

}

public class Bumblebee implements Robot {

    @Override

    public void sayHello() {

        System.out.println("Hello, I am Bumblebee.");

    }

}

然后META-INF/services 文件夹下创建一个文件，名称为 Robot 的全限定名 com.laowangzi.spi.Robot。文件内容为实现类的全限定的类名，如下：

com.laowangzi.spi.OptimusPrime

com.laowangzi.spi.Bumblebee

测试代码：

public class JavaSPITest {

    @Test

    public void sayHello() throws Exception {

        ServiceLoader<Robot> serviceLoader = ServiceLoader.load(Robot.class);

        System.out.println("Java SPI");

        serviceLoader.forEach(Robot::sayHello);

    }

}

测试结果：

dubbo SPI设计

从测试结果可以看出，两个实现类被成功的加载，并输出了相应的内容。

Dubbo SPI 示例

Dubbo 并未使用 Java SPI，而是重新实现了一套功能更强的 SPI 机制。Dubbo SPI 的相关逻辑被封装在了 ExtensionLoader 类中，通过 ExtensionLoader，可以加载指定的实现类。Dubbo SPI 的实现类配置放置在 META-INF/dubbo 路径下

optimusPrime = com.laowangzi.spi.OptimusPrime

bumblebee = com.laowangzi.spi.Bumblebee

与 Java SPI 实现类配置不同，Dubbo SPI 是通过键值对的方式进行配置，这样就可以按需加载指定的实现类了。另外，在测试 Dubbo SPI 时，需要在 Robot 接口上标注 @SPI 注解。下面来演示一下 Dubbo SPI 的使用方式：

public class DubboSPITest {

    @Test

    public void sayHello() throws Exception {

        ExtensionLoader<Robot> extensionLoader =

            ExtensionLoader.getExtensionLoader(Robot.class);

        Robot optimusPrime = extensionLoader.getExtension("optimusPrime");

        optimusPrime.sayHello();

        Robot bumblebee = extensionLoader.getExtension("bumblebee");

        bumblebee.sayHello();

    }

}

测试结果如下：

　　 dubbo SPI设计

Dubbo SPI 对 Java SPI 做的改进，以下内容引用至 Dubbo 官方文档。

JDK 标准的 SPI 会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加载，会很浪费资源。
如果扩展点加载失败，连扩展点的名称都拿不到了。比如：JDK 标准的 ScriptEngine，通过 getName() 获取脚本类型的名称，但如果 RubyScriptEngine 因为所依赖的 jruby.jar 不存在，导致 RubyScriptEngine 类加载失败，这个失败原因被吃掉了，和 ruby 对应不起来，当用户执行 ruby 脚本时，会报不支持 ruby，而不是真正失败的原因。
增加了对扩展点 IOC 和 AOP 的支持，一个扩展点可以直接 setter 注入其它扩展点。

其实就是提高了性能和增加了功能

提升性能

一想到性能就应该想到缓存，所以如果与jdk的spi对比,那么可以有以下几个点

1.增加缓存

public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {

    if (type == null)//拓展点类型非空判断

        throw new IllegalArgumentException("Extension type == null");

    if(!type.isInterface()) {//拓展点类型只能是接口

        throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");

    }

    if(!withExtensionAnnotation(type)) {//需要添加spi注解,否则抛异常

        throw new IllegalArgumentException("Extension type(" + type +

                ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");

    }

    //从缓存EXTENSION_LOADERS中获取,如果不存在则新建后加入缓存

    //对于每一个拓展,都会有且只有一个ExtensionLoader与其对应

    ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);

    if (loader == null) {

        EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));

        loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);

    }

    return loader;

}

private ExtensionLoader(Class<?> type) {

    this.type = type;

    //这里会存在递归调用,ExtensionFactory的objectFactory为null,其他的均为AdaptiveExtensionFactory

    //AdaptiveExtensionFactory的factories中有SpiExtensionFactory,SpringExtensionFactory

    //getAdaptiveExtension()这个是获取一个拓展装饰类对象.细节在下篇讲解

    objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());

}

以下是缓存拓展点对象的

public T getExtension(String name) {

    if (name == null || name.length() == 0)

        throw new IllegalArgumentException("Extension name == null");

    if ("true".equals(name)) {

        return getDefaultExtension();

    }

    Holder<Object> holder = cachedInstances.get(name);

    if (holder == null) {

        cachedInstances.putIfAbsent(name, new Holder<Object>());

        holder = cachedInstances.get(name);

    }

    Object instance = holder.get();

    if (instance == null) {

        synchronized (holder) {

            instance = holder.get();

            if (instance == null) {

                instance = createExtension(name);

                holder.set(instance);

            }

        }

    }

    return (T) instance;

}

2.@SPI注解

@SPI("javassist")

public interface Compiler {

    //省略...

}

public Class<?> compile(String code, ClassLoader classLoader) {

    Compiler compiler;

    ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader(Compiler.class);

    String name = DEFAULT_COMPILER; // copy reference

    if (name != null && name.length() > 0) {

        compiler = loader.getExtension(name);

    } else {

        compiler = loader.getDefaultExtension();

    }

    return compiler.compile(code, classLoader);

}

//com.alibaba.dubbo.common.compiler.Compiler 文件配置如下

adaptive=com.alibaba.dubbo.common.compiler.support.AdaptiveCompiler

jdk=com.alibaba.dubbo.common.compiler.support.JdkCompiler

javassist=com.alibaba.dubbo.common.compiler.support.JavassistCompiler

JDK的spi要用for循环,然后if判断才能获取到指定的spi对象,dubbo用指定的key就可以获取

//返回指定名字的扩展

public T getExtension(String name){}

JDK的spi不支持默认值,dubbo增加了默认值的设计

//@SPI("javassist")代表默认的spi对象,比如Compiler默认使用的是javassist,可通过

ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader(Compiler.class);

compiler = loader.getDefaultExtension();

//方式获取实现类,根据配置,即为

//com.alibaba.dubbo.common.compiler.support.JavassistCompiler

增加功能

spi增加了IoC、AOP

dubbo spi 中的IOC

dubbo SPI设计

objectFactory就是dubbo的IoC提供对象。

public <T> T getExtension(Class<T> type, String name) {

    //factories=[SpiExtensionFactory,SpringExtensionFactory]

    //遍历获取spi,先从SpiExtensionFactory获取,如果没有,再从SpringExtensionFactory获取

    for (ExtensionFactory factory : factories) {

        T extension = factory.getExtension(type, name);

        if (extension != null) {

            return extension;

        }

    }

    return null;

}

SpiExtensionFactory

public <T> T getExtension(Class<T> type, String name) {

    if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {

        ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);

        if (loader.getSupportedExtensions().size() > 0) {

            return loader.getAdaptiveExtension();

        }

    }

    return null;

}

SpringExtensionFactory

public <T> T getExtension(Class<T> type, String name) {

    for (ApplicationContext context : contexts) {

        if (context.containsBean(name)) {

            //从容器中获取注入的对象

            Object bean = context.getBean(name);

            if (type.isInstance(bean)) {

                return (T) bean;

            }

        }

    }

    return null;

}

dubbo spi 中的 aop

//dubbo spi中的aop

instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));

文档介绍：

ExtensionLoader 在加载扩展点时，如果加载到的扩展点有拷贝构造函数，则判定为扩展点 Wrapper 类。

Wrapper类内容：

package com.alibaba.xxx;

import com.alibaba.dubbo.rpc.Protocol;

public class XxxProtocolWrapper implemenets Protocol {

    Protocol impl;

    public XxxProtocol(Protocol protocol) { impl = protocol; }

    // 接口方法做一个操作后，再调用extension的方法

    public void refer() {

        //... 一些操作

        impl.refer();

        // ... 一些操作

    }

    // ...

}

通过 Wrapper 类可以把所有扩展点公共逻辑移至 Wrapper 中。新加的 Wrapper 在所有的扩展点上添加了逻辑，有些类似 AOP，即 Wrapper 代理了扩展点。

dubbo里面的spi增加的aop,其实就是装饰者设计模式

dubbo里面有个概念叫扩展点自适应,也就是给接口注入拓展点是一个Adaptive实例,直到方法执行时,才决定调用的是哪一个拓展点的实现.

实现类的对应关系是配置在文件中的，从ExtensionLoader会解析文件将数据添加到一个Map中，这样可以直接通过“dubbo”来获取到实现类DubboProtocol。这种实现还是比较简单，但有一个问题就是需要在代码中写死使用哪个实现类，这个就和SPI的初衷有所差别了，因此Dubbo提供了一个另外一个注解@Adaptive

获取适配器类
Dubbo通过注解@Adaptive作为标记实现了一个适配器类，并且这个类是动态生成的，因此在Dubbo的源码中是看不到代码的，但是我们还是可以看到其实现方式的。Dubbo提供一个动态的适配器类的原因就是可以通过配置文件来动态的使用想要的接口实现类，并且不用改变任何接口的代码，简单来说其也是通过代理来实现的。

@SPI("dubbo")

public interface Protocol {

    int getDefaultPort();

    @Adaptive

    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;

    @Adaptive

    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;

    void destroy();

}

在接口Protocol的两个方法export和refer方法中都添加了注解@Adaptive，我们可以认为这两个接口方法会被代理实现。

ExtensionLoader提供了接口获取代理类的方法：

Protocol refprotocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

1、getAdaptiveExtension首先尝试从缓存中获取实例，如果不存在则创建一个新的实例

@SuppressWarnings("unchecked")

    public T getAdaptiveExtension() {

        Object instance = cachedAdaptiveInstance.get();

        if (instance == null) {

            if(createAdaptiveInstanceError == null) {

                synchronized (cachedAdaptiveInstance) {

                    instance = cachedAdaptiveInstance.get();

                    if (instance == null) {

                        try {

                            //创建代理类

                            instance = createAdaptiveExtension();

                            cachedAdaptiveInstance.set(instance);

                        } catch (Throwable t) {

                            createAdaptiveInstanceError = t;

                            throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t);

                        }

                    }

                }

            }

            else {

                throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);

            }

        }

        return (T) instance;

    }

2、createAdaptiveExtension获取一个对象在初始化

 @SuppressWarnings("unchecked")

    private T createAdaptiveExtension() {

        try {

            return injectExtension((T) getAdaptiveExtensionClass().newInstance());

        } catch (Exception e) {

            throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e);

        }

    }

3、getAdaptiveExtensionClass获取类对象

  private Class<?> getAdaptiveExtensionClass() {

        getExtensionClasses();

        if (cachedAdaptiveClass != null) {

            return cachedAdaptiveClass;

        }

        return cachedAdaptiveClass = createAdaptiveExtensionClass();

    }

4、createAdaptiveExtensionClass中首先会获取代理类的源码，然后在编译源码获取一个Class

  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);

    }

5、Dubbo实现一个适配器类的关键在createAdaptiveExtensionClassCode，会生成一个类的代理适配器类的源码

//生成一个类的代理类源码

 private String createAdaptiveExtensionClassCode() {

        StringBuilder codeBuidler = new StringBuilder();

        Method[] methods = type.getMethods();

        boolean hasAdaptiveAnnotation = false;

        for(Method m : methods) {

            if(m.isAnnotationPresent(Adaptive.class)) {

                hasAdaptiveAnnotation = true;

                break;

            }

        }

        // 完全没有Adaptive方法，则不需要生成Adaptive类

        if(! hasAdaptiveAnnotation)

            throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");

        codeBuidler.append("package " + type.getPackage().getName() + ";");

        codeBuidler.append("\nimport " + ExtensionLoader.class.getName() + ";");

        codeBuidler.append("\npublic class " + type.getSimpleName() + "$Adpative" + " implements " + type.getCanonicalName() + " {");

        for (Method method : methods) {

            Class<?> rt = method.getReturnType();

            Class<?>[] pts = method.getParameterTypes();

            Class<?>[] ets = method.getExceptionTypes();

            Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);

            StringBuilder code = new StringBuilder(512);

            if (adaptiveAnnotation == null) {

                code.append("throw new UnsupportedOperationException(\"method ")

                        .append(method.toString()).append(" of interface ")

                        .append(type.getName()).append(" is not adaptive method!\");");

            } else {

                int urlTypeIndex = -1;

                for (int i = 0; i < pts.length; ++i) {

                    if (pts[i].equals(URL.class)) {

                        urlTypeIndex = i;

                        break;

                    }

                }

                // 有类型为URL的参数

                if (urlTypeIndex != -1) {

                    // Null Point check

                    String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"url == null\");",

                                    urlTypeIndex);

                    code.append(s);

                    s = String.format("\n%s url = arg%d;", URL.class.getName(), urlTypeIndex);

                    code.append(s);

                }

                // 参数没有URL类型

                else {

                    String attribMethod = null;

                    // 找到参数的URL属性

                    LBL_PTS:

                    for (int i = 0; i < pts.length; ++i) {

                        Method[] ms = pts[i].getMethods();

                        for (Method m : ms) {

                            String name = m.getName();

                            if ((name.startsWith("get") || name.length() > 3)

                                    && Modifier.isPublic(m.getModifiers())

                                    && !Modifier.isStatic(m.getModifiers())

                                    && m.getParameterTypes().length == 0

                                    && m.getReturnType() == URL.class) {

                                urlTypeIndex = i;

                                attribMethod = name;

                                break LBL_PTS;

                            }

                        }

                    }

                    if(attribMethod == null) {

                        throw new IllegalStateException("fail to create adative class for interface " + type.getName()

                                + ": not found url parameter or url attribute in parameters of method " + method.getName());

                    }

                    // Null point check

                    String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"%s argument == null\");",

                                    urlTypeIndex, pts[urlTypeIndex].getName());

                    code.append(s);

                    s = String.format("\nif (arg%d.%s() == null) throw new IllegalArgumentException(\"%s argument %s() == null\");",

                                    urlTypeIndex, attribMethod, pts[urlTypeIndex].getName(), attribMethod);

                    code.append(s);

                    s = String.format("%s url = arg%d.%s();",URL.class.getName(), urlTypeIndex, attribMethod);

                    code.append(s);

                }

                String[] value = adaptiveAnnotation.value();

                // 没有设置Key，则使用“扩展点接口名的点分隔 作为Key

                if(value.length == 0) {

                    char[] charArray = type.getSimpleName().toCharArray();

                    StringBuilder sb = new StringBuilder(128);

                    for (int i = 0; i < charArray.length; i++) {

                        if(Character.isUpperCase(charArray[i])) {

                            if(i != 0) {

                                sb.append(".");

                            }

                            sb.append(Character.toLowerCase(charArray[i]));

                        }

                        else {

                            sb.append(charArray[i]);

                        }

                    }

                    value = new String[] {sb.toString()};

                }

                boolean hasInvocation = false;

                for (int i = 0; i < pts.length; ++i) {

                    if (pts[i].getName().equals("com.alibaba.dubbo.rpc.Invocation")) {

                        // Null Point check

                        String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"invocation == null\");", i);

                        code.append(s);

                        s = String.format("\nString methodName = arg%d.getMethodName();", i);

                        code.append(s);

                        hasInvocation = true;

                        break;

                    }

                }

                String defaultExtName = cachedDefaultName;

                String getNameCode = null;

                for (int i = value.length - 1; i >= 0; --i) {

                    if(i == value.length - 1) {

                        if(null != defaultExtName) {

                            if(!"protocol".equals(value[i]))

                                if (hasInvocation)

                                    getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);

                                else

                                    getNameCode = String.format("url.getParameter(\"%s\", \"%s\")", value[i], defaultExtName);

                            else

                                getNameCode = String.format("( url.getProtocol() == null ? \"%s\" : url.getProtocol() )", defaultExtName);

                        }

                        else {

                            if(!"protocol".equals(value[i]))

                                if (hasInvocation)

                                    getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);

                                else

                                    getNameCode = String.format("url.getParameter(\"%s\")", value[i]);

                            else

                                getNameCode = "url.getProtocol()";

                        }

                    }

                    else {

                        if(!"protocol".equals(value[i]))

                            if (hasInvocation)

                                getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);

                            else

                                getNameCode = String.format("url.getParameter(\"%s\", %s)", value[i], getNameCode);

                        else

                            getNameCode = String.format("url.getProtocol() == null ? (%s) : url.getProtocol()", getNameCode);

                    }

                }

                code.append("\nString extName = ").append(getNameCode).append(";");

                // check extName == null?

                String s = String.format("\nif(extName == null) " +

                        "throw new IllegalStateException(\"Fail to get extension(%s) name from url(\" + url.toString() + \") use keys(%s)\");",

                        type.getName(), Arrays.toString(value));

                code.append(s);

                s = String.format("\n%s extension = (%<s)%s.getExtensionLoader(%s.class).getExtension(extName);",

                        type.getName(), ExtensionLoader.class.getSimpleName(), type.getName());

                code.append(s);

                // return statement

                if (!rt.equals(void.class)) {

                    code.append("\nreturn ");

                }

                s = String.format("extension.%s(", method.getName());

                code.append(s);

                for (int i = 0; i < pts.length; i++) {

                    if (i != 0)

                        code.append(", ");

                    code.append("arg").append(i);

                }

                code.append(");");

            }

            codeBuidler.append("\npublic " + rt.getCanonicalName() + " " + method.getName() + "(");

            for (int i = 0; i < pts.length; i ++) {

                if (i > 0) {

                    codeBuidler.append(", ");

                }

                codeBuidler.append(pts[i].getCanonicalName());

                codeBuidler.append(" ");

                codeBuidler.append("arg" + i);

            }

            codeBuidler.append(")");

            if (ets.length > 0) {

                codeBuidler.append(" throws ");

                for (int i = 0; i < ets.length; i ++) {

                    if (i > 0) {

                        codeBuidler.append(", ");

                    }

                    codeBuidler.append(ets[i].getCanonicalName());

                }

            }

            codeBuidler.append(" {");

            codeBuidler.append(code.toString());

            codeBuidler.append("\n}");

        }

        codeBuidler.append("\n}");

        if (logger.isDebugEnabled()) {

            logger.debug(codeBuidler.toString());

        }

        return codeBuidler.toString();

    }

Protocol refprotocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); 生成的代理适配器类的源码如下：

package com.alibaba.dubbo.rpc;

import com.alibaba.dubbo.common.extension.ExtensionLoader;

public class Protocol$Adpative implements com.alibaba.dubbo.rpc.Protocol {

    public void destroy() {

        throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");

    }

    public int getDefaultPort() {

        throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");

    }

    public com.alibaba.dubbo.rpc.Exporter (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.getProtocol() == null ? "dubbo" : url.getProtocol() );

        if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");

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

        return extension.export(arg0);

    }

    public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) throws com.alibaba.dubbo.rpc.RpcException {

        if (arg1 == null) throw new IllegalArgumentException("url == null");

        com.alibaba.dubbo.common.URL url = arg1;

        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );

        if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");

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

        return extension.refer(arg0, arg1);

    }

}

生成的代理器类如果被调用refer方法时会发生的处理操作，简单来说是通过代理方式来生成一个适配器类。

public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) throws com.alibaba.dubbo.rpc.RpcException {

        if (arg1 == null) throw new IllegalArgumentException("url == null");

        //被Adattive注解的方法中有个参数必须是URL对象或者参数可以通过getUrl()获取到一个url不然会抛出异常

        com.alibaba.dubbo.common.URL url = arg1;

        //首先会判断url中是否指定了协议，不然使用默认

        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );

        if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");

        //获取实现类

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

        //最终调用实现类的refer方法

        return extension.refer(arg0, arg1);

    }

Dubbo通过两个注解SPI和Adaptive，通过参数中URL.getProtocol可以动态的使用各种实现类。

参考：1.田小波dubbo源码分析-SPI机制

2.肥朝 dubbo源码解析-spi

3.dubbo源码学习--spi实现@SPI和@Adaptive

Java SPI 示例

Dubbo SPI 示例

提升性能

增加功能

相关文章