张孝祥老师Java高新技术学习笔记----------反射【一】及 Java类加载原理及类加载器

反射的基石->Class类
·Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。·对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？
-人-Person
-类-Class
·对比提问：Person类代表人，它的实例对象就是张三，李四这样的一个个具体的人，Class类代表Java类，它的各个实例对象又分别对应什么呢？
-对应各个类的内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
-一个类被类加载器加载到内存中，占用一片内存空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，
所以它们在内存中的内容是不同的，这个一个个的空间可以分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？

·如何得到各个字节码对应的实例对象（Class类型）
-类名.class,例如，System.class
-对象.getClass(),例如，new Date().getClass()
-Class.forName("类名"),例如，Class.forName("java.util.Date");

按参数中指定的字符串形式的类名去搜索并加载相应的类，如果该类字节码已经被加载过，则返回代表该字节码的Class实例对象，否则，按类加载器的委托机制去搜索和加载该类，如果所有的类加载器都无法加载到该类，则抛出ClassNotFoundException。加载完这个Class字节码后，接着就可以使用Class字节码的newInstance方法去创建该类的实例对象了。
有时候，我们程序中所有使用的具体类名在设计时（即开发时）无法确定，只有程序运行时才能确定，这时候就需要使用Class.forName去动态加载该类，这个类名通常是在配置文件中配置的，例如，spring的ioc中每次依赖注入的具体类就是这样配置的，jdbc的驱动类名通常也是通过配置文件来配置的，以便在产品交付使用后不用修改源程序就可以更换驱动类名。

·九个预定义Class实例对象：
-参看Class.isPrimitive方法的帮助
-Int.class == Integer.TYPE
八个基本类型+一个void，可以写成：void.class 形式的。
Boolean.TYPE, Character.TYPE, Byte.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE, Void.TYPE

·数组类型的Class实例对象
-Class.isArray()
-总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[],void...

1.Java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定，不同的实例对象有不同的属性值。Java程序中各个Java类，它们是否属于同一类事物，是不是可以用一个类来描述这个类事物呢？这个类的名字就是Class，要注意与小写class关键字的区别，Class类描述了哪些方面的信息呢？类的名字，类的访问属性，类所属于的包名，字段名的列表、方法名称的列表，等等。学习反射，首先就要明白Class这个类。

==============================================================================

Java类加载原理及类加载器

http://blog.csdn.net/zdwzzu2006/article/details/2253982

Java和其他语言不同的是，Java是运行于Java虚拟机(JVM)。这就意味着编译后的代码是以一种和平台无关的格式保存的，而不是某种特定的机器上运行的格式。这种格式和传统的可执行代码格式有很多重要的区别。具体来说，不同于C或者Ｃ++程序，Java程序不是一个独立的可执行文件，而是由很多分开的类文件组成，每个类文件对应一个Java类。 另外，这些类文件并不是马上加载到内存，而是当程序需要的时候才加载。 类加载器就是Java虚拟机中用来把类加载到内存的工具。而且，Java类加载器也是用Java实现的。这样你就不需要对Java虚拟机有深入的理解就可以很容易创建自己的类加载器了。

为什么要创建类加载器?
既然Java虚拟金已经有了类加载器，我们还要自己创建其他的呢?问得好。默认的类加载器只知道如何从本地系统加载类。当你的程序完全在本机编译的话，默认的类加载器一般都工作的很好。但是Java中最激动人心的地方之一就是很容易的从网络上而不只是本地加载类。举个例子，浏览器可以通过自定义的类加载器加载类。 还有很多加载类的方式。除了简单的从本地或者网络外，你还可以通过自定义Java中最激动人心的地方之一:
* 执行非信任代码前自动验证数字签名
* 根据用户提供的密码解密代码
* 根据用户的需要动态的创建类
你关心的任何东西都能方便的以字节码的形式集成到你的应用中自定义类加载器的例子.如果你已经使用过JDK(Java软件开发包)中的appletviewer（小应用程序浏览器）或者其他Java嵌入式浏览器，你就已经使用了自定义类加载器了。Sun刚刚发布Java语言的时候，最
令人兴奋的一件事就是观看Java如何执行从远程网站下载的代码。执行从远程站点通过HTTP连接传送来的字节码看起来有点不可思议。

之所以能够工作，因为Java有安装自定义类加载器的能力。小应用程序浏览器包含了一个类加载器，这个类加载器不从本地找Java类，而是访问远程服务器，通过HTTP加载原始字节码文件，然后在Java虚拟机中转化为Java类。当然类加载器还做了其他的很多事情：他们阻止不安全的Java类，而且保持不同页面上的不同小程序不会互相干扰。Luke Gorrie写的一个包Echidna是一个开放的Java软件包，他允许在一个Java虚拟机中安全的运行多个Java应用程序。它通过使用自定义类加载器给每个应用程
序一份类文件的拷贝来阻止应用程序之间的干扰。

