Dubbo（二）：深入理解Dubbo源碼之Dubbo的服務發現SPI機制

一、前言

　　用到微服務就不得不來談談服務發現的話題。通俗的來說，就是在提供服務方把服務注冊到注冊中心，並且告訴服務消費方現在已經存在了這個服務。那么里面的細節到底是怎么通過代碼實現的呢，現在我們來看看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)

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 an interface!");
        } else if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type (" + type + ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        } 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;
        }
    }

　　這個是可以將對應的接口轉換為ExtensionLoader 實例。相當於告訴Dubbo這是個服務接口，里面有對應的服務提供者

　　先是邏輯判斷傳進來的類不能為空，必須是接口且被@SPI注解注釋過。這三個條件都滿足就會創建ExtensionLoader 實例。同樣的，如果當前類已經被創建過ExtensionLoader 實例，那么直接拿取。否則新建一個。這里使用的是鍵值對的存儲類型，如下圖：

 

 

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

 

　　2、getExtension(String name)

public T getExtension(String name) {
    if (name == null || name.length() == 0)
        throw new IllegalArgumentException("Extension name == null");
    if ("true".equals(name)) {
        // 獲取默認的拓展實現類
        return getDefaultExtension();
    }
    // Holder，顧名思義，用於持有目標對象
    Holder<Object> holder = cachedInstances.get(name);
    if (holder == null) {
        cachedInstances.putIfAbsent(name, new Holder<Object>());
        holder = cachedInstances.get(name);
    }
    Object instance = holder.get();
    // 雙重檢查
    if (instance == null) {
        synchronized (holder) {
            instance = holder.get();
            if (instance == null) {
                // 創建拓展實例
                instance = createExtension(name);
                // 設置實例到 holder 中
                holder.set(instance);
            }
        }
    }
    return  instance;
}

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

private Holder<Object> getOrCreateHolder(String name) {
        //檢查緩存中是否存在
        Holder<Object> holder = (Holder)this.cachedInstances.get(name);
        if (holder == null) {
        //緩存中不存在就去創建一個新的Holder
            this.cachedInstances.putIfAbsent(name, new Holder());
            holder = (Holder)this.cachedInstances.get(name);
        }

        return holder;
    }

　　同樣，緩存池也是以ConcurrentHashMap為存儲結構

 

 

　　 3、createExtension(String name)

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

private T createExtension(String name) {
        Class<?> clazz = (Class)this.getExtensionClasses().get(name);
        if (clazz == null) {
            throw this.findException(name);
        } else {
            try {
                T instance = EXTENSION_INSTANCES.get(clazz);
                if (instance == null) {
                    EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                    instance = EXTENSION_INSTANCES.get(clazz);
                }

                this.injectExtension(instance);
                Set<Class<?>> wrapperClasses = this.cachedWrapperClasses;
                Class wrapperClass;
                if (CollectionUtils.isNotEmpty(wrapperClasses)) {
                    for(Iterator var5 = wrapperClasses.iterator(); var5.hasNext(); instance = this.injectExtension(wrapperClass.getConstructor(this.type).newInstance(instance))) {
                        wrapperClass = (Class)var5.next();
                    }
                }

                return instance;
            } catch (Throwable var7) {
                throw new IllegalStateException("Extension instance (name: " + name + ", class: " + this.type + ") couldn't be instantiated: " + var7.getMessage(), var7);
            }
        }
    }

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

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

　　　　3.2、通過反射創建拓展對象

　　　　3.3、向拓展對象中注入依賴（這里Dubbo有單獨的IOC后面會介紹）

　　　　3.4、將拓展對象包裹在相應的 Wrapper 對象中

　　4、getExtensionClasses()

private Map<String, Class<?>> getExtensionClasses() {
    // 從緩存中獲取已加載的拓展類
    Map<String, Class<?>> classes = cachedClasses.get();
    // 雙重檢查
    if (classes == null) {
        synchronized (cachedClasses) {
            classes = cachedClasses.get();
            if (classes == null) {
                // 加載拓展類
                classes = loadExtensionClasses();
                cachedClasses.set(classes);
            }
        }
    }
    return classes;
}

//進入到loadExtensionClasses中

private Map<String, Class<?>> loadExtensionClasses() {
    // 獲取 SPI 注解，這里的 type 變量是在調用 getExtensionLoader 方法時傳入的
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    if (defaultAnnotation != null) {
        String value = defaultAnnotation.value();
        if ((value = value.trim()).length() > 0) {
            // 對 SPI 注解內容進行切分
            String[] names = NAME_SEPARATOR.split(value);
            // 檢測 SPI 注解內容是否合法，不合法則拋出異常
            if (names.length > 1) {
                throw new IllegalStateException("more than 1 default extension name on extension...");
            }

            // 設置默認名稱，參考 getDefaultExtension 方法
            if (names.length == 1) {
                cachedDefaultName = names[0];
            }
        }
    }

    Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
    // 加載指定文件夾下的配置文件
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
    loadDirectory(extensionClasses, DUBBO_DIRECTORY);
    loadDirectory(extensionClasses, SERVICES_DIRECTORY);
    return extensionClasses;
}

//進入到loadDirectory中

