Java的SPI机制及其原理

刺骨的言语ヽ痛彻心扉 2022-01-28 07:11 221阅读 0赞

Apache 已经宣布Dubbo成为顶级的项目了,今天在看dubbo的源码导读.看到有个SPI,就了解一下了.

发现是一种接口和实现分开的解耦方式,挺有意思的.

**这篇文章的总结就是:**

**把接口的具体实现类的全名写成配置文件,然后进行读取,生成具体的实现类对象,进行方法的调用,从而实现解耦合.**

就这么简单.不想看全文的可以撤了,哈哈哈

**1 SPI****是什么**

SPI全称Service Provider Interface，是Java提供的一套用来被第三方实现或者扩展的API，它可以用来启用框架扩展和替换组件。

整体机制图如下：

![20190523154148809.png][]

Java SPI 实际上是“**基于接口的编程＋策略模式＋配置文件**”组合实现的动态加载机制。

系统设计的各个抽象，往往有很多不同的实现方案，在面向的对象的设计里，一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类，就违反了可拔插的原则，如果需要替换一种实现，就需要修改代码。为了实现在模块装配的时候能不在程序里动态指明，这就需要一种服务发现机制。  
Java SPI就是提供这样的一个机制：为某个接口寻找服务实现的机制。有点类似IOC的思想，就是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要。所以SPI的核心思想就是**解耦**。

**2** **使用场景**

概括地说，适用于：**调用者根据实际使用需要，启用、扩展、或者替换框架的实现策略**

比较常见的例子：

*  数据库驱动加载接口实现类的加载  
    JDBC加载不同类型数据库的驱动
 *  日志门面接口实现类加载  
    SLF4J加载不同提供商的日志实现类
 *  Spring  
    Spring中大量使用了SPI,比如：对servlet3.0规范对ServletContainerInitializer的实现、自动类型转换Type Conversion SPI(Converter SPI、Formatter SPI)等
 *  Dubbo  
    Dubbo中也大量使用SPI的方式实现框架的扩展, 不过它对Java提供的原生SPI做了封装，允许用户扩展实现Filter接口

**3** **使用介绍**

要使用Java SPI，需要遵循如下约定：

*  1、当服务提供者提供了接口的一种具体实现后，在jar包的META-INF/services目录下创建一个以“接口全限定名”为命名的文件，内容为实现类的全限定名；
 *  2、接口实现类所在的jar包放在主程序的classpath中；
 *  3、主程序通过java.util.ServiceLoder动态装载实现模块，它通过扫描META-INF/services目录下的配置文件找到实现类的全限定名，把类加载到JVM；
 *  4、**SPI的实现类必须携带一个不带参数的构造方法；**

jdk提供服务实现查找的一个工具类：java.util.ServiceLoader

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzOTg3NzE_size_16_color_FFFFFF_t_70][]

我们在开发中都有用到SPI机制，但是我们没有意识到比如：

**1.common-logging**

apache最早提供的日志的门面接口。只有接口，没有实现。具体方案由各提供商实现，发现日志提供商是通过扫描  META-INF/services/org.apache.commons.logging.LogFactory 配置文件，通过读取该文件的内容找到日志提工商实现类。只要我们的日志实现里包含了这个文件，并在文件里制定   LogFactory工厂接口的实现类即可。

**2.jdbc**

jdbc4.0以前，开发人员还需要基于Class.forName("xxx")的方式来装载驱动，jdbc4也基于spi的机制来发现驱动提供商了，可以通过META-INF/services/java.sql.Driver文件里指定实现类的方式来暴露驱动提供者。

学习到的知识：面向接口编程可以实现接口和实现的分离，这样做的最大好处就是能够在客户端未知的情况下修改实现代码。那么什么时候应该抽象出Java接口呢？一种是用在层和层之问的调用。层和层之间是最忌讳耦合度过高或是改变过于频繁。设计优秀的接口能够解决这个问题。另一种是用在那些不稳定的部分上。如果某些需求的变化性很大，那么定义接口也是一种解决之道。设计良好的接口就像是我们日常使用的万用插座一样，不论插头如何变化，都可以使用。

使用案例:

项目结构:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzOTg3NzE_size_16_color_FFFFFF_t_70 1][]

1.  定义接口

package com.onyx.api;
    
    /**
     * @author zk
     * @Description: 数字计算
     * @date 2019-05-23 14:54
     */
    public interface CalculateService {
    
        /**
         * 操作数字计算的抽象方法
         * @param a
         * @param b
         * @return
         */
        int operate(int a,int b);
    
    }

2.定义普通的实现类

package com.onyx.impl;
    
    import com.onyx.api.CalculateService;
    
    /**
     * @author zk
     * @Description: 加法
     * @date 2019-05-23 14:54
     */
    
    public class AddServiceImpl implements CalculateService {
    
        @Override
        public int operate(int a, int b) {
            return a+b;
        }
    }

3.定义SPI的实现类

package com.onyx.spi;
    import com.onyx.api.CalculateService;
    
    /**
     * @author zk
     * @Description: 除法
     * @date 2019-05-23 15:03
     */
    
    public class DivisionServiceImpl implements CalculateService{
    
        @Override
        public int operate(int a, int b) {
            return a/b;
        }
    }

package com.onyx.spi;
    
    import com.onyx.api.CalculateService;
    
    
    /**
     * @author zk
     * @Description: 减法
     * @date 2019-05-23 14:57
     */
    
    public class MinusServiceImpl implements CalculateService {
    
        @Override
        public int operate(int a, int b) {
            return a-b;
        }
    }

4.新建配置文件

在resources文件夹下创建META-INF 文件夹 ,在创建services文件夹,

创建一个叫com.onyx.api.CalculateService的文件,放入两个SPI实现类的全名

