Dubbo之SPI原理分析

Dubbo之SPI原理分析

从今天起开始学习Dubbo的一些原理知识,首先,要想深入的学习Dubbo的原理知识,读懂Dubbo的源码,就必须要深入的了解他的两个机制SPI机制和Adaptive机制。这两个机制可以说贯穿了Dubbo的整个源码。那么接下我们就要深入来了解一下这两个原理知识了。首先,要知道dubbo是根据Java的SPI进行改造的。

Java源生SPI机制

SPI的全名叫service provide interface。

先声明一个接口SayHello

建一个Maven项目,声明接口,install发布接口。

package com.lg.dubbo;

public interface SayHello {
    String sayHello();
}

写接口的实现

可以写多个实现,比如这里写两个实现类USASayHelloImpl和ChineseSayHelloImpl

package com.lg.dubbo;

public class USASayHelloImpl implements SayHello {
  
    @Override
    public String sayHello() {
        return "welcome to  American!";
    }
}
package com.lg.dubbo;

public class ChineseSayHelloImpl implements SayHello {
  
    @Override
    public String sayHello() {
        return "欢迎来到中国";
    }
}

配置

在实现类所在的项目中的resources目录下创建一个META-INF文件夹,之后再在META-INF下创建services文件夹,在services文件夹下创建一个文件,命名为接口类SayHello的全路径com.lg.dubbo.SayHello,并在文件写以下配置信息:

com.lg.dubbo.ChineseSayHelloImpl
com.lg.dubbo.USASayHelloImpl

注意配置文件的名称必须跟接口的全路径保持一致,程序是根据这个文件名跟实现类联系到一起的。

引入依赖

<dependency>
  <groupId>com.lg.dubbo</groupId>
  <artifactId>spi-mechanism-impl</artifactId>
  <version>1.0-SNAPSHOT</version>
</dependency>

可以查看引入的依赖包。
图片描述

写测试方法

public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
        ServiceLoader<SayHello> sayHellos = ServiceLoader.load(SayHello.class);
        for (SayHello sayHello : sayHellos) {
            System.out.println(sayHello.sayHello());
        }
    }

输出结果

欢迎来到中国
welcome to  American!

可以看到有两条输出结果,这说明java原生的SPI机制会将所有的写在配置文件中的实体类都加了。这是Java源生SPI的一个问题。这也正是Dubbo要实现自己的SPI机制的原因。

SPI用处

比如Java的JDBC,对于Java来说它只是定义了一套与数据库交互的规范,具体的工作都是根据不同的开发商具体去实现,比如MySql的Driver。

JDBC接口:

package java.sql;
import java.util.logging.Logger;
public interface Driver {
    Connection connect(String url, java.util.Properties info)
        throws SQLException;
    boolean acceptsURL(String url) throws SQLException;
    DriverPropertyInfo[] getPropertyInfo(String url, java.util.Properties info)
                         throws SQLException;
    int getMajorVersion();
    int getMinorVersion();
    boolean jdbcCompliant();
    public Logger getParentLogger() throws SQLFeatureNotSupportedException;
}

引入的Mysql的mysql-connector-java依赖之后的结果:
图片描述

Dubbo的SPI机制

Dubbo的SPI机制分为三种:

  • 自适应扩展点
  • 激活扩展点
  • 静态扩展点

为Protocol接口写实现

用Dubbo现有的Protocol接口作为被实现接口,说明dubbo的SPI实现,首先写一个自己的协议实现。

package com.lg.dubbo;

import org.apache.dubbo.common.URL;
import org.apache.dubbo.rpc.Exporter;
import org.apache.dubbo.rpc.Invoker;
import org.apache.dubbo.rpc.Protocol;
import org.apache.dubbo.rpc.RpcException;

public class MyProtocol implements Protocol {
    @Override
    public int getDefaultPort() {
        return 8081;   //默认的端口是8081
    }
    ...
}

配置

之后同样是在resources目录下的META-INF目录下创建dubbo目录,之后在这个目录下创建org.apache.dubbo.rpc.Protocol文件,在之后在文件中配置如下信息:

myProtocol=com.lg.dubbo.MyProtocol

可能你能注意到这里和Java源生SPI的区别,那就是这里会多出了一个myProtocol=,这是Dubbo所必须的,因为dubbo会根据这个=进行分割字符串。

测试

public class DubboSpiTest 
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
        Protocol protocol=ExtensionLoader.getExtensionLoader(Protocol.class).getExtension("myProtocol");
        System.out.println(protocol.getDefaultPort());
    }
}

结果

看一下输出结果:

八月 04, 2019 5:34:07 下午 org.apache.dubbo.common.logger.LoggerFactory info
信息: using logger: org.apache.dubbo.common.logger.jcl.JclLoggerAdapter
8081
Process finished with exit code 0

