在dubbo中，对Java中的spi机制进行了扩展，具体spi机制的使用，就不说了，在dubbo中进行了如下的扩展
1.可以通过xxxname = com.xxxx.MyFilter的配置方式，来指定自定义实现类的name
2.在使用的时候，可以根据name获取指定的扩展类，而不是像Java的spi机制直接获取所有的扩展类
在源码层面，SPI机制最为重要的类就是ExtensionLoader类，在该类中，有三个比较重要的方法
getExtension(String name)
getActivateExtension(URL url, String key)
getAdaptiveExtension()
其中，最为基础的方法是getExtension()方法，因为在该方法中，会去解析所有的扩展配置文件中配置的扩展类，然后解析在文件中配置的扩展类，是普通的扩展类，还是
@Active注解修饰的类、还是@Adaptive修饰的类、还是包装类
getExtension(String name)
在getExtension(String name)方法中，会通过DCL的方式去判断是否已经解析，如果没有解析，就会调用到
com.alibaba.dubbo.common.extension.ExtensionLoader#createExtension
去开始解析当前type所有的扩展类
/**
* 根据name创建对应的实现类，以protocol为例，如果入参http，则这里创建的是httpProtocol
*
* 1、创建class对象
* 2、属性注入
* 3、AOP
*/
private T createExtension(String name) {
/**
* 下面这一行代码中的getExtensionClasses()是最为重要的代码之一
*/
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null) {
throw findException(name);
}
try {
T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
/**
* 1.前面都是缓存的判断，这里会根据class创建一个对象
*/
EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
/**
* 2.IOC进行注入依赖
*/
injectExtension(instance);
/**
* 3.aop 进行wrapper类的包装
* cachedWrapperClasses这个变量是在解析META-INF.services目录下文件的时候，赋值的
*/
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);
}
}
根据源码可以看到，在获取某个name对应的扩展类的时候，会进行以下几个操作
1.解析完所有的扩展类之后，会先进行属性注入，这里的属性注入和spring中的概念还不太一样，这里的注入只支持通过set方法进行注入
2.通过类似于aop的操作，对包装类进行处理，将包装类包裹在目标方法外层
包装类的处理这里也依赖于getExtensionClasses()这个方法，这个方法是去解析当前所配置的所有扩展类，举个例子：比如protocol接口，在这里就会去解析dubbo自己提供的protocol接口的实现类，和我们提供的protocol实现类
解析配置文件
getExtensionClasses()
解析配置文件的原理，要从getExtensionClasses()这个方法看起：
private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
private Map<String, Class<?>> getExtensionClasses() {
Map<String, Class<?>> classes = cachedClasses.get();
if (classes == null) {
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
classes = loadExtensionClasses();
cachedClasses.set(classes);
}
}
}
return classes;
}
这里的cachedClasses中存储的是一个map集合，这个map集合就是解析出来扩展类对应的name和对应的实现类
loadExtensionClasses()
/**
* 这个方法返回的map是type对应的扩展类
* 比如：type是protocol的时候，会返回RegistryProtocol、HttpProtocol等
* @return
*/
private Map<String, Class<?>> loadExtensionClasses() {
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
/**
* 1.解析@SPI注解上对应的默认的实现类，只允许有一个默认的实现类，如果@SPI("dubbo,http")这样就会跑出异常
* 将默认的实现，赋值到全局变量：cachedDefaultName中
*/
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];
}
}
/**
* 2.从指定的目录下的文件中解析
* 在解析到之后，会赋值到extensionClasses中，在2.6之后的版本中，会兼容com.alibaba
*/
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadDirectory(extensionClasses, DUBBO_DIRECTORY);
loadDirectory(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
我们一层一层往下分析：这里的loadExtensionClasses(）方法中会判断当前目标接口是否添加了@SPI注解
然后会将@SPI注解中设置的name，设置为默认的name
最为核心的是三个loadDirectory()方法
我们通常说，在自定义扩展类的时候，需要在指定的路径下，分别有三个，是哪三个呢？就是这里的
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/";
我们接着来看loadDirectory方法
loadDirectory()
/**
* 从指定的dir目录下，查找class的实现类，通过class.forName()初始化，然后放入到extensionClasses中;
* @param extensionClasses
* @param dir
*/
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
String fileName = dir + type.getName();
try {
Enumeration<java.net.URL> urls;
/**
* 1.获取对应的classLoader
* 然后获取到对应文件中的所有url
*/
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();
/**
* 2.加载对应的实现类，这里的resourceURL就是文件中的：http=com.alibaba.....HttpProtocol
*/
loadResource(extensionClasses, classLoader, resourceURL);
}
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", description file: " + fileName + ").", t);
}
}
这个方法主要是根据路径地址 + typeName，拼接全类名，
loadClass
中间还有一个loadResource方法，就不贴代码了，loadResource()方法主要是根据
/**
* 这个方法主要是将name和clazz赋值到extensionClasses中，只是在put之前，会有一系列的逻辑判断
* @param extensionClasses
* @param resourceURL
* @param clazz
* @param name
* @throws NoSuchMethodException
*/
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
/**
* 1.判断clazz是否是type的实现类
* 如果type是Protocol，那么这里的clazz就是文件中配置的HttpProtocol实现类
*/
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.");
}
/**
* 2.判断当前实现类上是否有@Adaptive注解,需要注意的是一个接口，只允许有一个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)) {
/**
* 在判断是否是包装类的时候，就看对应类中是否有目标接口的构造函数
* 3.wrapper类的处理,如果当前clazz是type实现类的包装类，就暂时将包装类存入到一个集合中
* CarWrapper就会进入到这里来处理
*/
Set<Class<?>> wrappers = cachedWrapperClasses;
if (wrappers == null) {
cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
wrappers = cachedWrapperClasses;
}
wrappers.add(clazz);
} else {
/**
* 4.进入到这里，表示既不是包装类，也没有添加@Adaptive注解
* 必须要有无参构造函数，因为是通过class.newInstance()来初始化的
*/
clazz.getConstructor();
/**
* 4.2 如果在META-INF下的文件中，没有配置name，就从实现类上去判断，是否有添加@Extension注解，如果有添加，就返回
* @Extension 注解对应的value
*/
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);
}
}
/**
* 4.3 对name进行拆分
* 并且判断
*/
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());
}
}
}
}
}
loadClass主要是将解析到的clazz进行处理，在注释中已经写的比较明白了
1.首先判断是否是 对应的实现类
2.然后判断是否有添加@Adaptive注解，如果是第一次解析到adaptive实现类，就会放入到cachedAdaptiveClass中，如果一个接口有两个adaptive实现类，就会报错，在dubbo中是不允许的
3.然后判断是否是包装类
4.最后，除了上面的几种情况，就是一个普通的实现类了，但是也会判断是否有添加@Activate注解，如果有添加，就放入到cachedActivates中，这是一个默认激活的配置
在这个方法中，需要关注几个集合
cachedAdaptiveClass：存储的是程序员实现的adaptive实现类
cachedWrapperClasses：存储的是当前接口protocol的包装类
cachedActivates：存放的是加了@Activate注解的类
cachedNames：存储的是普通的实现类
getAdaptiveExtension()
如果我们没有声明接口的adaptive实现类，那在调用这个方法的时候，dubbo会默认帮我们生成一个adaptive实现类
/**
* 获取添加了@Adaptive注解的实现类
*/
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;
}
private T createAdaptiveExtension() {
try {
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
private Class<?> getAdaptiveExtensionClass() {
getExtensionClasses();
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
这里可以看到，在调用方法的时候，会先从cachedAdaptiveClass 中取，如果没有，就调用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);
}
这里createAdaptiveExtensionClassCode()方法，没太看明白，但是根据debug的结果来看，是拼接了一个类的字符串，然后通过 compiler.compile(code, classLoader);去生成一个adaptive实现类
下面是在启动的时候，dubbo生成的protocol的adaptive实现类，可以看到，export 和refer对应的实现方法中都有逻辑，但是destroy和getDefaultPort默认的实现方法中是抛出异常了，
这个adaptive的机制有关系：如果让dubbo自己动态的去生成adaptive实现类的时候，只会对目标接口中加了@Adaptive注解的方法进行实现
package com.alibaba.dubbo.rpc;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
public class Protocol$Adaptive 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.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);
}
public com.alibaba.dubbo.rpc.Exporter
export (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);
}
}
@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();
}
getActivateExtension()
/**
* Get activate extensions.
* 获取指定type对应的active实现类
* 1.遍历所有的active实现类，cachedActivates 这个集合在调用getExtension的时候，会将实现类中加了@Active注解的类放到该集合中
* 2.然后会判断group是否符合要求
* 3.会判断请求该方法的时候，如果指定了names,那就过滤出来指定的active实现类
* 4.接着判断注解中指定的value，在url的parameters中是否存在
* @param url url
* @param values extension point names
* @param group group
* @return extension list which are activated
* @see com.alibaba.dubbo.common.extension.Activate
*/
public List<T> getActivateExtension(URL url, String[] values, String group) {
List<T> exts = new ArrayList<T>();
List<String> names = values == null ? new ArrayList<String>(0) : Arrays.asList(values);
if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
getExtensionClasses();
for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Activate activate = entry.getValue();
/**
* 1.判断activate对应的group是否符合当前入参的group
*/
if (isMatchGroup(group, activate.group())) {
/**
* 2.根据name获取对应的实现类；这里的name，应该就是文件中filter对应的key
* 3.在isActive()方法中，判断当前url是否包含filter指定的value
*/
T ext = getExtension(name);
if (!names.contains(name)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
&& isActive(activate, url)) {
exts.add(ext);
}
}
}
Collections.sort(exts, ActivateComparator.COMPARATOR);
}
List<T> usrs = new ArrayList<T>();
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
if (Constants.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;
}
这里面比较核心的是isActive()方法，
/**
* 判断active注解中的value
* 如果我们在实现类上的active注解中，配置了value参数，表示在buildFilter的时候，不仅要满足group，还要满足：
* 在请求的url中，对应的parameter有value的值，且其值不为null
* @param activate：name对应的实现类上，指定的value
* @param url
* @return
*/
private boolean isActive(Activate activate, URL url) {
String[] keys = activate.value();
if (keys.length == 0) {
return true;
}
for (String key : keys) {
for (Map.Entry<String, String> entry : url.getParameters().entrySet()) {
String k = entry.getKey();
String v = entry.getValue();
if ((k.equals(key) || k.endsWith("." + key))
&& ConfigUtils.isNotEmpty(v)) {
return true;
}
}
}
return false;
}
总结
所以，对于dubbo的SPI机制，最为核心的是对所有扩展方法的解析，active和adaptive都依赖于对配置文件中，自定义实现类的解析，最后会对其进行wrapper包装类的处理，最为典型的应用：就是filter的使用，在服务暴露和服务引入的过程中，会经过一系列包装类和filter的处理，其依赖的就是SPI机制去解析的