------- android培训、java培训、期待与您交流！
----------

0.类加载机制知识体系

1.类与JVM进程

使用Java命令运行某个Java程序时，此命令会启动一个Java虚拟机进程，不管Java程序多复杂，开启了多少个线程，这个线程都运行在Java虚拟机进程里。同一个JVM的所有线程、所有变量都处于同一个进程里，都使用该JVM进程的内存区。

只有出现下列情况时，JVM进程才会终止：

1）程序正常结束。

2）程序执行到代码System.exit()或Runtime.getRuntime().exit()。

3）程序执行过程中遇到未捕获的异常或错误。

4）程序所在平台强制结束JVM进程。

如上介绍，当Java程序运行结束时，JVM进程结束，该进程在内存中的状态将会丢失。

如下代码可以看出：

class StaticValue {
	public static int val = 6;
}

public class ProcessTestA{
	//一个JVM进程
	public static void main(String[] args){
		StaticValue sv1 = new StaticValue();
		sv1.val++;
		System.out.println(sv1.val);
	}
}

public class ProcessTestB{
	//另一个JVM进程
	public static void main(String[] args){
		StaticValue sv2 = new StaticValue();
		System.out.println(sv2.val);
	}
}

以上两个程序属于不同的JVM进程，其中静态数据不能共享，一个输出7，一个输出6。

1.类加载、连接和初始化过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化3个步骤对该类进行初始化。如果没有意外发生，JVM将会连续完成这3个步骤，故有时也把此3步骤统称为类加载或类初始化。

1）类加载

类加载指是将类的class文件读入内存，并为之创建java.lang.class对象，即当程序使用任何类时，系统都会为之建立一个java.lang.Class对象。

注：类是某一类对象的抽象，类是概念层次的东西，但需要明白类本身其实也是一种对象 ，JVM中所有类实际上也是实例，都是java.lang.Class的实例。

类的加载由类加载器完成，类加载器通常由JVM提供，它们是所有程序运行的基础，JVM提供的类加载器称为系统类加载器；除此之外，还可以通过继承ClassLoader基类创建自己的类加载器。

不同的类加载器可以从不同来源加载类的二进制数据，通常有如下几种来源：

（1）从本地文件系统加载class文件。

（2）Java源文件动态编译并执行加载。

（3）从JAR包加载class文件，JDBC加载数据库驱动类就是该种方式。

（4）通过网络加载class文件。

加载器通常无须等到“首次使用”该类时才加载该类，JVM允许系统预先加载某些类，如String。

当类被加载之后，系统为之生成一个对应的Class对象，接着就会进入连接阶段。

2）类连接

连接阶段负责把类的二进制数据合并到JRE中，其又可以分成如下3个阶段：

（1）验证

验证阶段用于检测被加载的类是否有正确的内部结构，并和其它类协调一致。

（2）准备

类准备阶段则负责为类的静态字段分配内存，并设置默认初始值。

（3）解析

将类的二进制数据中的符号引用替换成直接引用。

3）类初始化

（1）初始化过程

在类的初始化阶段虚拟机负责对类进行初始化，主要是对静态字段进行初始化。对静态字段指定初始值有两种方式：①声明静态字段时指定初始值；②使用静态初始化块为静态字段指定初始值。如下代码：

public class InitTest {
	static{
		//2.使用静态初始化块为b初始化值
		b = 32;
	}
	//1.声明变量时指定初始值
	public static int a = 23;
	public static int b;
	//3.没有指定初始值，使用的默认初始值
	public static int c;
	public static void main(String[] args){
		System.out.println(a + " " + b + " " + c);
	}
}

声明变量时指定初始值，静态初始化块都将被当成类的初始化语句 ，JVM会这个语句在程序中的排列顺序依次执行他们。如下

public class InitTest {
	static{
		b = 32;
		System.out.println("b初始化完成！");
	}
	public static int a = 23;
	public static int b;
	public static int c;
	public static void main(String[] args){
		System.out.println(a + " " + b + " " + c);
	}
}

JVM初始化一个类包含如下几个步骤：