java类加载器:

java中默认有三种类加载器：引导类加载器，扩展类加载器，系统类加载器(也叫应用类加载器)

类加载器是Java最强大的特征之一。但是开发者常常忘记类加载组件。类加载器是在运行时负责寻找和加载类文件的类。Java允许使用不同的类加载器，甚至自定义的类加载器。

Java 程序包含很多类文件，每一个都与单个Java类相对应，这些类文件不像静态C程序，一次性加载入内存，它们随时需要随时加载。这就是类加载器与众不同的地 方。它从源文件（通常是.class 或 .jar文件）获得不依赖平台的字节码，然后将它们加载到JVM内存空间，所以它们能被解释和执行。默认状态下，应用程序的每个类由 java.lang.ClassLoader加载。因为它可以被继承，所以可以自由地加强其功能。

使用自定义类加载器的原因

　　默认的 java.lang.ClassLoader仅仅可以从加载本地文件系统的类。Java被设计成不论本地磁盘或网络都有足够的弹性加载类，并且可以在加载 之前处理特殊事物。例如：应用程序可以检查Web站点或FTP上插入类的更新版本并且自动校验数字签名确保执行可信任的代码。许多众所周知的软件都使用自 己的类加载器。

通常默认加载器是所谓的bootstrap类加载器；它负责加载诸如java.lang.Object等关键类和加 载其他rt.jar文件的运行时代码到内存。因为Java语言规范没有提供bootstrap类加载器的详细信息，不同的JVM可能有不同的类加载器。如 果看到网页上有applets在运行，则它使用的是自定义类加载器。嵌入到浏览器中的applet阅读器包含了可以访问远程服务器上站点的类加载器，它可 以通过HTTP加载原始字节码文件，并且在JVM中将它们转换成类。

　 类加载器（除了bootstrap类加载器）有父类加载器，这些父类是基本加载器的加载器实例。最重要的一点是设置正确的父加载器。然后可以使用 类加载器的getParent()方法实现委派类请求（例如：自定义类加载器找不到使用专门方法的类时）。此时必须为将父加载器作为 java.lang.ClassLoader构造器的参数：

public class MyClassLoader extends ClassLoader

{
public MyClassLoader()

{

super(MyClassLoader.class.getClassLoader());
}

}

loadClass(String name)方法是ClassLoader的入口。名字参数是完全资格类名（FQCN），例如关于包类名。如果父加载器设置正确，当请求 MyClassLoader中的loadClass(String name)方法加载类，但又找不到需要加载的类时，则首先会询问父加载器。如果父加载器也找不到此类，则调用findClass(String name)方法。默认状态下findClass(String name)会抛出ClassNotFoundException例外，很多开发人员都很清楚这个例外。自定义类加载器的开发者都希望从 java.lang.ClassLoader继承时跳过这个方法。

findClass()方法的目标是为MyClassLoader容纳所有专门代码，此时不需要重复其他代码（例如当加载失败时调用系统 ClassLoader）。在此方法中，ClassLoader需要从原文件中获取字节码。一旦找到字节码则会调用defineClass()方法。 ClassLoader实例调用此方法是非常重要的。因此，如果两个ClassLoader实例定义了来自不同或相同原文件的字节码，则被定义的类也将区 别对待。

我们给出两个相似的类加载器MyClassLoader1 和 MyClassLoader2，它们都可以从相同的源文件找到MyCoolClass字节码。如果一个程序通过这两个加载器分别独立加载 MyCoolClass实例（coolClass1通过MyClassLoader１加载， coolClass2通过MyClassLoader2加载），MyCoolClass.class能够被独立定义。执行下面的代码：

MyCoolClass coolClass1 = (MyCoolClass)coolClass2;

　　将得到一个ClassCastException例外。（开发者如果没有很好的理解类加载机制则经常碰到这样的情况。）因为它们是不同的加载器 所定义的，JVM将它们看成不同的类。虽然它们是相同类型的类并且从相同的源文件加载，但是变量coolClass1和coolClass2不兼容。

不论是否跳过findClass() 或 loadClass()，getSystemClassLoader()方法将以实际ClassLoader对象的形式直接访问系统 ClassLoader。也可以通过调用findSystemClass(String name)方法间接访问。getParent()方法允许获得父加载器。Listing A给出了可以运行的自定义类加载器示例。

==============================================================================

