JVM类加载机制、双亲委派机制、自定义类加载器、打破双亲委派机制[通俗易懂]

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

1、类加载器

站在Java虚拟机的角度看，只有两种不同的类加载器：一种是启动类加载器（Bootstrap ClassLoader），这个类加载器使用C++语言实现（HotSpot虚拟机、JDK8中），是虚拟机自身的一部分；另外一种是其他所有类加载器，这些类加载器都由Java语言实现，独立存在于虚拟机外部，并且全部继承自抽象类 java.lang.ClassLoader

JDK8及以前版本中绝大多数程序都会使用到以下3个系统提供的类加载器来进行加载

1. 启动类（引导类）加载器：负责加载支撑JVM运行的位于<JAVA_HOME>\lib目录下的核心类库，而且是Java虚拟机能够识别的类库加载到虚拟机内存中（如rt.jar、tools.jar、charsets.jar等，名字不符合的类库即使放到lib目录下也不会被加载）。

2. 扩展类加载器（Extension Class Loader）：这个类加载器是在类sun.misc. $ExtClassLoader中以Java代码的形式实现的。负责加载<JAVA_HOME>\lib\ext目录中或被java.ext.dirs系统变量所制定的路径中所有的类库，是一种Java系统类库的扩展机制

3. 应用程序类加载器（Application Class Loader）:是由sun.misc.launcher$AppClassLoader来实现，由于应用程序加载器是ClassLoader类中getSystemClassLoader()方法的返回值，也称为系统类加载器。负责加载用户类路径（ClassPath）上所有的类库，如应用程序中没有默认自己的类加载器，则使用应用程序加载器为默认加载器。

4. 自定义加载器：负责加载用户自定义路径下的类包

1.1、Launcher源码

package com.learn.jvm;

import com.sun.crypto.provider.DESKeyFactory;

/** * @author liushiwei */
public class JvmClassLoader { 
   


    public static void main(String[] args) { 
   
        // 查看String的类加载器
        System.out.println(String.class.getClassLoader());
        // 查看DESKeyFactory扩展包中的加载器
        System.out.println(DESKeyFactory.class.getClassLoader().getClass().getName());
        // 查看当前类加载器
        System.out.println(JvmClassLoader.class.getClassLoader().getClass().getName());

    }
}

1.1.1、Launcher

sun.misc.Launcher类是java的入口，在启动java应用的时候会首先创建Launcher类，创建Launcher类的时候回准备应用程序运行中需要的类加载器。

Java命令执行代码的大体流程，结合图可以查看Launcher类的源码

类加载器是一个抽象类。给定类的二进制名称，类装入器应该尝试查找或生成构成该类定义的数据。典型的策略是将名称转换为文件名，然后从文件系统中读取该名称的“类文件”。

2、双亲委派机制

双亲委派模型的工作过程是：如果一个类加载器收到了类加载请求，它首先不会自己尝试加载这个类，而是把这个请求委派给父类加载器去完成，每个层都是如此，因此所有加载请求最终都传送给顶层的启动类加载器，只有父加载器反馈自己无法加载这个加载请求时（它的搜索范围没有找到所需的类），子加载器才会尝试自己去完成加载，双亲委派机制说简单点就是，先找父亲加载，不行再由儿子自己加载

好处

1. 具备优先级的层次关系，例如java.lang.Object类，它放在rt.jar之中，无论那个类加载器加载这个类，都会向上委派给模型的最顶端启动类加载器加载，因此Object类在程序的各个类加载器中都能保证是一个类，从而保证被加载类的唯一性

2. 这样便可以防止核心API库被随意篡改，如自定义Object类

   package java.lang;
   
   public class Object { 
        
   
       public static void main(String[] args) { 
        
           System.out.println("Object");
       }
   }
   

   结果

2.1、ClassLoader源码

AppClassLoader的继承关系

应用程序类加载器AppClassLoader加载类的双亲委派机制源码，AppClassLoader的loadClass方法最终会调用其父类ClassLoader的loadClass方法，该方法的大体逻辑如下

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
{ 
   
    synchronized (getClassLoadingLock(name)) { 
   
        // 检查类是否已经加载
        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
                // 说明父类加载器无法完成加载请求
            }

            if (c == null) { 
   
                long t1 = System.nanoTime();
                // 在父加载器无法加载时，在调用本身的findClass方法进行类加载,
                // 最终调用的是URLClassLoader.findClass方法
                // 真正加载类的逻辑
                c = findClass(name);

                // 这是定义类加载器； 记录统计
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) { 
   
            resolveClass(c);
        }
        return c;
    }
}

