前言：在日常的代码中，我们经常使用简单工厂来生成，某个接口不同实现的实例，但是其实还是有替代方案来完成，比如java SPI和dubbo SPI
1.java SPI
例子其实烂大街了，代码可参见dubbo 官方文档，拿来主义见https://github.com/somewaters/java_case
贴下关键代码，可以看到，java spi的核心类即ServiceLoader
@Test
public void testJavaSPI(){
ServiceLoader<Robot> serviceLoader = ServiceLoader.load(Robot.class);
Iterator<Robot> it = serviceLoader.iterator();
while(it.hasNext()){
Robot robot = it.next();
robot.sayHello();
}
}
大眼一看，ServiceLoader做了两个动作，一个是load，一个是遍历。看下源码，在这两个动作中，究竟发生了什么呢？
public final class ServiceLoader<S> implements Iterable<S> {
private static final String PREFIX = "META-INF/services/";
private Class<S> service;
private ClassLoader loader;
private LinkedHashMap<String, S> providers = new LinkedHashMap();
private ServiceLoader<S>.LazyIterator lookupIterator;
public static <S> ServiceLoader<S> load(Class<S> var0) {
ClassLoader var1 = Thread.currentThread().getContextClassLoader();
return load(var0, var1);
}
首先，这个类实现了Iterable，那么后续自然可以看下其遍历相关的方法。
其次，这个类主要有五个属性
1.PREFIX ，这个值眼熟吧，就是spi文件的路径（jdk 1.8类里面用到路径的时候还是写的magic String）
2.Class<S> service ，一个泛型Class属性
3.ClassLoader loader，一个类加载器
4.LinkedHashMap<String, S> providers 一个map
5.一个自定义LazyIterator
回到开头两个动作的问题，load()做了什么？load利用构造函数实例化了一个ServiceLoader对象，且初始化了上述2，3，5三个属性，关键代码见下
public void reload() {
this.providers.clear();
this.lookupIterator = new ServiceLoader.LazyIterator(this.service, this.loader);
}
private ServiceLoader(Class<S> var1, ClassLoader var2) {
this.service = (Class)Objects.requireNonNull(var1, "Service interface cannot be null");
this.loader = var2 == null ? ClassLoader.getSystemClassLoader() : var2;
this.reload();
}
那么遍历的时候做了什么呢？
主要做了三件事，1.加载类文件2.生成实例3.将实例放入providers MAP中。
public S next() {
if (!this.hasNext()) {
throw new NoSuchElementException();
} else {
String var1 = this.nextName;
this.nextName = null;
Class var2 = null;
try {//@setp1，根据全限定名加载某一个实现类
var2 = Class.forName(var1, false, this.loader);
} catch (ClassNotFoundException var5) {
ServiceLoader.fail(this.service, "Provider " + var1 + " not found");
}
if (!this.service.isAssignableFrom(var2)) {
ServiceLoader.fail(this.service, "Provider " + var1 + " not a subtype");
}
try {
//@setp2，调用类的newInstance方法生成一个实例
Object var3 = this.service.cast(var2.newInstance());
//@setp3，将生成的实例放入MAP providers 中
ServiceLoader.this.providers.put(var1, var3);
return var3;
} catch (Throwable var4) {
ServiceLoader.fail(this.service, "Provider " + var1 + " could not be instantiated: " + var4, var4);
throw new Error();
}
}
}
放入providers MAP中做什么呢？其实ServiceLoader暴露给用户的接口，主要就在操作这个MAP来获取相应的service实现。
2.dubbo SPI
同样贴下关键代码，可以看到关键类为ExtensionLoader，核心操作也有两个
1.getExtensionLoader
2.getExtension
@Test
public void testDubboSPI(){
ExtensionLoader<Robot> extensionLoader = ExtensionLoader.getExtensionLoader(Robot.class);
Robot robot = extensionLoader.getExtension("bumblebee");
robot.sayHello();
}
ExtensionLoader的属性是相对比较多的，我只贴一下关键的几个，前面几个路径，可以对比java spi的相关路径，就知道是做什么用的了。主要关注一下两个ConcurrentMap EXTENSION_LOADERS和EXTENSION_INSTANCES ，看结构，一个是存ExtensionLoader本身，一个是用来存实例。
private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class);
private static final String SERVICES_DIRECTORY = "META-INF/services/";
private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
private static final String DUBBO_INTERNAL_DIRECTORY = "META-INF/dubbo/internal/";
private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap();
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap();
那么两个核心操作，getExtensionLoader和getExtension都做了什么呢？只需要看最后一个else分支
就是去EXTENSION_LOADERS这个ConcurrentMap里面去取，取不到new 一个放进去再取，比较简单就不分析了
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
if (type == null) {
throw new IllegalArgumentException("Extension type == null");
} else if (!type.isInterface()) {
throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
} else if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type(" + type + ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
} else {
ExtensionLoader<T> loader = (ExtensionLoader)EXTENSION_LOADERS.get(type);
if (loader == null) {
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
loader = (ExtensionLoader)EXTENSION_LOADERS.get(type);
}
return loader;
}
}
第二个核心操作，getExtension做了什么呢？看下核心代码。是同样的操作，去map取实例，没有的话，实例化之后放进去，然后再取。
T instance = EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
instance = EXTENSION_INSTANCES.get(clazz);
}
dubbo的所有核心功能，比如注册中心，序列化，传输等都支持使用spi的方式进行拓展，以负载均衡为例，dubbo内置了四种，Random，RoundRorbin，LeastActive，ConsistentHash.那么在dubbo的jar包中，有一个这样的文件，META-INF/dubbo/internal/com.alibaba.dubbo.rpc.cluster.LoadBalance，内容见下
random=com.alibaba.dubbo.rpc.cluster.loadbalance.RandomLoadBalance
roundrobin=com.alibaba.dubbo.rpc.cluster.loadbalance.RoundRobinLoadBalance
leastactive=com.alibaba.dubbo.rpc.cluster.loadbalance.LeastActiveLoadBalance
consistenthash=com.alibaba.dubbo.rpc.cluster.loadbalance.ConsistentHashLoadBalance
在初始化的时候，可以看到，确实是通过dubbo spi，以getExtension的方式来获取的LoadBalance实例。那么如果你需要实现自己开发的LoadBalance算法，其实只需要新增一个实现，然后在配置文件里面配上你自己的算法名称，然后就可以初始化的时候使用你自己的负载算法了。
protected LoadBalance initLoadBalance(List<Invoker<T>> invokers, Invocation invocation) {
if (CollectionUtils.isNotEmpty(invokers)) {
return ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(invokers.get(0).getUrl()
.getMethodParameter(RpcUtils.getMethodName(invocation), LOADBALANCE_KEY, DEFAULT_LOADBALANCE));
} else {
return ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(DEFAULT_LOADBALANCE);
}
}
3 三者的联系于区别是什么呢？
联系：三者都可以实现，根据client的不同输入，生产不同的实例交给client。
区别：
1.简单工厂需要自己实现工厂类，而另外两种相当于有现成的工厂类
2.java spi 需要在遍历的过程中，进行实例生成的工作。没有办法特定针对某一种实现直接生成实例，而dubbo spi就支持这一点。
3.dubbo spi的功能更丰富，还支持ioc，自适应拓展等其他更为复杂的功能
可以根据业务需要进行取舍。
