Java类加载机制

类加载过程

从类被加载到虚拟机内存中开始，到卸载出内存为止，类的生命周期包括加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）7个阶段。

加载：

在加载阶段，虚拟机主要完成三件事：

1.通过一个类的全限定名来获取定义此类的二进制字节流。

2.将这个字节流所代表的静态存储结构转化为方法区域的运行时数据结构。

3.在Java堆中生成一个代表这个类的java.lang.Class对象，作为方法区域数据的访问入口。

验证：

验证阶段作用是保证Class文件的字节流包含的信息符合JVM规范，不会给JVM造成危害。如果验证失败，就会抛出一个java.lang.VerifyError异常或其子类异常。验证过程分为四个阶段：

1.文件格式验证：验证字节流文件是否符合Class文件格式的规范，并且能被当前虚拟机正确的处理。 2.元数据验证：是对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言的规范。 3.字节码验证：主要是进行数据流和控制流的分析，保证被校验类的方法在运行时不会危害虚拟机。 4.符号引用验证：符号引用验证发生在虚拟机将符号引用转化为直接引用的时候，这个转化动作将在解析阶段中发生。

准备：

作用：
为类变量分配内存（这些内存在方法区分配）、
设置类变量零值

注意：
为类变量分配内存（为static对象分配内存，这也就是static变量存储在方法区的原理）类中的实例变量会随着对象实例的创建一起分配在堆中，当然若是基本数据类型的话，会随着对象的创建直接压入操作数栈
为static变量分配零值（默认零值）（eg.static int x = 123;//这时候x = 0，而x = 123是在”初始化”阶段发生的）
为final变量分配初始值（期望值）（eg.final int y = 456;//这时候y = 456）

解析：

解析过程是将常量池内的符号引用替换成直接引用。主要包括四种类型引用的解析。类或接口的解析、字段解析、方法解析、接口方法解析。

初始化：

其中加载（除了自定义加载）+链接（验证+准备+解析）的过程是完全由jvm负责的，什么时候要对类进行初始化工作（加载+链接在此之前已经完成了），jvm有严格的规定（四种情况）：

1.遇到new，getstatic，putstatic，invokestatic这4条字节码指令时，加入类还没进行初始化，则马上对其进行初始化工作。其实就是3种情况：用new实例化一个类时、读取或者设置类的静态字段时（不包括被final修饰的静态字段，因为他们已经被塞进常量池了）、以及执行静态方法的时候。

2.使用java.lang.reflect.的方法对类进行反射调用的时候，如果类还没有进行过初始化，马上对其进行。

3.初始化一个类的时候，如果他的父亲还没有被初始化，则先去初始化其父亲。

4.当jvm启动时，用户需要指定一个要执行的主类（包含static void main(String[] args)的那个类），则jvm会先去初始化这个类。

以上4种预处理称为对一个类进行主动的引用，其余的其他情况，称为被动引用，都不会触发类的初始化。

在准备阶段，类变量已经经过一次初始化了，在这个阶段，则是根据程序员通过程序制定的计划去初始化类的变量和其他资源。这些资源有static{}块，构造函数，父类的初始化等。

类加载过程

“加载”第一阶段：通过一个类的全限定类名来获取定义此类的二进制字节流
“验证”第一阶段：文件格式验证
“加载”第二阶段：将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
“加载”第三阶段：在方法区生成一个java.lang.Class对象，作为方法区内该类的各种数据的访问入口
“验证”第二阶段：元数据验证
“验证”第三阶段：验证方法体的字节码指令
“准备”第一阶段：类变量分配内存
“准备”第二阶段：设置类变量零值
“验证”第四阶段：符号引用验证（追随于”解析”，仅发生在”解析”的时候）
“解析”：符号引用转化为直接引用（不是必须要在”初始化”之前的步骤的步骤）
“初始化”：不一定发生在何时，但是一定要在”加载”、”验证”、”准备”之后

至于使用和卸载阶段阶段，这里不再过多说明，使用过程就是根据程序定义的行为执行，卸载由GC完成。

类加载器

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

类加载器的树状组织结构

Java 中的类加载器大致可以分成两类：一类是系统提供的，另外一类则是由 Java 应用开发人员编写的。系统提供的类加载器主要有下面三个：

（1）引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自 java.lang.ClassLoader。

BootStrapClassLoader

