09. 类加载器命名空间
命名空间
每个类加载器都有自己的命名空间，命名空间由该加载器及所有父加载器所加载的类组成
在同一个命名空间中，不会出现类的完整名字(包括类的包名)相同的两个类
在不同的命名空间中，有可能会出现类的完整名字(包括类的包名)相同的两个类
关于命名空间，看几个例子
首先分别定义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()方法被调用
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 系统 替换成\\
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的构造方法中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构造方法不会被调用，因此不会实例化MyCat对象，即没有对MyCat进行主动使用
Object object = clazz.newInstance();
}
}
这里将classpath路径下的class文件复制到/Users/zj/Desktop/这个目录，然后删除classpath路径下的MyCat.class文件，运行上述测试代码会抛ClassNotFoundException异常，这是因为
在MySample的构造方法中，实例化了一个MyCat对象，需要加载、连接并初始化MyCat，此时会由加载MySample的类加载器尝试加载MyCat
显而易见，MySample是由系统类加载器加载的，而系统类加载器加载不了MyCat.class，因为删除了，所以会抛ClassNotFoundException异常
然后同样的代码，重新build一下项目，将classpath路径下的class文件复制到/Users/zj/Desktop/这个目录，然后删除classpath路径下的MySample.class文件，运行上述测试代码，不会抛异常，这是因为
MySample是有自定义类加载器myClassLoader加载的，myClassLoader会委托系统类加载器加载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文件复制到/Users/zj/Desktop/这个目录，然后删除classpath路径下的MySample.class文件，运行上述测试代码会抛ClassNotFoundException异常，这是因为
对于类加载器命名空间，有如下重要说明
- 子加载器所加载的类能够访问到父加载器所加载的类
- 父加载器所加载的类无法访问到子加载器所加载的类
MySample类是由自定义类加载器myClassLoader加载的，而MyCat是由系统类加载器加载的，在MyCat的构造函数中，找MySample.class 是找不到的，因为系统类加载器是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路径下的代码复制到/Users/zj/Desktop/这个目录，然后删除classpath路径下的MySample.class文件，运行上述测试代码不会抛ClassNotFoundException异常，这是因为
MySample类是由自定义类加载器myClassLoader加载的，而MyCat是由系统类加载器加载的，在MySample的构造函数中，找MyCat.class 是找的到的，因为myClassLoader是系统类加载器的子加载器，子加载器所加载的类能够访问到父加载器所加载的类
不同类加载器的命名空间关系
同一个命名空间的类是相互可见的
子加载器的命名空间包含所有父加载器的命名空间。因此由子加载器加载的类能看见父加载器加载的类。例如系统类加载器加载的类能看见根类加载器加载的类。
由父加载器加载的类不能看见子加载器加载的类
如果两个加载器之间没有直接或间接的父子关系，那么它们各自加载的类相互不可见
试验1
public class MyTest20 {
// myClassLoader1、myClassLoader2是两个MyClassLoader对象
// myClassLoader1、myClassLoader2调用loadClass分别加载相同的binary name
// 通过反射创建两个实例
// 通过反射的方式 调用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");
// 结果为true
System.out.println(clazz1 == clazz2);
Object object1 = clazz1.newInstance();
Object object2 = clazz2.newInstance();
Method method = clazz1.getMethod("setMyPerson", Object.class);
// 在object1上调用method方法，参数是object2
method.invoke(object1, object2);
}
}
试验2
把MyPerson.class复制到桌面,删除classpath路径下MyPerson.class文件
public class MyTest21 {
// myClassLoader1、myClassLoader2是两个MyClassLoader对象
// myClassLoader1、myClassLoader2调用loadClass分别加载相同的binary name
// 通过反射创建两个实例
// 通过反射的方式 调用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");
// 结果为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上调用method方法，参数是object2
method.invoke(object1, object2);
}
}
