一、前言

  用到微服務就不得不來談談服務發現的話題。通俗的來說,就是在提供服務方把服務註冊到註冊中心,並且告訴服務消費方現在已經存在了這個服務。那麼裡面的細節到底是怎麼通過程式碼實現的呢,現在我們來看看Dubbo中的SPI機制

二、SPI簡介

  SPI 全稱為 Service Provider Interface,是一種服務發現機制。SPI本質是將介面實現類的全限定名配置在檔案中,並由服務載入器讀取配置檔案,載入實現類,這樣執行時可以動態的為介面替換實現類

三、Dubbo中的SPI

  Dubbo與上面的普通的Java方式實現SPI不同,在Dubbo中重新實現了一套功能更強的SPI機制,即通過鍵值對的方式進行配置及快取。其中也使用ConcurrentHashMap與synchronize防止併發問題出現。主要邏輯封裝在ExtensionLoader中。下面我們看看原始碼。

四、ExtensionLoader原始碼解析

  由於內部的方法實在太多,我們只挑選與實現SPI的重要邏輯部分拿出來講解。  

  1、getExtensionLoader(Class<T> type)

 1 public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
 2         if (type == null) {
 3             throw new IllegalArgumentException("Extension type == null");
 4         } else if (!type.isInterface()) {
 5             throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
 6         } else if (!withExtensionAnnotation(type)) {
 7             throw new IllegalArgumentException("Extension type (" + type + ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
 8         } else {
 9             ExtensionLoader<T> loader = (ExtensionLoader)EXTENSION_LOADERS.get(type);
10             if (loader == null) {
11                 EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
12                 loader = (ExtensionLoader)EXTENSION_LOADERS.get(type);
13             }
14 
15             return loader;
16         }
17     }
View Code

  這個是可以將對應的介面轉換為ExtensionLoader 例項。相當於告訴Dubbo這是個服務介面,裡面有對應的服務提供者

  先是邏輯判斷傳進來的類不能為空,必須是介面且被@SPI註解註釋過。這三個條件都滿足就會建立ExtensionLoader 例項。同樣的,如果當前類已經被建立過ExtensionLoader 例項,那麼直接拿取。否則新建一個。這裡使用的是鍵值對的儲存型別,如下圖:

 

 

   使用ConcurrentHashMap防止在併發時出現問題,並且效率高HashTable不少,所以我們日常專案併發場景中也應該多用ConcurrentHashMap進行儲存。

 

  2、getExtension(String name)

 1 public T getExtension(String name) {
 2     if (name == null || name.length() == 0)
 3         throw new IllegalArgumentException("Extension name == null");
 4     if ("true".equals(name)) {
 5         // 獲取預設的拓展實現類
 6         return getDefaultExtension();
 7     }
 8     // Holder,顧名思義,用於持有目標物件
 9     Holder<Object> holder = cachedInstances.get(name);
10     if (holder == null) {
11         cachedInstances.putIfAbsent(name, new Holder<Object>());
12         holder = cachedInstances.get(name);
13     }
14     Object instance = holder.get();
15     // 雙重檢查
16     if (instance == null) {
17         synchronized (holder) {
18             instance = holder.get();
19             if (instance == null) {
20                 // 建立拓展例項
21                 instance = createExtension(name);
22                 // 設定例項到 holder 中
23                 holder.set(instance);
24             }
25         }
26     }
27     return  instance;
28 }
View Code

  這個方法主要是相當於得到具體的服務,上述我們已經對服務的介面進行載入,現在我們需要呼叫服務介面下的某一個具體服務實現類。就用這個方法。上述方法可以看出是會進入getOrCreateHolder中,這個方法顧名思義是獲取或者建立Holder。進入到下面方法中:

 1 private Holder<Object> getOrCreateHolder(String name) {
 2         //檢查快取中是否存在
 3         Holder<Object> holder = (Holder)this.cachedInstances.get(name);
 4         if (holder == null) {
 5         //快取中不存在就去建立一個新的Holder
 6             this.cachedInstances.putIfAbsent(name, new Holder());
 7             holder = (Holder)this.cachedInstances.get(name);
 8         }
 9 
10         return holder;
11     }
View Code

  同樣,快取池也是以ConcurrentHashMap為儲存結構

 

 

   3、createExtension(String name)

  實際上getExtension方法不一定每次都能拿到,當服務實現類是第一次進行載入的時候就需要當前的方法

 1 private T createExtension(String name) {
 2         Class<?> clazz = (Class)this.getExtensionClasses().get(name);
 3         if (clazz == null) {
 4             throw this.findException(name);
 5         } else {
 6             try {
 7                 T instance = EXTENSION_INSTANCES.get(clazz);
 8                 if (instance == null) {
 9                     EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
10                     instance = EXTENSION_INSTANCES.get(clazz);
11                 }
12 
13                 this.injectExtension(instance);
14                 Set<Class<?>> wrapperClasses = this.cachedWrapperClasses;
15                 Class wrapperClass;
16                 if (CollectionUtils.isNotEmpty(wrapperClasses)) {
17                     for(Iterator var5 = wrapperClasses.iterator(); var5.hasNext(); instance = this.injectExtension(wrapperClass.getConstructor(this.type).newInstance(instance))) {
18                         wrapperClass = (Class)var5.next();
19                     }
20                 }
21 
22                 return instance;
23             } catch (Throwable var7) {
24                 throw new IllegalStateException("Extension instance (name: " + name + ", class: " + this.type + ") couldn't be instantiated: " + var7.getMessage(), var7);
25             }
26         }
27     }
View Code

  可以看出createExtension實際上是一個私有方法,也就是由上面的getExtension自動觸發。內部邏輯大致為:

    3.1、通過 getExtensionClasses 獲取所有的拓展類

    3.2、通過反射建立拓展物件

    3.3、向拓展物件中注入依賴(這裡Dubbo有單獨的IOC後面會介紹)

    3.4、將拓展物件包裹在相應的 Wrapper 物件中

  4、getExtensionClasses()

  1 private Map<String, Class<?>> getExtensionClasses() {
  2     // 從快取中獲取已載入的拓展類
  3     Map<String, Class<?>> classes = cachedClasses.get();
  4     // 雙重檢查
  5     if (classes == null) {
  6         synchronized (cachedClasses) {
  7             classes = cachedClasses.get();
  8             if (classes == null) {
  9                 // 載入拓展類
 10                 classes = loadExtensionClasses();
 11                 cachedClasses.set(classes);
 12             }
 13         }
 14     }
 15     return classes;
 16 }
 17 
 18 //進入到loadExtensionClasses中
 19 
 20 private Map<String, Class<?>> loadExtensionClasses() {
 21     // 獲取 SPI 註解,這裡的 type 變數是在呼叫 getExtensionLoader 方法時傳入的
 22     final SPI defaultAnnotation = type.getAnnotation(SPI.class);
 23     if (defaultAnnotation != null) {
 24         String value = defaultAnnotation.value();
 25         if ((value = value.trim()).length() > 0) {
 26             // 對 SPI 註解內容進行切分
 27             String[] names = NAME_SEPARATOR.split(value);
 28             // 檢測 SPI 註解內容是否合法,不合法則丟擲異常
 29             if (names.length > 1) {
 30                 throw new IllegalStateException("more than 1 default extension name on extension...");
 31             }
 32 
 33             // 設定預設名稱,參考 getDefaultExtension 方法
 34             if (names.length == 1) {
 35                 cachedDefaultName = names[0];
 36             }
 37         }
 38     }
 39 
 40     Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
 41     // 載入指定資料夾下的配置檔案
 42     loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
 43     loadDirectory(extensionClasses, DUBBO_DIRECTORY);
 44     loadDirectory(extensionClasses, SERVICES_DIRECTORY);
 45     return extensionClasses;
 46 }
 47 
 48 //進入到loadDirectory中
 49 
 50 private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
 51     // fileName = 資料夾路徑 + type 全限定名 
 52     String fileName = dir + type.getName();
 53     try {
 54         Enumeration<java.net.URL> urls;
 55         ClassLoader classLoader = findClassLoader();
 56         // 根據檔名載入所有的同名檔案
 57         if (classLoader != null) {
 58             urls = classLoader.getResources(fileName);
 59         } else {
 60             urls = ClassLoader.getSystemResources(fileName);
 61         }
 62         if (urls != null) {
 63             while (urls.hasMoreElements()) {
 64                 java.net.URL resourceURL = urls.nextElement();
 65                 // 載入資源
 66                 loadResource(extensionClasses, classLoader, resourceURL);
 67             }
 68         }
 69     } catch (Throwable t) {
 70         logger.error("...");
 71     }
 72 }
 73 
 74 //進入到loadResource中
 75 
 76 private void loadResource(Map<String, Class<?>> extensionClasses, 
 77     ClassLoader classLoader, java.net.URL resourceURL) {
 78     try {
 79         BufferedReader reader = new BufferedReader(
 80             new InputStreamReader(resourceURL.openStream(), "utf-8"));
 81         try {
 82             String line;
 83             // 按行讀取配置內容
 84             while ((line = reader.readLine()) != null) {
 85                 // 定位 # 字元
 86                 final int ci = line.indexOf('#');
 87                 if (ci >= 0) {
 88                     // 擷取 # 之前的字串,# 之後的內容為註釋,需要忽略
 89                     line = line.substring(0, ci);
 90                 }
 91                 line = line.trim();
 92                 if (line.length() > 0) {
 93                     try {
 94                         String name = null;
 95                         int i = line.indexOf('=');
 96                         if (i > 0) {
 97                             // 以等於號 = 為界,擷取鍵與值
 98                             name = line.substring(0, i).trim();
 99                             line = line.substring(i + 1).trim();
100                         }
101                         if (line.length() > 0) {
102                             // 載入類,並通過 loadClass 方法對類進行快取
103                             loadClass(extensionClasses, resourceURL, 
104                                       Class.forName(line, true, classLoader), name);
105                         }
106                     } catch (Throwable t) {
107                         IllegalStateException e = new IllegalStateException("Failed to load extension class...");
108                     }
109                 }
110             }
111         } finally {
112             reader.close();
113         }
114     } catch (Throwable t) {
115         logger.error("Exception when load extension class...");
116     }
117 }
118 
119 //進入到loadClass中
120 
121 private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, 
122     Class<?> clazz, String name) throws NoSuchMethodException {
123     
124     if (!type.isAssignableFrom(clazz)) {
125         throw new IllegalStateException("...");
126     }
127 
128     // 檢測目標類上是否有 Adaptive 註解
129     if (clazz.isAnnotationPresent(Adaptive.class)) {
130         if (cachedAdaptiveClass == null) {
131             // 設定 cachedAdaptiveClass快取
132             cachedAdaptiveClass = clazz;
133         } else if (!cachedAdaptiveClass.equals(clazz)) {
134             throw new IllegalStateException("...");
135         }
136         
137     // 檢測 clazz 是否是 Wrapper 型別
138     } else if (isWrapperClass(clazz)) {
139         Set<Class<?>> wrappers = cachedWrapperClasses;
140         if (wrappers == null) {
141             cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
142             wrappers = cachedWrapperClasses;
143         }
144         // 儲存 clazz 到 cachedWrapperClasses 快取中
145         wrappers.add(clazz);
146         
147     // 程式進入此分支,表明 clazz 是一個普通的拓展類
148     } else {
149         // 檢測 clazz 是否有預設的構造方法,如果沒有,則丟擲異常
150         clazz.getConstructor();
151         if (name == null || name.length() == 0) {
152             // 如果 name 為空,則嘗試從 Extension 註解中獲取 name,或使用小寫的類名作為 name
153             name = findAnnotationName(clazz);
154             if (name.length() == 0) {
155                 throw new IllegalStateException("...");
156             }
157         }
158         // 切分 name
159         String[] names = NAME_SEPARATOR.split(name);
160         if (names != null && names.length > 0) {
161             Activate activate = clazz.getAnnotation(Activate.class);
162             if (activate != null) {
163                 // 如果類上有 Activate 註解,則使用 names 陣列的第一個元素作為鍵,
164                 // 儲存 name 到 Activate 註解物件的對映關係
165                 cachedActivates.put(names[0], activate);
166             }
167             for (String n : names) {
168                 if (!cachedNames.containsKey(clazz)) {
169                     // 儲存 Class 到名稱的對映關係
170                     cachedNames.put(clazz, n);
171                 }
172                 Class<?> c = extensionClasses.get(n);
173                 if (c == null) {
174                     // 儲存名稱到 Class 的對映關係
175                     extensionClasses.put(n, clazz);
176                 } else if (c != clazz) {
177                     throw new IllegalStateException("...");
178                 }
179             }
180         }
181     }
182 }
View Code

  上面的方法較多,理一下邏輯:

  1、getExtensionClasses():先檢查快取,若快取未命中,則通過 synchronized 加鎖。加鎖後再次檢查快取,並判斷是否為空。此時如果 classes 仍為 null,則通過 loadExtensionClasses 載入拓展類。

  2、loadExtensionClasses():對 SPI 註解的介面進行解析,而後呼叫 loadDirectory 方法載入指定資料夾配置檔案。

  3、loadDirectory():方法先通過 classLoader 獲取所有資源連結,然後再通過 loadResource 方法載入資源。

  4、loadResource():用於讀取和解析配置檔案,並通過反射載入類,最後呼叫 loadClass 方法進行其他操作。loadClass 方法用於主要用於操作快取。

  5、小結:

  我們稍微捋一下Dubbo是如何進行SPI的即發現介面的實現類。先是需要例項化擴充套件類載入器。這裡為了更好的和微服務貼合起來,我們就把它稱作服務載入器。在服務載入器中用的是ConcurrentHashMap的快取結構。在我們需要尋找服務的過程中,Dubbo先通過反射載入類,而後將有@SPI表示的介面(即服務介面)的實現類(即服務提供方)進行配置對應的資料夾及檔案。將配置檔案以鍵值對的方式存到快取中key就是當前服務介面下類的名字,value就是Dubbo生成的對應的類配置檔案。方便我們下次呼叫。其中為了防止併發問題產生,使用ConcurrentHashMap,並且使用synchronize關鍵字對存在併發問題的節點進行雙重檢查。

