反射是框架设计的灵魂，从动态代理到spring IOC，都有它的身影。

什么是反射

JAVA反射是指在运行状态中，对于任何的一个类都能知道这个类里面所以的方法，属性；对于任何一个对象都可以调用它的方法和属性。

反射机制的相关类

反射机制就是识别未知类型的对象，每个类都会产生一个对应的Class对象，也就是保存在.class文件。所有类都是在对其第一次使用时，动态加载到JVM的，当程序创建一个对类的静态成员的引用时，就会加载这个类。Class对象仅在需要的时候才会加载，static初始化是在类加载时进行的。

类加载器首先会检查这个类的Class对象是否已被加载过，如果尚未加载，默认的类加载器就会根据类名查找对应的.class文件。

如果想在运行时使用类型信息，必须获取对象(比如类Base对象)的Class对象的引用，使用功能Class.forName()可以实现该目的，或者使用base.class，或者p.getClass()。值得注意的是，使用功能”.class”来创建Class对象的引用时，不会自动初始化该Class对象，使用forName()会自动初始化该Class对象，例如：

package ref;
class Base {
	static int n = 1;
	static {
		System.out.println("n的值： " + n);
	}
}
public class DemoTest {
	public static void main(String[] args) 
			throws ClassNotFoundException {
		// 不会初始化静态块
		Class clazz1 = Base.class;
		System.out.println("####");
		// 会初始化
		Class clazz2 = Class.forName("ref.Base");
		System.out.println("####");
		//使用对象获取
		Base base = new Base();
		Class clazz3 = base.getClass();
	}
}

打印结果：

####
n的值： 1
####

Class类与java.lang.reflect类库一起支持了反射，该类库包含Field类、Method类和Constructor类，这些类的对象由JVM在启动时创建，用以表示未知类里对应的成员。这样的话就可以使用Contructor创建新的对象，用get()和set()方法获取和修改类中与Field对象关联的字段，用invoke()方法调用与Method对象关联的方法。另外，还可以调用getFields()、getMethods()和getConstructors()等许多便利的方法，以返回表示字段、方法、以及构造器对象的数组，这样，对象信息可以在运行时被完全确定下来，而在编译时不需要知道关于类的任何事情。

反射机制并没有什么神奇之处，当通过反射与一个未知类型的对象打交道时，JVM只是简单地检查这个对象，看它属于哪个特定的类。因此，那个类的.class对于JVM来说必须是可获取的，要么在本地机器上，要么从网络获取。所以对于RTTI（RTTI，Run-Time Type Identification)和反射之间的真正区别只在于：

• RTTI，编译器在编译时打开和检查.class文件
• 反射，运行时打开和检查.class文件

泛化的Class引用

Class<Long>对象的引用指定了Long对象，所以不能将引用指向String.class。为了放松限制可以使用通配符?，即Class<?>，效果跟Class是一样的，但是代码更为优雅，使用Class<?>表示你并非是碰巧或疏忽才使用一个非具体的类引用。同时，也可以限制继承的类，如：

 Class<? extends Base> cc = Peaple.class;

反射机制应用

Spring中的IoC的实现原理就是工厂模式加反射机制。我们一起看下如下代码：

1、不用反射机制时的工厂模式

package ref;

/**

* 工厂模式

*/

interface fruit{

public abstract void eat();

}

class Apple implements fruit{

public void eat(){

System.out.println("Apple");

}

}

class Orange implements fruit{

public void eat(){

System.out.println("Orange");

}

}

// 构造工厂类

// 也就是说以后如果我们在添加其他的实例的时候需要修改工厂类

class Factory{

public static fruit getInstance(String fruitName){

fruit f=null;

if("Apple".equals(fruitName)){

f=new Apple();

}

if("Orange".equals(fruitName)){

f=new Orange();

}

return f;

}

}

public class DemoTest1{

public static void main(String[] a){

fruit fruit=Factory.getInstance("Apple");

fruit.eat();

}

}

打印结果：

 Apple

2、利用反射机制的工厂模式

package ref2;
interface fruit{
 public abstract void eat();
}
class Apple implements fruit{
 public void eat(){
 System.out.println("Apple");
 }
}
class Orange implements fruit{
 public void eat(){
 System.out.println("Orange");
 }
}
//通过反射机制创建类
class Factory{
 public static fruit getInstance(String ClassName){
 fruit f=null;
 try{
 f=(fruit)Class.forName(ClassName).newInstance();
 }catch (Exception e) {
 e.printStackTrace();
 }
 return f;
 }
}
public class DemoTest2{
 public static void main(String[] a){
 fruit fruit=Factory.getInstance("ref2.Apple");
 if(fruit!=null){
 	fruit.eat();
 }
 }
}

打印结果：

Apple

由此可见，如果我们现在添加任意多个子类的时候，工厂类都不用修改。

使用反射机制的工厂模式可以通过反射取得接口的实例，但是需要传入完整的包和类名。而且用户也无法知道一个接口有多少个可以使用的子类，所以我们通过属性文件的形式配置所需要的子类

3、使用反射机制并结合配置文件的工厂模式

首先创建一个fruit.properties的资源文件，内容如下：

 apple=ref3.Apple
 orange=ref3.Orange

测试类代码如下：

package ref3;
import java.io.*;
import java.util.*;
interface fruit{
 public abstract void eat();
}
class Apple implements fruit{
 public void eat(){
 System.out.println("Apple");
 }
}
class Orange implements fruit{
 public void eat(){
 System.out.println("Orange");
 }
}
class Factory{
 public static fruit getInstance(String ClassName){
 fruit f=null;
 try{
 f=(fruit)Class.forName(ClassName).newInstance();
 }catch (Exception e) {
 e.printStackTrace();
 }
 return f;
 }
}
class DemoTest3{
 public static void main(String[] a) throws FileNotFoundException, IOException{
 	Properties pro=new Properties();
 //加载配置文件
 	InputStream in = DemoTest3.class.getResourceAsStream("fruit.propertes");
 	pro.load(in);
 fruit fruit=Factory.getInstance(pro.getProperty("apple"));
 if(fruit!=null){
 	fruit.eat();
 }
 }
}