JAVA，Spring，Dubbo的SPI机制讲解
1 SPI机制讲解
1.1 引言
SPI(Service Provider Interface)是JDK内置的一种服务提供发现机制，可以用来启用框架扩展和替换组件，主要用于框架中开发，例如Dubbo、Spring、Common-Logging，JDBC等采用采用SPI机制，针对同一接口采用不同的实现提供给不同的用户，从而提高了框架的扩展性。
1.2 Java SPI实现
Java内置的SPI通过java.util.ServiceLoader类解析classPath和jar包的META-INF/services/目录下的以接口全限定名命名的文件，并加载该文件中指定的接口实现类，以此完成调用。
1.2.1 示例说明
创建动态接口
public interface VedioSPI
{
void call();
}
实现类1
public class Mp3Vedio implements VedioSPI
{
@Override
public void call()
{
System.out.println("this is mp3 call");
}
}
实现类2
public class Mp4Vedio implements VedioSPI
{
@Override
public void call()
{
System.out.println("this is mp4 call");
}
}
在项目的source目录下新建META-INF/services/目录下，创建com.skywares.fw.juc.spi.VedioSPI文件。
com.skywares.fw.juc.spi.Mp4Vedio
com.skywares.fw.juc.spi.Mp3Vedio
1.2.2 相关测试
public class VedioSPITest{
public static void main(String[] args)
{
ServiceLoader<VedioSPI> serviceLoader =ServiceLoader.load(VedioSPI.class);
serviceLoader.forEach(t->{
t.call();
});
}
}
说明：Java实现spi是通过ServiceLoader来查找服务提供的工具类。
运行结果：
this is mp4 call
this is mp3 call
1.2.3 源码分析
上述只是通过简单的示例来实现下java的内置的SPI功能。其实现原理是ServiceLoader是Java内置的用于查找服务提供接口的工具类，通过调用load()方法实现对服务提供接口的查找，最后遍历来逐个访问服务提供接口的实现类。
public final class ServiceLoader<S>
implements Iterable<S>
{
//服务提供接口对应文件放置目录
private static final String PREFIX = "META-INF/services/";
// The class or interface representing the service being loaded
private final Class<S> service;
// 类加载器
private final ClassLoader loader;
// The access control context taken when the ServiceLoader is created
private final AccessControlContext acc;
// 按照初始化顺序缓存服务提供接口实例
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
// 内部类实现了iterator接口
private LazyIterator lookupIterator;
}
从源码可以发现：
ServiceLoader类本身实现了Iterable接口并实现了其中的iterator方法，iterator方法的实现中调用了LazyIterator这个内部类中的方法，迭代器创建实例。- 所有服务提供接口的对应文件都是放置在
META-INF/services/目录下，final类型决定了PREFIX目录不可变更。
虽然java提供的SPI机制的思想非常好，但是也存在相应的弊端。具体如下：
Java内置的方法方式只能通过遍历来获取- 服务提供接口必须放到
META-INF/services/目录下。
针对java的spi存在的问题，Spring的SPI机制沿用的SPI的思想，但对其进行扩展和优化
1.3 Spring SPI
Spring SPI沿用了Java SPI的设计思想，Spring采用的是spring.factories方式实现SPI机制，可以在不修改Spring源码的前提下，提供Spring框架的扩展性。
1.3.1 Spring 示例
定义接口
public interface DataBaseSPI
{
void getConnection();
}
相关实现
##DB2实现
public class DB2DataBase implements DataBaseSPI
{
@Override
public void getConnection()
{
System.out.println("this database is db2");
}
}
##Mysql实现
public class MysqlDataBase implements DataBaseSPI
{
@Override
public void getConnection()
{
System.out.println("this is mysql database");
}
}
1、在项目的META-INF目录下，新增spring.factories文件
2、填写相关的接口信息，内容如下：
com.skywares.fw.juc.springspi.DataBaseSPI = com.skywares.fw.juc.springspi.DB2DataBase, com.skywares.fw.juc.springspi.MysqlDataBase
说明多个实现采用逗号分隔
1.3.2 相关测试类
public class SpringSPITest
{
public static void main(String[] args)
{
List<DataBaseSPI> dataBaseSPIs =SpringFactoriesLoader.loadFactories(DataBaseSPI.class,
Thread.currentThread().getContextClassLoader());
for(DataBaseSPI datBaseSPI:dataBaseSPIs){
datBaseSPI.getConnection();
}
}
}
输出结果
this database is db2
this is mysql database
从示例中我们看出，Spring 采用spring.factories实现SPI与java实现SPI非常相似，但是spring的spi方式针对java的spi进行的相关优化具体内容如下：
Java SPI是一个服务提供接口对应一个配置文件，配置文件中存放当前接口的所有实现类，多个服务提供接口对应多个配置文件，所有配置都在services目录下；Spring factories SPI是一个spring.factories配置文件存放多个接口及对应的实现类，以接口全限定名作为key，实现类作为value来配置，多个实现类用逗号隔开，仅spring.factories一个配置文件。
那么spring是如何通过加载spring.factories来实现SpI的呢?我们可以通过源码来进一步分析。
1.3.3 源码分析
说明:loadFactoryNames解析spring.factories文件中指定接口的实现类的全限定名，具体实现如下：
说明：获取所有jar包中META-INF/spring.factories文件路径，以枚举值返回。遍历spring.factories文件路径，逐个加载解析，整合factoryClass类型的实现类名称，获取到实现类的全类名称后进行类的实例话操作，其相关源码如下：
说明：实例化是通过反射来实现对应的初始化。
1.3.4 与@Component相比
在 Spring Boot 中，SPI（Service Provider Interface）和 @Component 注册是两种不同的组件注册方式，它们有不同的使用场景和优先级。
SPI注册：SPI是一种 Java 标准的服务提供者注册机制，通过在META-INF/services目录下提供对应接口的实现类，实现了自动发现和加载。SPI注册通常用于定义接口，然后允许多个实现方注册，Spring Boot通过spring.factories文件实现了对 SPI 的支持。SPI注册的优先级较低，多个实现类会按照加载的先后顺序进行注册。
@Component注册：@Component注解是Spring框架提供的注解，用于将 Java 类标记为 Spring 组件（Bean）。- 通过
@ComponentScan扫描指定的包，或者使用@Component、@Service、@Repository、@Controller等注解标记类，将它们注册为Spring管理的组件。 @Component注册的优先级较高，Spring Boot 在启动时会主动扫描并注册这些组件。 而@Service、@Controller等注解本质上都是@Component的衍生注解，它们具有相同的优先级
1.4 Dubbo SPI
1.4.1 简介
Dubbo 并未使用 Java SPI，而是重新实现了一套功能更强的 SPI 机制。Dubbo SPI 的相关逻辑被封装在了 ExtensionLoader 类中，通过 ExtensionLoader，我们可以加载指定的实现类。
Dubbo的 SPI（Service Provider Interface）机制是一种服务发现和加载的机制，它允许第三方为Dubbo提供扩展实现。Dubbo SPI机制的核心思想是面向接口编程，将接口和实现分离，使得在不修改原有代码的情况下，可以灵活地扩展和替换功能。这种机制在很大程度上提高了Dubbo框架的可扩展性和灵活性。
Dubbo SPI机制的实现主要包括以下几个步骤：
定义接口：首先需要定义一个接口，这个接口将作为扩展点，供第三方实现。例如，定义一个Filter接口，用于实现不同的过滤器功能。实现接口：第三方可以根据自己的需求，实现接口中的方法。例如，实现一个AuthFilter类，用于实现权限验证功能。配置文件：在META-INF/dubbo目录下创建一个与接口同名的文件，文件内容为key值=接口实现类的全限定名。
Dubbo是通过键值对的方式进行配置，内容和property配置文件类似，也是key=value格式，我们可以直接通过Key获取我们想要加载的实体类
例如，创建一个名为com.example.Filter的文件，文件内容为auth=com.example.AuthFilter。加载扩展：Dubbo在运行时会自动加载配置文件中指定的实现类，并根据需要创建实例。用户可以通过ExtensionLoader类来获取扩展实例，例如ExtensionLoader.getExtensionLoader(Filter.class).getExtension("auth")使用扩展：在Dubbo框架中，可以通过@SPI注解来声明一个接口为扩展点，并指定默认的实现。在需要使用扩展的地方，可以通过ExtensionLoader来获取扩展实例，并调用其方法。
1.4.2 示例说明
package test.spi;
public interface Animal {
/**
* 动物叫
*/
void call();
}
然后我们分别写两个不同的实现类，实现这个接口
package test.spi.impl;
import test.spi.Animal;
public class Cat implements Animal {
@Override
public void call() {
System.out.println("猫叫：喵喵喵~");
}
}
package test.spi.impl;
import test.spi.Animal;
public class Dog implements Animal {
@Override
public void call() {
System.out.println("狗叫：汪汪汪~");
}
}
在 ./resources/META-INF/dubbo 创建配置文件 test.spi.Animal，并在文件中写入键值对和实现类全限定类名
cat=test.spi.impl.Cat
dog=test.spi.impl.Dog
public class Main {
public static void main(String[] args) {
Animal cat = ExtensionLoader.getExtensionLoader(Animal.class)
.getExtension("cat");
Animal dog = ExtensionLoader.getExtensionLoader(Animal.class)
.getExtension("dog");
cat.call();
dog.call();
}
}