负责jdk_home/jre/lib目录下的核心 api或 -Xbootclasspath选项指定的jar包加载进来。

（2）扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。

ExtClassLoader

负责jdk_home/jre/lib/ext目录下的jar包或 -Djava.ext.dirs指定目录下的jar包加载进来。

（3）系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。

AppClassLoader

负责java -classpath/-Djava.class.path所指的目录下的类与jar包加载进来,System.getClassLoader获取到的就是这个类加载器。

除了系统提供的类加载器以外，开发人员可以通过继承 java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求。

除了引导类加载器之外，所有的类加载器都有一个父类加载器。getParent()方法可以得到。对于系统提供的类加载器来说，系统类加载器的父类加载器是扩展类加载器，而扩展类加载器的父类加载器是引导类加载器；对于开发人员编写的类加载器来说，其父类加载器是加载此类加载器 Java 类的类加载器。因为类加载器 Java 类如同其它的 Java 类一样，也是要由类加载器来加载的。一般来说，开发人员编写的类加载器的父类加载器是系统类加载器。类加载器通过这种方式组织起来，形成树状结构。树的根节点就是引导类加载器。

双亲委派模型

类加载器在尝试自己去查找某个类的字节代码并定义它时，会先代理给其父类加载器，由父类加载器先去尝试加载这个类，依次类推。

在介绍代理模式背后的动机之前，首先需要说明一下 Java 虚拟机是如何判定两个 Java 类是相同的。Java 虚拟机不仅要看类的全名是否相同，还要看加载此类的类加载器是否一样。只有两者都相同的情况，才认为两个类是相同的。即便是同样的字节代码，被不同的类加载器加载之后所得到的类，也是不同的。比如一个 Java 类 com.example.Sample，编译之后生成了字节代码文件 Sample.class。两个不同的类加载器 ClassLoaderA和 ClassLoaderB分别读取了这个 Sample.class文件，并定义出两个 java.lang.Class类的实例来表示这个类。这两个实例是不相同的。对于 Java 虚拟机来说，它们是不同的类。试图对这两个类的对象进行相互赋值，会抛出运行时异常 ClassCastException。

所以才有双亲委派模型，这样的话，可保证加载的类是同一个。

defining loader 和 initiating loader

前面提到过类加载器会首先代理给其它类加载器来尝试加载某个类。这就意味着真正完成类的加载工作的类加载器和启动这个加载过程的类加载器，有可能不是同一个。真正完成类的加载工作是通过调用 defineClass来实现的；而启动类的加载过程是通过调用 loadClass来实现的。前者称为一个类的定义加载器（defining loader），后者称为初始加载器（initiating loader）。在 Java 虚拟机判断两个类是否相同的时候，使用的是类的定义加载器。也就是说，哪个类加载器启动类的加载过程并不重要，重要的是最终定义这个类的加载器。两种类加载器的关联之处在于：一个类的定义加载器是它引用的其它类的初始加载器。如类 com.example.Outer引用了类 com.example.Inner，则由类 com.example.Outer的定义加载器负责启动类 com.example.Inner的加载过程。

方法 loadClass()抛出的是 java.lang.ClassNotFoundException异常；方法 defineClass()抛出的是 java.lang.NoClassDefFoundError异常。

类加载器在成功加载某个类之后，会把得到的 java.lang.Class类的实例缓存起来。下次再请求加载该类的时候，类加载器会直接使用缓存的类的实例，而不会尝试再次加载。也就是说，对于一个类加载器实例来说，相同全名的类只加载一次，即 loadClass方法不会被重复调用。

自定义类加载器