五、Dubbo中的IOC

  在createExtension中有提到過將拓展物件注入依賴。這裡使用的是injectExtension(T instance):

 1 private T injectExtension(T instance) {
 2     try {
 3         if (objectFactory != null) {
 4             // 遍歷目標類的所有方法
 5             for (Method method : instance.getClass().getMethods()) {
 6                 // 檢測方法是否以 set 開頭,且方法僅有一個引數,且方法訪問級別為 public
 7                 if (method.getName().startsWith("set")
 8                     && method.getParameterTypes().length == 1
 9                     && Modifier.isPublic(method.getModifiers())) {
10                     // 獲取 setter 方法引數型別
11                     Class<?> pt = method.getParameterTypes()[0];
12                     try {
13                         // 獲取屬性名,比如 setName 方法對應屬性名 name
14                         String property = method.getName().length() > 3 ? 
15                             method.getName().substring(3, 4).toLowerCase() + 
16                                 method.getName().substring(4) : "";
17                         // 從 ObjectFactory 中獲取依賴物件
18                         Object object = objectFactory.getExtension(pt, property);
19                         if (object != null) {
20                             // 通過反射呼叫 setter 方法設定依賴
21                             method.invoke(instance, object);
22                         }
23                     } catch (Exception e) {
24                         logger.error("fail to inject via method...");
25                     }
26                 }
27             }
28         }
29     } catch (Exception e) {
30         logger.error(e.getMessage(), e);
31     }
32     return instance;
33 }
View Code

  在上面程式碼中,objectFactory 變數的型別為 AdaptiveExtensionFactory,AdaptiveExtensionFactory 內部維護了一個 ExtensionFactory 列表,用於儲存其他型別的 ExtensionFactory。Dubbo 目前提供了兩種 ExtensionFactory,分別是 SpiExtensionFactory 和 SpringExtensionFactory。前者用於建立自適應的拓展,後者是用於從 Spring 的 IOC 容器中獲取所需的拓展。這就是我們常說的Dubbo為什麼能夠與Spring無縫連線,因為Dubbo底層就是依賴Spring的,對於Spring的IOC容器可直接拿來用。

六、總結

  從框架的原始碼中如果要繼續深挖的話,可以多思考思考synchronize用的地方,為什麼要用,如果不用的話會有什麼併發問題。Dubbo的服務發現只是為我們以後學習Dubbo框架打下基礎,至少讓我們知道Dubbo是如何進行服務發現的。