Java Spi以及Dubbo Spi

飞翔的汤姆猫

已于 2023-07-04 17:58:09 修改

阅读量659

点赞数

分类专栏：微服务文章标签： java jar 开发语言

于 2022-10-10 17:43:09 首次发布

本文链接：https://blog.csdn.net/weixin_44716359/article/details/127240390

版权

微服务专栏收录该内容

11 篇文章 0 订阅

订阅专栏

api跟spi

API：大多数情况下，都是实现方来制定接口并完成对接口的不同实现，即服务方暴露自己的服务供客户调用，调用方仅仅依赖且无权选择不同实现

SPI：如果是调用方来制定接口，实现方来针对接口来实现不同的实现。调用方来选择自己需要的实现方，再来实现某种功能，例子：JDBC连接数据库在这里插入图片描述

SPI的应用示例

当服务的提供者提供了一种借口的实现后，需要在 classpath 下的 META-INF/services 目录里创建一个以服务接口命名的文件，这个文件内容就是接口的具体实现类，这个实现类就是调用后具体的对应功能服务

JDBC的实现就是SPI，若程序需要连接数据库，则必须通过JDBC，不同的数据库需要用不同的驱动，实现该过程就是SPI

Java的SPI

约定在 Classpath 下的 META-INF/services/ 目录里创建一个以服务接口命名的文件，然后文件里面记录的是此 jar 包提供的具体实现类的全限定名

示例

public interface Person {
    void say();

}

public class XiaoHong implements Person {

    @Override
    public void say() {
        System.out.println("XiaoHong says something");
    }
}

public class XiaoMing implements Person {
    @Override
    public void say() {
        System.out.println("XiaoMing says something");
    }
}

// META-INF/services/下一个叫做spi.Person的文件
spi.XiaoMing
spi.XiaoHong

// 启动类
public static void main(String[] args) {
        // 第一步
        ServiceLoader<Person> serviceLoader = ServiceLoader.load(Person.class);
        // 第二步
        Iterator<Person> iterator = serviceLoader.iterator();
        // 第三步
        while (iterator.hasNext()) {
            // 第四步
            Person person = iterator.next();
            person.say();
        }
}

源码分析

第一步：先通过对应的接口生成相应的ServiceLoader，先找当前线程绑定的 ClassLoader，如果没有就用 SystemClassLoader，然后清除一下缓存，再创建一个 LazyIterator

第二步：拿到Iterator之后即要进行遍历

第三步：在约定好的地方找到接口对应的文件，然后加载文件并且解析文件里面的内容

第四步：循环加载实现类和创建其实例

总结：Java Spi就是约定一个目录，根据接口名去那个目录找到文件，文件解析得到实现类的全限定名，然后循环加载实现类和创建其实例

Java Spi的缺点

Java SPI 在查找扩展实现类的时候遍历 SPI 的配置文件并且将实现类全部实例化，假设一个实现类初始化过程比较消耗资源且耗时，但是你的代码里面又用不上它，这就产生了资源的浪费。所以说 Java SPI 无法按需加载实现类

Dubbo Spi

Dubbo Spi按需加载，首先你得给个名字，通过名字去文件里面找到对应的实现类全限定名然后加载实例化即可

并且 Dubbo SPI 除了可以按需加载实现类之外，增加了 IOC 和 AOP 的特性，还有个自适应扩展机制

配置文件里面存放的是键值对

Dubbo 对配置文件目录

不同于 Java SPI ，Dubbo 分为了三类目录

-META-INF/services/ 目录：该目录下的 SPI 配置文件是为了用来兼容 Java SPI

-META-INF/dubbo/ 目录：该目录存放用户自定义的 SPI 配置文件

-META-INF/dubbo/internal/ 目录：该目录存放 Dubbo 内部使用的 SPI 配置文件

示例

// 该注解表明要用SPI计值
@SPI(FailoverCluster.NAME)
public interface Robot {

    void action();

}

public class RobotXiaoMing implements Robot{
    @Override
    public void action() {
        System.out.println("RobotXiaoMing does something");
    }
}

public class RobotXiaoHong implements Robot{
    @Override
    public void action() {
        System.out.println("RobotXiaoHong does something");
    }
}

// 在META-INF.dubbo文件里创建一个接口全限定名文件
xiaoMing = dubbo.spi.RobotXiaoMing
xiaoHong = dubbo.spi.RobotXiaoHong

public static void main(String[] args) {
        ExtensionLoader<Robot> extensionLoader = ExtensionLoader.getExtensionLoader(Robot.class);
        Robot xiaoMing = extensionLoader.getExtension("xiaoMing");
        xiaoMing.action();
        Robot xiaoHong = extensionLoader.getExtension("xiaoHong");
        xiaoHong.action();
}

ExtensionLoader是类似ServiceLoader的存在

大致流程就是先通过接口类找到一个 ExtensionLoader ，然后再通过ExtensionLoader.getExtension(name) 得到指定名字的实现类实例

getExtensionLoader()：获取ExtensionLoader

做了一些判断然后从缓存里面找是否已经存在这个类型的 ExtensionLoader ，如果没有就新建一个塞入缓存。最后返回接口类对应的 ExtensionLoader

getExtension()：通过名字从类对应的 ExtensionLoader 中到实例化完的实现类

重点就是 createExtension()

先找实现类，判断缓存是否有实例，没有就反射建个实例，然后执行 set 方法依赖注入。如果有找到包装类的话，再包一层

那么问题来了 getExtensionClasses() 是怎么找的呢？injectExtension() 如何注入的呢（其实我已经说了set方法注入）？为什么需要包装类呢？

getExtensionClasses

而 loadDirectory里面就是根据类名和指定的目录，找到文件先获取所有的资源，然后一个一个去加载类，然后再通过loadResource里的loadClass去做一下缓存操作

可以看到，loadClass 之前已经加载了类，loadClass 只是根据类上面的情况做不同的缓存。分别有 Adaptive 、WrapperClass 和普通类这三种，普通类又将Activate记录了一下。至此对于普通的类来说整个 SPI 过程完结了

Adaptive 注解 - 自适应扩展

首先我们根据配置来进行 SPI 扩展的加载，但是我不想在启动的时候让扩展被加载，我想根据请求时候的参数来动态选择对应的扩展

Dubbo 通过一个代理机制实现了自适应扩展，简单的说就是为你想扩展的接口生成一个代理类，可以通过JDK 或者 javassist 编译你生成的代理类代码，然后通过反射创建实例

@SPI(value = "spi")
public interface SpiTest {

    String getName();

    @Adaptive
    int getAge(URL url);

    @Adaptive(value = "country")
    String getCountry(URL url);

    @Adaptive({"province", "city"})
    String getAddress(URL url);
}

@Test
public void adaptiveTest() {
    SpiTest spiTest = ExtensionLoader.getExtensionLoader(SpiTest.class).getAdaptiveExtension();
    System.out.println(spiTest);
}

原理

首先根据接口获取 ExtensionLoader 对象，Dubbo 会缓存 ExtensionLoader 和接口的 Class 对象的映射关系

接着调用 getAdaptiveExtension() 获取自适应扩展。同样，Dubbo 会缓存自适应扩展对象，但第一次会调用 createAdaptiveExtension() 创建自适应扩展对象。主要逻辑如下：

创建自适应扩展的步骤分为三步：
1.调用 getAdaptiveExtensionClass() 获取自适应扩展类的 Class 对象；
2.调用 Class.newInstance() 反射创建对象；
3.调用 injectExtension 为扩展对象注入依赖这是 Dubbo 实现的 IOC 机制，会为对象自动注入依赖