Java中的反射（二）

1. 当在命令行模式下执行java XXX.class 指令后，java运行程序会尝试找到JRE安装的所在目录，然后寻找jvm.dll(默认是在JRE目录下bin\client目录中),接着启动JVM并进行初始化动作，产生Bootstrap Loader，Bootstrap Loader会加载Extended Loader，并设定Extended Loader的parent为Bootstrap Loader。Bootstrap Loader会加载System Loader，并将System Loader的parent设定为Extended Loader。

2. Bootstrap Loader通常由C编写而成，Extended Loader是由Java编写而成，实际是对应于sun.misc.Launcher$ExtClassLoader(Launcher中的内部类)。System Loader是由Java编写而成，实际对应于sun.misc.Launcher$AppClassLoader(Launcher中的内部类)。

3.java程序启动与加载类的顺序如下：java XXX.class----->找到JRE目录----->找到jvm.dll---->JVM初始化--->产生BootStrap Loader ----(parent)---->载入ExtClassLoader---(parent)---->载入AppClassLoader---->载入XXX.class。

4. BootStrap Loader会搜索系统参数sun.boot.class.path中指定位置的类，默认是JRE所在目录的classes下的.class文件，或lib目录下.jar文件中的类并加载。可以使用"System.getProperty("sun.boot.class.path")语句来显示sun.boot.class.path中指定的路径。

5. Extended Loader(sun.misc.Launcher$ExtClassLoader)会搜索系统参数java.ext.dirs中指定位置的类，默认是JRE目录下lib\ext\classes目录下的.class文件，或lib\ext目录下的.jar文件中的类并加载。可以使用"System.getProperty("java.ext.dirs")语句来显示java.ext.dirs中指定的路径。

6. System Loader(sun.misc.Launcher$AppClassLoader)会搜索系统参数java.class.path中指定位置的类，也就是Classpath所指定的路径，默认是当前工作路径下的.class文件。可以使用System.getProperty("java.class.path")语句来显示java.class.path中指定的路径，在使用java运行程序时，也可以加上-cp来覆盖原有的Classpath设定，例如：

     java -cp ./classes SomeClass

7.Bootstrap Loader会在JVM启动后产生，然后它会加载Extended Loader并将其parent设为Bootstrap Loader，接着Bootstrap Loader会加载System Loader并将其parent设定为Extended Loader,最后System Loader开始加载指定的类。在加载类时，每个类加载器会先将加载类的任务交给其parent，如果parent找不到，再由自己负责加载。所以在加载时，会以Bootstrap Loader--->Extended Loader---->System Loader的顺序来寻找类，如果都找不到，会抛出NoClassDefFoundError。

8. 类加载器在Java中以java.lang.ClassLoader类型存在，每个类被加载后，都会有一个Class的实例来代表，而每个Class的实例都会记得自己是由哪个ClassLoader加载的。可以由Class的getClassLoader()方法取得加载该类的ClassLoader，而从ClassLoader的getParent()方法可以取得自己的parent。

                             getClass()                                  getClassLoader()                                 getParent()

实例SomeClass-----------------> class SomeClass-------------------------->AppClassLoader-------------------

                             getParent()

>ExtClassLoader------------------------->Bootstrap Loader.                                                                      

 

下面是一个实际例子。  

package ysu.hxy;

public class SomeClass 
{
	public static void main(String[] args) 
	{
		//建立SomeClass实例
        SomeClass some = new SomeClass();
		//取得SomeClass的Class实例
		Class c = some.getClass();
		//取得ClassLoader
		ClassLoader loader = c.getClassLoader();
		System.out.println(loader);
		//取得父ClassLoader
		System.out.println(loader.getParent());
		System.out.println(loader.getParent().getParent());
	}
}

          

运行结果如下：

D:\hxy>java ysu.hxy.SomeClass
sun.misc.Launcher$AppClassLoader@19821f
sun.misc.Launcher$ExtClassLoader@addbf1
null          （这里的null并不是表示ExtClassLoader没有设定parent,而是因为BootStrapLoader通常是由C语言编写的，在Java中并没有一个实际的类来表示它，所以才会显示为null的）  

