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定义,也就是连现行工作目录的路径也覆盖了。

 

发表评论

邮箱地址不会被公开。 必填项已用*标注

昵称 *