各種SPI實現均通過ClassLoader加載, 如何獲取ClassLoader, 可以參考各框架源碼, 或參考鏈接:
http://www.lxweimin.com/p/8c0adcdbafa5

1.SPI概述

SPI 全稱為 Service Provider Interface，是一種服務發現機制.

比如你有個接口，該接口有3個實現類，那么在系統運行時,這個接口到底選擇哪個實現類呢？
這就需要SPI了，需要根據指定的配置或者是默認的配置，找到對應的實現類加載進來，然后使用該實現類的實例.
#如:
接口A => 實現A1，實現A2，實現A3
配置一下，接口A = 實現A2
在系統實際運行的時候，會加載你的配置，用實現A2實例化一個對象來提供服務

比如說你要通過jar包的方式給某個接口提供實現，
然后你就在自己jar包的META-INF/services/目錄下放一個接口同名文件，
指定接口的實現是自己這個jar包里的某個類.

ok了，別人用了一個接口，然后用了你的jar包，就會在運行的時候通過你的jar包的那個文件找到這個接口該用哪個實現類.
這是JDK提供的一個功能.

比如你有個工程A，有個接口A，接口A在工程A是沒有實現類的,那么問題來了,系統運行時,怎么給接口A選擇一個實現類呢?
你可以自己搞一個jar包，META-INF/services/,放上一個文件,文件名即接口名，接口A，接口A的實現類=com.javaedge.service.實現類A2
讓工程A來依賴你的jar包,然后在系統運行時,工程A跑起來,對于接口A,
就會掃描依賴的jar包,看看有沒有META-INF/services文件夾,
如果有,看再看有沒有名為接口A的文件,如果有,
在里面找一下指定的接口A的實現是你的jar包里的哪個類!


經典的思想體現，其實大家平時都在用，比如說JDBC
Java定義了一套JDBC的接口，但是并沒有提供其實現類
但實際上項目運行時,要使用JDBC接口的哪些實現類呢?
一般來說，我們要根據自己使用的數據庫，比如
MySQL,你就將mysql-jdbc-connector.jar
oracle，你就將oracle-jdbc-connector.jar引入
系統運行時,碰到你使用JDBC的接口,就會在底層使用你引入的那個jar中提供的實現類

2.jdk中的SPI機制(jdk1.6開始)

2.1基本要求

0.定義一個接口, 以及接口對應的實現類
1.配置文件要求
1.1必須在classpath下, 即resources目錄下建立META-INF/services/目錄
1.2以接口全限定名為文件名, 實現類全限定名寫在對應接口文件中, 多個實現類時, 換行展示

2.ServiceLoader<S>類實現了Iterable<S>接口, 以便于遍歷某接口下的所有實現類

3.ServiceLoader<S>類通過ClassLoader來讀取classpath下META-INF/services/目錄的文件:
默認使用"Thread.currentThread().getContextClassLoader()"來加載, 也可指定其他類加載器

4.ServiceLoader<S>類的私有內部類LazyIterator實現了Iterable<S>接口,功能 & 要求如下:
4.1支持懶加載機制(可通過某實現類中添加'靜態代碼塊', 該實現類不配置到META-INF/services文件中來驗證)
4.2由于在其遍歷時,通過反射new了實現類, 因此接口實現類必須要有空參構造器, 否則加載失敗

5.Java SPI 實際上是“基于接口的編程＋策略模式＋配置文件”組合實現的動態加載機制。

JAVA-SPI機制.png

ServiceLoader--部分源碼.png

JDK-SPI示例結構.png

jdk-SPI.png

package com.zy.netty.spi;

/**
 * jdk的spi機制
 */
public interface SpiService {
    void sayHello(String name);
}

package com.zy.netty.spi;

public class SpiChineseServiceImpl implements SpiService {
    @Override
    public void sayHello(String name) {
        System.out.println(name + ", 你好啊!");
    }
}

package com.zy.netty.spi;

public class SpiEnglishServiceImpl implements SpiService {
    @Override
    public void sayHello(String name) {
        System.out.println(name + ", hello!");
    }
}

在src/main/resources 下創建META-INF/services/目錄,然后新建文件:
文件名為接口的全限定名,接口中的內容按行分開,每一行是實現類的全限定名

SPI-META-INF配置.png

@Test
public void fn03() {
   ServiceLoader<SpiService> loader = ServiceLoader.load(SpiService.class);
     Iterator<SpiService> it = loader.iterator();
     while (it.hasNext()) {
         it.next().sayHello("tom");
   }
}

3.dubbo中的SPI機制

