第4章：Dubbo扩展点加载机制

1.Java SPI

SPI，Service Provider Interface

Java SPI使用策略模式，一个接口多种实现。我们只申明接口，具体的实现并不在程序中直接指定，而是由程序之外的配置掌控。

具体步骤如下：

（1）定义一个接口及对应的方法

（2）编写一个该接口的实现类

（3）在META-INF/services目录下，创建一个以接口全路径命名的文件，如com.test.spi.PrintService。

（4）文件内容为具体实现类的全路径名，如果有多个，以分行符分隔。

（5）在代码中通过java.util.ServiceLoader来加载具体的实现类。

java SPI目录所示：

在这里插入图片描述

java SPI代码：

PrintService.java

package com.test.spi;

public interface PrintService {
    
    
    void printInfo();
}

PrintServiceImpl.java

package com.test.spi;

public class PrintServiceImpl implements PrintService{
    
    

    @Override
    public void printInfo() {
    
    
        System.out.println("hello world");
    }
}

Application.java

import com.test.spi.PrintService;

import java.util.ServiceLoader;

public class Application {
    
    
    public static void main(String[] args) {
    
    
        ServiceLoader<PrintService> serviceServiceLoader = ServiceLoader.load(PrintService.class);
        for (PrintService printService : serviceServiceLoader) {
    
    
            printService.printInfo();
        }
    }
}

com.test.spi.PrintService文件

com.test.spi.PrintServiceImpl

程序输出：
在这里插入图片描述

2.Dubbo SPI

Dubbo SPI对Java SPI进行了改进和优化

Java SPI会一次性实例化扩展点所有实现，扩展初始化浪费性能，Dubbo SPI只是加载配置文件中的类，并分 类和实例两个层级缓存在内存中

2.1 扩展点的配置规范

配置文件可以放置在META-INF/services/、META-INF/dubbo/、META-INF/dubbo/internal/ 三种目录下的任意一个

文件名是全路径类名

文件内容是key=value格式

2.2 扩展点的特性

2.2.1 自动包装

如果一个类的构造函数包含其他扩展点作为参数，那么这个类就会被认为是Wrapper类

private final Protocol protocol;

public ProtocolFilterWrapper(Protocol protocol) {
    
    
  if (protocol == null) {
    
    
    throw new IllegalArgumentException("protocol == null");
  }
  this.protocol = protocol;
}

2.2.2 自动加载

除了构造函数中带有参数，还可以使用setter方法设置属性值，如果一个扩展类是另外一个扩展点类的成员属性，并且拥有setter方法，那么框架就会自动注入扩展点实例

2.2.3 自适应

使用@Adaptive注解，动态地通过URL中的参数来确定使用哪个具体的实现类

2.2.4 自动激活

某个扩展类的多个实现类同时启用，如Filter扩展点

2.3 扩展点注解

@SPI

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({
    
    ElementType.TYPE})
public @interface SPI {
    
    

    /**
     * default extension name
     */
    String value() default "";

}

Dubbo框架中都是使用在接口上，标记这个接口是Dubbo SPI接口，即是一个扩展点

传入不同的参数来设置这个接口的默认实现类，如下示例表明Transporter接口使用Netty作为默认实现

@SPI("netty")
public interface Transporter{
    
    
  
}

@Adaptive

扩展点自适应注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({
    
    ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {
    
    

    String[] value() default {
    
    };

}

在实际应用场景中，一个扩展接口往往会有多种实现类，因为Dubbo是基于URL驱动，所以在运行时，通过传入URL中的某些参数来动态控制具体实现，这便是Dubbo的扩展点自适应特性。

在Dubbo中，@Adaptive一般用来修饰类和接口方法，在整个Dubbo框架中，只有少数几个地方使用在类级别上，如AdaptiveExtensionFactory和AdaptiveCompiler，其余都标注在方法上。

标记在方法上时，会自动生成和编译一个动态的Adaptive类

如果在放在实现类上，则整个实现类会直接作为默认实现，使用到了类和实例缓存避免重复实例化的开销

@Active

扩展点自动激活注解

主要作用是有多个扩展点实现需要根据不同条件实例化

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({
    
    ElementType.TYPE, ElementType.METHOD})
public @interface Activate {
    
    

    String[] group() default {
    
    };

    String[] value() default {
    
    };

    String[] before() default {
    
    };

    String[] after() default {
    
    };

    int order() default 0;
}

3.ExtensionLoader的工作原理

3.1 getExtension

getExtension(String name)方法是整个扩展加载器中最核心的方法，方法流程如下

读取SPI指定路径下的配置文件，根据配置加载所有配置类并缓存（不初始化）
根据传入的名称初始化对应的扩展类
找包装类（setter方法、构造函数），完成自动注入到实例中
返回扩展类实例

在上面的每一步中都先去检查缓存中有没有，如果有就直接返回，没有通过双重检查锁定实现单例，添加到缓存中

简单看一段代码：

ExtensionLoader#getExtension，获取扩展类

/**
     * Find the extension with the given name. If the specified name is not found, then {@link IllegalStateException}
     * will be thrown.
     */
@SuppressWarnings("unchecked")
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;
}

ExtensionLoader#createExtension，创建扩展类

@SuppressWarnings("unchecked")
private T createExtension(String name) {
    
    
  // 加载配置文件
  Class<?> clazz = getExtensionClasses().get(name);
  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);
    Set<Class<?>> wrapperClasses = cachedWrapperClasses;
    if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
    
    
      for (Class<?> wrapperClass : wrapperClasses) {
    
    
        instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
      }
    }
    return instance;
  } catch (Throwable t) {
    
    
    throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                                    type + ")  could not be instantiated: " + t.getMessage(), t);
  }
}