运行结果解释：

     ysu.hxy.SomeClass是一个自定义类，在当前工作目录下运行程序，首先AppClassLoader会将加载类的任务交给ExeClassLoader，而ExtClassLoader会将加载类的任务交给Bootstrap Loader.由于Bootstrap Loader在它的路径(sun.boot.class.path)下找不到类，所以由ExtClassLoader来试着寻找。而ExtClassLoader在它的路径(java.ext.dirs)下也找不到类，所以由AppClassLoader来试着寻找，AppClassLoader最后在Classpath(java.class.path)设定下找到指定的类并加载。

       如果将SomeClass的.class文件移到JRE目录下的lib\ext\classes下（由于设定了包，所以实际上SomeClass.class要放置在JRE目录下的lib\ext\classes\ysu\hxy下）。重新运行程序（在任何目录下），会看到以下结果：

C:\Documents and Settings\Administrator>java ysu.hxy.SomeClass
sun.misc.Launcher$ExtClassLoader@addbf1
null
Exception in thread "main" java.lang.NullPointerException
        at ysu.hxy.SomeClass.main(SomeClass.java:16)

由于SomeClass这次可以在ExtClassLoader的设定路径下找到，所以会由ExtClassLoader来加载SomeClass类。而ExtClassLoader的parent显示为null,所以再由null上尝试调用getParent()方法就会丢出NullPointerException异常。

 若再将SomeClass上移至JRE目录下的class目录下（实际上是JRE目录下的classes/ysu/hxy下）。在任意目录下重新运行程序结果如下：

C:\Documents and Settings\Administrator>java ysu.hxy.SomeClass
null
Exception in thread "main" java.lang.NullPointerException
        at ysu.hxy.SomeClass.main(SomeClass.java:15)

原因与上面类似。

9.取得ClassLoader的实例之后，可以使用它的loadClass()方法来加载类。使用loadClass()方法加载类时，不会运行静态区块。静态区块的运行会等到真正使用类来建立实例时。如下范例：

package ysu.hxy;

public class TestClass2 {
    static {
        System.out.println("[运行静态区块]");
    }
}

 

package ysu.hxy;

public class ForNameDemoV3 
{
	public static void main(String[] args) 
	{
		try
		{
			System.out.println("载入TestClass2");
			ClassLoader loader = ForNameDemoV3.class.getClassLoader();
			//使用loader加载类，不会执行静态区块，要等到创建对象时才执行静态区块
			Class c = loader.loadClass("ysu.hxy.TestClass2");

			System.out.println("使用TestClass2声明参考名称");
			TestClass2 test = null;

			System.out.println("使用TestClass2创建对象");
			test = new TestClass2();
		}
		catch(ClassNotFoundException e)
        {
			System.out.println("找不到指定的类");
		}
	}
}

 运行结果：

                D:\hxy>java ysu.hxy.ForNameDemoV3
                载入TestClass2
                使用TestClass2声明参考名称
                使用TestClass2创建对象
                [运行静态区块]

10. 使用自己的ClassLoader：

     ExtClassLoader与AppClassLoader都是java.net.URLClassLoader的子类，可以在使用java启动程序时，使用以下的指令来指定ExtClassLoader的搜索路径：

     java -D java.ext.dirs=c:\workspace\YourClass

     可以在使用java启动程序时，使用-classpath或-cp来指定AppClassLoader的搜索路径，也就是设定ClassPath：

     java -classpath c:\workspace\YourClass

     ExtClassLoader与AppClassLoader在程序启动后会在虚拟机中存在一份，在程序运行过程中无法再改变它的搜索路径。如果在程序运行过程中，打算动态从其他路径加载类，就要产生新的类加载器。

     可以使用URLClassLoader来产生新的类加载器，它需要java.net.URL作为其参数来指定类加载的搜索路径。例如：

URL url = new URL("file:/d:/workspace/");
ClassLoader urlClassLoader =
                 new URLClassLoader(new URL[] {url});
