【轉載】計算機程序的思維邏輯 (87) - 類加載機制

阿新 • • 發佈：2017-05-31

swift throw 組織 web開發 images 重啟限定 ech 重寫

上節，我們探討了動態代理，在前幾節中，我們多次提到了類加載器ClassLoader，本節就來詳細討論Java中的類加載機制與ClassLoader。

類加載器ClassLoader就是加載其他類的類，它負責將字節碼文件加載到內存，創建Class對象。與之前介紹的反射、註解、和動態代理一樣，在大部分的應用編程中，我們不太需要自己實現ClassLoader。

不過，理解類加載的機制和過程，有助於我們更好的理解之前介紹的內容，更好的理解Java。在反射一節，我們介紹過Class的靜態方法Class.forName，理解類加載器有助於我們更好的理解該方法。

ClassLoader一般是系統提供的，不需要自己實現，不過，通過創建自定義的ClassLoader，可以實現一些強大靈活的功能，比如：

熱部署，在不重啟Java程序的情況下，動態替換類的實現，比如Java Web開發中的JSP技術就利用自定義的ClassLoader實現修改JSP代碼即生效，OSGI (Open Service Gateway Initiative)框架使用自定義ClassLoader實現動態更新。
應用的模塊化和相互隔離，不同的ClassLoader可以加載相同的類但互相隔離、互不影響。Web應用服務器如Tomcat利用這一點在一個程序中管理多個Web應用程序，每個Web應用使用自己的ClassLoader，這些Web應用互不幹擾。OSGI利用這一點實現了一個動態模塊化架構，每個模塊有自己的ClassLoader，不同模塊可以互不幹擾。

從不同地方靈活加載，系統默認的ClassLoader一般從本地的.class文件或jar文件中加載字節碼文件，通過自定義的ClassLoader，我們可以從共享的Web服務器、數據庫、緩存服務器等其他地方加載字節碼文件。

理解自定義ClassLoader有助於我們理解這些系統程序和框架，如Tomat, JSP, OSGI，在業務需要的時候，也可以借助自定義ClassLoader實現動態靈活的功能。

下面，我們首先來進一步理解Java加載類的過程，理解類ClassLoader和Class.forName，介紹一個簡單的應用，然後我們探討如何實現自定義ClassLoader，演示如何利用它實現熱部署。

類加載的基本機制和過程

運行Java程序，就是執行java這個命令，指定包含main方法的完整類名，以及一個classpath，即類路徑。類路徑可以有多個，對於直接的class文件，路徑是class文件的根目錄，對於jar包，路徑是jar包的完整名稱（包括路徑和jar包名）。

Java運行時，會根據類的完全限定名尋找並加載類，尋找的方式基本就是在系統類和指定的類路徑中尋找，如果是class文件的根目錄，則直接查看是否有對應的子目錄及文件，如果是jar文件，則首先在內存中解壓文件，然後再查看是否有對應的類。

負責加載類的類就是類加載器，它的輸入是完全限定的類名，輸出是Class對象。類加載器不是只有一個，一般程序運行時，都會有三個：

啟動類加載器(Bootstrap ClassLoader)：這個加載器是Java虛擬機實現的一部分，不是Java語言實現的，一般是C++實現的，它負責加載Java的基礎類，主要是<JAVA_HOME>/lib/rt.jar，我們日常用的Java類庫比如String, ArrayList等都位於該包內。
擴展類加載器(Extension ClassLoader)：這個加載器的實現類是sun.misc.Launcher$ExtClassLoader，它負責加載Java的一些擴展類，一般是<JAVA_HOME>/lib/ext目錄中的jar包。
應用程序類加載器(Application ClassLoader)：這個加載器的實現類是sun.misc.Launcher$AppClassLoader，它負責加載應用程序的類，包括自己寫的和引入的第三方法類庫，即所有在類路徑中指定的類。

這三個類加載器有一定的關系，可以認為是父子關系，Application ClassLoader的父親是Extension ClassLoader，Extension的父親是Bootstrap ClassLoader，註意不是父子繼承關系，而是父子委派關系，子ClassLoader有一個變量parent指向父ClassLoader，在子ClassLoader加載類時，一般會首先通過父ClassLoader加載，具體來說，在加載一個類時，基本過程是：