defineClass：经历验证、解析等

3、自定义类加载器

加载的类

public class JvmClassLoader1 { 
   
    
    public void getValue(){ 
   
        System.out.println("JvmClassLoader1");
    }
}

自定义加载器，及测试内部类

package com.learn.jvm;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;
public class MyClassLoader  extends ClassLoader { 

private  String classPath;
public MyClassLoader(String classPath){ 

this.classPath= classPath;
}
private byte[] loadByte(String name) throws IOException { 

String path = name.replaceAll("\\.", "/");
FileInputStream fis = new FileInputStream(classPath + "/" + path.concat(".class"));
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
}
protected Class<?> findClass(String name) throws ClassNotFoundException { 

try { 

byte[] data = loadByte(name);
//defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组。
return defineClass(name, data, 0, data.length);
} catch (Exception e) { 

e.printStackTrace();
throw new ClassNotFoundException();
}
}
}
class MyClassLoaderDemo{ 

public static void main(String[] args) throws Exception { 

// 初始化自定义类加载器，会先初始化父类ClassLoader，
// 其中会把自定义类加载器的父加载器设置为应用程序类加载器AppClassLoader
// D盘创建 demo/com/learn/jvm 几级目录，将JvmClassLoader类的复制类JvmClassLoader1.class丢入该目录
MyClassLoader myClassLoader = new MyClassLoader("D:/demo");
Class<?> aClass = myClassLoader.loadClass("com.learn.jvm.JvmClassLoader1");
// 通过反射调用类中方法
Object object = aClass.newInstance();
Method getValues = aClass.getDeclaredMethod("getValue", null);
getValues.invoke(object);
System.out.println(aClass.getClassLoader().getClass().getName());
}
}

• 执行结果：

  • 如果当前项目路径下有JvmClassLoader1.class文件，则输出AppClassLoader应用程序加载器，因为自定义加载器的父加载器是AppClassLoader

  • 如果当前项目路径下无JvmClassLoader1.class文件，则输出MyClassLoader

为什么自定义的类加载器的父加载器是AppClassLoader

• 因为初始化自定义类加载器时，会初始化父类ClassLoader，而ClassLoader的构造方法中，会给this.parent赋值，如下l.getClassLoader();中对应的类加载器就是AppClassLoader，满足双亲委派机制
  

4、打破双亲委派机制

例如在Tomact中部署多个项目，每个项目使用的相同但不用版本的组件

自定义类加载器，在加载类时，没有遵循双亲委派机制（先委托父加载器，父加载器没有此类，最后在交给子加载器加载），可以是自己先加载，加载不到在委托父加载器，或不需要父加载器加载。

package com.learn.jvm;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;
public class MyClassLoader  extends ClassLoader { 

private  String classPath;
public MyClassLoader(String classPath){ 

this.classPath= classPath;
}
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{ 

synchronized (getClassLoadingLock(name)) { 

// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) { 

long t1 = System.nanoTime();
if(name.contains("com.learn.jvm")){ 

// 自定义加载器加载类
c = findClass(name);
}else{ 

// 父加载器加载
c = this.getParent().loadClass(name);
}
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
if (resolve) { 

resolveClass(c);
}
return c;
}
}
private byte[] loadByte(String name) throws IOException { 

String path = name.replaceAll("\\.", "/");
FileInputStream fis = new FileInputStream(classPath + "/" + path.concat(".class"));
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
}
protected Class<?> findClass(String name) throws ClassNotFoundException { 

try { 

byte[] data = loadByte(name);
//defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组。
return defineClass(name, data, 0, data.length);
} catch (Exception e) { 

e.printStackTrace();
throw new ClassNotFoundException();
}
}
}
class MyClassLoaderDemo{ 

public static void main(String[] args) throws Exception { 

// 初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载器设置为应用程序类加载器AppClassLoader
// D盘创建 demo/com/learn/jvm 几级目录，将JvmClassLoader类的复制类JvmClassLoader1.class丢入该目录
MyClassLoader myClassLoader = new MyClassLoader("D:/demo");
// 使用当前类加载器加载
ClassLoader classLoader = myClassLoader.getClass().getClassLoader();
Class<?> aClass = myClassLoader.loadClass("com.learn.jvm.JvmClassLoader1");
// 通过反射调用类中方法
Object object = aClass.newInstance();
Method getValues = aClass.getDeclaredMethod("getValue", null);
getValues.invoke(object);
System.out.println(aClass.getClassLoader().getClass().getName());
}
}