com.onyx.spi.MinusServiceImpl
    
    com.onyx.spi.DivisionServiceImpl

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzOTg3NzE_size_16_color_FFFFFF_t_70 2][]

5.测试

package com.onyx;
    import com.onyx.api.CalculateService;
    import com.onyx.impl.AddServiceImpl;
    import com.onyx.spi.DivisionServiceImpl;
    import com.onyx.spi.MinusServiceImpl;
    import java.util.Iterator;
    import java.util.ServiceLoader;
    
    /**
     * @author zk
     * @Description:
     * @date 2019-05-23 14:58
     */
    
    public class Test {
    
    
        public static void main(String[] args) {
            System.out.println(new AddServiceImpl().operate(1,4));
            System.out.println(new MinusServiceImpl().operate(3,5));
            System.out.println(new DivisionServiceImpl().operate(6,1));
    
            ServiceLoader<CalculateService> operations  = ServiceLoader.load(CalculateService.class);
            Iterator<CalculateService> operationIterator  = operations.iterator();
            System.out.println("classPath:"+System.getProperty("java.class.path"));
            //获取多个实现,并且调用起具体实现的方法
            while (operationIterator.hasNext()) {
                CalculateService operation = operationIterator.next();
                System.out.println(operation.operate(6, 3));
            }
        }
    }

运行测试,得到结果.

下面jdk的工具原理进行探究:

首先看ServiceLoader类的签名类的成员变量：

public final class ServiceLoader<S>
        implements Iterable<S>
    {
    
    
        private static final String PREFIX = "META-INF/services/";
    
        // SPI的接口
        private final Class<S> service;
    
        // 类加载器,使用的是当前线程的类加载器(Thread.currentThread().getContextClassLoader())
        private final ClassLoader loader;
    
        // 默认是null, 创建ServiceLoader时采用的访问控制上下文
        private final AccessControlContext acc;
    
        // Cached providers, in instantiation order
        private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
    
        // 当前的迭代器,默认初始化为: new LazyIterator(service, loader); 注意这里是懒加载的,只有使用的时候才去迭代,加载…
        private LazyIterator lookupIterator;

参考具体ServiceLoader具体源码，代码量不多，加上注释一共587行，梳理了一下，实现的流程如下：

*  1 应用程序调用ServiceLoader.load方法  
    ServiceLoader.load方法内先创建一个新的ServiceLoader，并实例化该类中的成员变量，包括：
    
     *  loader(ClassLoader类型，类加载器)
     *  acc(AccessControlContext类型，访问控制器)
     *  providers(LinkedHashMap<String,S>类型，用于缓存加载成功的类)
     *  lookupIterator(实现迭代器功能)
 *  2 应用程序通过迭代器接口获取对象实例  
    ServiceLoader先判断成员变量providers对象中(LinkedHashMap<String,S>类型)是否有缓存实例对象，如果有缓存，直接返回。  
    如果没有缓存，执行类的装载，实现如下：
 *  (1) 读取META-INF/services/下的配置文件，获得所有能被实例化的类的名称，值得注意的是，ServiceLoader**可以跨越jar包获取META-INF下的配置文件**，具体加载配置的实现代码如下：

只有在调用operationIterator.hasNext()  的时候才回去根据全名查找类的, 可以得到全名,

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzOTg3NzE_size_16_color_FFFFFF_t_70 3][]

得到两个具体的实现类的全名.标明有下一个

在调用operationIterator.next();

的时候,进行具体的类的实例化,进行返回,同时进行缓存已经实例化的对象.然后返回具体的实现对象

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzOTg3NzE_size_16_color_FFFFFF_t_70 4][]

*   (2) 通过反射方法Class.forName()加载类对象，并用instance()方法将类实例化。
 *  (3) 把实例化后的类缓存到providers对象中，(LinkedHashMap<String,S>类型）  
    然后返回实例对象。

**4****总结**

**优点**：  
使用Java SPI机制的优势是实现解耦，使得第三方服务模块的装配控制的逻辑与调用者的业务代码分离，而不是耦合在一起。应用程序可以根据实际业务情况启用框架扩展或替换框架组件。

**缺点**：

*  虽然ServiceLoader也算是使用的延迟加载，但是基本只能通过遍历全部获取，也就是接口的实现类全部加载并实例化一遍。如果你并不想用某些实现类，它也被加载并实例化了，这就造成了浪费。获取某个实现类的方式不够灵活，只能通过Iterator形式获取，不能根据某个参数来获取对应的实现类。
 *  多个并发多线程使用ServiceLoader类的实例是不安全的。

此博客一些内容摘自: [https://www.jianshu.com/p/46b42f7f593c][https_www.jianshu.com_p_46b42f7f593c] , 他的文字表述确实很好, 省去了我打字的时间,哈哈哈

[20190523154148809.png]: /images/20220128/44669d59f18b47318d6a016723638440.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzOTg3NzE_size_16_color_FFFFFF_t_70]: /images/20220128/e198fcdbf8a3495098f4f13036bb3639.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzOTg3NzE_size_16_color_FFFFFF_t_70 1]: /images/20220128/59b200b760724c1e99d9678714d7eb7f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzOTg3NzE_size_16_color_FFFFFF_t_70 2]: /images/20220128/2233ec00b4db44749ff9e2be5f2573bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzOTg3NzE_size_16_color_FFFFFF_t_70 3]: /images/20220128/2c48de0e7bd745e887761ad7a6583c08.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzOTg3NzE_size_16_color_FFFFFF_t_70 4]: /images/20220128/f8d8a5cd77924edd880ad091226fff56.png
[https_www.jianshu.com_p_46b42f7f593c]: https://www.jianshu.com/p/46b42f7f593c