1. main方法执行流程

?我们平常使用的main方法，右键执行main方法在底层加载步骤大致如下。

2. 类加载过程

上述classloader.loadclass过程大致细分为以下步骤：

加载：加载类文件到类加载器

验证：文件是否符合格式，默认开头CAFA BA BE格式，格式不能随意更改

准备：初始化值，int默认0，对象默认null，不影响最终声明的值

解析：将符号引用替换为直接引用，符号引用是我们所有看到的java符号都是符号引用，存在一个常量池中，可以使用javap -v class文件的方式查看constant pool-常量池。在使用的时候会将符号引用加载到内存中，符号就有了内存地址，这时候称之为直接引用，过程称之为动态链接。在碰到一些main方法之类的时候只是替换为指向内存的指针或句柄。这个过程称为静态链接。

初始化：执行一些静态方法和静态代码块。

/**
 * 测试静态方法和构造方法哪个先加载
 */
public class Math {

    static{
        System.out.println("load Math");
    }

    public static void main(String[] args) {
        new A();
        System.out.println("load test");
    }

}

class A{
    static {
        System.out.println("load A");
    }

    public A(){
        System.out.println("initial A");
    }
}

?3.类加载器和类加载过程(TODO)

常见的类加载器：

引导类加载器(bootstrapClassLoader):C++实现的类加载器，主要加载/jdk/lib下的jar包和核心类库。

扩展类加载器(ExtClassLoader):主要加载/jdk/lib/ext路径下的jar包

应用程序类加载器(AppClassLoader):主要加载classpath路径下的类

自定义加载器：继承AppClassLoader实现自己的loadClass类加载

类加载主要是classLoader的loadclass方法，需要debug一下，这里时间不够，后续补充。

4. 为什么要设计双亲委派机制？

1.沙箱安全机制：防止string之类的核心类库被篡改。

2.保证类加载只能加载一次，保证类的唯一性。

全盘委托机制：当加载一个类时，会使用一个类加载器把类引用的类都给加载，除非显示使用其他类加载加载引用的类。

package java.lang;

/**
 * 错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
 *    public static void main(String[] args)
 * 否则 JavaFX 应用程序类必须扩展javafx.application.Application
 */
public class String {

    public static void main(String[] args) {
        System.out.println("test");
    }
}

5.自定义加载器(TODO)

?1.自定义加载器步骤：1.继承classLoader 2.重写findclass方法

代码未写成功，明天解决！

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;

public class MyClassLoader extends ClassLoader{

    private String path;//类路径

    public MyClassLoader(String path) {
        this.path = path;
    }

    @Override
    protected Class<?> findClass(String name) {
        //加载类文件二进制数据
        byte[] data = new byte[0];
        try {
            data = loadBytes(name);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return defineClass(name,data,0, data.length);
    }

    private byte[] loadBytes(String name) throws IOException {
        name = name.replaceAll("\\.","/");
        FileInputStream fis = new FileInputStream(path + "/" + name + ".class");
        int len = fis.available();

        byte[] data = new byte[len];

        fis.read(data);
        fis.close();
        return  data;
    }

    public static void main(String[] args) throws Exception {
        MyClassLoader myClassLoader = new MyClassLoader("D:/test");
        Class<?> aClass = myClassLoader.loadClass("com.test.User");
        Object obj = aClass.newInstance();
        Method method = aClass.getDeclaredMethod("sout", null);
        method.invoke(obj,null);
        System.out.println(aClass.getClassLoader().getClass().getName());
    }
}

?6.打破双亲委派机制

打破双亲委派机制步骤：继承classLoader，重写loadClass方法和findClass方法

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;

public class MyClassLoader extends ClassLoader{

    private String path;//类路径

    public MyClassLoader(String path) {
        this.path = path;
    }

    @Override
    protected Class<?> findClass(String name) {
        //加载类文件二进制数据
        byte[] data = new byte[0];
        try {
            data = loadBytes(name);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return defineClass(name,data,0, data.length);
    }

    private byte[] loadBytes(String name) throws IOException {
        name = name.replaceAll("\\.","/");
        FileInputStream fis = new FileInputStream(path + "/" + name + ".class");
        int len = fis.available();

        byte[] data = new byte[len];

        fis.read(data);
        fis.close();
        return  data;
    }

    /**
     * 打破双亲委派机制
     * @param name
     * @param resolve
     * @return
     * @throws ClassNotFoundException
     */
    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 t0 = System.nanoTime();

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();

                    //判断如果不是指定的路径走双亲委派机制，如果是走自定义类加载
                    if(!name.startsWith("com.test")){
                        c = this.getParent().loadClass(name);
                    }else{
                        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;
        }
    }

    public static void main(String[] args) throws Exception {
        MyClassLoader myClassLoader = new MyClassLoader("D:/test");
        Class<?> aClass = myClassLoader.loadClass("com.test.User");
        Object obj = aClass.newInstance();
        Method method = aClass.getDeclaredMethod("sout", null);
        method.invoke(obj,null);
        System.out.println(aClass.getClassLoader().getClass().getName());
    }
}