跟着大佬们的文章学习，这次再深入学习一下类加载器

一、简介：

一切的Java类都必须经过JVM加载后才能运行，而类加载器（ClassLoader）的主要作用就是Java类文件的加载。ClassLoader负责动态加载Java类到Java虚拟机的内存空间中，用于加载系统、网络或者其他来源的类文件

系统程序不会一开始就加载所有的Class文件到内存中，当需要用到时才会动态地加载所需Class文件到内存中。

程序经过javac.exe命令以后，会生成一个或多个字节码文件（.class结尾）。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。

二、类文件的编译过程

将一个java后缀的文件编译成一个class文件（字节码文件），接着需要经过一系列的类的生命周期（加载、连接（验证–>准备–>解析）和初始化操作，最后就是我们的java虚拟机内存使用自身方法区中字节码二进制数据去引用堆区的Class对象。

三、类加载器

类加载器大致分为JVM自带的类加载器与用户自定义的类加载器
JVM自带的类加载器包含：

1. 引导类加载器（bootstrap class loader）：
2. 扩展类加载器（extensions class loader）：
3. 系统类加载器（system class loader）：

用户自定义的类加载器：
开发人员可以通过继承 java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求

此外，引导类加载器并不继承ClassLoader类，其余的扩展类加载器、系统类加载器、用户自定义的类加载器都继承自ClassLoader类

引导类加载器(BootstrapClassLoader)

加载的是JVM自身需要的类，这个类加载使用C++语言实现的，是虚拟机自身的一部分。它用来加载 Java 的核心库，并不继承自 java.lang.ClassLoader。出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类

我们在尝试获取被Bootstrap ClassLoader类加载器所加载的类的ClassLoader时候都会返回null。

<JAVA_HOME>/jre/lib/rt.jar目录下的都是Java核心库，这些会在加载JVM时一并加载，也就是说这些类不需要我们自己导入，即可直接使用

扩展类加载器(ExtensionsClassLoader)

扩展类加载器是指Sun公司实现的sun.misc.Launcher$ExtClassLoader类，是Launcher的静态内部类，它负责加载<JAVA_HOME>/lib/ext目录下用来加载 Java 的扩展库。

应用类加载器/系统类加载器（AppClassLoader）

指 Sun公司实现的sun.misc.Launcher$AppClassLoader。一般通过(java.class.path或者Classpath环境变量)来加载Java类，也就是我们常说的 classpath路径。通常我们是使用这个加载类来加载Java应用类，可以使用ClassLoader.getSystemClassLoader()来获取它。

自定义类加载器(UserDefineClassLoader)

通过继承java.lang.ClassLoader类的方式实现自己的类加载器

四、双亲委派机制

双亲委派模式是在Java 1.2后引入的，其工作原理的是，如果一个类加载器收到了类加载请求， 它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载， 这就是双亲委派模式，

五、双亲委派机制的好处

1、避免类的重复加载。Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关可以避免类的重复加载，当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次。
2、其次是考虑到安全因素。java核心api中定义类型不会被随意替换，假设通过网络传递一个名为java.lang.Integer的类，通过双亲委托模式传递到启动类加载器，而启动类加载器在核心Java API发现这个名字的类，发现该类已被加载，并不会重新加载网络传递的过来的java.lang.Integer，而直接返回已加载过的Integer.class，这样便可以防止核心API库被随意篡改。可能你会想，如果我们在classpath路径下自定义一个名为java.lang.SingleInterge类(该类是胡编的)呢？该类并不存在java.lang中，经过双亲委托模式，传递到启动类加载器中，由于父类加载器路径下并没有该类，所以不会加载，将反向委托给子类加载器加载，最终会通过系统类加载器加载该类。但是这样做是不允许，因为java.lang是核心API包，需要访问权限，强制加载将会报出如下异常

java.lang.SecurityException: Prohibited package name: java.lang

六、CLassLoader类核心方法

6.1：loadClass(String)——加载指定的Java类

1、执行findLoadedClass(String)先从缓存中查找是否已经加载过该class对象，如JVM已初始化该类则返回类对象
2、执行parent.loadClass()来调用父加载器的方法。如果父加载器为null，则委托给启动加载器(Bootstrap ClassLoader)去加载。这也解释了ExtClassLoader.getParent() 虽然返回null值，但仍然说Bootstrap ClassLoader是它的父加载器
3、如果向上委托父加载器都没有加载成功，则通过自定义实现的findClass(String)去查找并加载
4、如果当前的ClassLoader没有重写了findClass方法，那么直接返回类加载失败异常。如果当前类重写了findClass方法并通过传入的类名找到了对应的类字节码，那么应该调用defineClass方法去JVM中注册该类。
5、resolve参数代表是否生成class对象的同时进行解析相关操作。如果resolve的布尔值是true，那么在最后还会调用resolveClass进行解析操作