得到的默认端口正式我们自己定义的MyProtocol的默认端口。

Dubbo之SPI源码分析

静态扩展点

使用上面测试类的代码来分析静态扩展点源码。所谓的静态就下面的代码一样,我们指出了我们需要的扩展点实现。

protocol=ExtensionLoader.getExtensionLoader(Protocol.class).getExtension("myProtocol")
ExtensionLoader

先看一下ExtensionLoader的成员常量。

public class ExtensionLoader<T> {

    private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class);

    private static final String SERVICES_DIRECTORY = "META-INF/services/";

    private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";

    private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";

    private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");

    private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<>();

    private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<>();

这里在META-INF下的三个路径是配置扩展点地方,dubbo也是通过这三个路径去获得扩展点的,再看getExtensionLoader方法

getExtensionLoader方法
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 an interface!");
  }
  if (!withExtensionAnnotation(type)) {       //1
    throw new IllegalArgumentException("Extension type (" + type +
                                       ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
  }

  ExtensionLoader<T> loader = 
    (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);//2
  if (loader == null) {
    EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));//3
    loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
  }
  return loader;
}

分析:

  • 1.判断type是否被Dubbo的@SPI注解,被注解返回true、没有返回false;
  • 2.先从缓存中获得type对应的ExtensionLoader如果没有得到就创建新的,并保存到EXTENSION_LOADERS中,EXTENSION_LOADERS是一个ConcurrentHashMap;

看一下new ExtensionLoader<T>(type)

private ExtensionLoader(Class<?> type) {
  this.type = type;  //1 
  objectFactory = (type == ExtensionFactory.class ? null : 
                   ExtensionLoader
                   .getExtensionLoader(ExtensionFactory.class)
                   .getAdaptiveExtension());  //2
}

分析:

  • 1.保存当前的这个借口信息,做关联;
  • 2.看一看到如果传进来的借口正是ExtensionFactory的时候放回为null,想想就知道原因,防止传入ExtensionFactory造成死循环,如果传入的不是使用自适应的方式去获得一个ExtensionFactory的实现类;
getExtension方法
public T getExtension(String name) {
  ... //去掉不必要的代码
    Holder<Object> holder = getOrCreateHolder(name);    // 1
  Object instance = holder.get();
  if (instance == null) {
    synchronized (holder) {                // 2
      instance = holder.get();
      if (instance == null) {
        instance = createExtension(name);    // 3
        holder.set(instance);
      }
    }
  }
  return (T) instance;
}

分析:

  • 1.从实例缓存cachedInstances中获取实例对象,cachedInstances是一个ConcurrentHashMap;
  • 2.使用双重检查锁的方式构建实现类
  • 3.关键代码
createExtension方法
private T createExtension(String name) {
   Class<?> clazz = getExtensionClasses().get(name);     // 1
   if (clazz == null) {
     throw findException(name);
   }
   try {
     T instance = (T) EXTENSION_INSTANCES.get(clazz);
     if (instance == null) {
       EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
       instance = (T) EXTENSION_INSTANCES.get(clazz);
     }
     injectExtension(instance);      // 2
     Set<Class<?>> wrapperClasses = cachedWrapperClasses;
     if (CollectionUtils.isNotEmpty(wrapperClasses)) {
       for (Class<?> wrapperClass : wrapperClasses) {
         instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));    //3
       }
     }
     return instance;
   } catch (Throwable t) {
     throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                                     type + ") couldn't be instantiated: " + t.getMessage(), t);
   }
}

分析:

  • 1.生成实例对象,并保存到EXTENSION_INSTANCES中
  • 2.依赖注入

先看1中的源码

getExtensionClasses方法
private Map<String, Class<?>> getExtensionClasses() {
        Map<String, Class<?>> classes = cachedClasses.get();  //1
  if (classes == null) {
    synchronized (cachedClasses) {
      classes = cachedClasses.get();
      if (classes == null) {
        classes = loadExtensionClasses();  //2
        cachedClasses.set(classes);
      }
    }
  }
  return classes;
}

分析:

  • 1.先从缓存cachedClasses中获取代对应的Class ;
  • 2.没有得到,通过loadExtensionClasses()方法得到,并放到缓存cachedClasses中;
loadExtensionClasses()方法
private Map<String, Class<?>> loadExtensionClasses() {
        cacheDefaultExtensionName();

  Map<String, Class<?>> extensionClasses = new HashMap<>();
  loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());//1
  loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));//2
  loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());//1
  loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));//2
  loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());//1
  loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));//2
  return extensionClasses;
}

