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扩展机制,开发了自己的一套扩展机制,是为了更好的、更灵活的适配。
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论