JVM類加載機制以及類緩存問題的處理

 

　　當一個java項目啟動的時候，JVM會找到main方法，根據對象之間的調用來對class文件和所引用的jar包中的class文件進行加載（其步驟分為加載、驗證、准備、解析、初始化、使用和卸載），方法區中開辟內存來存儲類的運行時數據結構（包括靜態變量、靜態方法、常量池、類結構等），同時在堆中生成相應的Class對象指向方法區中對應的類運行時數據結構。具體的類加載過程可以參考尚學堂高琪老師的視頻教程：http://www.bjsxt.com/2014/down_0425/34.html第218集。

　　用最簡單的一句話來概括，類加載的過程就是JVM根據所需的class文件的路徑，通過IO流的方式來讀取class字節碼文件，並通過一系列解析初始化等步驟來注入到內存。 java中的類加載器有：BootstrapClassLoader（最上層）、ExtClassLoader、AppClassLoader、以及用戶自定義的ClassLoader（最下層）。JVM對於不同種類的jar包（或class文件），會有不同種類的類加載器進行加載。對應關系如下：　　

BootstrapClassLoader  用於加載JVM運行所需要的類：

　　　　JAVA_HOME/jre/lib/resources.jar:

　　　　JAVA_HOME/jre/lib/rt.jar:

　　　　JAVA_HOME/jre/lib/sunrsasign.jar:

　　　　JAVA_HOME/jre/lib/jsse.jar:

　　　　JAVA_HOME/jre/lib/jce.jar:

　　　　JAVA_HOME/jre/lib/charsets.jar:

　　　　JAVA_HOME/jre/lib/jfr.jar:

　　　　JAVA_HOME/jre/classes

　

　　ExtClassLoader 用於加載擴展類：　　

　　　　../Java/Extensions:

　　　　../JAVA_HOME/jre/lib/ext:

　　　　../Library/Java/Extensions:/Network/Library/Java/Extensions:

　　　　../System/Library/Java/Extensions:

　　　　../lib/java

　　

　　AppClassLoader 用於加載我們項目中ClassPath下所創建的類和jar包中引用的類。

　　整個類加載，是通過一種叫做雙親委派的機制來進行加載。

　　舉例來說，一個類被最下層的加載器（用戶自定義ClassLoader）進行加載，此加載器首先會調用上一層的加載器（AppClassLoader）進行加載，而AppClassLoader會繼續轉交給上層（ExtClassLoader）的加載器進行加載，直到BootstrapClassLoader。  如果BootstrapClassLoader所加載的類路徑找不到此類，那么才會交給下一層的加載器（ExtClassLoader）進行加載，如果找不到此類，繼續交給下一層（AppClassLoader）進行加載。以此類推，如果用戶自定義的ClassLoader也找不到此類，那么程序就會拋出一個ClassNotFoundError。整個加載過程圖示如下：

（圖片引用自：https://www.cnblogs.com/xing901022/p/4574961.html）

　　類加載源的源碼跟蹤如下（在此對源碼進行了適當的簡化），讀者可以點入源碼進行查看：

package java.lang.ClassLoader;

import ....

 protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First，在虛擬機內存中查找是否已經加載過此類...類緩存的主要問題所在！！！ 
            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) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
　　　　　　　　　　　　//調用此類加載器所實現的findClass方法進行加載
                    c = findClass(name);
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

　　在源碼中可以完全領略到雙親委派機制的過程，其中最重要的三句代碼已經進行了標注：

　　　　findLoadedClass（在虛擬機內存中查找是否已經加載過此類...類緩存的主要問題所在！！！）

　　　　parent.loadClass（先讓上一層加載器進行加載）

　　　　findClass（調用此類加載器所實現的findClass方法進行加載）


　　如果用戶需要自定義加載器，加載自己指定路徑的class文件，需要繼承ClassLoader，並實現findClass(String name)方法。舉例如下：

package com.jiefupay.utils;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class ServiceClassLoader extends ClassLoader{

    private String classPath;
    
    public ServiceClassLoader(String classPath) {
        this.classPath = classPath;
    }
    
    /**
     * 重寫父類的findClass 方法。  父類的loadClass會調用此方法
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
   
        Class<?> c = null;
        
        byte[] classData = getClassData(name);
        
        if (classData!=null) {
            c = defineClass(name, classData, 0, classData.length);
        }else {
            throw new ClassNotFoundException();
        }
        
        return c;
    }
　　
　　
　　 // 將class文件通過IO流讀取，轉化為字節數組 private byte[] getClassData(String name) {
        
        String path = classPath + "/"+ name.replace('.', '/') + ".class";
        
        InputStream iStream = null;
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        try {
            iStream = new FileInputStream(path);
            
            byte[] buffer = new byte[1024];
            int temp = 0;
            while ((temp = iStream.read(buffer))!=-1) {
                byteArrayOutputStream.write(buffer, 0, temp);
            }
            if (byteArrayOutputStream!=null) {
                return byteArrayOutputStream.toByteArray();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (iStream!=null) {
                    iStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (byteArrayOutputStream!=null) {
                    byteArrayOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

　　對類加載器的使用代碼如下：

ServiceClassLoader serviceClassLoader = new ServiceClassLoader("c:\myclass");
Czlass<?> c = ServiceClassLoader.loadClass("com.jiefupay.service.Myclass");

　　如果用同一個ServiceClassLoader對象去加載同一個Class文件多次，每次加載后的Class對象為同一個！ 然而如果new不同的自定義ClassLoader去加載同一個Class文件，則每次會返回不同的Class對象。

　　注意：不能將所要加載的Class文件放到classpath目錄及其任何子目錄下，否則會被AppClassLoader優先加載（這是由於類加載采用雙親委派機制，同時AppClassLoader可以加載所有在classpath下的class文件），每次都是同一個AppClassLoader進行加載，因此會出現類緩存問題。

　　這樣就解決了通常在JVM類加載時，直接使用反射出現的類緩存的問題。