Class c = urlClassLoader.loadClass("SomeClass");

     ClassLoader 是J2SE的标准API之一，可以在rt.jar中找到，因而会由Bootstrap Loader来载入ClassLoader类。在新增了ClassLoader实例后，可以使用它的loadClass()方法指定要加载的类名称。在新增ClassLoader 时，会自动将新增的ClassLoader 的parent设定为AppClassLoader，并在每次加载类时，先委托parent代为搜索。所以上例中搜索SomeClass类时，会一直往上委托至Bootstrap Loader开始搜索，接着是ExtClassLoader、AppClassLoader。如果都找不到，才使用新建的ClassLoader搜索。

     Java的类加载器层次架构除了可以达到动态加载类的目的之外，还有着安全上的考虑。因为每次寻找类时都是委托parent开始寻找，所以除非有人可以侵入您的计算机，置换掉标准J2SE API与您自己安装的延伸包，否则不可能通过编写自己的类载入器来载入恶意类，以置换掉标准J2SE API与您自己安装的延伸包。

     由于每次的类载入是由子ClassLoader委托父ClassLoader先尝试加载，但父ClassLoader看不到子ClassLoader，所以同一层次的子ClassLoader不会被误用，从而避免了加载错误类的可能性。

     由同一个ClassLoader加载的类文件，会只有一份Class实例。如果同一个类文件由两个不同的ClassLoader载入，则会有两份不同的Class实例。注意，如果有两个不同的ClassLoader搜索同一个类，而在parent的AppClassLoader搜索路径中可以找到指定类，则Class实例就会有一个，因为两个不同的ClassLoader都是在委托父ClassLoader时找到该类的。如果父ClassLoader找不到，而是由各自的ClassLoader搜索到，则Class的实例会有两份。

     下面范例是一个简单的示范，可用来测试加载路径与Class实例是否为同一对象。

package ysu.hxy;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

public class ClassLoaderDemo
{
	public static void main(String[] args) 
	{
		try
		{
			//测试路径 
			String classPath = args[0];
			//测试类
			String className = args[1];

			URL url1 = new URL(classPath);
			//建立ClassLoader
			ClassLoader loader1 =
				new URLClassLoader(new URL[]{url1});

			//加载指定类 
			Class c1 = loader1.loadClass(className);
			//显示类描述
			System.out.println(c1);

			URL url2 = new URL(classPath);
			//建立ClassLoader
			ClassLoader loader2 =
				new URLClassLoader(new URL[]{url2});

			//加载指定类 
			Class c2 = loader2.loadClass(className);
			//显示类描述
			System.out.println(c2);

			System.out.println("C1与C2为同一实例？"+(c1 == c2));
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println("没有指定类加载路径与名称");
		}
		catch(MalformedURLException e)
		{
			System.out.println("加载路径错误");
		}
		catch(ClassNotFoundException e)
		{
			System.out.println("找不到指定的类");
		}
	}
}

 可以设计任意一个测试类，例如Test，其中classpath可以输入不为ExtClassLoader或AppClassLoader的搜索路径，例如file:d:/workspace/。这样同一个类会分由两个ClassLoader载入，结果会有两份Class实例。测试c1与c2是否为同一实例时，结果会显示false。一个运行结果如下：

      D:\hxy>java ysu.hxy.ClassLoaderDemo file:/d:/ Test3
      class Test3
      class Test3
      C1与C2为同一实例？false

  如果在运行程序时，以-cp将file:/d:/加入为Classpath的一部分，由于两个ClassLoader的parent都是AppClassLoader，而AppClassLoader会在ClassPath中找到指定的类，所以最后会只有一个指定的类的Class实例。测试c1与c2是否为同一实例时，结果会显示true。一个运行结果如下：

                  D:\hxy>java -cp .;d:\ ysu.hxy.ClassLoaderDemo file:d:/ Test3
                  class Test3
                  class Test3
                  C1与C2为同一实例？true

使用-cp指定Classpath时，会覆盖原有的Classpath定义，也就是连现行工作目录的路径也覆盖了。