类加载与类初始化

很多人会把这两个概念混淆。我们先来看看这两者的概念。

类加载

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

\quad ·加载

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

\quad ·链接

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

\quad ·初始化

\quad • 初始化阶段是执行类构造器()方法的过程。类构造器()方法是由编译器自动收集
类中的所有类变量的赋值动作和静态语句块(static块)中的语句合并产生的。
\quad • 当初始化一个类的时候，如果发现其父类还没有进行过初始化、则需要先出发其父类的初始化。
\quad • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

类初始化

没错，这其实是类加载的最后一个过程。只是很多时候我们执行完前面两步后马上就会执行初始化，所以有时会用它来指代整个类加载。但我们应该分清楚。下面我们看看什么时候会发生类初始化。

\quad 类的主动引用（一定会发生类的初始化）

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

\quad 类的被动引用(不会发生类的初始化)

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

public class Demo02 {
    static {
        System.out.println("main方法所在类初始化啦");
    }

    public static void main(String[] args) {
        //A a = new A();
        System.out.println(A.a);  //访问类A的静态常量，不初始化类A
        System.out.println(B.name); //由类B访问继承自类A的静态变量，不初始化类B
    }
}

class A {
    public static final int a = 8;
    public static String name = "Jack";
    static {
        System.out.println("A初始化啦");
    }
}

class B extends A {
    static {
        System.out.println("B初始化啦");
    }
}

类加载器

• 类加载器的作用

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

• 类缓存

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

java.class.ClassLoader类

• 作用：
\quad – java.lang.ClassLoader类的基本职责就是根据一个指定的类的名称，找到或者生成其对应的字节代码，然后从这些字节代码中定义出一个Java 类，即 java.lang.Class类的一个实例。
\quad – 除此之外，ClassLoader还负责加载 Java 应用所需的资源，如图像文件和配置文件等。

类加载器的层次结构(树状结构)

以上类加载器间的父子关系为组合而非继承

• 引导类加载器（bootstrap class loader）

– 它用来加载 Java 的核心库(JAVA_HOME/jre/lib/rt.jar,或sun.boot.class.path路径下的
内容)，是用原生代码来实现的，并不继承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 类。一般来说，Java 应用的类都是由它来完成加载的。
– 由sun.misc.Launcher$AppClassLoader实现

• 自定义类加载器

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

类加载器的代理模式

·代理模式

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

·双亲委托机制

– 就是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次追溯，直到最高的爷爷辈的，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。
– 双亲委托机制是为了保证 Java 核心库的类型安全。
• 这种机制就保证不会出现用户自己能定义java.lang.Object类的情况。
– 类加载器除了用于加载类，也是安全的最基本的屏障。

·双亲委托机制是代理模式的一种

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

自定义类加载器

常见的有：
• 文件系统类加载器
• 文件类加载器
• 网络类加载器
• 加密解密类加载器

• 自定义类加载器的流程：

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

public class FileSystemClassLoader extends ClassLoader {
    private String rootDir; //.class文件所在目录

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

    @Override
    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 className) {
        String path = rootDir + "/" + className.replace('.', '/') + ".class";
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try(InputStream is = new FileInputStream(path)) {
            byte[] buff = new byte[1024];
            int len = -1;
            while((len = is.read(buff)) != -1)
                baos.write(buff, 0, len);
            return baos.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public class Demo03 {
    public static void main(String[] args) throws Exception {
        FileSystemClassLoader loader = new FileSystemClassLoader("d:/test");
        Class<?> c = loader.loadClass("com.sxt.gaoqi.Hello");
        System.out.println(c);
    }
}

思考：Class.forName(String classname)也能返回一个Class对象，它和ClassLoader.loadClass(String name)有什么区别？
我们来看看Class.forName(String classname)的源码：

@CallerSensitive
public static Class<?> forName(String className)
            throws ClassNotFoundException {
    Class<?> caller = Reflection.getCallerClass();
    return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}

它最后调用的是forName0()，我们再看看这又是什么东西：

private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller)
        throws ClassNotFoundException;

好吧，我承认我看不出它有什么用，不过我们可以看看它的形参名，第一个是类名，第二个是一个布尔类型的变量，叫initialize，即是否对类进行初始化，第三个是类加载器，也就是说forName()实际上也是调用ClassLoader来实现的。再看看forName(String classname)中调用forName0()时传入的第二个参数，是true，表明它会初始化加载的类。
实际上forName()有一个重载的方法可以手动选择是否要初始化类。

* @param name       fully qualified name of the desired class
* @param initialize if {@code true} the class will be initialized.
*                   See Section 12.4 of <em>The Java Language Specification</em>.
* @param loader     class loader from which the class must be loaded
//省略其它注释
@CallerSensitive
public static Class<?> forName(String name, boolean initialize,
                               ClassLoader loader)
    throws ClassNotFoundException
{
    Class<?> caller = null;
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        // Reflective call to get caller class is only needed if a security manager
        // is present.  Avoid the overhead of making this call otherwise.
        caller = Reflection.getCallerClass();
        if (loader == null) {
            ClassLoader ccl = ClassLoader.getClassLoader(caller);
            if (ccl != null) {
                sm.checkPermission(
                    SecurityConstants.GET_CLASSLOADER_PERMISSION);
            }
        }
    }
    return forName0(name, initialize, loader, caller);
}

第二行注释描述的是：if {@code true} the class will be initialized. 也就是说，如果该参数为true，则加载的类会被初始化。