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();
}
}