ExtensionLoader#loadResource，读取配置文件，通过反射获取实例

private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
    
    
  try {
    
    
    // I/O读取配置文件
    BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), "utf-8"));
    try {
    
    
      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('=');
            if (i > 0) {
    
    
              name = line.substring(0, i).trim();
              line = line.substring(i + 1).trim();
            }
            if (line.length() > 0) {
    
    
              /*
              	1.通过Class.forName获取扩展类实例
              	2.加入到缓存中
              */
              loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);
            }
          } 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);
          }
        }
      }
    } finally {
    
    
      reader.close();
    }
  } catch (Throwable t) {
    
    
    logger.error("Exception when load extension class(interface: " +
                 type + ", class file: " + resourceURL + ") in " + resourceURL, t);
  }
}

ExtensionLoader#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 when load extension class(interface: " +
                                    type + ", class line: " + clazz.getName() + "), class "
                                    + clazz.getName() + "is not subtype of interface.");
  }
  // Adaptive自适应
  if (clazz.isAnnotationPresent(Adaptive.class)) {
    
    
    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());
    }
  } else if (isWrapperClass(clazz)) {
    
    
    //Wrapper包装类
    Set<Class<?>> wrappers = cachedWrapperClasses;
    if (wrappers == null) {
    
    
      cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
      wrappers = cachedWrapperClasses;
    }
    wrappers.add(clazz);
  } else {
    
    
    // 普通扩展类，自动激活Activate也是普通扩展类
    clazz.getConstructor();
    if (name == null || name.length() == 0) {
    
    
      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 (names != null && names.length > 0) {
    
    
      Activate activate = clazz.getAnnotation(Activate.class);
      if (activate != null) {
    
    
        cachedActivates.put(names[0], activate);
      }
      for (String n : names) {
    
    
        if (!cachedNames.containsKey(clazz)) {
    
    
          cachedNames.put(clazz, n);
        }
        Class<?> c = extensionClasses.get(n);
        if (c == null) {
    
    
          extensionClasses.put(n, clazz);
        } else if (c != clazz) {
    
    
          throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
        }
      }
    }
  }
}

3.2 ExtensionFactory实现原理

ExtensionFactory是一个工厂接口，有3个实现类
在这里插入图片描述

AdaptiveExtensionFactory类上有@Adaptive注解，作为默认实现，在AdaptiveExtensionFactory的构造方法中，就会去加载所有的扩展类工厂放入到一个List中。

在AdaptiveExtensionFactory#getExtension方法时，实际上会去调用所有扩展类工厂去获取，缓存的工厂会通过TreeSet排序，SPI在前面，Spring在后面。依次遍历，发现存在扩展类实例返回。

public AdaptiveExtensionFactory() {
    
    
  // 加载所有的扩展类工厂
  ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
  List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
  for (String name : loader.getSupportedExtensions()) {
    
    
    list.add(loader.getExtension(name));
  }
  // 扩展类工厂存放在List中
  factories = Collections.unmodifiableList(list);
}

@Override
public <T> T getExtension(Class<T> type, String name) {
    
    
  for (ExtensionFactory factory : factories) {
    
    
    // 调用每个扩展类工厂的getExtension方法，SPI->Spring
    T extension = factory.getExtension(type, name);
    if (extension != null) {
    
    
      return extension;
    }
  }
  return null;
}

4.Javassist动态代码编译

Java基于字节码动态生成Class的方式有很多，如CGLIB、ASM、Javassist等。而自适应扩展点使用了生成字符串代码再编译为Class的方式。

主要讲解Javassist动态代码生成：

通过正则匹配不同部位的代码（如classpath、import、extends、implements、{}等）。
调用javassist库的API生成不同部位的代码。
编译生成Class。