分析:

  • 1.三个参数,第一个参数需要扩展的Class,第二个参数是配置扩展点的目录,一共有三个目录META-INF/services/、META-INF/dubbo/和META-INF/dubbo/internal/,第三个参数是类的全路径,因为我们是以这个来命名文件的;
  • 2.将org.apache替换成com.alibaba是为了兼容,因为更老的版本有可能还是以老版本的全路径命名而没有更改,为com.alibaba生成一套;
  • 注意这里出现的type就是我们传参的Protocol.class,所以下面会根据这类的全路径找到对应的配置文件,加载配置中类;
loadDirectory方法
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type) {
  String fileName = dir + type;
  try {
    Enumeration<java.net.URL> urls; //1
    ClassLoader classLoader = findClassLoader();   
    if (classLoader != null) {
      urls = classLoader.getResources(fileName);   
    } else {
      urls = ClassLoader.getSystemResources(fileName);  
    }
    if (urls != null) {
      while (urls.hasMoreElements()) {
        java.net.URL resourceURL = urls.nextElement();
        loadResource(extensionClasses, classLoader, resourceURL); //2
      }
    }
  } catch (Throwable t) {
    logger.error("Exception occurred when loading extension class (interface: " +
                 type + ", description file: " + fileName + ").", t);
  }
}

分析:

  • 1.使用类加载器获得资源路径;
  • 2.加载资源
loadResource方法
 private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
   try {
     try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
       String line;
       while ((line = reader.readLine()) != null) {
         final int ci = line.indexOf('#');
         if (ci >= 0) {
           line = line.substring(0, ci);
         }
         line = line.trim();
         if (line.length() > 0) {
           try {
             String name = null;
             int i = line.indexOf('=');  // 1
             if (i > 0) {
               name = line.substring(0, i).trim();  
               line = line.substring(i + 1).trim();
             }
             if (line.length() > 0) {
               loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);   //2
             }
           } catch (Throwable t) {
             IllegalStateException e = new IllegalStateException("Failed to load extension class (interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
             exceptions.put(line, e);
           }
         }
       }
     }
   } catch (Throwable t) {
     logger.error("Exception occurred when loading extension class (interface: " +
                  type + ", class file: " + resourceURL + ") in " + resourceURL, t);
   }
 }

分析:

  • 1.使用=分割name和对应扩展点实现类的全限定名称;
  • 2.loadClass加载class;
loadClass方法
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
  if (!type.isAssignableFrom(clazz)) {
    throw new IllegalStateException("Error occurred when loading extension class (interface: " +
                                    type + ", class line: " + clazz.getName() + "), class "
                                    + clazz.getName() + " is not subtype of interface.");
  }
  if (clazz.isAnnotationPresent(Adaptive.class)) {  // 1
    cacheAdaptiveClass(clazz);   
  } else if (isWrapperClass(clazz)) {      // 2
    cacheWrapperClass(clazz);
  } else {
    clazz.getConstructor();
    if (StringUtils.isEmpty(name)) {
      name = findAnnotationName(clazz);
      if (name.length() == 0) {
        throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
      }
    }

    String[] names = NAME_SEPARATOR.split(name);
    if (ArrayUtils.isNotEmpty(names)) {
      cacheActivateClass(clazz, names[0]);   // 3
      for (String n : names) {
        cacheName(clazz, n);
        saveInExtensionClass(extensionClasses, clazz, name);  //4
      }
    }
  }
}

