什么是Java動態類加載和重新加載

這篇文章將為大家詳細講解有關什么是Java動態類加載和重新加載，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。

Java中可以在運行時加載和重新加載類，雖然并不像我們想像中那么簡單。本文將解釋何時、怎樣在Java中加載、重新加載類。
你可以爭論動態加載類是Java反射的一部分還是Java核心的一部分。不管怎樣，我把它放在了Java反射中，因為沒有更好的地方放置它。

類加載器

Java程序的所有類都是使用 java.lang.ClassLoader的一些子類加載的。因此，動態加載類也必須使用 java.lang.ClassLoader的子類。
當一個類加載，它所引用的類也會被加載。類加載模式是遞歸加載的，直到所有需要的類加載完畢。這可能并不是應用程序的所有類。未被引用的類在引用前不會被加載。

類加載層級結構

類加載在Java中被組織成層級。當你創建一個獨立的ClassLoader，你必須提供一個父級ClassLoader。如果ClassLoader被請求加載一個類，它會請求它的父級ClassLoader去加載它。如果父級類加載器找不到這個類，子類加載器會嘗試自加載。

類加載

類加載器加載類的步驟如下：

1. 檢查該類是否已被加載

2. 如類未加載，請求父類加載器加載它

3. 如父類加載器不能加載該類，嘗試使用當前類加載器加載它

當你實現一個能夠重載類的類加載器時，你需要從這個序列中偏離一點。不應請求父類加載程序加載要重裝的類。稍后再談。

動態類加載

動態加載類非常簡單。所有你需要做的是獲得一個ClassLoader并調用它的loadClass()方法。示例如下：

public class MainClass {

  public static void main(String[] args){

    ClassLoader classLoader = MainClass.class.getClassLoader();

    try {
        Class aClass = classLoader.loadClass("com.jenkov.MyClass");
        System.out.println("aClass.getName() = " + aClass.getName());
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

}

動態類重新加載

動態類重新加載有一些挑戰。Java內建的類加載器在加載類之前總會檢查類是否已被加載。因此，使用Java的內置類加載器不可能重新加載類。重新加載一個類你必須實現自己的ClassLoader子類。
即使使用類加載器的自定義子類，也會遇到挑戰。所有已被加載的類都需要被鏈接。這個方法是final的，因此不能被你的ClassLoader子類重載。resolve()方法不允許ClassLoader實例鏈接一個類2次。因此，每當你需要重新加載類時，你必須重新創建一個ClassLoader類的實例。這不是不可能的，但必須知道何時設計類重新加載。

類重載代碼設計

如上文述，不能使用加載指定類的ClassLoader重新加載這個類。因此，必須使用不同的ClassLoader加載這個類。但是，這會帶來新的問題。
Java程序中加載的每一個類都以其全限定名（包名+類名）標識，并且由ClassLoader實例加載。這意味著，類MyObject由類加載器A加載，是和由類加載器B加載的同一個類MyObject不相同。模擬代碼如下：

MyObject object = (MyObject)
    myClassReloadingFactory.newInstance("com.jenkov.MyObject");

注意，類MyObject在代碼中是如何引用的，是作為object類型的變量。這導致MyObject類被已加載過這個類的駐留代碼的類加載器加載。
如果myClassReloadingFactory對象工廠使用與駐留代碼不同的類加載器加載MyObject，你不能強制轉換重新加載的Object類型的變量MyObject為MyObject類型。因為這兩個MyObject由不同的類加載器加載，他們被視為不同的類，盡管他們擁有相同的全限定名。嘗試強轉一個object的類為另一個類的引用將拋出ClassCastException。
有可能繞過這個限制，但是你必須用兩種方式來改變你的代碼：

1. 使用接口作為變量類型，并且只重新加載實現類

2. 使用超類作為變量類型，并且只重新加載子類

這里是示例代碼：

MyObjectInterface object = (MyObjectInterface)
    myClassReloadingFactory.newInstance("com.jenkov.MyObject");

MyObjectSuperclass object = (MyObjectSuperclass)
    myClassReloadingFactory.newInstance("com.jenkov.MyObject");

如果變量類型是接口或超類，上面的代碼都會正常運行，接口或超類在重新加載實現或子類時不會被重新加載。
為了上面代碼的正常運行，你當然需要實現自己的類加載器，讓接口或超類由其父類加載。當你的類加載器被請求加載MyObject時，它也會被請求加載MyObjectInterface接口或者MyObjectSuperclass類，因為它們被MyObject類在內部引用。你的類加載器必須把類加載委派給相同的類加載器，即加載了接口或超類的類加載器。

類加載器加載/重新加載示例

上文包含了很多內容。讓我們看一下簡單的示例。下面是一個簡單的ClassLoader子類。注意它如何將類加載委托給它的父類，除了它想要重裝的一個類之外。如果類加載被委派給了它的父類，它以后將不能被重新加載。記住，一個類只能被同一個ClassLoader實例加載。
如前所述，這只是一個示例，它顯示了類加載器的行為的基本知識。這并不是一個你的類加載器的生產就緒的模板。你的類加載器可能并不僅限于一個類，可能是一個你想要重新加載的類的集合。此外，你也不能硬編碼class path。

public class MyClassLoader extends ClassLoader{

    public MyClassLoader(ClassLoader parent) {
        super(parent);
    }

    public Class loadClass(String name) throws ClassNotFoundException {
        if(!"reflection.MyObject".equals(name))
                return super.loadClass(name);

        try {
            String url = "file:C:/data/projects/tutorials/web/WEB-INF/" +
                            "classes/reflection/MyObject.class";
            URL myUrl = new URL(url);
            URLConnection connection = myUrl.openConnection();
            InputStream input = connection.getInputStream();
            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            int data = input.read();

            while(data != -1){
                buffer.write(data);
                data = input.read();
            }

            input.close();

            byte[] classData = buffer.toByteArray();

            return defineClass("reflection.MyObject",
                    classData, 0, classData.length);

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

}

下面是使用MyClassLoader的示例：

public static void main(String[] args) throws
    ClassNotFoundException,
    IllegalAccessException,
    InstantiationException {

    ClassLoader parentClassLoader = MyClassLoader.class.getClassLoader();
    MyClassLoader classLoader = new MyClassLoader(parentClassLoader);
    Class myObjectClass = classLoader.loadClass("reflection.MyObject");

    AnInterface2       object1 =
            (AnInterface2) myObjectClass.newInstance();

    MyObjectSuperClass object2 =
            (MyObjectSuperClass) myObjectClass.newInstance();

    //create new class loader so classes can be reloaded.
    classLoader = new MyClassLoader(parentClassLoader);
    myObjectClass = classLoader.loadClass("reflection.MyObject");

    object1 = (AnInterface2)       myObjectClass.newInstance();
    object2 = (MyObjectSuperClass) myObjectClass.newInstance();

}

reflection.MyObject類是由自定義類加載器加載的。注意，它是如何繼承一個超類、實現一個接口的。這只是為了這個例子。在你的代碼中，只需要兩個中的一個，繼承超類或實現接口。

public class MyObject extends MyObjectSuperClass implements AnInterface2{
    //... body of class ... override superclass methods
    //    or implement interface methods
}

關于什么是Java動態類加載和重新加載就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。