JVM深入学习（三）类加载深入解析和命名空间

类的卸载

由用户自定义的类加载器所加载的类是可以被卸载的。

System.gc(); 强制调用gc做一次回收

类加载深入剖析

自定义类加载器

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 String path;

private final String fileExtension = ".class";

public void setPath(String path) {
    this.path = path;
}

//    public MyClassLoader(){
//        super();
//    }

public MyClassLoader(ClassLoader parent){
    super(parent);
}


public MyClassLoader(String classLoaderName) {
    super();//将系统类加载器当作该类加载器的父加载器
    this.classLoaderName = classLoaderName;
}

public MyClassLoader(ClassLoader parent, String classLoaderName) {
    super(parent); //显示指定该类加载器的父加载器 （可以自己自定义父加载器是谁）
    this.classLoaderName = classLoaderName;
}

@Override
public String toString() {
    return "[" + this.classLoaderName + "]";
}

//根据传入的name 寻找对应的Class
@Override
protected Class<?> findClass(String classname) throws ClassNotFoundException {
    System.out.println("class loader name: "+classname);
    byte[] data=this.loadClassData(classname);
    //调用该方法可以返回Class对象，很重要的方法
    return this.defineClass(classname,data,0,data.length);
}

// 传入class文件的名字 返回类的字节数组
private byte[] loadClassData(String name) {
    InputStream is = null;
    byte[] data = null;
    ByteArrayOutputStream baos = null;

    name=name.replace(".",File.separator);

    try {
      
        is = new FileInputStream(new File(this.path+name + this.fileExtension));
        baos = new ByteArrayOutputStream();
        int ch = 0;
        while (-1 != (ch = is.read())) {
            baos.write(ch);
        }
        data = baos.toByteArray();
    } catch (Exception ex) {
        ex.printStackTrace();
    } finally {
        try {
            is.close();
            baos.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    return data;
}

public static  void test(ClassLoader classLoader) throws Exception {
    Class<?> clazz=classLoader.loadClass("com.xuge.MyClassLoader");
    Object object=clazz.newInstance(); //返回实例化对象
    System.out.println(clazz.getClassLoader());
}
}

将MySample.class 和MyCat.class文件放入到桌面路径的com.xuge里，删除classpath的class文件

打印：

因为

MySample调用了new MyCat，加载MyCat 的类加载器为加载MySample的加载器。

2. 不删除classpath中 的MySample.class， 只删除MyCat.class。 运行：

分析 ：原因如上，在MySample中 new 的MyCat，由加载MySample的类加载器来加载，而此时加载MySamole的类加载器为系统类加载器AppClassLoader,能在classpath路径下找到MySample，找不到MyCat

3. 不删除classpath中 的MyCat.class，只删除MySample.class，保留指定路径下的class文件。运行如下：
   
   分析：委托给 AppclassLoader加载器加载MySample，继续委托给父类来回一次都无法加载成功MySample，所以返回由loader1加载MySample， 而MySample里引用 new MyCat(),所以加载MyCat的类加载器为加载MySample的类加载器loader1. 而loader1委托给父类加载器AppClassloader，来回一遍，而AppClassloader 能在classpath中找到MyCat并加载成功。

命名空间

父类加载器是看不到子类加载器加载的类的

类加载器的命名空间关系

改造代码MyCat，增加如下代码

在classpath路径下删除MySample.class，保留MyCat.class。在指定路径下保留全部class。运行结果如下:

分析： MySample是由自定义loader1加载器加载的，MyCat是由loader1的父类加载器AppClassLoader加载的，两个类在不同的类加载器中加载，属于不同的命名空间。而MyCat的构造方法中调用了MySample.class。 父类加载器是看不到子类加载器加载的类的；
反过来，子类加载器加载的对象是访问到由父类加载器加载的class对象 的。

自定义的类class文件可以放入根加载器的加载目录中去，不同jdk版本或操作系统的类加载器路径可能不一样

类加载器命名空间分析

运行：true

原因是loader’1委托系统类加载器加载成功MyPerson， 而loader2也同样委托同一个类加载器，发现MyPerson已经加载过了，不会再次加载，而是返回同一个calss对象‘’

改造

删除classpath 的MyPerson.class,放到指定路径

打印：

分析： object1和object是分别有两个不同的类加载器loader1和loader2加载的，它们不存在直接或间接父子关系，在不同命名空间，所以object1和object2是互不可见的