先来看下JDK类加载器的源码

    /**     * Loads the class with the specified <a href="#name">binary name</a>.  The     * default implementation of this method searches for classes in the     * following order:     *     * <ol>     *     *   <li><p> Invoke {@link #findLoadedClass(String)} to check if the class     *   has already been loaded.  </p></li>     *     *   <li><p> Invoke the {@link #loadClass(String) <tt>loadClass</tt>} method     *   on the parent class loader.  If the parent is <tt>null</tt> the class     *   loader built-in to the virtual machine is used, instead.  </p></li>     *     *   <li><p> Invoke the {@link #findClass(String)} method to find the     *   class.  </p></li>     *     * </ol>     *     * <p> If the class was found using the above steps, and the     * <tt>resolve</tt> flag is true, this method will then invoke the {@link     * #resolveClass(Class)} method on the resulting <tt>Class</tt> object.     *     * <p> Subclasses of <tt>ClassLoader</tt> are encouraged to override {@link     * #findClass(String)}, rather than this method.  </p>     *     * <p> Unless overridden, this method synchronizes on the result of     * {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method     * during the entire class loading process.     *     * @param  name     *         The <a href="#name">binary name</a> of the class     *     * @param  resolve     *         If <tt>true</tt> then resolve the class     *     * @return  The resulting <tt>Class</tt> object     *     * @throws  ClassNotFoundException     *          If the class could not be found     */    protected Class<?> loadClass(String name, boolean resolve)        throws ClassNotFoundException    {        synchronized (getClassLoadingLock(name)) {            // First, check if the class has already been loaded            Class<?> c = findLoadedClass(name);            if (c == null) {                long t0 = System.nanoTime();                try {                    if (parent != null) {                        c = parent.loadClass(name, false);                    } else {                        c = findBootstrapClassOrNull(name);                    }                } catch (ClassNotFoundException e) {                    // ClassNotFoundException thrown if class not found                    // from the non-null parent class loader                }                if (c == null) {                    // If still not found, then invoke findClass in order                    // to find the class.                    long t1 = System.nanoTime();                    c = findClass(name);                    // this is the defining class loader; record the stats                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);                    sun.misc.PerfCounter.getFindClasses().increment();                }            }            if (resolve) {                resolveClass(c);            }            return c;        }    }

解释的非常清楚，首先检查该类是否已经被加载；如果未被加载，调用父类加载器的loadClass方法，不断向上调用，直到父类加载器为空，即Bootstrap class loader，然后尝试加载该类（findClass()），如果能加载就返回java.lang.class类型，如果不能就交给子类加载器加载。加载成功后,根据是否需要解析的参数resolve，调用解析方法。

findClass()方法源码：

    /**     * Finds the class with the specified <a href="#name">binary name</a>.     * This method should be overridden by class loader implementations that     * follow the delegation model for loading classes, and will be invoked by     * the {@link #loadClass <tt>loadClass</tt>} method after checking the     * parent class loader for the requested class.  The default implementation     * throws a <tt>ClassNotFoundException</tt>.     *     * @param  name     *         The <a href="#name">binary name</a> of the class     *     * @return  The resulting <tt>Class</tt> object     *     * @throws  ClassNotFoundException     *          If the class could not be found     *     * @since  1.2     */    protected Class<?> findClass(String name) throws ClassNotFoundException {        throw new ClassNotFoundException(name);    }

findClass()方法是一个用来重写的方法，因此自定义类加载器就是继承ClassLoader类，然后重写findClass()方法。

以下是一个自定义类加载期的示例

public class MyClassLoader extends ClassLoader{    public MyClassLoader()    {    }    public MyClassLoader(ClassLoader parent)    {        super(parent);    }    protected Class<?> findClass(String name) throws ClassNotFoundException    {        File file = getClassFile(name);        try        {            byte[] bytes = getClassBytes(file);            Class<?> c = this.defineClass(name, bytes, 0, bytes.length);            return c;        }         catch (Exception e)        {            e.printStackTrace();        }        return super.findClass(name);    }    private File getClassFile(String name)    {        File file = new File("D:/Person.class");        return file;    }    private byte[] getClassBytes(File file) throws Exception    {        // 这里要读入.class的字节，因此要使用字节流        FileInputStream fis = new FileInputStream(file);        FileChannel fc = fis.getChannel();        ByteArrayOutputStream baos = new ByteArrayOutputStream();        WritableByteChannel wbc = Channels.newChannel(baos);        ByteBuffer by = ByteBuffer.allocate(1024);        while (true)        {            int i = fc.read(by);            if (i == 0 || i == -1)                break;            by.flip();            wbc.write(by);            by.clear();        }        fis.close();        return baos.toByteArray();    }}

public class TestMyClassLoader{    public static void main(String[] args) throws Exception    {        MyClassLoader mcl = new MyClassLoader();                Class<?> c1 = Class.forName("com.xrq.classloader.Person", true, mcl);         Object obj = c1.newInstance();        System.out.println(obj);        System.out.println(obj.getClass().getClassLoader());    }}

http://www.cnblogs.com/java-zhao/p/5199364.html
http://www.cnblogs.com/szlbm/p/5504631.html