JAVA之类加载

类加载机制

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

类的加载

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的二进制运行时数据结构，在堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口。

加载类的方式有以下几种：
1）从本地系统直接加载
2）通过网络下载.class文件
3）从zip，jar等归档文件中加载.class文件
4）从专有数据库中提取.class文件
5）将Java源文件动态编译为.class文件（服务器）

类的链接

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

为什么有初始化了还需要准备呢？
注意，在准备阶段只是将类变量赋默认值而不是初始化的值。例如 public static int a = 3;在准备阶段为a分配内存并给a默认值，此时a = 0，在初始化阶段将3赋值给a。

类的初始化

初始化是执行类构造器方法的过程。类构造器()方法是由编译器自动收集类中的所有类变量的赋值操作和静态语句块(static块)中的语句合并产生的。
虚拟机会保证一个类的方法在多线程环境中被正确的加锁和同步。

package com.vvvvvv.test;/* * 结果：静态初始化类Demo01        main方法！！        静态初始化A_Father        静态初始化类A        创建A类对象        100        创建A类对象        //说明        类和静态域只被初始化一次 */public class Demo01 {    static {        System.out.println("静态初始化类Demo01");    }    public static void main(String[] args) {        System.out.println("main方法！！");        A a = new A();        System.out.println(A.Length);        A a1 = new A();    }}class A extends A_Father {    public static int Length = 100;    static {        System.out.println("静态初始化类A");    }    public A() {        System.out.println("创建A类对象");    }}class A_Father {    static {        System.out.println("静态初始化A_Father");    }}

类的主动引用（一定会发生类的初始化）
1.new一个类的对象

package com.vvvvvv.test;/* * 结果：静态初始化类Demo01        main方法！！        静态初始化A_Father        静态初始化类A        创建A类对象 */public class Demo01 {    static {        System.out.println("静态初始化类Demo01");    }    public static void main(String[] args) {        System.out.println("main方法！！");        new A();    }}class A extends A_Father {    public static int Length = 100;    static {        System.out.println("静态初始化类A");    }    public A() {        System.out.println("创建A类对象");    }}class A_Father {    static {        System.out.println("静态初始化A_Father");    }}

2.调用类的静态成员（除了final常量）和静态方法

package com.vvvvvv.test;/* * 结果：静态初始化类Demo01        main方法！！        静态初始化A_Father        静态初始化类A */public class Demo01 {    static {        System.out.println("静态初始化类Demo01");    }    public static void main(String[] args) {        System.out.println("main方法！！");        int a = A.Length;    }}class A extends A_Father {    public static int Length = 100;    static {        System.out.println("静态初始化类A");    }    public A() {        System.out.println("创建A类对象");    }}class A_Father {    static {        System.out.println("静态初始化A_Father");    }}

3.调用Java.lang.reflect包的方法对类进行反射调用

package com.vvvvvv.test;/* * 结果：静态初始化类Demo01        main方法！！        静态初始化A_Father        静态初始化类A  */public class Demo01 {    static {        System.out.println("静态初始化类Demo01");    }    public static void main(String[] args) throws ClassNotFoundException {        System.out.println("main方法！！");        Class.forName("com.vvvvvv.test.A");    }}class A extends A_Father {    public static int Length = 100;    public static final int width = 200;    static {        System.out.println("静态初始化类A");    }    public A() {        System.out.println("创建A类对象");    }}class A_Father {    static {        System.out.println("静态初始化A_Father");    }}

4.当虚拟机启动，java Hello，则一定会初始化hello类，说白了就是先启动main方法所在的类
5.当初始化一个类，如果其父类没有被初始化，则先回初始化它的父类

类的被动引用（不会发生类的初始化）
1.当访问一个静态域时，只有真正声明这个域的类才会被初始化。
通过子类引用父类的静态变量，不会导致子类初始化。