判斷是否已經加載過了，加載過了，直接返回Class對象，一個類只會被一個ClassLoader加載一次。
如果沒有被加載，先讓父ClassLoader去加載，如果加載成功，返回得到的Class對象。
在父ClassLoader沒有加載成功的前提下，自己嘗試加載類。

這個過程一般被稱為"雙親委派"模型，即優先讓父ClassLoader去加載。為什麽要先讓父ClassLoader去加載呢？這樣，可以避免Java類庫被覆蓋的問題，比如用戶程序也定義了一個類java.lang.String，通過雙親委派，java.lang.String只會被Bootstrap ClassLoader加載，避免自定義的String覆蓋Java類庫的定義。

需要了解的是，"雙親委派"雖然是一般模型，但也有一些例外，比如：

自定義的加載順序：盡管不被建議，自定義的ClassLoader可以不遵從"雙親委派"這個約定，不過，即使不遵從，以"java"開頭的類也不能被自定義類加載器加載，這是由Java的安全機制保證的，以避免混亂。
網狀加載順序：在OSGI框架中，類加載器之間的關系是一個網，每個OSGI模塊有一個類加載器，不同模塊之間可能有依賴關系，在一個模塊加載一個類時，可能是從自己模塊加載，也可能是委派給其他模塊的類加載器加載。
父加載器委派給子加載器加載：典型的例子有JNDI服務(Java Naming and Directory Interface)，它是Java企業級應用中的一項服務，具體我們就不介紹了。

一個程序運行時，會創建一個Application ClassLoader，在程序中用到ClassLoader的地方，如果沒有指定，一般用的都是這個ClassLoader，所以，這個ClassLoader也被稱為系統類加載器(System ClassLoader)。

下面，我們來具體看下表示類加載器的類 - ClassLoader。

理解ClassLoader

基本用法

類ClassLoader是一個抽象類，Application ClassLoader和Extension ClassLoader的具體實現類分別是sun.misc.Launcher$AppClassLoader和sun.misc.Launcher$ExtClassLoader，Bootstrap ClassLoader不是由Java實現的，沒有對應的類。

每個Class對象都有一個方法，可以獲取實際加載它的ClassLoader，方法是：

public ClassLoader getClassLoader()

ClassLoader有一個方法，可以獲取它的父ClassLoader：

public final ClassLoader getParent()

如果ClassLoader是Bootstrap ClassLoader，返回值為null。

比如：

public class ClassLoaderDemo {
    public static void main(String[] args) {
        ClassLoader cl = ClassLoaderDemo.class.getClassLoader();
        while (cl != null) {
            System.out.println(cl.getClass().getName());
            cl = cl.getParent();
        }
        
        System.out.println(String.class.getClassLoader());
    }
}

輸出為：

sun.misc.Launcher$AppClassLoader
sun.misc.Launcher$ExtClassLoader
null

ClassLoader有一個靜態方法，可以獲取默認的系統類加載器：

public static ClassLoader getSystemClassLoader()

ClassLoader中有一個主要方法，用於加載類：

public Class<?> loadClass(String name) throws ClassNotFoundException

比如：