http://dubbo.apache.org/zh-cn/docs/source_code_guide/dubbo-spi.html
http://dubbo.apache.org/zh-cn/docs/dev/SPI.html
http://www.lxweimin.com/p/764cec6ebb3d (Dubbo SPI重點參考)

3.1基本要求

1.定義一個接口, 接口必須加 '@SPI'注解, 否則報錯
1.1由于通過反射new了實現類, 因此接口實現類必須要有空參構造器, 否則加載失敗

2.配置文件要求
2.1必須在classpath下, 即resources目錄下建立目錄, 目錄名分三類
2.2以接口全限定名為文件名, 實現類全限定名寫在對應接口文件中(k-v結構), 多個實現類時, 換行展示

3.ExtensionLoader通過ClassLoader加載目錄

Dubbo-SPI部分源碼.png

ExtensionLoader加載目錄.png

ExtensionLoader通過ClassLoader加載目錄.png

使用示例

dubbo提供了多種通信協議類型, 如dubbo類型, http類型, hessian類型等
若想在項目中使用其中一種類型, 可行的配置如下圖所示

Dubbo-Protocol.png

項目中配置Dubbo-Protocol的類型.png

3.2 Dubbo SPI 擴展實現

http://dubbo.apache.org/zh-cn/docs/dev/impls/filter.html

Dubbo SPI 擴展實現.png

引入下述依賴后, 即可看到相關擴展實現類

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo</artifactId>
    <version>2.7.3</version>
</dependency>

原生SPI擴展實現類.png

3.3 @Activate

3.3.1 @Activate 源碼示例 org.apache.dubbo.rpc.Filter

http://www.lxweimin.com/p/f390bb88574d

關于激活的過濾器：
都需要在擴展類的配置文件中標識 過濾器名=xxx.xxx.xxx.xxxFilter
1.默認過濾器
>> 需要被@Activate標識
>> 如果需要在服務暴露時裝載，那么group="provider"
>> 如果需要在服務引用的時候裝載，那么group="consumer"
>> 如果想被暴露和引用時同時被裝載，那么group={"consumer", "provider"}
>> 如果需要url中有某個特定的值才被加載，那么value={"token", "bb"}
那么就需要配置一個token, value數組與URL中的某一個屬性相同就行了
2.普通自定義過濾器
>> 需要配置在url上 比如
過濾器擴展類上可以有@Activate也可以沒有（自定義的就不要加了）
3.去掉某個過濾器
在filter屬性上使用-號標識需要去掉的過濾器 比如:
registry://192.168.1.7:9090/org.apache.dubbo.service1?server.filter=-defalut,value1 去掉默認的，添加value1
registry://192.168.1.7:9090/org.apache.dubbo.service1?server.filter=value1,-value2 去掉value2，添加value1

dubbo filter官網
http://dubbo.apache.org/zh-cn/docs/dev/impls/filter.html

將dubbo中filter聚合的wrapper

org.apache.dubbo.rpc.protocol.ProtocolFilterWrapper
該類實現了程序啟動時, 將所有filter搞成一個鏈表, 然后調用時候, 依次調用.

Dubbo 自定義一個 Filter

Dubbo 自定義一個 Filter.png

3.3.2 @Activate 源碼分析

3.3.3 @Activate小demo

demo結構及接口層實現.png

IActivate接口實現類.png

test

package com.zy.activate;

import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.extension.ExtensionLoader;
import org.junit.Test;
import java.util.List;

/**
 * 參考鏈接
 * http://www.lxweimin.com/p/bc523348f519
 *
 * @Activate 適用場景
 *  主要用在filter上，有的 filter 需要在 provider 邊需要加的，有的需要在 consumer 邊需要加的，
 *  根據URL中的參數指定，當前的環境是 provider 還是 consumer，運行時決定哪些 filter 需要被引入執行。
 *
 */
public class ActivateTest {

    /**
     * @Activate 注解中聲明一個 group
     */
    @Test
    public void fn01() {
        ExtensionLoader<IActivate> loader = ExtensionLoader.getExtensionLoader(IActivate.class);
        URL url = URL.valueOf("activate://127.0.0.1/activate");
        // 查詢 group 為 default_group 的 IActivate 的實現
        List<IActivate> list = loader.getActivateExtension(url, new String[]{}, "default_group");
        list.forEach(e -> System.out.println(e.getClass()));
    }

