7.1-dubbo源码阅读之-java spi, dubbo spi 和 Spring spi 到底有啥区别

SPI

SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。
Java SPI 实际上是“基于接口的编程+策略模式+配置文件”组合实现的动态加载机制。

Java SPI

案例

接口

public interface Hello {
    void say();
}

实现类

public class LiHello implements Hello{
    public void say() {
        System.out.println("li hello");
    }
}

public class ZhangHello implements Hello{
    public void say() {
        System.out.println("zhang hello");
    }
}

接口全限定名 作为文件名，实现类全限定名为内容

com.wfg.spi.javaspi.LiHello
com.wfg.spi.javaspi.ZhangHello

public class JavaSpi {
    public static void main(String[] args) {
        ServiceLoader<Hello> load = ServiceLoader.load(Hello.class);
        load.forEach(Hello::say);

    }
}

调用过程：
应用程序调用ServiceLoader.load方法，创建一个新的ServiceLoader，并实例化该类中的成员变量

应用程序通过迭代器接口获取对象实例，ServiceLoader先判断成员变量providers对象中(LinkedHashMap类型)是否有缓存实例对象，如果有缓存，直接返回。

如果没有缓存，执行类的装载，

优缺点

优点

使用 Java SPI 机制的优势是实现解耦，使得接口的定义与具体业务实现分离，而不是耦合在一起。应用进程可以根据实际业务情况启用或替换具体组件。

缺点

• 不能按需加载。虽然 ServiceLoader 做了延迟载入，但是基本只能通过遍历全部获取，也就是接口的实现类得全部载入并实例化一遍。如果你并不想用某些实现类，或者某些类实例化很耗时，它也被载入并实例化了，这就造成了浪费。

• 获取某个实现类的方式不够灵活，只能通过 Iterator 形式获取，不能根据某个参数来获取对应的实现类。

• 多个并发多线程使用 ServiceLoader 类的实例是不安全的。

• 加载不到实现类时抛出并不是真正原因的异常，错误很难定位。

Spring SPI

Dubbo SPI

概述

Dubbo 并未使用 Java SPI，而是重新实现了一套功能更强的 SPI 机制。Dubbo SPI 的相关逻辑被封装在了 ExtensionLoader 类中，通过 ExtensionLoader，我们可以加载指定的实现类。

简单案例

此时只写和java不同的地方
接口上添加@SPI 注解

@SPI("hello")
public interface Hello {
    void say();
}

配置内容是键值对方式，因此可以根据key获取实现类

dubbo会从四个目录读取文件META-INF/dubbo/internal/ 、META-INF/dubbo/ 、META-INF/services/、META-INF/dubbo/external/，文件名为接口的全限定名，内容为键值对，键为短名称（可以理解为spring中的对象的名称），值为实现类

h1=com.wfg.spi.dubbospi.LiHello
h2=com.wfg.spi.dubbospi.ZhangHello

public class DubboSpi {

    public static void main(String[] args) {
        ExtensionLoader<Hello> extensionLoader =
                ExtensionLoader.getExtensionLoader(Hello.class);
        Hello h1 = extensionLoader.getExtension("h1");
        h1.say();
        Hello h2 = extensionLoader.getExtension("h2");
        h2.say();
    }
}

Dubbo SPI 除了支持按需加载接口实现类，还增加了 IOC 和 AOP 等特性，这些特性将会在接下来的源码分析章节中一一进行介绍。

aop 案例

@SPI
public interface Car {

    public String getColor();
}

public class BackCar implements Car{
    @Override
    public String getColor() {
        System.out.println("黑色车");
        return "red";
    }
}

public class RedCar implements Car{
    @Override
    public String getColor() {
        System.out.println("红色车");
        return "red";
    }
}

public class CarMain {

    public static void main(String[] args) {
        ExtensionLoader<Car> extensionLoader =
                ExtensionLoader.getExtensionLoader(Car.class);
        Car red = extensionLoader.getExtension("red");
        red.getColor();

        Car back = extensionLoader.getExtension("back");
        back.getColor();

//        Car wrapper = extensionLoader.getExtension("wrapper");
//        wrapper.getColor();
    }
}

上面是最基本的用法，我们下面增加一个包装类

public class CarWrapper implements Car {

    private Car car;

    public CarWrapper(Car car) {
        this.car = car;
    }

    @Override
    public String getColor() {
        System.out.println("carWrapper before");
        String color = car.getColor();
        System.out.println("carWrapper after");
        return color;
    }
}

其实包装类和普通的实现类没有太大的区别，是通过一个构造方法注入了一个继承的接口类，
运行效果如下：

这个还是需要写的

red=com.wfg.dubbo.demo.spi.RedCar
back=com.wfg.dubbo.demo.spi.BackCar
wrapper=com.wfg.dubbo.demo.spi.CarWrapper

ioc 案例

上面我们可以看到已经实现了aop， aop是靠的构造方法实现， 接下来用的ioc是靠的set方法实现的；

主要的注解： @Adaptive

代码修改如下

@SPI
public interface Car {
    @Adaptive(value = "carType")
    public String getColor(URL url);
}
public class BackCar implements Car {
    @Override
    public String getColor(URL url) {
        System.out.println("黑色车");
        return "back";
    }
}
public class RedCar implements Car {

    @Override
    public String getColor(URL url) {
        System.out.println("红色车");
        return "red";
    }
}

修改点：1. 参数增加URL 参数， 也可以是POJO的一个属性
2. 方法上增加@Adaptive 注解

下面我们在用扩展点实现一个Driver的扩展点：

@SPI
public interface Driver {

    public void driverCar(URL url);
}
public class Trucker implements Driver {
    private Car car;
    // dubbo 的ioc 是靠set 方法注入的
    //但是这个实例又是如何选择的
    public void setCar(Car car) {
        this.car = car;
    }
    @Override
    public void driverCar(URL url) {
        System.out.println("Trucker =====");
        car.getColor(url);
    }
}

Trucker 中注入一个Car 类型的属性， car.getColor(url); car的实例是在运行的时候动态赋值的

调用代码如下：

public class DriverMain {

    public static void main(String[] args) {
        ExtensionLoader<Driver> extensionLoader =
                ExtensionLoader.getExtensionLoader(Driver.class);
        Driver trucker = extensionLoader.getExtension("trucker");
        Map<String,String> map = new HashMap<>();
        map.put("carType","red");
        URL url = new URL("","",0,map);
        trucker.driverCar(url);
    }
}

这里靠的是URL 传参，识别出用哪个car的实例

源码分析

自己实现一个SPI