java中的Class裝載系統(tǒng)ClassLoader是怎樣使用

java中的Class裝載系統(tǒng)ClassLoader是怎樣使用，針對這個問題，這篇文章詳細(xì)介紹了相對應(yīng)的分析和解答，希望可以幫助更多想解決這個問題的小伙伴找到更簡單易行的方法。

ClassLoader在Java中有著非常重要的作用，它主要工作是在Class裝載的加載階段，主要作用是從系統(tǒng)外部獲得Class二進(jìn)制數(shù)據(jù)流。

1. 認(rèn)識ClassLoader

ClassLoader是java的核心組件，所有的Class都是由ClassLoader進(jìn)行加載的，ClassLoader負(fù)責(zé)通過各種方式將ClassLoader在整個裝載階段，只能影響類的加載，而無法通過ClassLoader改變類的連接和初始化行為。

從代碼層面上看，ClassLoader是一個抽象類，它提供了一些重要的接口，用于自定義Class的加載流程和加載方式。ClassLoader的主要方法如下：

• public Class<?> loadClass(String name) throws ClassNotFoundException：給定一個類名，加載一個類，返回代碼這個類的Class實(shí)例，如果找不到類，則返回ClassNotFoundException異常。

• protected final Class<?> defineClass(byte[] b, int off, int len)：根據(jù)給定的字節(jié)碼流b定義一個類，off和len參數(shù)表示實(shí)際Class信息在byte數(shù)組中的位置和長度，其中byte數(shù)組b是ClassLoader從外部獲取的。這是一個受保護(hù)的方法，只有在自定義ClassLoader子類中可以使用。

• protected Class<?> findClass(String name) throws ClassNotFoundException：查找一個類，這是一個受保護(hù)的方法，也是重載ClassLoader時重要的系統(tǒng)擴(kuò)展點(diǎn)。這個方法在loadClass()中被調(diào)用，用于自定義查找類的邏輯。如果不需要修改類加載默認(rèn)機(jī)制，只是想改變類加載的形式，就可以重載該方法。

• protected final Class<?> findLoadedClass(String name)：這也是一個受保護(hù)的方法，它會尋找已經(jīng)加載的類。這個方法是final方法，無法被修改。

在ClassLoader的結(jié)構(gòu)中，還有一個重要的字段：parnet。它也是一個ClassLoader的實(shí)例，這個字段所表示的ClassLoader稱為這個ClassLoader的雙親。在類加載的過程中，ClassLoader可能會將某些請求交給自己的雙親處理。

2. ClassLoader的分類

在標(biāo)準(zhǔn)的java程序中，java虛擬機(jī)會創(chuàng)建3類ClassLoader為整個應(yīng)用程序服務(wù)。它們分別是：Bootstrap ClassLoader（啟動類加載器）、Extension ClassLoader（擴(kuò)展類加載器）和 App ClassLoader（應(yīng)用類加載器，也稱系統(tǒng)類加載器）。此外每一個應(yīng)用程序還可以擁有自定義的 ClassLoader，以擴(kuò)展java虛擬機(jī)獲取Class數(shù)據(jù)的能力。

ClassLoader層次結(jié)構(gòu)如下圖所示。當(dāng)系統(tǒng)需要使用一個類時，在判斷類是否已經(jīng)被加載時，會從底層類加載器開始進(jìn)行判斷。當(dāng)系統(tǒng)需要加載一個類時，會從頂層類開始加載，依次向下嘗試，直到成功。

• 啟動類加載器：完全由c語言實(shí)現(xiàn)，并且java中沒有對象與之對應(yīng)，負(fù)責(zé)加載系統(tǒng)的核心類，比如rt.jar中的java類。

