Dubbo和JDK的SPI究竟有何区别?
Posted 肥朝
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Dubbo和JDK的SPI究竟有何区别?相关的知识,希望对你有一定的参考价值。
前言
上一篇简单的介绍了spi
的基本一些概念,但是其实Dubbo
对jdk的spi进行了一些改进,具体改进了什么,来看看文档的描述
JDK 标准的 SPI 会一次性实例化扩展点所有实现,如果有扩展实现初始化很耗时,但如果没用上也加载,会很浪费资源。
如果扩展点加载失败,连扩展点的名称都拿不到了。比如:JDK 标准的 ScriptEngine,通过 getName() 获取脚本类型的名称,但如果 RubyScriptEngine 因为所依赖的 jruby.jar 不存在,导致 RubyScriptEngine 类加载失败,这个失败原因被吃掉了,和 ruby 对应不起来,当用户执行 ruby 脚本时,会报不支持 ruby,而不是真正失败的原因。
增加了对扩展点 IoC 和 AOP 的支持,一个扩展点可以直接 setter 注入其它扩展点。
那dubbo这个改良后的spi
究竟怎么提高性能,又增加了什么功能,那就是本篇要讲的.
插播面试题
既然你对spi有一定了解,那么Dubbo的spi和jdk的spi有区别吗?有的话,究竟有什么区别?
你说你看过Dubbo源码,那你简单说下,他在设计上有哪些细节让你觉得很巧妙?(区分度高)
概念铺垫
Dubbo的拓展点机制
涉及到众多的知识点,也是Dubbo中比较难的地方,和之前的集群容错有Cluster
、Directory
、Router
、LoadBalance
关键词一样,这个拓展点机制
也有几个关键词,SPI
、Adaptive
、Activate
.这些会陆续讲解,最后总结.
直入主题
提升性能
提升性能,我们最容易想到的方式是什么?其实这个和初高中政治答题一样,有万能公式的,那就是"缓存".所以面试无论问你什么(适用于android,ios,Web前端,Java等等…),只要和提升性能有关的,往缓存方向
答肯定没错(当然按照"按点给分"的套路,往缓存方向答只是不至于让你拿0分,但是仅仅
答缓存肯定拿不到满分).所以如果与jdk的spi对比,那么可以有以下几个点
1.从"万能公式"角度分析,增加缓存
因为部分朋友反馈说喜欢贴代码的形式,所以讲解在注释中
1public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
2 if (type == null)//拓展点类型非空判断
3 throw new IllegalArgumentException("Extension type == null");
4 if(!type.isInterface()) {//拓展点类型只能是接口
5 throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
6 }
7 if(!withExtensionAnnotation(type)) {//需要添加spi注解,否则抛异常
8 throw new IllegalArgumentException("Extension type(" + type +
9 ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
10 }
11 //从缓存EXTENSION_LOADERS中获取,如果不存在则新建后加入缓存
12 //对于每一个拓展,都会有且只有一个ExtensionLoader与其对应
13 ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
14 if (loader == null) {
15 EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
16 loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
17 }
18 return loader;
19}
20
21private ExtensionLoader(Class<?> type) {
22 this.type = type;
23 //这里会存在递归调用,ExtensionFactory的objectFactory为null,其他的均为AdaptiveExtensionFactory
24 //AdaptiveExtensionFactory的factories中有SpiExtensionFactory,SpringExtensionFactory
25 //getAdaptiveExtension()这个是获取一个拓展装饰类对象.细节在下篇讲解
26 objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
27}
以下是缓存拓展点对象的
1public T getExtension(String name) {
2 if (name == null || name.length() == 0)
3 throw new IllegalArgumentException("Extension name == null");
4 if ("true".equals(name)) {
5 return getDefaultExtension();
6 }
7 Holder<Object> holder = cachedInstances.get(name);
8 if (holder == null) {
9 cachedInstances.putIfAbsent(name, new Holder<Object>());
10 holder = cachedInstances.get(name);
11 }
12 Object instance = holder.get();
13 if (instance == null) {
14 synchronized (holder) {
15 instance = holder.get();
16 if (instance == null) {
17 instance = createExtension(name);
18 holder.set(instance);
19 }
20 }
21 }
22 return (T) instance;
23}
为什么这个要单独拿出来说呢?很多朋友容易产生大意心理,以为缓存嘛,无非就是判断一下是否存在,不存在则添加.dubbo也不过如此.我不看源码也懂.但是你如果稍加注意,就会发现它在细节方面做得很好.
敲黑板划重点
在上一篇中我就强调了,无论做什么,都要形成差异性.在Java中,最容易形成差异性的知识点,就是JVM
和并发包
.既然上一篇中我们提了JVM
相关的内容(双亲委派机制),那么本篇我们就说说并发包
的相关内容.我们仔细看上面的这段double-checked locking
代码
1//double-checked locking
2Object instance = holder.get();
3if (instance == null) {
4 synchronized (holder) {
5 instance = holder.get();
6 if (instance == null) {
7 instance = createExtension(name);
8 holder.set(instance);
9 }
10 }
11}
1public class Holder<T> {
2
3 private volatile T value;
4
5 public void set(T value) {
6 this.value = value;
7 }
8
9 public T get() {
10 return value;
11 }
12
13}
这里为什么用到了volatile
关键字呢?看源码更重要的是看到这些细节,魔鬼都藏在细节当中!本来肥朝想展开讲一下这个volatile
秀一波操作的,但是无奈篇幅有限,那个我给你个关键词.doubleCheck Singleton 重排序
,你把这个关键词对着浏览器一搜.然后把搜索到的第一页结果都看完,你就知道这段代码并不是你想的只是判空加个缓存这么简单.他在并发细节上是有考虑的
2.从注解角度入手分析
既然是对比spi
区别,并且dubbo中有@spi
这个注解,那我们顺着注解看看能有什么线索.
如果在15年有用过dubbo,那么就会留意到@Extension
这个注解,但是后来因为含义广泛废弃,换成了@SPI
.
1@SPI("javassist")
2public interface Compiler {
3 //省略...
4}
1public Class<?> compile(String code, ClassLoader classLoader) {
2 Compiler compiler;
3 ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader(Compiler.class);
4 String name = DEFAULT_COMPILER; // copy reference
5 if (name != null && name.length() > 0) {
6 compiler = loader.getExtension(name);
7 } else {
8 compiler = loader.getDefaultExtension();
9 }
10 return compiler.compile(code, classLoader);
11}
1//com.alibaba.dubbo.common.compiler.Compiler 文件配置如下
2adaptive=com.alibaba.dubbo.common.compiler.support.AdaptiveCompiler
3jdk=com.alibaba.dubbo.common.compiler.support.JdkCompiler
4javassist=com.alibaba.dubbo.common.compiler.support.JavassistCompiler
我们从上面这两部分代码和配置文件就不难分析出两点(如果对spi不熟悉的请先把上一篇spi(一)看一遍,基础不牢地动山摇的情况下没法分析)
JDK的
spi
要用for循环,然后if判断才能获取到指定的spi对象,dubbo用指定的key就可以获取
1//返回指定名字的扩展
2public T getExtension(String name){}
JDK的
spi
不支持默认值,dubbo增加了默认值的设计
1//@SPI("javassist")代表默认的spi对象,比如Compiler默认使用的是javassist,可通过
2ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader(Compiler.class);
3compiler = loader.getDefaultExtension();
4//方式获取实现类,根据配置,即为
5//com.alibaba.dubbo.common.compiler.support.JavassistCompiler
增加功能
增加的功能,就如文档所说的,spi
增加了IoC
、AOP
AOP
这是个老生常谈的话题了,谈到AOP
大家最容易联想到Spring
,甚至因为AOP
常用在事务的场景,甚至就有不少人认为AOP
就是事务.所以肥朝建议初学者
学习AOP
的路线大致如下:
1// 这一步步演进的过程,才是最大的收获
2装饰者设计模式->静态代理->JDK、cglib、Javassist优缺点对比->AOP源码
写在最后
以上是关于Dubbo和JDK的SPI究竟有何区别?的主要内容,如果未能解决你的问题,请参考以下文章