    /**
     * @Activate 注解中聲明多個 group
     */
    @Test
    public void fn02() {
        ExtensionLoader<IActivate> loader = ExtensionLoader.getExtensionLoader(IActivate.class);
        URL url = URL.valueOf("activate://127.0.0.1/activate");
        // 查詢 group 為 group01 的 IActivate 的實現
        List<IActivate> list = loader.getActivateExtension(url, new String[]{}, "group01");
        list.forEach(e -> System.out.println(e.getClass()));
    }

    /**
     * @Activate 注解中聲明了 group 與 value
     */
    @Test
    public void fn03() {
        ExtensionLoader<IActivate> loader = ExtensionLoader.getExtensionLoader(IActivate.class);
        URL url = URL.valueOf("activate://127.0.0.1/activate");
        // 根據 key = v1, group = value
        // @Activate(value = {"v1"}, group = {"value_group"}) 來激活擴展
        // com.zy.activate.ValueActivate
        // 這里有個坑, url 被重新賦值了
        url = url.addParameter("v1", "value_group");
        // 查詢 value 為 v1, group 為 value_group 的 IActivate 的實現
        List<IActivate> list = loader.getActivateExtension(url, new String[]{}, "value_group");
        list.forEach(e -> System.out.println(e.getClass()));
    }

    /**
     * @Activate 注解中聲明了 order, 低的排序優先級高
     */
    @Test
    public void fn04() {
        ExtensionLoader<IActivate> loader = ExtensionLoader.getExtensionLoader(IActivate.class);
        URL url = URL.valueOf("activate://127.0.0.1/activate");
        List<IActivate> list = loader.getActivateExtension(url, new String[]{}, "group_by_order");
        // 查詢 group 為 group_by_order, 并且有 order 排序的 IActivate 的實現
        list.forEach(e -> System.out.println(e.getClass()));
    }

}

classpath下文件: com.zy.activate.IActivate

group=com.zy.activate.GroupActivate
order01=com.zy.activate.OrderActivate01
order02=com.zy.activate.OrderActivate02
value=com.zy.activate.ValueActivate
com.zy.activate.DefaultActivate

3.4 @Adaptive

自適應擴展點注解。
adaptive設計的目的是為了識別固定已知類和擴展未知類。

在實際應用場景中，一個擴展接口往往會有多種實現類，而Dubbo是基于URL驅動，
所以在運行時，通過傳入URL中的某些參數來動態控制具體實現，這便是Dubbo的擴展點自適應特性。
URL來自于 ReferenceConfig, ConsumerConfig等各種config, 即yml或XML中的producer或consumer的各種配置.

在Dubbo中，@Adaptive一般用來修飾類和接口方法，在整個Dubbo框架中，
只有AdaptiveExtensionFactory和AdaptiveCompiler使用在類級別上,
其余都標注在方法上。

3.4.1 修飾方法級別

當擴展點的方法被@Adaptive修飾時，
在Dubbo初始化擴展點時會自動生成和編譯一個動態的Adaptive類。

含有@Adaptive的方法中都可以根據方法參數動態獲取各自需要真實的擴展點。
它主要是用于SPI，因為spi的類是不固定、未知的擴展類，所以設計了動態$Adaptive類；
ExtensionLoader.getAdaptiveExtension方法會返回動態編譯生成的$Adaptive

例如： 
Protocol的spi類有injvm、dubbo、registry、filter、listener等很多未知擴展類，
ExtensionLoader.getAdaptiveExtension會動態編譯Protocol$Adaptive的類，
再通過在動態累的方法中調用ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(spi類);來提取對象。

以Protocol接口為例

package org.apache.dubbo.rpc;

import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.extension.Adaptive;
import org.apache.dubbo.common.extension.SPI;

@SPI("dubbo")
public interface Protocol {
    int getDefaultPort();
    @Adaptive
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
    @Adaptive
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
    void destroy();
}

