1.Dubbo SPI是什么
首先看下dubbo官网的描述：
SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。不过，Dubbo 并未使用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满足需求。在 Dubbo 中，SPI 是一个非常重要的模块。基于 SPI，我们可以很容易的对 Dubbo 进行拓展。如果大家想要学习 Dubbo 的源码，SPI 机制务必弄懂。
2.Java SPI和Dubbo SPI示例
参考官网的例子，下面以Robot(机器人)接口为例，有两个实现类OptimusPrime(擎天柱) 和Bumblebee(大黄蜂)。
@SPI //JavaSPI不需要这个注解，使用dubboSPI的时候需要
public interface Robot {
void sayHello();
}
public class OptimusPrimeimplements Robot {
@Override
public void sayHello() {
System.out.println("Hello, I am Optimus Prime.");
}
}
public class Bumblebeeimplements Robot {
@Override
public void sayHello() {
System.out.println("Hello, I am Bumblebee.");
}
}
Java SPI配置文件放在 META-INF/services 下,如下：
com.pigcoffe.spi.Bumblebee
com.pigcoffe.spi.OptimusPrime
Dubbo SPI的配置文件放在META-INF/dubbo下，如下：
optimusPrime = com.pigcoffe.spi.OptimusPrime
bumblebee = com.pigcoffe.spi.Bumblebee
文件名都是接口全类名。
Java SPI测试类：
package com.pigcoffe.spi;
import com.pigcoffe.spi.Robot;
import org.junit.Test;
import java.util.ServiceLoader;
public class JavaSPITest {
@Test
public void sayHello() throws Exception {
ServiceLoader<Robot> serviceLoader = ServiceLoader.load(Robot.class);
System.out.println("Java SPI");
serviceLoader.forEach(Robot::sayHello);
}
}
输出：
Java SPI
Hello, I am Bumblebee.
Hello, I am Optimus Prime.
Dubbo SPI测试类，这里需要引入dubbo依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>dubbo</artifactId>
<version>2.6.4</version>
</dependency>
package com.pigcoffe.spi;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
import org.junit.Test;
public class DubboSPITest {
@Test
public void sayHello() throws Exception {
ExtensionLoader<Robot> extensionLoader =
ExtensionLoader.getExtensionLoader(Robot.class);
Robot optimusPrime = extensionLoader.getExtension("optimusPrime");
optimusPrime.sayHello();
Robot bumblebee = extensionLoader.getExtension("bumblebee");
bumblebee.sayHello();
}
}
输出：
Hello, I am Optimus Prime.
Hello, I am Bumblebee.
3.Dubbo SPI有什么优势，为什么不使用jdk自带的SPI
从示例代码中就能看出来一些区别了
- JDK 标准的 SPI 会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加载，会很浪费资源。
- 如果扩展点加载失败，连扩展点的名称都拿不到了。比如：JDK 标准的 ScriptEngine，通过 getName() 获取脚本类型的名称，但如果 RubyScriptEngine 因为所依赖的 jruby.jar 不存在，导致 RubyScriptEngine 类加载失败，这个失败原因被吃掉了，和 ruby 对应不起来，当用户执行 ruby 脚本时，会报不支持 ruby，而不是真正失败的原因。
- JDK SPI不支持缓存，不支持默认值，不支持IOC和AOP功能
4.源码分析
从第一行代码开始
ExtensionLoader<Robot> extensionLoader = ExtensionLoader.getExtensionLoader(Robot.class);
Robot optimusPrime = extensionLoader.getExtension("optimusPrime");
从extensionLoader.getExtension(“optimusPrime”);跟进代码
public T getExtension(String name) {
if (name != null && name.length() != 0) {
if ("true".equals(name)) {
return this.getDefaultExtension();
} else {
Holder<Object> holder = (Holder)this.cachedInstances.get(name);
if (holder == null) {
this.cachedInstances.putIfAbsent(name, new Holder());
holder = (Holder)this.cachedInstances.get(name);
}
Object instance = holder.get();
if (instance == null) {
synchronized(holder) {
instance = holder.get();
if (instance == null) {
//缓存中没有，新创建
instance = this.createExtension(name);
holder.set(instance);
}
}
}
return instance;
}
} else {
throw new IllegalArgumentException("Extension name == null");
}
}
逻辑比较简单，就是先从缓存获取对象，如果没有就创建this.createExtension(name)并加入缓存
下面是createExtension(String name) 方法
private T createExtension(String name) {
//从配置文件中加载所有的拓展类，可得到“配置项名称”到“配置类”的映射关系表
Class<?> clazz = (Class)this.getExtensionClasses().get(name);
if (clazz == null) {
throw this.findException(name);
} else {
try {
T instance = EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
instance = EXTENSION_INSTANCES.get(clazz);
}
//dubbo IOC
this.injectExtension(instance);
Set<Class<?>> wrapperClasses = this.cachedWrapperClasses;
Class wrapperClass;
if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
for(Iterator i$ = wrapperClasses.iterator(); i$.hasNext();
//dubbo AOP
instance = this.injectExtension(wrapperClass.getConstructor(this.type).newInstance(instance))) {
wrapperClass = (Class)i$.next();
}
}
return instance;
} catch (Throwable var7) {
throw new IllegalStateException("Extension instance(name: " + name + ", class: " + this.type + ") could not be instantiated: " + var7.getMessage(), var7);
}
}
}
这段代码首先是getExtensionClasses()从配置文件中加载所有的拓展类，可得到“配置项名称”到“配置类”的映射关系表，
ExtensionLoader#getExtensionClasses()–>loadExtensionClasses()
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 Map<String, Class<?>> loadExtensionClasses() {
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];
}
}
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadDirectory(extensionClasses, DUBBO_DIRECTORY);
loadDirectory(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
这里体现出dubbo SPI配置文件目录了，这里除了META-INF/dubbo/，还有META-INF/dubbo/internal/，internal目录下主要放的都是dubbo框架自己的扩展，用户新建的扩展一般放在dubbo目录下，上面示例的配置文件移动到META-INF/dubbo/internal/目录下也可以正常运行。
然后涉及到dubbo的IOC和AOP实现，先进入this.injectExtension(instance) IOC的实现
private T injectExtension(T instance) {
try {
if (this.objectFactory != null) {
Method[] arr$ = instance.getClass().getMethods();
int len$ = arr$.length;
for(int i$ = 0; i$ < len$; ++i$) {
Method method = arr$[i$];
if (method.getName().startsWith("set") && method.getParameterTypes().length == 1 && Modifier.isPublic(method.getModifiers())) {
Class pt = method.getParameterTypes()[0];
try {
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
Object object = this.objectFactory.getExtension(pt, property);
if (object != null) {
method.invoke(instance, object);
}
} catch (Exception var9) {
logger.error("fail to inject via method " + method.getName() + " of interface " + this.type.getName() + ": " + var9.getMessage(), var9);
}
}
}
}
} catch (Exception var10) {
logger.error(var10.getMessage(), var10);
}
return instance;
}
这里通过反射获取方法遍历找到setter方法注入依赖的对象，依赖的对象通过objectFactory获取，有两种SpiExtensionFactory和SpringExtensionFactory，就是为了获取一个对象
AOP的实现就在这一行代码：
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
这里的wapperClass实际上就是一个 拥有构造函数中参数是目标接口的 类，这里使用了装饰者设计模式，以上面的Robert接口为例，新建一个RobotCheckWapper类实现aop功能，再在机器人say helle之前检查是否携带武器，如下
package com.pigcoffe.spi;
import com.alibaba.dubbo.common.extension.Adaptive;
public class RobotCheckWapper implements Robot {
private final Robot robot;
public RobotCheckWapper(Robot robot){
this.robot = robot;
}
@Override
public void sayHello() {
System.out.println("--->say hello之前检查下是否带有武器 ---->");
robot.sayHello();
}
}
在配置文件增加一行：
optimusPrime = com.pigcoffe.spi.OptimusPrime
bumblebee = com.pigcoffe.spi.Bumblebee
bumblebeeWapper = com.pigcoffe.spi.RobotCheckWapper
运行之前的DubboSPITest测试类打印如下：
--->say hello之前检查下是否带有武器 ---->
Hello, I am Optimus Prime.
--->say hello之前检查下是否带有武器 ---->
Hello, I am Bumblebee.
是不是以及完成了AOP的功能，换成日志记录或者时间统计也就类似了。
5.总结
本文介绍了什么是SPI,什么是Dubbo SPI,以及基本使用；
对比了dubbo SPI相比jdk SPI有什么优点；
简单介绍了dubbo IOC和AOP的实现原理；
下一篇要介绍dubbo的扩展机制@Adaptie注解还有@Active注解
