Java的SPI机制及其原理

65 阅读 0 评论 43 点赞

我是靠谱客的博主美丽唇彩，最近开发中收集的这篇文章主要介绍Java的SPI机制及其原理，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

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

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

这篇文章的总结就是:

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

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

1 SPI是什么

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

整体机制图如下：

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

我们在开发中都有用到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接口呢？一种是用在层和层之问的调用。层和层之间是最忌讳耦合度过高或是改变过于频繁。设计优秀的接口能够解决这个问题。另一种是用在那些不稳定的部分上。如果某些需求的变化性很大，那么定义接口也是一种解决之道。设计良好的接口就像是我们日常使用的万用插座一样，不论插头如何变化，都可以使用。

使用案例:

项目结构:

定义接口

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

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()  的时候才回去根据全名查找类的, 可以得到全名,

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

在调用operationIterator.next();

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

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

4总结

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

缺点：

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

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