java反射机制



      引言：最近无意中在项目中看到了使用反射机制的代码，好奇心顿起，于是在网上找了些资料学习了下...

      反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。   

      Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method；其中class代表的时类对 象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象。通过这四个对象我们可以粗略的看到一个类的各个组成部分。
     Java反射机制主要提供了以下功能：在运行时判定任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判定任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。hibernate的延迟载入，spring的AOP都是这么实现的.

 下面我们来看看具体的代码实现：

实体类：Simple

package test;

public class Simple {
	public String a = "zwm";
	protected int m = 2;
	private int i = 1;
	public Simple(){
	  }
   public Simple(String s){
	  this.a=s;
  }
	protected void print(String str, int i) {
		System.out.println(i + "--测试---" + str);
	}
	private void print1(String str ) {
		System.out.println("测试---" + str);
	}
}

测试类：testFs

package test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class testFs {
	public static void main(String[] args) throws ClassNotFoundException,
			SecurityException, NoSuchMethodException, InstantiationException,
			IllegalAccessException, IllegalArgumentException,
			InvocationTargetException, NoSuchFieldException {
		Class<?> simpleClass = Class.forName("test.Simple");
		Object simpelObject = simpleClass.newInstance();
		//getFields()、getDeclaredFields()，它们分别是用来获取反射类中所有公有
		//属性和反射类中所有的属性的方法
		Field[] fields=simpleClass.getFields();//获取反射类中所有公有属性
		System.out.println("获取反射类中所有公有属性:");
		System.out.println("fields.length====>"+fields.length);
		for (int i = 0; i < fields.length; i++) {
			Class<?> cl=fields[i].getType();
			System.out.println("cl===>"+cl);
		}
		Field[] fields1=simpleClass.getDeclaredFields();//获取反射类中所有的属性
		System.out.println("获取反射类中所有的属性:");
		System.out.println("fields1.length====>"+fields1.length);
		for (int i = 0; i < fields1.length; i++) {
			Class<?> cl1=fields1[i].getType();
			System.out.println("cl1===>"+cl1);
		}
		
		Field f = simpleClass.getDeclaredField("i");//获取反射类中私有的属性
		//setAccessible方法，它是用来设置是否有权限访问反射类中的私有属性的，只有设置为true时才可以访问，默认为false
		f.setAccessible(true);    
		Integer i = (Integer)f.get(new Simple());
		System.out.println("获取反射类中私有的属:");
        System.out.println("i====>"+i);
        String className = simpleClass.getName(); //获取指定类的类名    
        Constructor[] constructors = simpleClass.getConstructors();//获取指定类的构造方法   
        System.out.println("获取指定类的构造方法:");
        for ( int  m= 0 ; m<constructors.length; m++) {    
        Class[] parameterTypes = constructors[m].getParameterTypes();//获取指定构造方法的参数的集合
        System.out.print(className + "(" );    
        for ( int  j= 0 ; j<parameterTypes.length; j++)    
        System.out.print(parameterTypes[j].getName() + " " );    
        System.out.println(")" );    
           
        }   

        Method[] Methods= simpleClass.getDeclaredMethods();
        System.out.println("获取指定类的所有方法");
        for (int j = 0; j < Methods.length; j++) {
        	//输出方法的返回类型     
        	System.out.print(Methods[j].getReturnType().getName());   
        	//输出方法名     
        	System.out.print(" " +Methods[j].getName()+ "(" );    
        	//获取方法的参数     
        	Class[] parameterTypes = Methods[j].getParameterTypes();   
        	for ( int  k= 0 ; k<parameterTypes.length; k++){    
        	System.out.print(parameterTypes[k].getName());   
        	if (parameterTypes.length>k+ 1 ){    
        	System.out.print("," );    
        	}   
        	}   
        	System.out.println(")" );   
		}
        
        
		Class[] args1 = new Class[2];
		args1[0] = String.class;//对应方法的参数类型
		args1[1] = int.class;//对应方法的参数类型
		Method simpleMethod = simpleClass.getDeclaredMethod("print",
				args1);
		Object[] argments = new Object[2];//参数值
		argments[0] = "Hello,Reflection!!!";
		argments[1] = 2;
		simpleMethod.invoke(simpelObject, argments);//方法调用

		
		Class[] args2 = new Class[1];
		args2[0] = String.class;//对应方法的参数类型
		Method simpleMethod1 = simpleClass.getDeclaredMethod("print1",
				args2);
		//setAccessible方法，它是用来设置是否有权限访问反射类中的私有方法的，只有设置为true时才可以访问，默认为false
	    simpleMethod1.setAccessible(true);
	    String[] argments1 = new String[1];//参数值
		argments1[0] = "Hello,Reflection!!!";
		simpleMethod1.invoke(simpelObject, argments1);//方法调用
	}
}

输出结果：

获取反射类中所有公有属性:
fields.length====>1
cl===>class java.lang.String
获取反射类中所有的属性:
fields1.length====>3
cl1===>class java.lang.String
cl1===>int
cl1===>int
获取反射类中私有的属:
i====>1
获取指定类的构造方法:
test.Simple()
test.Simple(java.lang.String )
获取指定类的所有方法
void print1(java.lang.String)
void print(java.lang.String,int)
2--测试---Hello,Reflection!!!
测试---Hello,Reflection!!!

  初次接触java的反射机制，理解的不是很深，有不对的地方还望各位不惜赐教！！！