ClassLoader cl = ClassLoader.getSystemClassLoader();
try {
    Class<?> cls = cl.loadClass("java.util.ArrayList");
    ClassLoader actualLoader = cls.getClassLoader();
    System.out.println(actualLoader);
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

需要說明的是，由於委派機制，Class的getClassLoader()方法返回的不一定是調用loadClass的ClassLoader，比如，上面代碼中，java.util.ArrayList實際由BootStrap ClassLoader加載，所以返回值就是null。

ClassLoader vs Class.forName

在反射一節，我們介紹過Class的兩個靜態方法forName：

public static Class<?> forName(String className)
public static Class<?> forName(String name, boolean initialize, ClassLoader loader)

第一個方法使用系統類加載器加載，第二個指定ClassLoader，參數initialize表示，加載後，是否執行類的初始化代碼(如static語句塊)，沒有指定默認為true。

ClassLoader的loadClass方法與forName方法都可以加載類，它們有什麽不同呢？基本是一樣的，不過，有一個不同，ClassLoader的loadClass不會執行類的初始化代碼，看個例子：

public class CLInitDemo {
    public static class Hello {
        static {
            System.out.println("hello");
        }
    };

    public static void main(String[] args) {
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        String className = CLInitDemo.class.getName() + "$Hello";
        try {
            Class<?> cls = cl.loadClass(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

使用ClassLoader加載靜態內部類Hello，Hello有一個static語句塊，輸出"hello"，運行該程序，類被加載了，但沒有任何輸出，即static語句塊沒有被執行。如果將loadClass的語句換為：

Class<?> cls = Class.forName(className);

則static語句塊會被執行，屏幕將輸出"hello"。

實現代碼

我們來看下ClassLoader的loadClass代碼，以進一步理解其行為：

public Class<?> loadClass(String name) throws ClassNotFoundException {
    return loadClass(name, false);
}

它調用了另一個loadClass方法，其主要代碼為(省略了一些代碼，加了註釋，以便於理解)：

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 首先，檢查類是否已經被加載了
        Class c = findLoadedClass(name);
        if (c == null) {
            //沒被加載，先委派父ClassLoader或BootStrap ClassLoader去加載
            try {
                if (parent != null) {
                    //委派父ClassLoader，resolve參數固定為false
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                //沒找到，捕獲異常，以便嘗試自己加載                
            }
            if (c == null) {
                // 自己去加載，findClass才是當前ClassLoader的真正加載方法
                c = findClass(name);
            }
        }
        if (resolve) {
            // 鏈接，執行static語句塊
            resolveClass(c);
        }
        return c;
    }
}

參數resolve類似Class.forName中的參數initialize，可以看出，其默認值為false，即使通過自定義ClassLoader重寫loadClass，設置resolve為true，它調用父ClassLoader的時候，傳遞的也是固定的false。

findClass是一個protected方法，類ClassLoader的默認實現就是拋出ClassNotFoundException，子類應該重寫該方法，實現自己的加載邏輯，後文我們會看個具體例子。

類加載應用 - 可配置的策略

可以通過ClassLoader的loadClass或Class.forName自己加載類，但什麽情況需要自己加載類呢？

很多應用使用面向接口的編程，接口具體的實現類可能有很多，適用於不同的場合，具體使用哪個實現類在配置文件中配置，通過更改配置，不用改變代碼，就可以改變程序的行為，在設計模式中，這是一種策略模式，我們看個簡單的示例。

定義一個服務接口IService：

public interface IService {
    public void action();
}

客戶端通過該接口訪問其方法，怎麽獲得IService實例呢？查看配置文件，根據配置的實現類，自己加載，使用反射創建實例對象，示例代碼為：

public class ConfigurableStrategyDemo {
    public static IService createService() {
        try {
            Properties prop = new Properties();
            String fileName = "data/c87/config.properties";
            prop.load(new FileInputStream(fileName));
            String className = prop.getProperty("service");
            Class<?> cls = Class.forName(className);
            return (IService) cls.newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        IService service = createService();
        service.action();
    }
}

config.properties的內容示例為：

service=shuo.laoma.dynamic.c87.ServiceB

代碼比較簡單，就不贅述了。

自定義ClassLoader

基本用法

Java類加載機制的強大之處在於，我們可以創建自定義的ClassLoader，自定義ClassLoader是Tomcat實現應用隔離、支持JSP，OSGI實現動態模塊化的基礎。

怎麽自定義呢？一般而言，繼承類ClassLoader，重寫findClass就可以了。怎麽實現findClass呢？使用自己的邏輯尋找class文件字節碼的字節形式，找到後，使用如下方法轉換為Class對象：

protected final Class<?> defineClass(String name, byte[] b, int off, int len)

name表示類名，b是存放字節碼數據的字節數組，有效數據從off開始，長度為len。

看個例子：

public class MyClassLoader extends ClassLoader {

    private static final String BASE_DIR = "data/c87/";

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String fileName = name.replaceAll("\\.", "/");
        fileName = BASE_DIR + fileName + ".class";
        try {
            byte[] bytes = BinaryFileUtils.readFileToByteArray(fileName);
            return defineClass(name, bytes, 0, bytes.length);
        } catch (IOException ex) {
            throw new ClassNotFoundException("failed to load class " + name, ex);
        }
    }
}

MyClassLoader從BASE_DIR下的路徑中加載類，它使用了我們在57節介紹的BinaryFileUtils讀取文件，轉換為byte數組。MyClassLoader沒有指定父ClassLoader，默認是系統類加載器，即ClassLoader.getSystemClassLoader()的返回值，不過，ClassLoader有一個可重寫的構造方法，可以指定父ClassLoader：

protected ClassLoader(ClassLoader parent)

用途

MyClassLoader有什麽用呢？將BASE_DIR加到classpath中不就行了，確實可以，這裏主要是演示基本用法，實際中，可以從Web服務器、數據庫或緩存服務器獲取bytes數組，這就不是系統類加載器能做到的了。

不過，不把BASE_DIR放到classpath中，而是使用MyClassLoader加載，確實有一個很大的好處，可以創建多個MyClassLoader，對同一個類，每個MyClassLoader都可以加載一次，得到同一個類的不同Class對象，比如：

MyClassLoader cl1 = new MyClassLoader();
String className = "shuo.laoma.dynamic.c87.HelloService";
Class<?> class1 = cl1.loadClass(className);

MyClassLoader cl2 = new MyClassLoader();
Class<?> class2 = cl2.loadClass(className);

if (class1 != class2) {
    System.out.println("different classes");
}

cl1和cl2是兩個不同的ClassLoader，class1和class2對應的類名一樣，但它們是不同的對象。

這到底有什麽用呢？

可以實現隔離，一個復雜的程序，內部可能按模塊組織，不同模塊可能使用同一個類，但使用的是不同版本，如果使用同一個類加載器，它們是無法共存的，不同模塊使用不同的類加載器就可以實現隔離，Tomcat使用它隔離不同的Web應用，OSGI使用它隔離不同模塊。
可以實現熱部署，使用同一個ClassLoader，類只會被加載一次，加載後，即使class文件已經變了，再次加載，得到的也還是原來的Class對象，而使用MyClassLoader，則可以先創建一個新的ClassLoader，再用它加載Class，得到的Class對象就是新的，從而實現動態更新。

下面，我們來具體看熱部署的示例。

自定義ClassLoader的應用 - 熱部署

所謂熱部署，就是在不重啟應用的情況下，當類的定義，即字節碼文件修改後，能夠替換該Class創建的對象，怎麽做到這一點呢？我們利用MyClassLoader，看個簡單的示例。

我們使用面向接口的編程，定義一個接口IHelloService：

public interface IHelloService {
    public void sayHello();
}

實現類是shuo.laoma.dynamic.c87.HelloImpl，class文件放到MyClassLoader的加載目錄中。

演示類是HotDeployDemo，它定義了以下靜態變量：

private static final String CLASS_NAME = "shuo.laoma.dynamic.c87.HelloImpl";
private static final String FILE_NAME = "data/c87/"
            +CLASS_NAME.replaceAll("\\.", "/")+".class";
private static volatile IHelloService helloService;

CLASS_NAME表示實現類名稱，FILE_NAME是具體的class文件路徑，helloService是IHelloService實例。

當CLASS_NAME代表的類字節碼改變後，我們希望重新創建helloService，反映最新的代碼，怎麽做呢？先看用戶端獲取IHelloService的方法：

public static IHelloService getHelloService() {
    if (helloService != null) {
        return helloService;
    }
    synchronized (HotDeployDemo.class) {
        if (helloService == null) {
            helloService = createHelloService();
        }
        return helloService;
    }
}

這是一個單例模式，createHelloService()的代碼為：

private static IHelloService createHelloService() {
    try {
        MyClassLoader cl = new MyClassLoader();
        Class<?> cls = cl.loadClass(CLASS_NAME);
        if (cls != null) {
            return (IHelloService) cls.newInstance();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

它使用MyClassLoader加載類，並利用反射創建實例，它假定實現類有一個public無參構造方法。

在調用IHelloService的方法時，客戶端總是先通過getHelloService獲取實例對象，我們模擬一個客戶端線程，它不停的獲取IHelloService對象，並調用其方法，然後睡眠1秒鐘，其代碼為：

public static void client() {
    Thread t = new Thread() {
        @Override
        public void run() {
            try {
                while (true) {
                    IHelloService helloService = getHelloService();
                    helloService.sayHello();
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
            }
        }
    };
    t.start();
}

怎麽知道類的class文件發生了變化，並重新創建helloService對象呢？我們使用一個單獨的線程模擬這一過程，代碼為：

public static void monitor() {
    Thread t = new Thread() {
        private long lastModified = new File(FILE_NAME).lastModified();

        @Override
        public void run() {
            try {
                while (true) {
                    Thread.sleep(100);
                    long now = new File(FILE_NAME).lastModified();
                    if (now != lastModified) {
                        lastModified = now;
                        reloadHelloService();
                    }
                }
            } catch (InterruptedException e) {
            }
        }
    };
    t.start();
}

我們使用文件的最後修改時間來跟蹤文件是否發生了變化，當文件修改後，調用reloadHelloService()來重新加載，其代碼為：

public static void reloadHelloService() {
    helloService = createHelloService();
}

就是利用MyClassLoader重新創建HelloService，創建後，賦值給helloService，這樣，下次getHelloService()獲取到的就是最新的了。

在主程序中啟動client和monitor線程，代碼為：

public static void main(String[] args) {
    monitor();
    client();
}

在運行過程中，替換HelloImpl.class，可以看到行為會變化，為便於演示，我們在data/c87/shuo/laoma/dynamic/c87/目錄下準備了兩個不同的實現類HelloImpl_origin.class和HelloImpl_revised.class，在運行過程中替換，會看到輸出不一樣，如下圖所示：

技術分享

使用cp命令修改HelloImpl.class，如果其內容與HelloImpl_origin.class一樣，輸出為"hello"，如果與HelloImpl_revised.class一樣，輸出為"hello revised"。

完整的代碼和數據在github上，文末有鏈接。

小結

本節探討了Java中的類加載機制，包括Java加載類的基本過程，類ClassLoader的用法，以及如何創建自定義的ClassLoader，探討了兩個簡單應用示例，一個通過動態加載實現可配置的策略，另一個通過自定義ClassLoader實現熱部署。

從84節到本節，我們探討了Java中的多個動態特性，包括反射、註解、動態代理和類加載器，作為應用程序員，大部分用的都比較少，用的較多的就是使用框架和庫提供的各種註解了，但這些特性大量應用於各種系統程序、框架、和庫中，理解這些特性有助於我們更好的理解它們，也可以在需要的時候自己實現動態、通用、靈活的功能。

在註解一節，我們提到，註解是一種聲明式編程風格，它提高了Java語言的表達能力，日常編程中一種常見的需求是文本處理，在計算機科學中，有一種技術大大提高了文本處理的表達能力，那就是正則表達式，大部分編程語言都有對它的支持，它有什麽強大功能呢？

(與其他章節一樣，本節所有代碼位於 https://github.com/swiftma/program-logic，位於包shuo.laoma.dynamic.c87下)

【轉載】計算機程序的思維邏輯 (87) - 類加載機制

swift throw 組織 web開發 images 重啟限定 ech 重寫上節，我們探討了動態代理，在前幾節中，我們多次提到了類加載器ClassLoader，本節就來詳細討論Java中的類加載機制與ClassLoader。類加載器ClassLoader就是加載其他

【轉載】計算機程序的思維邏輯 (87) - 類加載機制

【轉載】計算機程序的思維邏輯 (87) - 類加載機制

【轉載】計算機程序的思維邏輯 (8) - char的真正含義

【轉載】計算機程序的思維邏輯 (13) - 類

【轉載】國外程序員整理的Java資源大全

【轉載】適合程序員的畫圖技法

【轉載】C++程序崩潰排查方法

【轉載】釘釘開發c#幫助類獲取用戶信息 DingHelper.cs

【Tomcat】Tomcat的類加載機制

《轉載》圖解Tomcat類加載機制

一個優秀的程序員所具備的14個品質【轉載】

給程序員一些建議【轉載】

對程序員更好的建議【轉載】

程序員應該怎麽做呢？【轉載】

【轉載】一個c程序在執行main函數之前和main之後都做了那些事情

【轉載】如何使用docker部署c/c++程序

【轉載】使用Docker Hub官方gcc:latest鏡像編譯C/C++程序以及縮小鏡像的方法

小程序swiper組件高度自適應【轉載】

【轉載】【計算機網路】【TCP】當我們說"TCP是可靠協議"時，我們真正表達的是什麼？

【轉載】雲端計算背景下計算機網路安全問題

【轉載】Stanford機器學習---第三講. 邏輯迴歸和過擬合問題的解決 logistic Regression & Regularization

【轉載】計算機程序的思維邏輯 (87) - 類加載機制

相關推薦