package com.vvvvvv.test;/* * 结果：静态初始化类Demo01        main方法！！        静态初始化A_Father        静态初始化类A         100 */public class Demo01 {    static {        System.out.println("静态初始化类Demo01");    }    public static void main(String[] args) throws ClassNotFoundException {        System.out.println("main方法！！");        System.out.println(B.Length);    }}class A extends A_Father {    public static int Length = 100;    public static final int width = 200;    static {        System.out.println("静态初始化类A");    }    public A() {        System.out.println("创建A类对象");    }}class A_Father {    static {        System.out.println("静态初始化A_Father");    }}class B extends A {    static {        System.out.println("静态初始化类B");    }    public B() {        System.out.println("创建B对象");    }}

2.通过数组定义类引用，不会出发此类的初始化。

package com.vvvvvv.test;/* * 结果：静态初始化类Demo01        main方法！！ */public class Demo01 {    static {        System.out.println("静态初始化类Demo01");    }    public static void main(String[] args) throws ClassNotFoundException {        System.out.println("main方法！！");        A[] a = new A[10];    }}class A extends A_Father {    public static int Length = 100;    public static final int width = 200;    static {        System.out.println("静态初始化类A");    }    public A() {        System.out.println("创建A类对象");    }}class A_Father {    static {        System.out.println("静态初始化A_Father");    }}class B extends A {    static {        System.out.println("静态初始化类B");    }    public B() {        System.out.println("创建B对象");    }}

3.引用常量不会出发此类的初始化（常量在编译阶段就存入调用类的常量池中了）

package com.vvvvvv.test;/* * 结果：静态初始化类Demo01        main方法！！ */public class Demo01 {    static {        System.out.println("静态初始化类Demo01");    }    public static void main(String[] args) {        System.out.println("main方法！！");        int a = A.width;    }}class A extends A_Father {    public static int Length = 100;    public static final int width = 200;    static {        System.out.println("静态初始化类A");    }    public A() {        System.out.println("创建A类对象");    }}class A_Father {    static {        System.out.println("静态初始化A_Father");    }}

类加载器的作用

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的运行时数据结构，在堆中生成一个代表这个类的Java.lang.Class对象，作为方法区类数据的访问入口。

类加载器的层次结构

图片来自 https://www.ibm.com/developerworks/cn/java/j-lo-classloader/

引导类加载器（bootstrap class loader)

它用来加载Java的核心库(JAVA_HOME/jre/lib/rt.jar或者sun.boot.class.path路径下的内容)，是由原生代码（它的执行不依赖某个虚拟机或者解释器，编译后可直接依附操作系统运行，不需要经过虚拟机之类的东西。类似于c++，c）来实现的，并不继承自java.lang.ClassLoader。

加载扩展类和应用程序类加载器。并制定他们的父类加载器。

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

由sun.misc.Launcher$ExtClassLoader实现。

应用类加载器(application class loader);
它根据java应用的类路径（classpath,java.class.path类）。
一般来说，java应用的类都是由它来完成加载的。

由sun.misc.Launcher$AppClassLoader实现。

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

java.lang.ClassLoader类介绍
java.lang.ClassLoader类的基本职责就是根据一个指定的类的名称，找到或者生成其对应的字节代码，然后从这些字节代码中定义出一个 Java 类，即 java.lang.Class类的一个实例。除此之外，ClassLoader还负责加载 Java 应用所需的资源，如图像文件和配置文件等。不过本文只讨论其加载类的功能。为了完成加载类的这个职责，ClassLoader提供了一系列的方法，比较重要的方法如 表 1所示。关于这些方法的细节会在下面进行介绍。
相关方法

简单代码测试内部关系

package com.vvvvvv.test;public class Demo02 {    public static void main(String[] args) {        System.out.println(ClassLoader.getSystemClassLoader());        System.out.println(ClassLoader.getSystemClassLoader().getParent());        System.out.println(ClassLoader.getSystemClassLoader().getParent().getParent());    }}//结果：sun.misc.Launcher$[e-mail]$ExtClassLoader@15db9742null//为什么为Null?由于引导类加载器是由原生代码实现的，所以java获取不到

