【转】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.从"万能公式"角度分析,增长缓存

由于部分朋友反馈说喜欢贴代码的形式,因此讲解在注释中

1  public 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
21  private 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}

　　

如下是缓存拓展点对象的

 1  public 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也不过如此.我不看源码也懂.可是你若是稍加注意,就会发现它在细节方面作得很好.

敲黑板划重点

在上一篇从Dubbo内核聊聊双亲委派机制中我就强调了,不管作什么,都要造成差别性.在Java中,最容易造成差别性的知识点,就是JVM和并发包.既然上一篇中咱们提了JVM相关的内容(双亲委派机制),那么本篇咱们就说说并发包的相关内容.咱们仔细看上面的这段double-checked locking代码

 1  //double-checked locking
 2  Object instance = holder.get();
 3  if (instance == null) {
 4    synchronized (holder) {
 5        instance = holder.get();
 6        if (instance == null) {
 7            instance = createExtension(name);
 8            holder.set(instance);
 9        }
10    }
11  }
 1  public 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")
2  public interface Compiler {
3    //省略...
4 }
 1  public 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 文件配置以下
2 adaptive=com.alibaba.dubbo.common.compiler.support.AdaptiveCompiler
3 jdk=com.alibaba.dubbo.common.compiler.support.JdkCompiler
4 javassist=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,可经过
2 ExtensionLoader<Compiler> loader = 
 ExtensionLoader.getExtensionLoader(Compiler.class);
3 compiler = loader.getDefaultExtension();
4 //方式获取实现类,根据配置,即为
5 //com.alibaba.dubbo.common.compiler.support.JavassistCompiler

　　

增长功能

增长的功能,就如文档所说的,spi增长了IoC、AOP

AOP这是个老生常谈的话题了,谈到AOP你们最容易联想到Spring,甚至由于AOP经常使用在事务的场景,甚至就有很多人认为AOP就是事务.因此肥朝建议初学者学习AOP的路线大体以下:

原文：https://mp.weixin.qq.com/s/HQb4MpiqJBrqi2u7Zscnrw