protected Class<?> loadClass(String name, boolean resolve)
      throws ClassNotFoundException
  {
    
      synchronized (getClassLoadingLock(name)) {
    
          // 先从缓存查找该class对象，找到就不用重新加载
          Class<?> c = findLoadedClass(name);
          if (c == null) {
    
              long t0 = System.nanoTime();
              try {
    
                  if (parent != null) {
    
                      //如果找不到，则委托给父类加载器去加载
                      c = parent.loadClass(name, false);
                  } else {
    
                  //如果没有父类，则委托给启动加载器去加载
                      c = findBootstrapClassOrNull(name);
                  }
              } catch (ClassNotFoundException e) {
    
                  // ClassNotFoundException thrown if class not found
                  // from the non-null parent class loader
              }

              if (c == null) {
    
                  // If still not found, then invoke findClass in order
                  // 如果都没有找到，则通过自定义实现的findClass去查找并加载
                  c = findClass(name);

                  // this is the defining class loader; record the stats
                  sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                  sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                  sun.misc.PerfCounter.getFindClasses().increment();
              }
          }
          if (resolve) {
    //是否需要在加载时进行解析
              resolveClass(c);
          }
          return c;
      }
  }

6.2：findClass(String)——查找指定的Java类

在JDK1.2之后，建议把自定义的类加载逻辑写在findClass()方法中，这样就可以保证自定义的类加载器也符合双亲委托模式。需要注意的是ClassLoader类中并没有实现findClass()方法的具体代码逻辑，取而代之的是抛出ClassNotFoundException异常，同时应该知道的是findClass方法通常是和defineClass()方法一起使用的

//直接抛出异常
protected Class<?> findClass(String name) throws ClassNotFoundException {
    
        throw new ClassNotFoundException(name);
}

6.3：defineClass(byte[] b, int off, int len)——将byte字节流解析成JVM能够识别的Class对象

defineClass()方法是用来将 byte字节流解析成JVM能够识别的Class对象。通过这个方法不仅能够通过class文件实例化class对象，也可以通过其他方式实例化class对象，如通过网络接收一个类的字节码，然后转换为byte字节流创建对应的Class对象

例子：

protected Class<?> findClass(String name) throws ClassNotFoundException {
    
	  // 通过getClassData()获取类的字节数组
      byte[] classData = getClassData(name);  
      if (classData == null) {
    
          throw new ClassNotFoundException();
      } else {
    
	      //使用defineClass()生成class对象
          return defineClass(name, classData, 0, classData.length);
      }
  }

6.4：resolveClass(Class<?> c)——链接指定的Java类

使用该方法可以使用类的Class对象创建完成也同时被解析。前面我们说链接阶段主要是对字节码进行验证，为类变量分配内存并设置初始值同时将字节码文件中的符号引用转换为直接引用。

6.5：findLoadedClass(String)——查找JVM已经加载过的类

检测某个类是不是已经加载过了，加载过则返回Class对象，未加载则返回null

protected final Class<?> findLoadedClass(String name) {
    
        if (!checkName(name))
            return null;
        return findLoadedClass0(name);
}

七、自定义类加载器

自定义的类加载器：
1、编写一个类继承自ClassLoader抽象类
2、复写findClass()方法
3、在findClass()方法中调用defineClass()返回实例对象

案例：

package MyClassLoader;

public class HelloWorld {
    
    @Override
    public String toString() {
    
        return "Hello World";
    }
}

package MyClassLoader;

import java.io.*;

public class MyFileClassLoader extends ClassLoader{
    
    private String directory;   //被加载类所在的目录
    public MyFileClassLoader(){
    

    }
    public MyFileClassLoader(String directory){
    
        this.directory = directory;
    }


    protected Class<?> findClass(String name)throws ClassNotFoundException {
    
        byte[] classData = getClassData(name);
        if(classData == null){
    
            throw new ClassNotFoundException();
        }else {
    
            return defineClass(name,classData,0,classData.length);
        }
    }