类加载器的代理模式

交给其他加载器来加载指定的类。

双亲委托机制
就是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次回溯，直到最高的加载器，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务才自己去加载。

双亲委托机制是为了保证Java核心库的类型安全。
例如：
用户自己定义了一个java.lang.Object类，如果采用双亲委托机制，会先一级一级网上找是否有java.lang.Object类，如果有的话就加载，如果没有的话才轮到用户自定义的类加载，这就保证了Java核心类安全。

tomcat服务器类加载器也使用代理模式，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的。

自定义类加载器

//文件类加载器package com.vvvvvv.test;import java.io.ByteArrayOutputStream;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.io.InputStream;public class FileSystemClassLoader extends ClassLoader {    private String rootDir;    public FileSystemClassLoader() {    }    public FileSystemClassLoader(String rootDir) {        super();        this.rootDir = rootDir;    }    protected Class<?> findClass(String name) throws ClassNotFoundException {        Class<?> c = findLoadedClass(name);        if (c != null) {            return c;        } else {            ClassLoader parent = this.getParent();            try {                c = parent.loadClass(name);            } catch (Exception e) {                e.printStackTrace();            }            if (c != null) {                return c;            } else {                byte[] classData = getClassData(name);                if (classData == null) {                    throw new ClassNotFoundException();                } else {                    c = defineClass(name, classData, 0, classData.length);                }            }        }        return c;    }    private byte[] getClassData(String name) {        String path = rootDir + "/" + name.replace('.', '/') + ".class";        InputStream is = null;        ByteArrayOutputStream baos = new ByteArrayOutputStream();        try {            is = new FileInputStream(path);            int len = 0;            byte[] b = new byte[1024];            while ((len = is.read(b)) != -1) {                baos.write(b, 0, len);                baos.flush();            }            return baos.toByteArray();        } catch (FileNotFoundException e) {            // TODO Auto-generated catch block            e.printStackTrace();            return null;        } catch (IOException e) {            // TODO Auto-generated catch block            e.printStackTrace();            return null;        } finally {            try {                if (is != null) {                    is.close();                }            } catch (IOException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            try {                if (baos != null) {                    baos.close();                }            } catch (IOException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }    }}

//网络类加载器package com.vvvvvv.test;import java.io.ByteArrayOutputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.io.InputStream;import java.net.URL;public class NetClassLoader extends ClassLoader {    private String rootUrl;    public NetClassLoader() {    }    public NetClassLoader(String rootUrl) {        super();        this.rootUrl = rootUrl;    }    protected Class<?> findClass(String name) throws ClassNotFoundException {        Class<?> c = findLoadedClass(name);        if (c != null) {            return c;        } else {            ClassLoader parent = this.getParent();            try {                c = parent.loadClass(name);            } catch (Exception e) {                e.printStackTrace();            }            if (c != null) {                return c;            } else {                byte[] classData = getClassData(name);                if (classData == null) {                    throw new ClassNotFoundException();                } else {                    c = defineClass(name, classData, 0, classData.length);                }            }        }        return c;    }    private byte[] getClassData(String name) {        String path = rootUrl + "/" + name.replace('.', '/') + ".class";        InputStream is = null;        ByteArrayOutputStream baos = new ByteArrayOutputStream();        try {            URL url = new URL(path);            is = url.openStream();            int len = 0;            byte[] b = new byte[1024];            while ((len = is.read(b)) != -1) {                baos.write(b, 0, len);                baos.flush();            }            return baos.toByteArray();        } catch (FileNotFoundException e) {            // TODO Auto-generated catch block            e.printStackTrace();            return null;        } catch (IOException e) {            // TODO Auto-generated catch block            e.printStackTrace();            return null;        } finally {            try {                if (is != null) {                    is.close();                }            } catch (IOException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            try {                if (baos != null) {                    baos.close();                }            } catch (IOException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }    }}