反射
·反射就是把Java类中的各种成分 映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息业用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应的类的实例对象来表示，它们是Field、Method、Contructor、Package等等。
·一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

<pre class="java" name="code">package com.itm.test;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;

public class ReflectTest {

	/**
	 * @param args
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws Exception {
		
		
		String str1 = "abc";
		Class cls1 = str1.getClass();
		Class cls2 = String.class;
		Class cls3 = Class.forName("java.lang.String");
		System.out.println(cls1 == cls2);
		System.out.println(cls1 == cls3);
		
		/**************************
		 * 
		 * 
	 	Constructor类代表某个类中的一个构造方法

		·得到某个来所有的构造方法：
		-例子：Constructor[] constructors = 
							Class.forName("java.lang.String").getConstructors();
		
		
			·得到某一个构造方法：
		-例子：Constructor constructor = 
							Class.forName("java.lang.String").getConstructor(StringBuffer.class);
		 * 
		 * 
		 * 
		 * ********************************************/
		// 得到：StringBuffer类的构造函数。
		//  获得方法时要用到类型。
		Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
		/**
		 * 
		 
		 ·创建实例对象：
 			-通常方式：String str = new String(new StringBuffer("abc"));
 			-反射方式：String str = (String)constructor.newInstance(new StringBuffer("abc"));

		 * 
		 */
		String str2 = (String)constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));
		System.out.println(str2.charAt(2)); // 结果为 c，说明 从零计数开始。
		
		
		
		
		/**
		 * 
		 												重点 理解：
		 												
	Method类
		·Method类代表某个类中的一个成员方法
	·得到类中的某一个方法：
			-例子：Method charAt = Class.forName("java.lang.String").getMethod("charAt",int.class); 
	·调用方法：
		-通常方式：System.out.println(str.charAt(1)); 
		-反射方式：System.out.println(charAt.invoke(str,1));
		
	·如果传递给Method对象的invoke()方法的第一个参数为null，
			这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！
	·jdk1.4和jdk1.5的invoke方法的区别：
			-Jdk1.5：public Object invoke(Object obj,Object... args)
			-Jdk1.4：public Object invoke(Object obj,Object[] args),
					即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，
			
	数组的每个元素分别对应被调用方法中的一个参数，所以，
	调用charAt方法的代码也可以用Jdk1.4改写为charAt.invoke("str",new Object[]{1})形式。
	
		Method methodCharAt = String.class.getMethod("charAt", int.class);
		System.out.println(methodCharAt.invoke(str1, 1));
		 * 
		 */
		//  ·得到类中的某一个方法：
		Method methodCharAt = String.class.getMethod("charAt", int.class);
		System.out.println(methodCharAt.invoke(str1, 1)); // 利用反射机制 调用该方法           结果是   b
		System.out.println(methodCharAt.invoke(str1, new Object[]{2}));  // 是  c
		
		
		
		
		/**************************************************************
		 * 
		 										数组的反射
				具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
				
						·代表数组的Class实例对象的getSuperclass()方法返回的父类为Object类对应的Class。
						·基本类型的一维数组可以被当做Object类型使用，不能当做Object[]类型使用；
						                       非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

		 * 
		 */
		int[] a1 = new int[]{1,2,3};
		int[] a2 = new int[4];
		int[][] a3 = new int[2][3];
		String[] a4 = new String[]{"a","b","c"};
		
		System.out.println(a1.getClass() == a2.getClass());
		System.out.println(a1.getClass().getName());
		System.out.println(a1.getClass().getSuperclass().getName());
		System.out.println(a4.getClass().getSuperclass().getName());
		
		
		Object aObj1 = a1;
		Object aObj2 = a4;
		//Object[] aObj3 = a1;
		Object[] aObj4 = a3;
		Object[] aObj5 = a4;
		
		System.out.println(a1);
		System.out.println(a4);
		/**
		 * 
		 	·Arrays.asList()方法处理int[]和String[]时的差异。
 			System.out.println(Arrays.asList(a1));
 			System.out.println(Arrays.asList(a4)); 
		 * 
		 */
		System.out.println(Arrays.asList(a1));
		System.out.println(Arrays.asList(a4));	
		
		System.out.println("===============================================================");
		
		  printObject(a1);
		  printObject(a4);
		  printObject("zyz");

	}
	
	/**
	 *    
	          ·Array工具类用于完成对数组的反射操作。
	 * @param obj
	 */
	private static void printObject(Object obj){
		Class clazz = obj.getClass();
		if(clazz.isArray()){
			int len  = Array.getLength(obj);
			for(int i=0;i<len;i++){
				System.out.println(Array.get(obj, i));
			}
		}else{
			System.out.println(obj);
		}
	}

	
	
}

</pre>