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 , 他的文字表述确实很好, 省去了我打字的时间,哈哈哈
