什麼是ClassLoader

ClassLoader 做什麼的？

class Class<T> {
  ...
  private final ClassLoader classLoader;
  ...
}

延遲載入

各司其職

JVM 運行實例中會存在多個 ClassLoader，不同的 ClassLoader 會從不同的地方載入位元組碼文件。它可以從不同的文件目錄載入，也可以從不同的 jar 文件中載入，也可以從網路上不同的靜態文件伺服器來下載位元組碼再載入。

JVM 中內置了三個重要的 ClassLoader，分別是 BootstrapClassLoader、ExtensionClassLoader 和 AppClassLoader。

ClassLoader 傳遞性

雙親委派

class ClassLoader {
  ...
  private final ClassLoader parent;
  ...
}

Class.forName

當我們在使用 jdbc 驅動時，經常會使用 Class.forName 方法來動態載入驅動類。

Class.forName("com.mysql.cj.jdbc.Driver");

其原理是 mysql 驅動的 Driver 類里有一個靜態代碼塊，它會在 Driver 類被載入的時候執行。這個靜態代碼塊會將 mysql 驅動實例註冊到全局的 jdbc 驅動管理器里。

class Driver {
  static {
    try {
       java.sql.DriverManager.registerDriver(new Driver());
    } catch (SQLException E) {
       throw new RuntimeException("Can't register driver!");
    }
  }
  ...
}

forName 方法同樣也是使用調用者 Class 對象的 ClassLoader 來載入目標類。不過 forName 還提供了多參數版本，可以指定使用哪個 ClassLoader 來載入

Class<?> forName(String name, boolean initialize, ClassLoader cl)

通過這種形式的 forName 方法可以突破內置載入器的限制，通過使用自定類載入器允許我們自由載入其它任意來源的類庫。根據 ClassLoader 的傳遞性，目標類庫傳遞引用到的其它類庫也將會使用自定義載入器載入。

自定義載入器

ClassLoader 裡面有三個重要的方法 loadClass()、findClass() 和 defineClass()。

class ClassLoader {

  // 載入入口，定義了雙親委派規則
  Class loadClass(String name) {
    // 是否已經載入了
    Class t = this.findFromLoaded(name);
    if(t == null) {
      // 交給雙親
      t = this.parent.loadClass(name)
    }
    if(t == null) {
      // 雙親都不行，只能靠自己了
      t = this.findClass(name);
    }
    return t;
  }
  
  // 交給子類自己去實現
  Class findClass(String name) {
    throw ClassNotFoundException();
  }
  
  // 組裝Class對象
  Class defineClass(byte[] code, String name) {
    return buildClassFromCode(code, name);
  }
}

class CustomClassLoader extends ClassLoader {

  Class findClass(String name) {
    // 尋找位元組碼
    byte[] code = findCodeFromSomewhere(name);
    // 組裝Class對象
    return this.defineClass(code, name);
  }
}

// ClassLoader 構造器
protected ClassLoader(String name, ClassLoader parent);

雙親委派規則可能會變成三親委派，四親委派，取決於你使用的父載入器是誰，它會一直遞歸委派到根載入器。

Class.forName vs ClassLoader.loadClass

這兩個方法都可以用來載入目標類，它們之間有一個小小的區別，那就是 Class.forName() 方法可以獲取原生類型的 Class，而 ClassLoader.loadClass() 則會報錯。

Class<?> x = Class.forName("[I");
System.out.println(x);

x = ClassLoader.getSystemClassLoader().loadClass("[I");
System.out.println(x);

---------------------
class [I

Exception in thread "main" java.lang.ClassNotFoundException: [I
...

鑽石依賴

項目管理上有一個著名的概念叫著「鑽石依賴」，是指軟體依賴導致同一個軟體包的兩個版本需要共存而不能衝突。

我們平時使用的 maven 是這樣解決鑽石依賴的，它會從多個衝突的版本中選擇一個來使用，如果不同的版本之間相容性很糟糕，那麼程式將無法正常編譯運行。Maven 這種形式叫「扁平化」依賴管理。

$ cat ~/source/jcl/v1/Dep.java
public class Dep {
	public void print() {
		System.out.println("v1");
	}
}

$ cat ~/source/jcl/v2/Dep.java
public class Dep {
 public void print() {
  System.out.println("v1");
 }
}

$ cat ~/source/jcl/Test.java
public class Test {
	public static void main(String[] args) throws Exception {
		String v1dir = "file:///Users/qianwp/source/jcl/v1/";
		String v2dir = "file:///Users/qianwp/source/jcl/v2/";
		URLClassLoader v1 = new URLClassLoader(new URL[]{new URL(v1dir)});
		URLClassLoader v2 = new URLClassLoader(new URL[]{new URL(v2dir)});
		
  Class<?> depv1Class = v1.loadClass("Dep");
		Object depv1 = depv1Class.getConstructor().newInstance();
		depv1Class.getMethod("print").invoke(depv1);

		Class<?> depv2Class = v2.loadClass("Dep");
		Object depv2 = depv2Class.getConstructor().newInstance();
		depv2Class.getMethod("print").invoke(depv2);
	 
  System.out.println(depv1Class.equals(depv2Class));
 }
}

在運行之前，我們需要對依賴的類庫進行編譯

$ cd ~/source/jcl/v1
$ javac Dep.java
$ cd ~/source/jcl/v2
$ javac Dep.java
$ cd ~/source/jcl
$ javac Test.java
$ java Test
v1
v2
false

在這個例子中如果兩個 URLClassLoader 指向的路徑是一樣的，下麵這個表達式還是 false，因為即使是同樣的位元組碼用不同的 ClassLoader 載入出來的類都不能算同一個類

depv1Class.equals(depv2Class)

我們還可以讓兩個不同版本的 Dep 類實現同一個介面，這樣可以避免使用反射的方式來調用 Dep 類裡面的方法。

Class<?> depv1Class = v1.loadClass("Dep");
IPrint depv1 = (IPrint)depv1Class.getConstructor().newInstance();
depv1.print()

分工與合作

這裡我們重新理解一下 ClassLoader 的意義，它相當於類的命名空間，起到了類隔離的作用。位於同一個 ClassLoader 裡面的類名是唯一的，不同的 ClassLoader 可以持有同名的類。ClassLoader 是類名稱的容器，是類的沙箱。

Thread.contextClassLoader

class Thread {
  ...
  private ClassLoader contextClassLoader;
  
  public ClassLoader getContextClassLoader() {
    return contextClassLoader;
  }
  
  public void setContextClassLoader(ClassLoader cl) {
    this.contextClassLoader = cl;
  }
  ...
}

contextClassLoader「線程上下文類載入器」，這究竟是什麼東西？

Thread.currentThread().getContextClassLoader().loadClass(name);

這意味著如果你使用 forName(string name) 方法載入目標類，它不會自動使用 contextClassLoader。那些因為代碼上的依賴關係而懶惰載入的類也不會自動使用 contextClassLoader來載入。