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);
    }
}

你可能感兴趣的:(09. 类加载器命名空间)