概述

我们知道，当编写完一个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的安装目录下的：jrelibext子目录下加载类库。我们可以将我们的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 ClassLoaderc = 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文件。

@Testpublic 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加载完毕了。

父委托机制

类加载的父委托机制的优点就是能够提高软件系统的安全性，防止同一个字节码文件被多次的加载。

我们引用同包目录的下的不同类，之所以不用再写import ...，不仅是他们是在同一个包下面，并且他们都是被同一个类加载器加载的。如果仅同包，而被不同类加载器加载，那么此刻同包类之间是相互引用不到的。

每个类加载器都由自己的命令空间，命名空间由该加载器及所有的父类加载器所加载的类组成。同一个命名空间内的类是相互可见的，即可以相互import的。子类的命令空间包括了所有的父类空间，所以前面所说子类加载器加载的类能看到父类加载器的类，如系统类加载器能看到启动类加载器中的所有的类。

当然了，没有这种父子关系的两个类加载器，他们之间的命令空间是相互独立的，也就是不可见的。

JVM类加载机制理解

概述