from：http://blog.abreaking.com

概述

我们知道，当编写完一个java文件后，使用javac命令可以将该java文件编译成java字节码文件，即.class的文件。class文件存储者该类的各种描述信息，而后我们可以使用java命令启动java虚拟机，虚拟机把描述类的数据从class文件中加载到内存，并对数据进行校验、解析及初始化，最终形成可被虚拟机直接使用的Java类型。

从字节码文件到可使用的Java类型这样的一个流程，就是类的加载、连接、初始化的过程。

类的加载：就是将类的.class文件中的二进制数据读入到内存中去，将其放在运行时数据区的方法区中；然后在堆中创建一个Java.lang.Class对象，用来封装类在方法区中的数据结构。可以认为，类加载的最终的成品是位于堆中Class对象，该对象封装了类在方法区中的数据结构，并提供访问方法区中数据结构的接口。

类的连接：主要为3部分：

验证：即确保被加载类的正确性。
准备：为类的静态变量分配内存，并初始化默认值。
把类中符号引用转换为符号引用。

类的初始化：为类的静态变量赋予正确的初始值。

类的加载

JVM类加载器

类加载class文件，不管这个文件是正常本地文件、还是jar包里面的文件，还是位于其他的位置。JVM自带三种类加载器：

根类加载器（Boostrap ClassLoader）：负责加载虚拟机的核心类，如java.lang包下面的类。这个类加载器的实现依赖底层操作系统;
扩展类加载器（Extension ClassLoader）：它的父类加载器是根类加载器，它从java.ext.dirs系统属性所指定的目录中加载类库，或者从jdk的安装目录下的：jre\lib\ext子目录下加载类库。我们可以将我们的jar包放在该目录下，就会被该类加载器加载。扩展类加载器是java.lang.ClassLoader的子类；
系统类加载器（System ClassLoader）：也叫做应用类加载器，父类加载器是扩展类加载器。就是加载classpath路径下指定的类或者jar包。

注意，以上所说的父类加载器并不是继承，而是包装，即在构造方法中包装父类加载器。当然，也可以自定义类加载器。

类加载机制

类的加载机制是父类委托机制，如下。除根类加载器外，其余类加载器有且只有一个父类加载器。

当某个class文件被底层的类加载器加载时，该类加载器并不会即刻对该字节码文件进行加载，而是先委托给父类加载器，父类再委托给父类，直到根类加载器，如果根类加载器能够加载该类，那么就加载，否则就让其子类加载器加载，以此类推，在某一级中该类被加载了，那么就表示类加载完成，类加载完毕的数据信息会告知其子类加载器（准确的说，因为子类加载器包装了父类，那么就拥有父类的加载信息），该级的类加载器就称之为该定义类的加载器。

如果仍然没有类加载可以加载该类，那么就会抛出ClassNotFoundException异常。

在java.lang.ClassLoader#loadClass(java.lang.String, boolean)方法中，

Class<?> c = findLoadedClass(name);
    if (c == null) {
    long t0 = System.nanoTime();
    try {
        if (parent != null) {
                //这里，如果父类加载器不为空，那么就有父类加载器去加载
        c = parent.loadClass(name, false);
        } else {
               //没父类加载器，那么就是Bootstarp ClassLoader
        c = findBootstrapClassOrNull(name);
        }
    } catch (ClassNotFoundException e) {
        // ClassNotFoundException thrown if class not found
        // from the non-null parent class loader
    }
......

自定义类加载器

自定义类加载器需要继承ClassLoader这个类，可复写loadClass或findClass方法，loadClass这个方法一般没必要复写，ClassLoader已经指定了父类委托机制的算法，所以，我们复写findClass这个方法。如：

public class MyClassLoader extends ClassLoader {
    //假设在这个目录下放着一个class文件
    String fileDir = "e:\\classloader\\";
    public MyClassLoader(){
    }
    //可指定一个父类加载器，进而测试父类委托机制
    public MyClassLoader(ClassLoader parent){
        super(parent);
    }
    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException{
        FileInputStream inputStream = null;
        try {
            String name = className;  //类名，一般就是类的全限定名
            className = className.replace(".","\\");
            className += ".class";
            //找到这个类的class文件，读取为输入流
            inputStream = new FileInputStream(new File(fileDir+className));
            //将class文件的二进制数据保存到字节数组中
            byte[] bytes = new byte[inputStream.available()];
            inputStream.read(bytes);
            //调用ClassLoader的defineClass方法获取到该类的class对象，defineClass方法由本地(native)方法实现
            Class<?> aClass = defineClass(name, bytes, 0, bytes.length);
            return aClass;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        throw new ClassNotFoundException("没有这个类");
    }
}

以上就自定义了一个类加载器。我在fileDir目录下写了一个java类，并用javac命令编译成了class文件。

package com.foo.test;
public class User
{}

使用以上定义的类加载器去加载编译后的class文件。

@Test
public void test01() throws Exception {
         String className = "com.foo.test.User";
        MyClassLoader classLoader = new MyClassLoader();
        //使用自定义类加载器去加载这个类
        Class<?> clazz = classLoader.loadClass(className);
        System.out.println("类名："+clazz.getName());
        System.out.println("类加载器："+clazz.getClassLoader());
    }

结果如下，说明能够加载到该类：

我们再验证下父类委托机制，创建两个类加载器：classLoader1，classLoader2。classLoader2包装了classLoader1，那么classLoader1就是classLoader2的父类加载器，使用classLoader2去加载User的class文件。

@Test
public void test02()throws Exception {
    String className = "com.foo.test.User";
    MyClassLoader classLoader1 = new MyClassLoader();
    //classLoader2包装了classLoader1，那么classLoader1就是classLoader2的父类加载器
    MyClassLoader classLoader2 = new MyClassLoader(classLoader1);
    //使用classLoader2去加载该类
    Class<?> clazz = classLoader2.loadClass(className);
    System.out.println("classLoader1:"+classLoader1);
    System.out.println("classLoader2:"+classLoader2);
    System.out.println("该类的定义类加载器为："+clazz.getClassLoader());
}

结果为：

可见，尽管用了classLoader2去加载该类，该类确是被classLoader1加载了。这就是因为classLoader1是classLoader2的父类加载器，classLoader2会先委托为classLoader1尝试去加载该类，如果classLoader1还有父类，还会委托给其父类，其父类不能加载，才回到classLoader1去加载，此刻classLoader1能够加载该类，那么该类就会被classLoader1加载完毕了。