java对象加载的过程，有哪些类加载器?双亲委派模型,为什么使用双亲委派模型,如何自定义类加载器?什么时候自定义?

小鱼儿 2022-06-08 13:59 148阅读 0赞

### java类的加载需要经历以下过程 ###

1）  编译:.java文件编译后生成.class字节码文件  
2）  加载：类加载器负责根据一个类的全限定名来读取此类的二进制字节流到JVM内部，并存储在运行时内存区的方法区，然后将其转换为一个与目标类型对应的java.lang.Class对象实例  
3）  链接 : 原始的类信息平滑的转入jvm的过程  
验证：格式（class文件规范） 语义（final类是否有子类） 操作  
准备：静态变量赋初值和内存空间，final修饰的内存空间直接赋原值，此处不是用户指定的初值。  
解析：符号引用转化为直接引用，分配地址  
4）  初始化  
有父类先初始化父类，然后初始化自己；将static修饰代码执行一遍，如果是静态变量，则用用户指定值覆盖原有初值；如果是代码块，则执行一遍操作。

符号引用:不知道实际引用目标的内存地址,用符号表示实际的引用目标  
直接引用:知道实际引用目标的地址,此时被引用的目标一定被加载到内存中了,有如下三种:  
        a 直接指向目标的指针  
         b 相对偏移量  
         c 一个能间接定位到目标的句柄

### 类加载器 ###

启动类加载器(bootstrap classLoader，级别最高),扩展类加载器(extension),应用类加载器(Application),自定义类加载器(user ClassLoader);

### 双亲委派模型 ###

双亲委派的代码

//双亲委派模型的工作过程源码
    protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException{
        // First, check if the class has already been loaded
        Class c = findLoadedClass(name);
        if (c == null) {
            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 to find the class
                //子加载器进行类加载 
                c = findClass(name);
            }
        }
     
        if (resolve) {
            //判断是否需要链接过程，参数传入
            resolveClass(c);
        }
     
        return c;
    }

双亲委派模型的工作过程如下：  
（1）当前类加载器从自己已经加载的类中查询是否此类已经加载，如果已经加载则直接返回原来已经加载的类。  
（2）如果没有找到，就去委托父类加载器去加载（如代码c = parent.loadClass(name, false)所示）。父类加载器也会采用同样的策略，查看自己已经加载过的类中是否包含这个类，有就返回，没有就委托父类的父类去加载，一直到启动类加载器。因为如果父加载器为空了，就代表使用启动类加载器作为父加载器去加载。  
（3）如果启动类加载器加载失败（例如在$JAVA\_HOME/jre/lib里未查找到该class），则会抛出一个异常ClassNotFoundException，然后再调用当前加载器的findClass()方法进行加载。   
原文链接：https://blog.csdn.net/SEU\_Calvin/article/details/52315125

双亲委派的原因：  
（1）主要是为了安全性，避免用户自己编写的类动态替换 Java的一些核心类，比如 String。  
（2）同时也避免了类的重复加载，因为 JVM中区分不同类，不仅仅是根据类名，相同的 class文件被不同的 ClassLoader加载就是不同的两个类。

### 为什么需要自定义类加载器: ###

1)加密:java代码可以轻易的被反编译,如果你需要对你的代码进行加密以防止反编译,可以先将编译后的代码用加密算法加密,类加密后就不能再使用java自带的类加载器了,这时候就需要自定义类加载器.

2)从非标准的来源加载代码:字节码是放在数据库,甚至是云端,就可以自定义类加载器,从指定来源加载类.

### 自定义类加载器的方法 ###

自定义一个People.java类做例子

public class People {
    //该类写在记事本里，在用javac命令行编译成class文件，放在d盘根目录下
        private String name;
     
        public People() {}
     
        public People(String name) {
            this.name = name;
        }
     
        public String getName() {
            return name;
        }
     
        public void setName(String name) {
            this.name = name;
        }
     
        public String toString() {
            return "I am a people, my name is " + name;
        }
    }

2.2 自定义类加载器

自定义一个类加载器，需要继承ClassLoader类，并实现findClass方法。其中defineClass方法可以把二进制流字节组成的文件转换为一个java.lang.Class（只要二进制字节流的内容符合Class文件规范）。

import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.nio.ByteBuffer;
    import java.nio.channels.Channels;
    import java.nio.channels.FileChannel;
    import java.nio.channels.WritableByteChannel;
     
    public class MyClassLoader extends ClassLoader
    {
        public MyClassLoader()
        {
            
        }
        
        public MyClassLoader(ClassLoader parent)
        {
            super(parent);
        }
        
        protected Class<?> findClass(String name) throws ClassNotFoundException
        {
            File file = new File("D:/People.class");
            try{
                byte[] bytes = getClassBytes(file);
                //defineClass方法可以把二进制流字节组成的文件转换为一个java.lang.Class
                Class<?> c = this.defineClass(name, bytes, 0, bytes.length);
                return c;
            } 
            catch (Exception e)
            {
                e.printStackTrace();
            }
            
            return super.findClass(name);
        }
        
        private byte[] getClassBytes(File file) throws Exception
        {
            // 这里要读入.class的字节，因此要使用字节流
            FileInputStream fis = new FileInputStream(file);
            FileChannel fc = fis.getChannel();
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            WritableByteChannel wbc = Channels.newChannel(baos);
            ByteBuffer by = ByteBuffer.allocate(1024);
            
            while (true){
                int i = fc.read(by);
                if (i == 0 || i == -1)
                break;
                by.flip();
                wbc.write(by);
                by.clear();
            }
            fis.close();
            return baos.toByteArray();
        }
    }

2.3 在主函数里使用

MyClassLoader mcl = new MyClassLoader(); 
    Class<?> clazz = Class.forName("People", true, mcl); 
    Object obj = clazz.newInstance();
           
    System.out.println(obj);
    System.out.println(obj.getClass().getClassLoader());//打印出我们的自定义类加载器

参考：https://blog.csdn.net/SEU\_Calvin/article/details/52315125

但是tomcat违反了上面的双亲委派模型！！

违背双亲委派模型的例子 Tomcat？自己写一个HashMap走双亲委派会被覆盖吗？为啥优先加载jre  
一个web容器可能需要部署两个应用程序，不同的应用程序可能会依赖同一个第三方类库的不同版本。通过自定义类加载器，一个应用一个加载器。不会覆盖jre中的hashMap，因为首先起作用的加载器是bootstrap。

美团面试题：自定义的类加载器的父加载器是谁？各个加载器负责加载什么？

启动（Bootstrap）类加载器：引导类加载器，它负责将 <JAVA\_HOME>/lib 下面的核心类库 或 -Xbootclasspath 选项指定的 jar 包等 虚拟机识别的类库 加载到内存中。。

扩展（Extension）类加载器：扩展类加载器它负责将 <JAVA\_HOME>/lib/ext 或者由系统变量 - Djava.ext.dir 指定位置中的类库 加载到内存中。

系统（System）类加载器：系统类加载器是由 Sun 的 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的，它负责将当前类所在路径及其引用的第三方类库的路径。

自定义加载器：继承自AppClassloader，自定义类的加载范围。