a. 假如此类没有被加载连接，则程序先加载并连接该类。

b. 假如该类的直接父类还没有初始化，则先初始化其直接父类。

c. 假如类中有初始化语句，则系统依次执行这些初始化语句。

当执行到第2个步骤时，系统对直接父类的初始化步骤也遵循此步骤1-3；如果该直接父类又有直接父类，则系统再次重复这3步骤来初始化父类...所以JVM最先初始化的总是java.lang.Object类。当程序主动使用任何一个类，系统会保证该类以及所有父类（包括直接父类和间接父类）都会被初始化。

（2）类初始化时机

当程序首次通过下面6种方式使用某个类或接口时，系统就会初始化该类或接口。

a. 创建类的实例。为某个类创建实例的方式包括：使用new操作符创建实例；通过反射创建实例；通过反序列化创建实例。

b. 调用某个类的静态方法。

c. 访问某个类或接口的静态字段，或为该静态字段赋值。

d. 使用反射方式强制创建某个类或接口对应的java.lang.Class对象。如代码：Class.forName("Person")，如果系统还未初始化Person，此处就会导致Person类被初始化，并返回Person类对应的java.lang.Class对象。

e. 初始化某个类的子类。当初始化某个类的子类时，该子类的所有父类都会被初始化。

f. 直接使用java.exe命令运行某个主类。当运行某个主类时，程序会先初始化该主类。

对于一个final型的静态字段，如果该字段的值在编译时就可以确定下来，那么此字段就相当于宏变量，Java编译器会在出现此字段的地方替换成它的值，因此即使程序使用该静态字段，也不会导致该类的初始化。

如下代码：

class Constant{
	static{
		System.out.println("该类正在初始化...");
	}
	public static final int luckNum = 23;
}
public class ConstantTest {

	public static void main(String[] args)
	{
		System.out.println(Constant.luckNum);//只输出23，因为luckNum当成宏变量处理。
	}
}

而如下代码，就会输出文字：

class Constant{
	static{
		System.out.println("该类正在初始化...");
	}
	public static final int luckNum = (int)System.currentTimeMillis();
}
public class ConstantTest {
	public static void main(String[] args) {
		System.out.println(Constant.luckNum);//输出句子
	}
}

因为luckNum必须在运行时才能确定，所有ConstantTest类必须对Constant类的静态字段保持引用，使用了字段导致类被初始化。

当使用ClassLoader类的loadClass()方法加载某个类时，该方法只是加载该类，并不会执行该类的初始化。使用Class的forName()静态方法才会导致强制初始化该类。如下代码可以证明这点：

class TargetClass{
	static{
		System.out.println("正在初加载！");
	}
}
public class ClassLoaderTest {
	public static void main(String[] args) throws ClassNotFoundException{
		ClassLoader c = ClassLoader.getSystemClassLoader();
		c.loadClass("TargetClass");//不会完成类的初始化
		System.out.println("loadClass Finished");
		Class.forName("TargetClass");//完成类的初始化
	}
}

2.类加载器

1）类加载器简介

类加载器负责将.class文件（可能在磁盘或网络上）加载到内存中，并为之生成对应的java.lang.Class对象，一旦一个类被加载 JVM中，同一个类就不会被再次被载入，那么JVM是如何计算“同一类的”？

