简单工厂、java spi、dubbo spi

前言：在日常的代码中，我们经常使用简单工厂来生成，某个接口不同实现的实例，但是其实还是有替代方案来完成，比如java SPI和dubbo SPI

1.java SPI

例子其实烂大街了，代码可参见dubbo 官方文档，拿来主义见https://github.com/somewaters/java_case
贴下关键代码，可以看到，java spi的核心类即ServiceLoader

@Test
    public void testJavaSPI(){
        ServiceLoader serviceLoader = ServiceLoader.load(Robot.class);
        Iterator it =  serviceLoader.iterator();
        while(it.hasNext()){
            Robot robot = it.next();
            robot.sayHello();
        }
    }

大眼一看，ServiceLoader做了两个动作，一个是load，一个是遍历。看下源码，在这两个动作中，究竟发生了什么呢？

public final class ServiceLoader implements Iterable {
    private static final String PREFIX = "META-INF/services/";
    private Class service;
    private ClassLoader loader;
    private LinkedHashMap providers = new LinkedHashMap();
    private ServiceLoader.LazyIterator lookupIterator;

    public static  ServiceLoader load(Class var0) {
        ClassLoader var1 = Thread.currentThread().getContextClassLoader();
        return load(var0, var1);
    }

首先，这个类实现了Iterable，那么后续自然可以看下其遍历相关的方法。
其次，这个类主要有五个属性
1.PREFIX ，这个值眼熟吧，就是spi文件的路径（jdk 1.8类里面用到路径的时候还是写的magic String）
2.Class service ，一个泛型Class属性
3.ClassLoader loader，一个类加载器
4.LinkedHashMap 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 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 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, ExtensionLoader> EXTENSION_LOADERS = new ConcurrentHashMap();
    private static final ConcurrentMap, Object> EXTENSION_INSTANCES = new ConcurrentHashMap();

那么两个核心操作，getExtensionLoader和getExtension都做了什么呢？只需要看最后一个else分支
就是去EXTENSION_LOADERS这个ConcurrentMap里面去取，取不到new 一个放进去再取，比较简单就不分析了

public static  ExtensionLoader getExtensionLoader(Class 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 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> 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，自适应拓展等其他更为复杂的功能
可以根据业务需要进行取舍。