命名空間
每個類加載器都有自己的命名空間，命名空間由該加載器及所有父加載器所加載的類組成
在同一個命名空間中，不會出現(xiàn)類的完整名字(包括類的包名)相同的兩個類
在不同的命名空間中，有可能會出現(xiàn)類的完整名字(包括類的包名)相同的兩個類
關(guān)于命名空間，看幾個例子
首先分別定義MyCat、MySample、MyClassLoader類
package com.zj.study.jvm.classloader;
public class MyCat {
public MyCat() {
System.out.println("MyCat is loaded by: " + this.getClass().getClassLoader());
}
}
package com.zj.study.jvm.classloader;
public class MySample {
public MySample() {
System.out.println("MySample is loaded by: " + this.getClass().getClassLoader());
// 會由加載MySample的類加載器嘗試加載MyCat
new MyCat();
}
}
package com.zj.study.jvm.classloader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class MyClassLoader extends ClassLoader{
private String classLoaderName;
private final String fileExtension = ".class";
private String path;
public void setPath(String path) {
this.path = path;
}
public MyClassLoader(String classLoaderName) {
super();
this.classLoaderName = classLoaderName;
}
public MyClassLoader(ClassLoader classLoader, String classLoaderName) {
super(classLoader);
this.classLoaderName = classLoaderName;
}
@Override
protected Class<?> findClass(String className) throws ClassNotFoundException {
// 這兩個信息輸出 說明findClass()方法被調(diào)用
System.out.println("findClass invoked: " + className);
System.out.println("class loader name: " + this.classLoaderName);
byte[] data = this.loadClassData(className);
return this.defineClass(className, data, 0, data.length);
}
private byte[] loadClassData(String className) {
InputStream is = null;
byte[] data = null;
ByteArrayOutputStream baos = null;
// windows 系統(tǒng) 替換成\\
className = className.replace(".", "/");
try {
is = new FileInputStream(new File( this.path + className + this.fileExtension));
baos = new ByteArrayOutputStream();
int ch = 0;
while (-1 != (ch = is.read())){
baos.write(ch);
}
data = baos.toByteArray();
}catch (Exception e) {
e.printStackTrace();
}finally {
try {
is.close();
baos.close();
}catch (Exception e) {
e.printStackTrace();
}
}
return data;
}
@Override
public String toString() {
return "[" + this.classLoaderName + "]";
}
}
上述代碼很簡單，MyClassLoader是自定義的一個類加載器，在MySample的構(gòu)造方法中new了一個MyCat的實例
接著看測試代碼
public class MyTest17 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
MyClassLoader myClassLoader = new MyClassLoader("myClassLoader");
myClassLoader.setPath("/Users/zj/Desktop/");
Class<?> clazz = myClassLoader.loadClass("com.zj.study.jvm.classloader.MySample");
System.out.println("clazz:" + clazz.hashCode());
// 如果注釋掉該行，那么并不會實例化MySample對象，即MySample構(gòu)造方法不會被調(diào)用，因此不會實例化MyCat對象，即沒有對MyCat進(jìn)行主動使用
Object object = clazz.newInstance();
}
}
這里將classpath路徑下的class文件復(fù)制到/Users/zj/Desktop/這個目錄，然后刪除classpath路徑下的MyCat.class文件，運(yùn)行上述測試代碼會拋ClassNotFoundException異常，這是因為
在MySample的構(gòu)造方法中，實例化了一個MyCat對象，需要加載、連接并初始化MyCat，此時會由加載MySample的類加載器嘗試加載MyCat
顯而易見，MySample是由系統(tǒng)類加載器加載的，而系統(tǒng)類加載器加載不了MyCat.class，因為刪除了，所以會拋ClassNotFoundException異常
然后同樣的代碼，重新build一下項目，將classpath路徑下的class文件復(fù)制到/Users/zj/Desktop/這個目錄，然后刪除classpath路徑下的MySample.class文件，運(yùn)行上述測試代碼，不會拋異常，這是因為
MySample是有自定義類加載器myClassLoader加載的，myClassLoader會委托系統(tǒng)類加載器加載MyCat，是可以加載到的。
接下來修改MyCat.java
public class MyCat {
public MyCat() {
System.out.println("MyCat is loaded by: " + this.getClass().getClassLoader());
System.out.println("from MyCat:" + MySample.class);
}
}
同樣的測試代碼，重新build一下項目，將classpath路徑下的class文件復(fù)制到/Users/zj/Desktop/這個目錄，然后刪除classpath路徑下的MySample.class文件，運(yùn)行上述測試代碼會拋ClassNotFoundException異常，這是因為
對于類加載器命名空間，有如下重要說明
- 子加載器所加載的類能夠訪問到父加載器所加載的類
- 父加載器所加載的類無法訪問到子加載器所加載的類
MySample類是由自定義類加載器myClassLoader加載的，而MyCat是由系統(tǒng)類加載器加載的，在MyCat的構(gòu)造函數(shù)中，找MySample.class 是找不到的，因為系統(tǒng)類加載器是myClassLoader的父加載器，父加載器所加載的類無法訪問到子加載器所加載的類
接下來再次修改MySample.java和MyCat.java
package com.zj.study.jvm.classloader;
public class MySample {
public MySample() {
System.out.println("MySample is loaded by: " + this.getClass().getClassLoader());
// 會由加載MySample的類加載器嘗試加載MyCat
new MyCat();
System.out.println("from MySample: " + MyCat.class);
}
}
package com.zj.study.jvm.classloader;
public class MyCat {
public MyCat() {
System.out.println("MyCat is loaded by: " + this.getClass().getClassLoader());
}
}
同樣的測試代碼，重新build一下項目，將classpath路徑下的代碼復(fù)制到/Users/zj/Desktop/這個目錄，然后刪除classpath路徑下的MySample.class文件，運(yùn)行上述測試代碼不會拋ClassNotFoundException異常，這是因為
MySample類是由自定義類加載器myClassLoader加載的，而MyCat是由系統(tǒng)類加載器加載的，在MySample的構(gòu)造函數(shù)中，找MyCat.class 是找的到的，因為myClassLoader是系統(tǒng)類加載器的子加載器，子加載器所加載的類能夠訪問到父加載器所加載的類
不同類加載器的命名空間關(guān)系
同一個命名空間的類是相互可見的
子加載器的命名空間包含所有父加載器的命名空間。因此由子加載器加載的類能看見父加載器加載的類。例如系統(tǒng)類加載器加載的類能看見根類加載器加載的類。
由父加載器加載的類不能看見子加載器加載的類
如果兩個加載器之間沒有直接或間接的父子關(guān)系，那么它們各自加載的類相互不可見
試驗1
public class MyTest20 {
// myClassLoader1、myClassLoader2是兩個MyClassLoader對象
// myClassLoader1、myClassLoader2調(diào)用loadClass分別加載相同的binary name
// 通過反射創(chuàng)建兩個實例
// 通過反射的方式 調(diào)用setMyPerson()方法
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
MyClassLoader myClassLoader1 = new MyClassLoader("loader1");
MyClassLoader myClassLoader2 = new MyClassLoader("loader2");
Class<?> clazz1 = myClassLoader1.loadClass("com.zj.study.jvm.classloader.MyPerson");
Class<?> clazz2 = myClassLoader2.loadClass("com.zj.study.jvm.classloader.MyPerson");
// 結(jié)果為true
System.out.println(clazz1 == clazz2);
Object object1 = clazz1.newInstance();
Object object2 = clazz2.newInstance();
Method method = clazz1.getMethod("setMyPerson", Object.class);
// 在object1上調(diào)用method方法，參數(shù)是object2
method.invoke(object1, object2);
}
}
試驗2
把MyPerson.class復(fù)制到桌面,刪除classpath路徑下MyPerson.class文件
public class MyTest21 {
// myClassLoader1、myClassLoader2是兩個MyClassLoader對象
// myClassLoader1、myClassLoader2調(diào)用loadClass分別加載相同的binary name
// 通過反射創(chuàng)建兩個實例
// 通過反射的方式 調(diào)用setMyPerson()方法
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
MyClassLoader myClassLoader1 = new MyClassLoader("loader1");
MyClassLoader myClassLoader2 = new MyClassLoader("loader2");
myClassLoader1.setPath("/Users/zj/Desktop/");
myClassLoader2.setPath("/Users/zj/Desktop/");
Class<?> clazz1 = myClassLoader1.loadClass("com.zj.study.jvm.classloader.MyPerson");
Class<?> clazz2 = myClassLoader2.loadClass("com.zj.study.jvm.classloader.MyPerson");
// 結(jié)果為false
System.out.println(clazz1 == clazz2);
Object object1 = clazz1.newInstance();
Object object2 = clazz2.newInstance();
// clazz1 和 clazz2 不可見， 由此生成的對象 object1 和 object2 不可見
Method method = clazz1.getMethod("setMyPerson", Object.class);
// 在object1上調(diào)用method方法，參數(shù)是object2
method.invoke(object1, object2);
}
}