分析:

  • 1.clazz被Adaptive注解,就会通过cacheWrapperClass`方法
 private void cacheAdaptiveClass(Class<?> clazz) {
   if (cachedAdaptiveClass == null) {
     cachedAdaptiveClass = clazz;
   } else if (!cachedAdaptiveClass.equals(clazz)) {
     throw new IllegalStateException("More than 1 adaptive class found: "
                                     + cachedAdaptiveClass.getClass().getName()
                                     + ", " + clazz.getClass().getName());
   }
 }

可以看出在对应的配置文件中,只允许一个类被Adaptive注解,这个问题后面再来解释?

  • 2.isWrapperClass
private boolean isWrapperClass(Class<?> clazz) {
  try {
    clazz.getConstructor(type);   
    return true;
  } catch (NoSuchMethodException e) {
    return false;
  }
}
private void cacheWrapperClass(Class<?> clazz) {
  if (cachedWrapperClasses == null) {
    cachedWrapperClasses = new ConcurrentHashSet<>();
  }
  cachedWrapperClasses.add(clazz);
}

分析: 这里的type就是ExtensionLoader缓存type,我们这里是Protocol.class,意思就是要看Protocol.class对应的配置文件中的类那些有以Protocol.class作为构造器的类,这些类都会被缓存在cachedWrapperClasses中保存起来,后面会用到;

  • 3.cacheActivateClass方法
private void cacheActivateClass(Class<?> clazz, String name) {
  Activate activate = clazz.getAnnotation(Activate.class);   // a
  if (activate != null) {
    cachedActivates.put(name, activate);   //a
  } else {
    // support com.alibaba.dubbo.common.extension.Activate
    com.alibaba.dubbo.common.extension.Activate oldActivate = clazz.getAnnotation(com.alibaba.dubbo.common.extension.Activate.class);  //b
    if (oldActivate != null) {
      cachedActivates.put(name, oldActivate);    //b
    }
  }
}

分析:

​ a.这里就是验证是否配置文件中有的类被Activate注解了,如果有就是激活扩展点,这个后面讲;

​ b.是为了兼容alibaba时期的dubbo;

  • 4.saveInExtensionClass方法缓存配置文件中剩下的类

这里我们可以看到对于ExtensionLoader(clazz)来说,clazz相对的配置文件中的类都被分类保存到了不同的的cache中保存起来,以备后用。最后返回的扩展点是下面这些。

图片描述

加载后得到的缓存列表

图片描述

可以看到我们写的MyProtocol被加载了。

再回到createExtension的方法中,看injectExtension(instance)方法,依赖注入

依赖注入injectExtension方法

为了测试依赖注入,我给MyProtocol类添加了,一个属性dubboProtocol,如下:

private Protocol dubboProtocol;

public void setDubboProtocol(Protocol dubboProtocol) {
  this.dubboProtocol = dubboProtocol;
}

之后再来看injectExtension方法

private T injectExtension(T instance) {
  try {
    if (objectFactory != null) {
      for (Method method : instance.getClass().getMethods()) {
        if (isSetter(method)) {
          /**
                         * Check {@link DisableInject} to see if we need auto injection for this property
                         */
          if (method.getAnnotation(DisableInject.class) != null) {
            continue;
          }
          Class<?> pt = method.getParameterTypes()[0];
          if (ReflectUtils.isPrimitives(pt)) {        // 1
            continue;
          }
          try {
            String property = getSetterProperty(method);  // 2
            Object object = 
              objectFactory.getExtension(pt, property);   //3
            if (object != null) {
              method.invoke(instance, object);
            }
          } catch (Exception e) {
            logger.error("Failed to inject via method " + method.getName()
                         + " of interface " + type.getName() + ": " + e.getMessage(), e);
          }
        }
      }
    }
  } catch (Exception e) {
    logger.error(e.getMessage(), e);
  }
  return instance;
}

分析:

  • 1.涉及到了下面一段代码,就是属性是源生类型、String类型、Boolean类型、Character类型、Number类型、Date类型的类的话,不需要依赖注入;
public static boolean isPrimitive(Class<?> cls) {
        return cls.isPrimitive() || cls == String.class || cls == Boolean.class || cls == Character.class
                || Number.class.isAssignableFrom(cls) || Date.class.isAssignableFrom(cls);
    }
  • 2.得到属性的名称,我这里的objectFactory是一个AdaptiveExtensionFactory类,所以进入AdaptiveExtensionFactory的getExtension方法
AdaptiveExtensionFactory
@Override
    public <T> T getExtension(Class<T> type, String name) {
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);  // 1
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

分析:

  • 1.factories中有两个ExtensionFactory的实现类,SpiExtensionFactory和SpringExtensionFactory,循环两个扩展点工厂,先来看SpiExtensionFactory的实现:
@Override
    public <T> T getExtension(Class<T> type, String name) {
        if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {// 1
            ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
            if (!loader.getSupportedExtensions().isEmpty()) { //2
                return loader.getAdaptiveExtension(); // 3
            }
        }
        return null;
    }

分析:

  • 1.被@SPI注解的接口,使用type对应的ExtensionLoader,如果有就查看接口protocol类,支持的扩展点类表是不是空的,我这里不是空的,如下

图片描述

  • 2-3.不为空使用getAdaptiveExtension获取自适应的扩展点,这个接下来会分析

回到前面再来看看SpringExtensionFactory的实现:

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

        //SPI should be get from SpiExtensionFactory
        if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {  // 1
            return null;
        }

        for (ApplicationContext context : CONTEXTS) {
            if (context.containsBean(name)) {   // 2
                Object bean = context.getBean(name);
                if (type.isInstance(bean)) {
                    return (T) bean;
                }
            }
        }

        logger.warn("No spring extension (bean) named:" + name + ", try to find an extension (bean) of type " + type.getName());

        if (Object.class == type) {
            return null;
        }

        for (ApplicationContext context : CONTEXTS) {
            try {
                return context.getBean(type);  //3
            } catch (NoUniqueBeanDefinitionException multiBeanExe) {
                logger.warn("Find more than 1 spring extensions (beans) of type " + type.getName() + ", will stop auto injection. Please make sure you have specified the concrete parameter type and there's only one extension of that type.");
            } catch (NoSuchBeanDefinitionException noBeanExe) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Error when get spring extension(bean) for type:" + type.getName(), noBeanExe);
                }
            }
        }

        logger.warn("No spring extension (bean) named:" + name + ", type:" + type.getName() + " found, stop get bean.");

        return null;
    }

分析:

  • 1.跳过被@SPI注解的注解的接口或者类,被@SPI注解的要去SpiExtensionFactory中获取;
  • 2-3.说白了就是去Spring上下文工厂中获取对象实例,依赖注入;
依赖注入总结

通过AdaptiveExtensionFactory自适应到对应的扩展工厂SpiExtensionFactory和SpringExtensionFactory去获取属性的实例,之后进行依赖注入。
图片描述

这里是一个Protocol$Adaptive类,就是自适应扩展点。会根据很多种情况来自适应。剧透一下我这里的实现,得到的是默认的DubboProtocol,因为Protocol的注解@SPI("dubbo"),dubbo为默认实现,如下:

@SPI("dubbo")
public interface Protocol {
    ...
}

回到createExtension方法中的第3点:
图片描述

配置文件中的三个wrapper类
图片描述

最后得到的就是下面的对象:这最后包装的是一个代理类Protocol$Adaptive,我觉得这个是为了最后适配使用的,会根据项目环境使用的具体协议自适应。
图片描述

自适应扩展点

分为两种一种是Adaptive加在类级别上,另一种是加在方法级别上,有什么区别呢?接下来就来分析。

Adaptive加在类上
使用Compiler为例
@SPI("javassist")
public interface Compiler {
    Class<?> compile(String code, ClassLoader classLoader);
}

@SPI("javassist")默认实现是JDK的javassist。

Compiler compiler = ExtensionLoader.getExtensionLoader(Compiler.class).getAdaptiveExtension();

先看一下得到的compiler为何物
图片描述

AdaptiveCompiler又是从哪里来的呢?这个是从Compiler扩展点配置文件中得到,可以看到在AdaptiveCompiler前有一个adaptive的name,正式从这里得到的。
图片描述

可以看到这个AdaptiveCompiler有一个Adaptive注解,既然有这个注解,前面上一节的分析,Compiler对应的 ExtensionLoader回去加载Compiler对应的配置文件org.apache.dubbo.common.compiler.Compiler中所有的类,分别放到对应的缓存中,AdaptiveCompiler会被缓存在cachedAdaptiveClass中,当使用getAdaptiveExtension()方法获取自适应的时候,cachedAdaptiveClass中有就会拿到,这个Compiler的自适应扩展点dubbo帮我们写好了,很多情况下是没有这个类的,这时候如果没有,就会使用字节码生成的方式得到一个带$的类,就如上面一个例子中的Protocol$Adaptive。

@Adaptive
public class AdaptiveCompiler implements Compiler {
    private static volatile String DEFAULT_COMPILER;
    public static void setDefaultCompiler(String compiler) {
        DEFAULT_COMPILER = compiler;
    }
    @Override
    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);   // 1
        } else {
            compiler = loader.getDefaultExtension();  // 2
        }
        return compiler.compile(code, classLoader);
    }

}

对于两个扩展点:jdk=org.apache.dubbo.common.compiler.support.JdkCompiler和javassist=org.apache.dubbo.common.compiler.support.JavassistCompiler,究竟会使用哪一个呢?

这就要看自适应扩展点的作用了

自适应扩展类的作用

究竟使用到哪一个具体的扩展实现,对于AdaptiveCompiler来说就是使用其compile方法,可以看到两个方法:

  • 1.compiler = loader.getExtension(name)是根据具体的name来的到,这个不需要过多的解释;
  • 2.compiler = loader.getDefaultExtension()的到默认的扩展点;
getDefaultExtension方法
public T getDefaultExtension() {
  getExtensionClasses();
  if (StringUtils.isBlank(cachedDefaultName) || "true".equals(cachedDefaultName)) {
    return null;
  }
  return getExtension(cachedDefaultName);
}

来看一下cachedDefaultName的值是怎么得到的

在研究静态扩展点的时候已经看到过getExtensionClasses()往下会调用到loadExtensionClasses方法

在之后会调用到cacheDefaultExtensionName()方法

cacheDefaultExtensionName方法
private void cacheDefaultExtensionName() {
  final SPI defaultAnnotation = type.getAnnotation(SPI.class);
  if (defaultAnnotation != null) {
    String value = defaultAnnotation.value();
    if ((value = value.trim()).length() > 0) {
      String[] names = NAME_SEPARATOR.split(value);
      if (names.length > 1) {
        throw new IllegalStateException("More than 1 default extension name on extension " + type.getName()
                                        + ": " + Arrays.toString(names));
      }
      if (names.length == 1) {
        cachedDefaultName = names[0];
      }
    }
  }
}

从代码中可以看到默认的时间就是SPI注解中配置的值,配置了多个的话会提示超过一个默认扩展点。

加在类上就是说dubbo已经帮我们实现了Adaptive的扩展点。

Adaptive加在方法上
以Protocol为例
@SPI("dubbo")
public interface Protocol {
    ...
    @Adaptive
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
  
    @Adaptive
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
    ...
}

两个方法都加了Adaptive注解

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

配置文件中也没有一个是属于adaptive的扩展点,这时候怎么呢?

filter=org.apache.dubbo.rpc.protocol.ProtocolFilterWrapper
listener=org.apache.dubbo.rpc.protocol.ProtocolListenerWrapper
mock=org.apache.dubbo.rpc.support.MockProtocol
dubbo=org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol
injvm=org.apache.dubbo.rpc.protocol.injvm.InjvmProtocol
rmi=org.apache.dubbo.rpc.protocol.rmi.RmiProtocol
hessian=org.apache.dubbo.rpc.protocol.hessian.HessianProtocol
http=org.apache.dubbo.rpc.protocol.http.HttpProtocol
org.apache.dubbo.rpc.protocol.webservice.WebServiceProtocol
thrift=org.apache.dubbo.rpc.protocol.thrift.ThriftProtocol
native-thrift=org.apache.dubbo.rpc.protocol.nativethrift.ThriftProtocol
memcached=org.apache.dubbo.rpc.protocol.memcached.MemcachedProtocol
redis=org.apache.dubbo.rpc.protocol.redis.RedisProtocol
rest=org.apache.dubbo.rpc.protocol.rest.RestProtocol
xmlrpc=org.apache.dubbo.xml.rpc.protocol.xmlrpc.XmlRpcProtocol
registry=org.apache.dubbo.registry.integration.RegistryProtocol
qos=org.apache.dubbo.qos.protocol.QosProtocolWrapper

先看一下得到的是什么,生成了一个Protocol$Adaptive类
图片描述

getAdaptiveExtension方法
public T getAdaptiveExtension() {
  Object instance = cachedAdaptiveInstance.get();
  if (instance == null) {
    if (createAdaptiveInstanceError == null) {
      synchronized (cachedAdaptiveInstance) {
        instance = cachedAdaptiveInstance.get();
        if (instance == null) {
          try {
            instance = createAdaptiveExtension();   // 1
            cachedAdaptiveInstance.set(instance);
          } catch (Throwable t) {
            createAdaptiveInstanceError = t;
            throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
          }
        }
      }
    } else {
      throw new IllegalStateException("Failed to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
    }
  }

  return (T) instance;
}

重要1处的代码

createAdaptiveExtension方法
private T createAdaptiveExtension() {
  try {
    return injectExtension((T) getAdaptiveExtensionClass().newInstance()); // a
  } catch (Exception e) {
    throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
  }
}

先看a处getAdaptiveExtensionClass方法

private Class<?> getAdaptiveExtensionClass() {
  getExtensionClasses(); // B
  if (cachedAdaptiveClass != null) {
    return cachedAdaptiveClass;
  }
  return cachedAdaptiveClass = createAdaptiveExtensionClass(); // C
}
  • B. 又看到了getExtensionClasses()方法,不在做过多的解释,就是去加载ExtensionLoader中type对应的配置文件中的各个类,分类并缓存,cachedAdaptiveClass为空,说明在配置文件中没有一个name为adaptive的类;
  • C.没有一个name为adaptive的类时,执行createAdaptiveExtensionClass(),这里应该会生成我们要找的带$的代理类;
createAdaptiveExtensionClass方法
private Class<?> createAdaptiveExtensionClass() {
  String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();// D
  ClassLoader classLoader = findClassLoader();
  org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
  return compiler.compile(code, classLoader);
}

D处的代码就是去动态生成一个自适应的类,以Protocol为例,看生成的是什么

public class Protocol$Adaptive implements org.apache.dubbo.rpc.Protocol {
    public void destroy()  {
        throw new UnsupportedOperationException("The method public abstract void org.apache.dubbo.rpc.Protocol.destroy() of interface org.apache.dubbo.rpc.Protocol is not adaptive method!");
    }
    public int getDefaultPort()  {
        throw new UnsupportedOperationException("The method public abstract int org.apache.dubbo.rpc.Protocol.getDefaultPort() of interface org.apache.dubbo.rpc.Protocol is not adaptive method!");
    }
    public org.apache.dubbo.rpc.Invoker refer(java.lang.Class arg0, org.apache.dubbo.common.URL arg1) throws org.apache.dubbo.rpc.RpcException {
        if (arg1 == null) throw new IllegalArgumentException("url == null");
        org.apache.dubbo.common.URL url = arg1;
        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
        if(extName == null) throw new IllegalStateException("Failed to get extension (org.apache.dubbo.rpc.Protocol) name from url (" + url.toString() + ") use keys([protocol])");
        org.apache.dubbo.rpc.Protocol extension = (org.apache.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.Protocol.class).getExtension(extName);
        return extension.refer(arg0, arg1);
    }
    public org.apache.dubbo.rpc.Exporter export(org.apache.dubbo.rpc.Invoker arg0) throws org.apache.dubbo.rpc.RpcException {
        if (arg0 == null) throw new IllegalArgumentException("org.apache.dubbo.rpc.Invoker argument == null");
        if (arg0.getUrl() == null) throw new IllegalArgumentException("org.apache.dubbo.rpc.Invoker argument getUrl() == null");
        org.apache.dubbo.common.URL url = arg0.getUrl();
        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
        if(extName == null) throw new IllegalStateException("Failed to get extension (org.apache.dubbo.rpc.Protocol) name from url (" + url.toString() + ") use keys([protocol])");
        org.apache.dubbo.rpc.Protocol extension = (org.apache.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.Protocol.class).getExtension(extName);
        return extension.export(arg0);
    }
}

这里还有一个小知识点,方法上加Adaptive最后的作用是什么呢?createAdaptiveExtensionClass的D处代码generate()-->code.append(generateMethod(method))-->generateMethodContent(method),一连串的调用之后找到了答案;

generateMethodContent方法
private String generateMethodContent(Method method) {
  Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class); //E
  StringBuilder code = new StringBuilder(512);
  if (adaptiveAnnotation == null) {
    return generateUnsupported(method);    //F
  } else {
    int urlTypeIndex = getUrlTypeIndex(method);
    // found parameter in URL type
    if (urlTypeIndex != -1) {
      // Null Point check
      code.append(generateUrlNullCheck(urlTypeIndex));
    } else {
      // did not find parameter in URL type
      code.append(generateUrlAssignmentIndirectly(method));
    }
    String[] value = getMethodAdaptiveValue(adaptiveAnnotation);
    boolean hasInvocation = hasInvocationArgument(method);
    code.append(generateInvocationArgumentNullCheck(method));
    code.append(generateExtNameAssignment(value, hasInvocation));
    // check extName == null?
    code.append(generateExtNameNullCheck(value));
    code.append(generateExtensionAssignment());
    // return statement
    code.append(generateReturnAndInvocation(method));
  }
  return code.toString();
}
  • E处代码用到了Adaptive注解,辨别是Adaptive的方法;
  • F代码的作用如下,就是为不是Adaptive的方法生成如下代码,对比Protocol$Adaptive就明白了;

图片描述

激活扩展点

这类扩展点是被Activate注解的类

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Activate {
    /**
     * Activate the current extension when one of the groups matches. The group passed into
     */
    String[] group() default {};

    /**
     * Activate the current extension when the specified keys appear in the URL's parameters.
     */
    String[] value() default {};

    @Deprecated
    String[] before() default {};

    @Deprecated
    String[] after() default {};

    int order() default 0;
}

group:中出现一个就可以加载;

value:当url中出现这个value指定的key是可以激活;

以Filter为例

这个接口没有Activate注解

@SPI
public interface Filter {
    Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException;
    @Deprecated
    default Result onResponse(Result appResponse, Invoker<?> invoker, Invocation invocation) {
        return appResponse;
    }
    interface Listener {
        void onResponse(Result appResponse, Invoker<?> invoker, Invocation invocation);
        void onError(Throwable t, Invoker<?> invoker, Invocation invocation);
    }
}

看一下配置文件

cache=org.apache.dubbo.cache.filter.CacheFilter
validation=org.apache.dubbo.validation.filter.ValidationFilter
echo=org.apache.dubbo.rpc.filter.EchoFilter
generic=org.apache.dubbo.rpc.filter.GenericFilter
genericimpl=org.apache.dubbo.rpc.filter.GenericImplFilter
token=org.apache.dubbo.rpc.filter.TokenFilter
accesslog=org.apache.dubbo.rpc.filter.AccessLogFilter
activelimit=org.apache.dubbo.rpc.filter.ActiveLimitFilter
classloader=org.apache.dubbo.rpc.filter.ClassLoaderFilter
context=org.apache.dubbo.rpc.filter.ContextFilter
consumercontext=org.apache.dubbo.rpc.filter.ConsumerContextFilter
exception=org.apache.dubbo.rpc.filter.ExceptionFilter
executelimit=org.apache.dubbo.rpc.filter.ExecuteLimitFilter
deprecated=org.apache.dubbo.rpc.filter.DeprecatedFilter
compatible=org.apache.dubbo.rpc.filter.CompatibleFilter
timeout=org.apache.dubbo.rpc.filter.TimeoutFilter
trace=org.apache.dubbo.rpc.protocol.dubbo.filter.TraceFilter
future=org.apache.dubbo.rpc.protocol.dubbo.filter.FutureFilter
monitor=org.apache.dubbo.monitor.support.MonitorFilter
metrics=org.apache.dubbo.monitor.dubbo.MetricsFilter

随便看一个配置文件中的类,这个类是被Activate注解的

@Activate(group = {CONSUMER, PROVIDER}, value = CACHE_KEY)
public class CacheFilter implements Filter {
    ...
}

String CACHE_KEY = "cache";

示例代码1:

URL url = new URL("", "", 0);
List<Filter> list = ExtensionLoader.getExtensionLoader(Filter.class)
  .getActivateExtension(url, "cache");

结果:
图片描述

示例代码2:

RL url = new URL("", "", 0);
url = url.addParameter("cache", "cache");
List<Filter> list = ExtensionLoader.getExtensionLoader(Filter.class)
  .getActivateExtension(url, "cache");

结果2:
图片描述

从两个不同的结果对比可以看出多出了一个CacheFilter对象,这是因为在CacheFilter的Activate注解里有一个cache,也就是说当cache出现的时候,这类才会被激活加载,这有点想springboot中的ConditionOnClass和ConditionOnBean等Condition类的条件注解。

getActivateExtension
public List<T> getActivateExtension(URL url, String key) {
  return getActivateExtension(url, key, null);
}
public List<T> getActivateExtension(URL url, String key, String group) {
  String value = url.getParameter(key);
  return getActivateExtension(url, StringUtils.isEmpty(value) ? null :                                      COMMA_SPLIT_PATTERN.split(value), group);
}
public List<T> getActivateExtension(URL url, String[] values, String group) {
        List<T> exts = new ArrayList<>();
        List<String> names = values == null ? new ArrayList<>(0) : Arrays.asList(values);
        if (!names.contains(REMOVE_VALUE_PREFIX + DEFAULT_KEY)) {
            getExtensionClasses();
            for (Map.Entry<String, Object> entry : cachedActivates.entrySet()) {// G
                String name = entry.getKey();
                Object activate = entry.getValue();

                String[] activateGroup, activateValue;

                if (activate instanceof Activate) {
                    activateGroup = ((Activate) activate).group();
                    activateValue = ((Activate) activate).value();
                } else if (activate instanceof com.alibaba.dubbo.common.extension.Activate) {
                    activateGroup = ((com.alibaba.dubbo.common.extension.Activate) activate).group();
                    activateValue = ((com.alibaba.dubbo.common.extension.Activate) activate).value();
                } else {
                    continue;
                }
                if (isMatchGroup(group, activateGroup)) {  // H
                    T ext = getExtension(name);
                    if (!names.contains(name)
                            && !names.contains(REMOVE_VALUE_PREFIX + name)
                            && isActive(activateValue, url)) { // I
                        exts.add(ext);
                    }
                }
            }
            exts.sort(ActivateComparator.COMPARATOR);
        }
        List<T> usrs = new ArrayList<>();
        for (int i = 0; i < names.size(); i++) {
            String name = names.get(i);
            if (!name.startsWith(REMOVE_VALUE_PREFIX)
                    && !names.contains(REMOVE_VALUE_PREFIX + name)) {
                if (DEFAULT_KEY.equals(name)) {
                    if (!usrs.isEmpty()) {
                        exts.addAll(0, usrs);
                        usrs.clear();
                    }
                } else {
                    T ext = getExtension(name);
                    usrs.add(ext);
                }
            }
        }
        if (!usrs.isEmpty()) {
            exts.addAll(usrs);
        }
        return exts;
    }
    private boolean isActive(String[] keys, URL url) {
        if (keys.length == 0) {
            return true;
        }
        for (String key : keys) {
            for (Map.Entry<String, String> entry : url.getParameters().entrySet()) {  //J
                String k = entry.getKey();
                String v = entry.getValue();
                if ((k.equals(key) || k.endsWith("." + key))
                        && ConfigUtils.isNotEmpty(v)) {
                    return true;
                }
            }
        }
        return false;
    }

分析:

  • G.在loadClass方法的第3条中就会将可激活的扩展点加载到缓存cachedActivates中;
  • H、I和 J. group匹配判断,以及将Activate注解中的value值和URL中的参数进行匹配,符合条件的就会配加载到并返回;

总结

以上就是dubbo中的SPI扩展机制的内容,dubbo根据Java自身的SPI扩展机制,开发了自己的一套扩展机制,是为了更好的、更灵活的适配。

评论

暂无评论