export 和 refer 兩個方法被 @Adaptive 注解修飾
Dubbo在初始化擴展點時(即provider或consumer向注冊中心注冊，會生成一個Protocol$Adaptive類，
該動態代理類會實現這兩個方法，方法里會有一些抽象的通用邏輯，
根據解析URL得到的信息，找到并調用真正的實現類。
生成的代碼如下：

package org.apache.dubbo.rpc;
import org.apache.dubbo.common.extension.ExtensionLoader;
public class Protocol$Adaptive implements org.apache.dubbo.rpc.Protocol {
    public void destroy()  {
        throw new UnsupportedOperationException("The method public abstract void org.apache.dubbo.rpc.Protocol.destroy() of interface org.apache.dubbo.rpc.Protocol is not adaptive method!");
    }
    
    public int getDefaultPort()  {
        throw new UnsupportedOperationException("The method public abstract int org.apache.dubbo.rpc.Protocol.getDefaultPort() of interface org.apache.dubbo.rpc.Protocol is not adaptive method!");
    }
    
    public org.apache.dubbo.rpc.Exporter export(org.apache.dubbo.rpc.Invoker arg0) throws org.apache.dubbo.rpc.RpcException {
        if (arg0 == null) 
            throw new IllegalArgumentException("org.apache.dubbo.rpc.Invoker argument == null");
        if (arg0.getUrl() == null) 
            throw new IllegalArgumentException("org.apache.dubbo.rpc.Invoker argument getUrl() == null");
        org.apache.dubbo.common.URL url = arg0.getUrl();
        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
        if(extName == null) 
            throw new IllegalStateException("Failed to get extension (org.apache.dubbo.rpc.Protocol) name from url (" + url.toString() + ") use keys([protocol])");
        org.apache.dubbo.rpc.Protocol extension = (org.apache.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.Protocol.class).getExtension(extName);
        return extension.export(arg0);
    }
    
    public org.apache.dubbo.rpc.Invoker refer(java.lang.Class arg0, org.apache.dubbo.common.URL arg1) throws org.apache.dubbo.rpc.RpcException {
        if (arg1 == null) 
            throw new IllegalArgumentException("url == null");
        org.apache.dubbo.common.URL url = arg1;
        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
        if(extName == null) 
            throw new IllegalStateException("Failed to get extension (org.apache.dubbo.rpc.Protocol) name from url (" + url.toString() + ") use keys([protocol])");
        org.apache.dubbo.rpc.Protocol extension = (org.apache.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.Protocol.class).getExtension(extName);
        return extension.refer(arg0, arg1);
    }
}

Protocol$Adaptive.png

解釋下上述生成的export(org.apache.dubbo.rpc.Invoker arg0)方法

1.String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
從arg0中解析出擴展點名稱extName，extName的默認值為@SPI的value。
這是adaptive的精髓：每一個方法都可以根據方法參數動態獲取各自需要的擴展點。

2.Protocol extension = (Protocol)ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.Protocol.class).getExtension(extName);
根據extName重新獲取指定的Protocol.class擴展點。
如果所有擴展點中含有Wrapper（listener,fiter）則ExtensionLoader.getExtension()
會將真正的實現類通過 Wrapper（listener,fiter）包裝后返回。
如
>> ProtocolListenerWrapper
>> ProtocolFilterWrapper
>> QosProtocolWrapper
>> StubProxyFactoryWrapper

3.extension.export(arg0)
執行目標類的目標方法

3.4.2 修飾類級別

以AdaptiveCompiler類為例，它作為Compiler擴展點的實現類，被@Adaptive在類級別修飾。

在類所在工程的resource/META-INF/dubbo/internal路徑下可以找到擴展點配置文件:
org.apache.dubbo.common.compiler.Compiler

這樣在Dubbo加載擴展點時便可以根據adaptive屬性找到AdaptiveComiler實現類，
再通過compiler方法決定是調用默認實現，還是指定的實現，默認實現由擴展點接口上的@SPI注解指定。
此處: 
@SPI("javassist")
public interface Compiler { ... }

對比方法級別，類級別省略了生成動態代理類的過程，由指定類決定具體實現，
另外對于同一個擴展點，類級別的Adaptive只能有一個。

// 1. 為什么AdaptiveCompiler這個類是固定已知的？
因為整個框架僅支持Javassist和JdkCompiler；
// 2. 為什么AdaptiveExtensionFactory這個類是固定已知的？
因為整個框架僅支持2個objFactory,一個是spi,另一個是spring；
ExtensionLoader.getAdaptiveExtension方法會直接返回這個類的實例

4.Spring中的SPI機制

Spring-SPI部分源碼.png

關于何時加載classpath下的spring.factories文件, 參考下文
http://www.lxweimin.com/p/5d5890645165

參考資源
http://www.lxweimin.com/p/08b41189eb4c (dubbo-spi)
http://www.lxweimin.com/p/0d196ad23915 (spring-spi)
https://www.cnblogs.com/leeego-123/p/10906674.html
https://blog.csdn.net/vbirdbest/article/details/79863883
http://www.lxweimin.com/p/bc523348f519 (@Activate擴展)
https://www.cnblogs.com/qiaozhuangshi/p/11007032.html (@Activate擴展)
http://www.lxweimin.com/p/7e116f480165 (@Activate擴展示例)
https://blog.csdn.net/qq_30051265/article/details/82776395 (Dubbo 中的 filter)
https://blog.csdn.net/u011212394/article/details/102762197 (@Adaptiv)