【基础总结】类加载过程

要点：
1、类加载机制的原理
2、程序初始化的顺序
3、类加载的代理模式（双亲委托机制）

一、类加载机制

JVM把class文件加载到内存，并对数据进行校验、准备、解析、初始化，最终形成JVM可以直接使用的Java类型的过程。‘

类加载全过程

1、加载

将class字节码文件加载到内存中，并将这些数据转换成方法区中的运行时数据（静态变量、静态代码块、常量池等），在堆中生成一个Class类对象代表这个类（反射原理），作为方法区类数据的访问入口。

类的加载原理

2、链接

将Java类的二进制代码合并到JVM的运行状态之中。
• 验证
确保加载的类信息符合JVM规范，没有安全方面的问题。
• 准备
正式为类变量(static变量)分配内存并设置类变量初始值的阶段，这些内存都将在方法区中进行分配。注意此时的设置初始值为默认值，具体赋值在初始化阶段完成。
• 解析
虚拟机常量池内的符号引用替换为直接引用（地址引用）的过程。

3、初始化

初始化阶段是执行类构造器()方法的过程。类构造器()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块(static块)中的语句合并产生的。

• 当初始化一个类的时候，如果发现其父类还没有进行过初始化、则需要先初始化其父类。
• 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

二、Java程序初始化顺序

1、父类的静态变量
2、父类的静态代码块
3、子类的静态变量
4、子类的静态代码块
5、父类的非静态变量
6、父类的非静态代码块
7、父类的构造方法
8、子类的非静态变量
9、子类的非静态代码块
10、子类的构造方法

/**
 * @ClassName Demo01
 * @Description 测试程序初始化顺序
 * @Author xwd
 * @Date 2018/10/23 21:50
 */
public class Demo01 {
    public static void main(String[] args) {
        B b = new B();
    }
}

class A{

    static String str1 = "父类A的静态变量";
    String str2 = "父类A的非静态变量";

    static {
        System.out.println("执行了父类A的静态代码块");
    }

    {
        System.out.println("执行了父类A的非静态代码块");
    }

    public A(){
        System.out.println("执行了父类A的构造方法");
    }
}

class B extends A{

    static String str1 = "子类B的静态变量";
    String str2 = "子类B的非静态变量";

    static {
        System.out.println("执行了子类B的静态代码块");
    }

    {
        System.out.println("执行了子类B的非静态代码块");
    }

    public B(){
        System.out.println("执行了子类B的构造方法");
    }
}

控制台输出：

程序初始化顺序

三、类的引用

1、主动引用（一定会初始化）

• new一个类的对象。
• 调用类的静态成员(除了final常量)和静态方法。
• 使用java.lang.reflect包的方法对类进行反射调用。
• 当虚拟机启动，java Hello，则一定会初始化Hello类。说白了就是先启动main方法所在的类。
• 当初始化一个类，如果其父类没有被初始化，则先会初始化他的父类

2、被动引用

• 当访问一个静态域时，只有真正声明这个域的类才会被初始化。例如：通过子类引用父类的静态变量，不会导致子类初始化。
• 通过数组定义类引用，不会触发此类的初始化。
• 引用常量不会触发此类的初始化（常量在编译阶段就存入调用类的常量池中了）。

/**
 * @ClassName Demo02
 * @Description 测试类的引用
 * @Author xwd
 * @Date 2018/10/23 21:58
 */
public class Demo02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //主动引用：new一个类的对象
//        People people = new People();
        //主动引用：调用类的静态成员(除了final常量)和静态方法
//        People.getAge();
//        System.out.println(People.age);
        //主动调用：使用java.lang.reflect包的方法对类进行反射调用
//        Class.forName("pri.xiaowd.classloader.People");


        //被动引用:当访问一个静态域时，只有真正声明这个域的类才会被初始化。
//        System.out.println(WhitePeople.age);
        //被动引用:通过数组定义引用，不会初始化
//        People[] people = new People[10];
        //被动引用:引用常量不会触发此类的初始化
        System.out.println(People.num);
    }
    //主动调用：先启动main方法所在的类
//    static {
//        System.out.println("main方法所在的类在虚拟机启动时就加载");
//    }
}

class People{

    static int age = 3;
    static final int num = 20;

    static {
        System.out.println("People被初始化了！");
    }

    public People() {
    }

    public static int getAge() {
        return age;
    }

    public static void setAge(int age) {
        People.age = age;
    }
}

class WhitePeople extends People{

    static {
        System.out.println("WhitePeople被初始化了！");
    }
}

四、类加载器的原理

1、类缓存

标准的Java SE类加载器可以按要求查找类，一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过，JVM垃圾收集器可以回收这些Class对象。

2、类加载器的分类

类加载器的分类

引导类加载器（bootstrap class loader）
（1）它用来加载 Java 的核心库(JAVA_HOME/jre/lib/rt.jar,sun.boot.class.path路径下的内容)，是用原生代码（C语言）来实现的，并不继承自 java.lang.ClassLoader。
（2）加载扩展类和应用程序类加载器。并指定他们的父类加载器。