• 擴(kuò)展類加載器：用于加載%JAVA_HOME%/lib/ext/*.jar中的java類。

• 應(yīng)用類加載器：用于加載用戶類，也就是用戶程序的類。

• 自定義類加載器：用于加載一些特殊途徑的類，一般也是用戶程序的類。

下列代碼輸出了加載的類加載器：

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

代碼中先取得裝載當(dāng)前類Demo04的ClassLoader，然后打印當(dāng)前ClassLoader并獲得其雙親，直到類加載器樹被遍歷完成。運(yùn)行結(jié)果如下：

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

由此得知，Demo03是由AppClasLoader(應(yīng)用類加載器)加載的，而AppClassLoader的雙親為ExtClassLoader(擴(kuò)展類加載器)。從ExtClassLoader無法再取得啟動類加載器，因?yàn)檫@是一個系統(tǒng)級的純C語言實(shí)現(xiàn)。因此，任何啟動類加載器中加載的類是無法獲得其ClassLoader實(shí)例的，比如：

String.class.getClassLoader()

由于String屬于java核心類，會被啟動類加載器加載，故以上代碼返回的是null.

3. ClassLoader 的雙親委托模式

系統(tǒng)中的ClassLoader在協(xié)同工作時，默認(rèn)會使用雙親委托模式。在類加載的時候，系統(tǒng)會判斷當(dāng)前類是否已經(jīng)被加載，如果已經(jīng)被加載，就會直接返回可用的類，否則就會嘗試加載。在嘗試加載時，會請求雙親處理，如果請求失敗，則會自己加載。

以下代碼顯示了ClassLoader加載類的詳細(xì)過程，它在ClassLoader.loadClass()中實(shí)現(xiàn)：

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 檢查類是否已經(jīng)加載
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // 如果雙親不為null
                    // 在雙親加載不成功時，拋出ClassNotFoundException
                }

                if (c == null) {
                    // 如果雙親加載不成功
                    // 使用findClass查找類
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // 定義類加載器，記錄數(shù)據(jù)
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

判斷類是否加載時，應(yīng)用類加載器會順著雙親路徑往上判斷，直到啟動類加載器。但是啟動類加載器不會往下詢問，這個委托是單向的。

4. 雙親委托模式的弊端

由前面的分析可知，檢查類是否已加載的委托過程是單向。這種方式雖然從結(jié)構(gòu)上比較清晰，使用各個ClassLoader的職責(zé)非常明確，但是會帶來一個問題：即上層的ClassLoader無法訪問下層的ClassLoader所加載的類，如下圖：

通常情況下，啟動類加載器中的類為系統(tǒng)核心類，包括一些重要的系統(tǒng)接口，而在應(yīng)用類加載器中為應(yīng)用類。按照這種模式，應(yīng)用類訪問系統(tǒng)類自然沒問題，但是系統(tǒng)類訪問應(yīng)用類就會出現(xiàn)問題。比如，在系統(tǒng)類中提供了一個接口，該接口需要在應(yīng)用中得以實(shí)現(xiàn)，還綁定一個工廠方法，用于創(chuàng)建該接口的實(shí)例，而接口和工廠方法都在啟動類加載器中。這些就會出現(xiàn)該工廠方法無法創(chuàng)建由應(yīng)用類加載器的應(yīng)用實(shí)例的問題。

5. 雙親委托模式的補(bǔ)充

在java平臺中，通常把核心類（rt.jar）中提供外部服務(wù)、可由應(yīng)用層自行實(shí)現(xiàn)的接口稱為Service Provider Interface,即SPI.

下面以javax.xml.parsers中實(shí)現(xiàn)XML文件解析功能模塊為例，說明如何在啟動類加載中訪問由應(yīng)用類加載器實(shí)現(xiàn)的SPI接口實(shí)例。

public static DocumentBuilderFactory newInstance() {
    return FactoryFinder.find(
            /* The default property name according to the JAXP spec */
            DocumentBuilderFactory.class, // "javax.xml.parsers.DocumentBuilderFactory"
            /* The fallback implementation class name */
            "com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl");
}

FactoryFinder.find()函數(shù)試圖加載并返回一個DocumentBuilderFactory實(shí)例。當(dāng)這個實(shí)例在應(yīng)用層jar包時，它會使用如下方法進(jìn)行查找：

Object provider = findJarServiceProvider(factoryId);

其中factoryId就是字條串javax.xml.parsers.DocumentBuilderFactory，findJarServiceProvider的主要內(nèi)容如下代碼所示（這段代碼并非jdK中的源碼，為了展示主要功能，做了刪減）：

private static Object findJarServiceProvider(String factoryId) throw ConfigurationError {
	String serviceId = "META-INF/services" + factoryId;
	InputStream is = null;
	ClassLoader cl = ss.getContextClassLoader();
	InputStream is = ss.getResourceAsStream(cl, serviceId);
	BufferedReader rd = new BufferedReader(new InputStreamReader(is, "UTF-8"));
	String factoryClassName = rd.readLine();
	return newInterface(factoryClassName, cl, false, useBSClsLoader);
}

從以上代碼可知，系統(tǒng)通過讀取jar包中META-INF/services目錄下的類名文件讀取工廠類類名，然后根據(jù)類名生成對應(yīng)的實(shí)例，并將此ClassLoader傳入newInstance()方法，由這個ClassLoader完成實(shí)例的加載和創(chuàng)建，而不是由這段代碼所在的啟動類加載品加載。從而解決了啟動類加載器無法訪問factoryClassName指定類的問題。

以上代碼中，加載工廠類方法略有曲折，我們平時寫代碼時，知道了一個類的包名.類名，要生成該類的對象，通常是這么進(jìn)行的：

1. Class.forname("包名.類名")，拿到Class對象。

2. 拿到Class對象后，調(diào)用Class.newInstance()方法，生成該對象的實(shí)例。

但是，在DocumentBuilderFactory中，這樣做就行不通了，主要原因在于Class.forName()無法拿到類加載器。我們來看看Class.forName()的源碼：