Java中的对象有唯一的标识，每个载入JVM的类也有唯一的标识。Java中是其全限定类名（包名和类名）作为标识，而在JVM中，一个类用其全限定类名和其类加载器作为其唯一标识。如：Person类在pg包中，被类加载器ClassLoader的对象cl负责加载，则该类对应的Class对象在JVM中表示为(Person、pg、cl）。

（1）根类加载器：Bootstrap ClassLoader

其中Bootstrap ClassLoader被称为引导（原始、根）类加载器，负责加载Java的核心类。当执行java.exe时，使用-Xbootclasspath选项或使用-D选项指定sun.boot.class.path系统属性值可以指定加载附加的类。根类加载器非常特殊，它并不是java.lang.ClassLoader的子类，而是由JVM自身实现的。

下面程序可以获得根类加载器所加载的核心类库。

import java.net.URL;

public class BootstrapTest {
	public static void main(String[] args){

		URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
		for(int i = 0; i < urls.length; i++){
			System.out.println(urls[i].toExternalForm());
		}
	}
}

（2）扩展类加载器：Extension ClassLoader

Extention ClassLoader被称为扩展类加载器，负责JRE的扩展目录（%JAVA_HOME%/jre/lib/ext或由java.ext.dirs系统属性指定的目录）中JAR包的类。通过这种方式，就可以为java扩展核心类以外的新功能，只要把开发好的jar包文件放入此目录下即可。

（3）系统类加载器：System ClassLoader

System ClassLoader被称为系统（应用）类加载器，它负责在JVM启动时加载来自java命令-classpath选项、java.class.path系统属性，或CLASSPATH环境变量所指定的JAR包和类路径。程序可以通过ClassLoader的静态方法getSystemClassLoader()获取系统类加载器。如果没有特别指定，则用户自定义类加载器都此类加载器作为父加载器。

2）类加载器工作机制

JVM的类加载器工作机制主要有以下3种：

（1）全盘负责

所谓全盘负责，就是当一个类加载器负责加载某个class时，该Class所依赖的和引用的其它Class也将由该类加载器负责载入，除非显式使用另一个类加载器来载入。

（2）父类委托

所谓父类委托，则是让parent（父）类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。

（3）缓存机制

缓存机制将保证所有加载过的Class都会被缓存，当程序中需要使用某个Class时类加载器先从缓存中搜寻该Class，只有当缓存中不存在该Class对象时，系统才会读取该类所对应的二进制数据并将其转换成Class对象，存入缓存区中，这也就是为什么修改了Class后必须要重新启动JVM，程序所做的修改才会生效。 除了Java提供的类加载器之外，用户可以实现自己的类加载器，自定义的类加载器通过继承ClassLoader实现。

下面程序说明如何访问JVM中的类加载器。

import java.net.URL;
import java.util.Enumeration;
import java.io.IOException;

public class ClassLoaderTest
{
	public static void main(String[] args) throws IOException
	{
		//获取系统类加载器
		ClassLoader cl = ClassLoader.getSystemClassLoader();
		System.out.println(cl);
		/*
			获取系统类加载器的加载路径--通常是由CLASSPATH环境变量指定。如果操作系统没有指定CLASSPATH环境变量，
			默认以当前路径作为系统加载器的加载路径。
		*/
		Enumeration<URL> emurl = cl.getResources("");
		while(emurl.hasMoreElements()){
			System.out.println(emurl.nextElement());
		}
		//获取系统类加载器的父类加载器，得到扩展类加载器
		ClassLoader extLoader = cl.getParent();
		System.out.println("扩展类加载器：" + extLoader);
		System.out.println("扩展类加载器的加载路径：" + System.getProperty("java.ext.dirs"));
		System.out.println("扩展类加载器的parent：" + extLoader.getParent());
	}
}

根类加载器并没有继承ClassLoader抽象类，所以扩展类加载器getParent()方法返回null，但实际上，扩展类加载器的父类加载器是根类加载器，只是根类加载器并不是由java语言实现，而且程序通常无需访问根类加载器，因此访问扩展类加载器的父类加载器时返回null。

系统类加载器是AppClassLoader的实例，扩展类加载器是ExtClassLoader的实例，两者都是URLClassLoader类的实例。

类加载器加载Class通常经过如下8个步骤：

（1）检测此Class是否载入过（即在缓存区中是否有此Class），如果有则直接进入第8步，否则接着执行第2步。

（2）如果父类加载器不存在（如果没有父类加载，则要么parent一定是根类加载器，要么本身就是根类加载器），则执行第4步；如果父类加载器存在，执行第3步。

（3）请求使用父类加载器去载入目标类，如果成功载入则跳到第8步，否则接着执行第5步。

（4）请求使用根类加载器载入目标，如果成功载入则跳到第8步，否则跳到第7步。

（5）当前类加载器尝试寻找Class文件（从与此ClassLoader相关的类路径中寻找），如果找到则执行第6步，如果找不到则跳到第7步。

（6）从文件中载入Class，成功载入后跳到第8步。

（7）返回对应的ClassNotFoundException异常。

（8）返回对应的java.lang.Class对象。

第6、6步允许重写ClassLoader的findClass()方法来实现自己的载入策略，甚至重写loadClass()方法实现自己的载入过程。

3）创建并使用自定义的类加载器

Java中除根类加载器之外的所有的类加载器都是ClassLoader子类的实例，开发者可以通过扩展ClassLoader子类，并重写ClassLoader所包含的方法来实现自定义的类加载器。ClassLoader中包含大量protected方法，这些方法都可被子类重写。

（1）ClassLoader两个关键方法

ClassLoader类有如下两个关键方法：

a. loadClass(String name,boolean resolve)：该方法是ClassLoader的入口点，根据指定的二进制名称来加载类，系统就是调用ClassLoader的该方法来获取指定类对应的Class对象。

b. findClass(String name)：根据二进制名称来查找类。

如果需要实现自定义的ClassLoader，则可以通过重写以上两个方法来实现，推荐重写findClass()方法而不是loadClass()方法。

（2）loadClass()方法的执行步骤

a. 用findLoadedClass(String)：检查是否已经加载类，如果已经加载则直接返回。

b. 在父类加载器上调用loadClass()方法。如果父类加载器为null，则使用根类加载器来加载。

c. 调用findClass(String)方法查找类。

从上面步骤中可以看出，重写findClass()方法可以避免覆盖默认类加载器的父类委托、缓冲机制两种策略；如果重写loadClass()方法，则实现逻辑更为复杂。

在ClassLoader里还有一个核心方法：Clss defineClass(String name,byte[] b,int off,int len)，该方法负责将指定类的字节码文件（即Class文件）读入字节数组byte[] b内，并将它转换成Class对象，该字节码文件可以来源于文件或网络等。

defineClass()方法管理JVM的许多复杂实现，它负责将字节码分成运行时数据结构，并校验有效性，该方法不能重写，因为是final型。

（3）ClassLoader中普通方法

（1）findSystemClass(String name)：从本地文件系统装入文件。它在本地文件系统中寻找类文件，如果存在，就使用defineClass()方法将原始字节转换成Class对象，以将该文件转换成类。

（2）static getSystemClassLoader()：静态方法，用于返回系统类加载器。

（3）getParent()：获取该类加载器的父类加载器。

（4）resolveClass(Class<?> C)：链接指定的类。类加载器可以使用此方法来链接类c。

（5）findLoadedClass(String name)：如果此java虚拟机已加载了名为name的类，则直接返回该类对应的Class实例，否则返回null。该方法是java类加载缓存机制的体现。

4）URLClassLoader类

Java为ClassLoader提供了URLClassLoader实现类，该类也是系统类加载器和扩展类加载器的父类（此处是父类，就是指类与类之间的继承关系）。URLClassLoader功能比较强大，它既可以从本地文件系统获取二进制文件来加载类，也可以从远程主机获取二进制文件来加载类。

实际上，在应用程序可以直接使用URLClassLoader来加载类，URLClassLoader类提供了如下两个构造器。

（1）URLClassLoader(URL[] urls)：使用默认父类加载器创建一个ClassLoader对象，该对象将从urls所指定的系列路径来查询并加载类。

（2）URLClassLoader(URL[] urls,ClassLoader parent)：使用指定的父类加载器创建一个ClassLoader对象，其他功能与前一个构造器相同。

一旦得到了URLClassLoader对象之后，就可以调用对象的loadClass()来加载指定类。下面程序示范了如何直接从文件系统中加载MySQL驱动，并使用该驱动来获取数据库连接。通过这种方式获取数据库连接，可以无须将MySQL驱动添加到CLASSSPATH环境变量中。

------- android培训、java培训、期待与您交流！
----------

黑马程序员_类加载机制