扩展类加载器（extensions class loader）
（1）用来加载 Java 的扩展库(JAVA_HOME/jre/ext/*.jar，或java.ext.dirs路径下的内容) 。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java类。
（2）由sun.misc.Launcher$ExtClassLoader实现。

应用程序类加载器（application class loader）
（1）它根据 Java 应用的类路径（classpath，java.class.path 路径下的内容）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。
（2）由sun.misc.Launcher$AppClassLoader实现。

自定义类加载器
（1）开发人员可以通过继承 java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求。

3、java.class.ClassLoader类

（1）作用：

• java.lang.ClassLoader类的基本职责就是根据一个指定的类的名称，找到或者生成其对应的字节代码，然后从这些字节代码中定义出一个Java类，即java.lang.Class类的一个实例。

• ClassLoader还负责加载 Java 应用所需的资源，如图像文件和配置文件等。
  （2）常用方法：

• getParent() 返回该类加载器的父类加载器。

• loadClass(String name) 加载名称为 name的类，返回的结果是java.lang.Class类的实例。
  此方法负责加载指定名字的类，首先会从已加载的类中去寻找，如果没有找到；从parent ClassLoader[ExtClassLoader]中加载；如果没有加载到，则从Bootstrap ClassLoader中尝试加载(findBootstrapClassOrNull方法), 如果还是加载失败，则自己加载。如果还不能加载，则抛出异常ClassNotFoundException。

• findClass(String name) 查找名称为 name的类，返回的结果是java.lang.Class类的实例。

• findLoadedClass(String name) 查找名称为 name的已经被加载过的类，返回的结果是 java.lang.Class类的实例。

• defineClass(String name, byte[] b, int off, int len) 把字节数组 b中的内容转换成 Java 类，返回的结果是java.lang.Class类的实例。这个方法被声明为 final的。

• resolveClass(Class c) 链接指定的 Java 类。

五、类加载器的代理模式

代理模式即是将指定类的加载交给其他的类加载器。常用双亲委托机制。

1、双亲委托机制

某个特定的类加载器接收到类加载的请求时，会将加载任务委托给自己的父类，直到最高级父类引导类加载器（bootstrap class loader），如果父类能够加载就加载，不能加载则返回到子类进行加载。如果都不能加载则报错。ClassNotFoundException

双亲委托机制

双亲委托机制是为了保证 Java 核心库的类型安全。这种机制保证不会出现用户自己能定义java.lang.Object类等的情况。例如，用户定义了java.lang.String，那么加载这个类时最高级父类会首先加载，发现核心类中也有这个类，那么就加载了核心类库，而自定义的永远都不会加载。

值得注意是，双亲委托机制是代理模式的一种，但并不是所有的类加载器都采用双亲委托机制。在tomcat服务器类加载器也使用代理模式，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的。

六、自定义类加载器

自定义类加载器的流程

（1）首先检查请求的类型是否已经被这个类装载器装载到命名空间中了，如果已经装载，直接返回；否则转入步骤2。
（2）委派类加载请求给父类加载器，如果父类加载器能够完成，则返回父类加载器加载的Class实例；否则转入步骤3。
（3）调用本类加载器的findClass（…）方法，试图获取对应的字节码，如果获取的到，则调用defineClass（…）导入类型到方法区；如果获取不到对应的字节码或者其他原因失败，返回异常给loadClass（…）， loadClass（…）转抛异常，终止加载过程（注意：这里的异常种类不止一种）。
- 注意：被两个类加载器加载的同一个类，JVM认为是不相同的类。

import java.io.*;

/**
 * @ClassName FileSystemClassLoader
 * @Description 自定义文件类加载器
 * @Author xwd
 * @Date 2018/10/24 9:23
 */
public class FileSystemClassLoader extends ClassLoader {
    private String rootDir;//根目录

    public FileSystemClassLoader(String rootDir) {
        this.rootDir = rootDir;
    }

    /**
     * @MethodName findClass
     * @Descrition 加载类
     * @Param [name]
     * @return java.lang.Class
     */
    @Override
    protected Class findClass(String name) throws ClassNotFoundException {
        Class loadedClass = findLoadedClass(name);//查询该类是否已经被加载过
        if(loadedClass != null){  //该类已经被加载过了,直接返回
            return loadedClass;
        }else{  //该类还没有被加载过
            ClassLoader classLoader = this.getParent();//委派给父类加载
            try {
                loadedClass = classLoader.loadClass(name);
            } catch (ClassNotFoundException e) {
//                e.printStackTrace();
            }
            if(loadedClass != null){  //父类加载成功,返回
                return loadedClass;
            }else{
                byte[] classData = getClassData(name);
                if(classData == null){
                    throw new ClassNotFoundException();
                }else{
                    loadedClass = defineClass(getName(),classData,0,classData.length);
                }
            }
        }
        return loadedClass;
    }

    /**
     * @MethodName getClassData
     * @Descrition 根据类名获得对应的字节数组
     * @Param [name]
     * @return byte[]
     */
    private byte[] getClassData(String name) {
        //pri.xiaowd.test.A  -->  D:/myjava/pei/xiaowd/test/A.class
        String path = rootDir + "/" + name.replace('.','/') + ".class";
//        System.out.println(path);
        InputStream is = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        try {
            is = new FileInputStream(path);

            byte[] bytes = new byte[1024];
            int temp = 0;
            while((temp = is.read(bytes)) != -1){
                baos.write(bytes,0,temp);
            }
            return baos.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            return null;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                if(baos != null){
                    baos.close();
                }
                if(is != null){
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

七、线程上下文类加载器

通常当你需要动态加载资源的时候 , 你至少有三个 ClassLoader 可以选择 :
1.系统类加载器或叫作应用类加载器 (system classloader or application classloader)
2.当前类加载器
3.当前线程类加载器

• 当前线程类加载器是为了抛弃双亲委派加载链模式。
每个线程都有一个关联的上下文类加载器。如果你使用new Thread()方式生成新的线程，新线程将继承其父线程的上下文类加载器。如果程序对线程上下文类加载器没有任何改动的话，程序中所有的线程将都使用系统类加载器作为上
下文类加载器。
• Thread.currentThread().getContextClassLoader()

八、Tomcat服务器的类加载器

每个 Web 应用都有一个对应的类加载器实例。该类加载器也使用代理模式(不同于前面说的双亲委托机制)，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的。但也是为了保证安全，这样核心库就不在查询范围之内。