public static Class<?> forName(String className)
            throws ClassNotFoundException {
    Class<?> caller = Reflection.getCallerClass();
    return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}

從上面可以看到，在哪個類里調(diào)用了Class.forName()，就使用加載那個類的類加載器進(jìn)行類加載，即DocumentBuilderFactory調(diào)用了Class.forName()，就使用加載DocumentBuilderFactory的類加載器進(jìn)行加載包名.類名，但問題是DocumentBuilderFactory是由BootClassLoader加載的，獲取到的類加載器是null，這是無法加載包名.類名。

6. 突破雙親模式

雙親模式的類加載方式是虛擬機(jī)默認(rèn)的行為，但并非必須這么做，通過重載ClassLoader可以修改該行為。下面將演示如何打破默認(rèn)的雙親模式：

package jvm.chapter10;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.WritableByteChannel;


class MyClassLoader extends ClassLoader {

    private String fileName;

    public MyClassLoader(String fileName) {
        this.fileName = fileName;
    }

    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        Class re = findClass(name);
        if (re != null) {
            return re;
        }
        System.out.println("load class " + name + " failed, parent load start");
        return super.loadClass(name, resolve);
    }

    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        Class clazz = this.findLoadedClass(className);
        if (null == clazz) {
            try {
                String classFile = getClassFile(className);
                FileInputStream fis = new FileInputStream(classFile);
                FileChannel fileChannel = fis.getChannel();
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                WritableByteChannel outChannel = Channels.newChannel(baos);
                ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
                while (true) {
                    int i = fileChannel.read(buffer);
                    if (i == 0 || i == -1) {
                        break;
                    }
                    buffer.flip();
                    outChannel.write(buffer);
                    buffer.clear();
                }
                fis.close();
                byte[] bytes = baos.toByteArray();
                clazz = defineClass(className, bytes, 0, bytes.length);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return clazz;
    }

    private String getClassFile(String packageName) {
        return fileName + packageName.replaceAll("\\.", File.separator) + ".class";
    }

}

/**
 * ｛這里添加描述｝
 *
 * @author chengyan
 * @date 2019-11-29 4:12 下午
 */
public class Demo05 {

    public static void main(String[] args) throws Exception {
        MyClassLoader myClassLoader = new MyClassLoader("/Users/chengyan/IdeaProjects/myproject/DataStructuresAndAlgorithms/out/production/DataStructuresAndAlgorithms/");
        Class clz = myClassLoader.loadClass("jvm.chapter10.Demo01");
        System.out.println(clz.getClassLoader().getClass().getName());

        System.out.println("=======class load tree===========");
        ClassLoader cl = clz.getClassLoader();
        while(cl != null) {
            System.out.println(cl.getClass().getName());
            cl = cl.getParent();
        }
    }

}

以上代碼通過自定義ClassLoader重載loadClass()方法，改變了默認(rèn)的委托雙親加載的方式，運(yùn)行結(jié)果如下：

java.io.FileNotFoundException: /Users/chengyan/IdeaProjects/myproject/DataStructuresAndAlgorithms/out/production/DataStructuresAndAlgorithms/java/lang/Object.class (No such file or directory)
	at java.io.FileInputStream.open0(Native Method)
	at java.io.FileInputStream.open(FileInputStream.java:195)
	at java.io.FileInputStream.<init>(FileInputStream.java:138)
	at java.io.FileInputStream.<init>(FileInputStream.java:93)
	at jvm.chapter10.MyClassLoader.findClass(Demo05.java:36)
	at jvm.chapter10.MyClassLoader.loadClass(Demo05.java:22)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:642)
	at jvm.chapter10.MyClassLoader.findClass(Demo05.java:52)
	at jvm.chapter10.MyClassLoader.loadClass(Demo05.java:22)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	at jvm.chapter10.Demo05.main(Demo05.java:76)
load class java.lang.Object failed, parent load start
jvm.chapter10.MyClassLoader
=======class load tree===========
jvm.chapter10.MyClassLoader
sun.misc.Launcher$AppClassLoader
sun.misc.Launcher$ExtClassLoader

可以看到，程序首先試圖由MyClassLoader加載Object類，但由于指定的路徑中沒有該類信息，故加載失敗，拋出異常，但隨后就由應(yīng)用類加載器加載成功。接著嘗試加載Demo01，Demo01在指定的路徑中，加載成功。打印加載Demo01的ClassLoader，顯示為MyClassLoader，打印ClassLoader層次，依次為MyClassLoader，AppClassLoader，ExtClassLoader.

關(guān)于java中的Class裝載系統(tǒng)ClassLoader是怎樣使用問題的解答就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，如果你還有很多疑惑沒有解開，可以關(guān)注億速云行業(yè)資訊頻道了解更多相關(guān)知識。