前言：在日常的代碼中彻坛，我們經(jīng)常使用簡單工廠來生成顷啼，某個接口不同實現(xiàn)的實例，但是其實還是有替代方案來完成昌屉，比如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烤咧，一個是遍歷偏陪。看下源碼煮嫌，在這兩個動作中笛谦，究竟發(fā)生了什么呢？

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);
    }

首先昌阿，這個類實現(xiàn)了Iterable饥脑，那么后續(xù)自然可以看下其遍歷相關的方法。
其次懦冰，這個類主要有五個屬性
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利用構(gòu)造函數(shù)實例化了一個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，根據(jù)全限定名加載某一個實現(xiàn)類
                    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祭犯，調(diào)用類的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實現(xiàn)。

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 问词，看結(jié)構(gòu)，一個是存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的所有核心功能逼庞，比如注冊中心，序列化瞻赶，傳輸?shù)榷贾С质褂胹pi的方式進行拓展赛糟，以負載均衡為例，dubbo內(nèi)置了四種砸逊，Random璧南，RoundRorbin，LeastActive师逸，ConsistentHash.那么在dubbo的jar包中司倚，有一個這樣的文件，META-INF/dubbo/internal/com.alibaba.dubbo.rpc.cluster.LoadBalance篓像，內(nèi)容見下

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實例盒粮。那么如果你需要實現(xiàn)自己開發(fā)的LoadBalance算法，其實只需要新增一個實現(xiàn)奠滑，然后在配置文件里面配上你自己的算法名稱丹皱，然后就可以初始化的時候使用你自己的負載算法了。

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 三者的聯(lián)系于區(qū)別是什么呢宋税？

聯(lián)系：三者都可以實現(xiàn)摊崭，根據(jù)client的不同輸入，生產(chǎn)不同的實例交給client杰赛。
區(qū)別：
1.簡單工廠需要自己實現(xiàn)工廠類呢簸，而另外兩種相當于有現(xiàn)成的工廠類
2.java spi 需要在遍歷的過程中，進行實例生成的工作。沒有辦法特定針對某一種實現(xiàn)直接生成實例根时，而dubbo spi就支持這一點瘦赫。
3.dubbo spi的功能更豐富，還支持ioc啸箫，自適應拓展等其他更為復雜的功能
可以根據(jù)業(yè)務需要進行取舍耸彪。

簡單工廠辰斋、java spi、dubbo spi

簡單工廠钉蒲、java spi、dubbo spi

1.java SPI

2.dubbo SPI

3 三者的聯(lián)系于區(qū)別是什么呢宋税？