private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
    // fileName = 文件夾路徑 + type 全限定名 
    String fileName = dir + type.getName();
    try {
        Enumeration<java.net.URL> urls;
        ClassLoader classLoader = findClassLoader();
        // 根據文件名加載所有的同名文件
        if (classLoader != null) {
            urls = classLoader.getResources(fileName);
        } else {
            urls = ClassLoader.getSystemResources(fileName);
        }
        if (urls != null) {
            while (urls.hasMoreElements()) {
                java.net.URL resourceURL = urls.nextElement();
                // 加載資源
                loadResource(extensionClasses, classLoader, resourceURL);
            }
        }
    } catch (Throwable t) {
        logger.error("...");
    }
}

//進入到loadResource中

private void loadResource(Map<String, Class<?>> extensionClasses, 
    ClassLoader classLoader, java.net.URL resourceURL) {
    try {
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(resourceURL.openStream(), "utf-8"));
        try {
            String line;
            // 按行讀取配置內容
            while ((line = reader.readLine()) != null) {
                // 定位 # 字符
                final int ci = line.indexOf('#');
                if (ci >= 0) {
                    // 截取 # 之前的字符串，# 之后的內容為注釋，需要忽略
                    line = line.substring(0, ci);
                }
                line = line.trim();
                if (line.length() > 0) {
                    try {
                        String name = null;
                        int i = line.indexOf('=');
                        if (i > 0) {
                            // 以等於號 = 為界，截取鍵與值
                            name = line.substring(0, i).trim();
                            line = line.substring(i + 1).trim();
                        }
                        if (line.length() > 0) {
                            // 加載類，並通過 loadClass 方法對類進行緩存
                            loadClass(extensionClasses, resourceURL, 
                                      Class.forName(line, true, classLoader), name);
                        }
                    } catch (Throwable t) {
                        IllegalStateException e = new IllegalStateException("Failed to load extension class...");
                    }
                }
            }
        } finally {
            reader.close();
        }
    } catch (Throwable t) {
        logger.error("Exception when load extension class...");
    }
}

//進入到loadClass中

private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, 
    Class<?> clazz, String name) throws NoSuchMethodException {
    
    if (!type.isAssignableFrom(clazz)) {
        throw new IllegalStateException("...");
    }

    // 檢測目標類上是否有 Adaptive 注解
    if (clazz.isAnnotationPresent(Adaptive.class)) {
        if (cachedAdaptiveClass == null) {
            // 設置 cachedAdaptiveClass緩存
            cachedAdaptiveClass = clazz;
        } else if (!cachedAdaptiveClass.equals(clazz)) {
            throw new IllegalStateException("...");
        }
        
    // 檢測 clazz 是否是 Wrapper 類型
    } else if (isWrapperClass(clazz)) {
        Set<Class<?>> wrappers = cachedWrapperClasses;
        if (wrappers == null) {
            cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
            wrappers = cachedWrapperClasses;
        }
        // 存儲 clazz 到 cachedWrapperClasses 緩存中
        wrappers.add(clazz);
        
    // 程序進入此分支，表明 clazz 是一個普通的拓展類
    } else {
        // 檢測 clazz 是否有默認的構造方法，如果沒有，則拋出異常
        clazz.getConstructor();
        if (name == null || name.length() == 0) {
            // 如果 name 為空，則嘗試從 Extension 注解中獲取 name，或使用小寫的類名作為 name
            name = findAnnotationName(clazz);
            if (name.length() == 0) {
                throw new IllegalStateException("...");
            }
        }
        // 切分 name
        String[] names = NAME_SEPARATOR.split(name);
        if (names != null && names.length > 0) {
            Activate activate = clazz.getAnnotation(Activate.class);
            if (activate != null) {
                // 如果類上有 Activate 注解，則使用 names 數組的第一個元素作為鍵，
                // 存儲 name 到 Activate 注解對象的映射關系
                cachedActivates.put(names[0], activate);
            }
            for (String n : names) {
                if (!cachedNames.containsKey(clazz)) {
                    // 存儲 Class 到名稱的映射關系
                    cachedNames.put(clazz, n);
                }
                Class<?> c = extensionClasses.get(n);
                if (c == null) {
                    // 存儲名稱到 Class 的映射關系
                    extensionClasses.put(n, clazz);
                } else if (c != clazz) {
                    throw new IllegalStateException("...");
                }
            }
        }
    }
}

　　上面的方法較多，理一下邏輯：

　　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)：

private T injectExtension(T instance) {
    try {
        if (objectFactory != null) {
            // 遍歷目標類的所有方法
            for (Method method : instance.getClass().getMethods()) {
                // 檢測方法是否以 set 開頭，且方法僅有一個參數，且方法訪問級別為 public
                if (method.getName().startsWith("set")
                    && method.getParameterTypes().length == 1
                    && Modifier.isPublic(method.getModifiers())) {
                    // 獲取 setter 方法參數類型
                    Class<?> pt = method.getParameterTypes()[0];
                    try {
                        // 獲取屬性名，比如 setName 方法對應屬性名 name
                        String property = method.getName().length() > 3 ? 
                            method.getName().substring(3, 4).toLowerCase() + 
                                method.getName().substring(4) : "";
                        // 從 ObjectFactory 中獲取依賴對象
                        Object object = objectFactory.getExtension(pt, property);
                        if (object != null) {
                            // 通過反射調用 setter 方法設置依賴
                            method.invoke(instance, object);
                        }
                    } catch (Exception e) {
                        logger.error("fail to inject via method...");
                    }
                }
            }
        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    }
    return instance;
}

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

六、總結

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