    /**
     * 编写获取class文件并转换位字节码流的逻辑
     * @param className
     * @return
     */
    private byte[] getClassData(String className){
    
        //读取类文件的字节
        String path = classNameToPath(className);
        try{
    
            InputStream ins = new FileInputStream(path);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int bufferSize = 4096;
            byte[] buffer = new byte[bufferSize];
            int bytesNumRead = 0;
            //读取类文件的字节码
            while ((bytesNumRead = ins.read(buffer)) != -1){
    
                baos.write(buffer,0,bytesNumRead);
            }
            return baos.toByteArray();
        } catch (IOException e ){
    
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 类文件的完全路径
     * @param className
     * @return
     */
    private String classNameToPath(String className){
    
        return directory + File.separatorChar + className.replace('.',File.separatorChar) + ".class";
    }

	//创建main方法
    public static void main(String[] args) throws Exception{
    
        String directory = "E:/IDEA2020/app/src/";
        //创建自定义文件类加载器MyFileClassLoader
        MyFileClassLoader loader = new MyFileClassLoader(directory);
        try{
    
            //加载指定的class文件
            Class<?> object1 = loader.loadClass("MyClassLoader.HelloWorld");
            System.out.println(object1.newInstance().toString());   //输出结果:Hello World

        }catch (Exception e){
    
            e.printStackTrace();
        }
    }
}

八、URLClassLoader

8.1：本地class文件调用

编辑一份TestEval.java，javac TestEval.java编译得到.class文件

package MyClassLoader;

import java.io.IOException;

public class TestEval {
    
    public TestEval(){
    
        try {
    
            Runtime.getRuntime().exec("calc");	//编辑命令
        } catch (IOException e) {
    
            e.printStackTrace();
        }
    }
}

编辑URLClassLoaderTest.java，其中修改要加载的class文件位置

package MyClassLoader;

import java.io.File;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;


public class URLClassLoaderTest {
    
    public static void main(String[] args) throws Exception {
    
        File file = new File("E:\\IDEA2020\\app\\src\\");
        URI uri = file.toURI();
        URL url = uri.toURL();

        URLClassLoader classLoader = new URLClassLoader(new URL[]{
    url});
        Class clazz = classLoader.loadClass("MyClassLoader.TestEval");	//要加载的class文件
        clazz.newInstance();
        }
}

8.2：网络传输class文件调用

在VPS上编辑一个javaeval.java文件：

import java.io.IOException;

public class javaeval {
    

    public static Process exec(String cmd) throws IOException {
    
        return Runtime.getRuntime().exec(cmd);
    }
}
r

//编译
javac javaeval.java		
//打包javaeval.class为javaeval.jar 
jar cvf javaeval.jar javaeval.class	

本地编辑一个TestURLClassLoader .java：

package MyClassLoader;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.URL;
import java.net.URLClassLoader;

public class TestURLClassLoader {
    

    public static void main(String[] args) {
    
        try {
    
            // 定义远程加载的jar路径
            URL url = new URL("http://119.29.60.71/javaeval.jar");

            // 创建URLClassLoader对象，并加载远程jar包
            URLClassLoader ucl = new URLClassLoader(new URL[]{
    url});

            // 定义需要执行的系统命令
            String cmd = "calc";

            // 通过URLClassLoader加载远程jar包中的CMD类
            Class cmdClass = ucl.loadClass("javaeval");

            // 调用CMD类中的exec方法，等价于: Process process = CMD.exec("whoami");
            Process process = (Process) cmdClass.getMethod("exec", String.class).invoke(null, cmd);

            // 获取命令执行结果的输入流
            InputStream           in   = process.getInputStream();
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[]                b    = new byte[1024];
            int                   a    = -1;

            // 读取命令执行结果
            while ((a = in.read(b)) != -1) {
    
                baos.write(b, 0, a);
            }

            // 输出命令执行结果
            System.out.println(baos.toString());
        } catch (Exception e) {
    
            e.printStackTrace();
        }
    }

}

参考

https://xz.aliyun.com/t/9002#toc-14

https://blog.csdn.net/javazejian/article/details/73413292/

https://zhishihezi.net/endpoint/richtext/4aaa4fe6bc2249252df9ae2b1891b451?event=436b34f44b9f95fd3aa8667f1ad451b173526ab5441d9f64bd62d183bed109b0ea1aaaa23c5207a446fa6de9f588db3958e8cd5c825d7d5216199d64338d9d00f31548dfe08150ea441b2e8b5b1ff2815007ee7d0070dfde1640b5779eca8d36254c858bd38596ae8769abdaece4c94f8de34d1a659242a6c24a2236b63a4b4805829f983bb396ab7064e983f15975a0234a8962f7a674e2dbbd5cb38c5f4f735fd0c3af7ad8e0e44cd09b5bde02700eac5be57fbcee0d34607cf8b53178e742314a3585d4b93a5c630358c4a708c1cd43bd087357c5272698d3c1a057f8826d9d4652ed2880fbaa14923e329a4c4c01a6f9c322ee4f4716958ad3fa698c4c52#2

https://blog.csdn.net/briblue/article/details/54973413