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

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），它会将请求委托给扩展类加载器（Extension ClassLoader）。同样，如果扩展类加载器不能加载这个类，它会将请求委托给应用程序类加载器（Application ClassLoader）。如果应用程序类加载器也不能加载类，它会尝试自己去加载这个类。如果成功，就返回这个类的Class对象；如果失败，抛出ClassNotFoundException。

原文链接：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，自定义类的加载范围。