java的反射_java中的反射

public classReflectionTest {

@Testpublic void testMethod() throwsException{

Class clazz= Class.forName("com.atguigu.java.fanshe.Person");// //1.获取方法// 1.1 获取取clazz对应类中的所有方法--方法数组(一)//不能获取private方法,且获取从父类继承来的所有方法

Method[] methods =clazz.getMethods();for(Method method:methods){

System.out.print(" "+method.getName());

}

System.out.println();//

// 1.2.获取所有方法，包括私有方法 --方法数组(二)//所有声明的方法，都可以获取到，且只获取当前类的方法

methods =clazz.getDeclaredMethods();for(Method method:methods){

System.out.print(" "+method.getName());

}

System.out.println();//

// 1.3.获取指定的方法//需要参数名称和参数列表，无参则不需要写//对于方法public void setName(String name) { }

Method method = clazz.getDeclaredMethod("setName", String.class);

System.out.println(method);//而对于方法public void setAge(int age) { }

method = clazz.getDeclaredMethod("setAge", Integer.class);

System.out.println(method);//这样写是获取不到的，如果方法的参数类型是int型//如果方法用于反射，那么要么int类型写成Integer： public void setAge(Integer age) { }

// 要么获取方法的参数写成int.class//

//2.执行方法//invoke第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要传入的参数

Object obje =clazz.newInstance();

method.invoke(obje,2);

//如果一个方法是私有方法，第三步是可以获取到的，但是这一步却不能执行

//私有方法的执行，必须在调用invoke之前加上一句method.setAccessible(true);

}

}

主要用到的两个方法

/***@paramname the name of the method

*@paramparameterTypes the list of parameters

*@returnthe {@codeMethod} object that matches the specified*/

public Method getMethod(String name, Class>... parameterTypes){

}/***@paramobj the object the underlying method is invoked from

*@paramargs the arguments used for the method call

*@returnthe result of dispatching the method represented by*/

publicObject invoke(Object obj, Object... args){

}

自定义工具方法

自定义一个方法

把类对象和类方法名作为参数，执行方法

把全类名和方法名作为参数，执行方法

比如Person里有一个方法

public voidtest(String name,Integer age){

System.out.println("调用成功");

}

那么我们自定义一个方法

1. 把类对象和类方法名作为参数，执行方法

/***

*@paramobj: 方法执行的那个对象.

*@parammethodName: 类的一个方法的方法名. 该方法也可能是私有方法.

*@paramargs: 调用该方法需要传入的参数

*@return: 调用方法后的返回值

**/

public Object invoke(Object obj, String methodName, Object ... args) throwsException{//1. 获取 Method 对象//因为getMethod的参数为Class列表类型，所以要把参数args转化为对应的Class类型。Class [] parameterTypes= newClass[args.length];for(int i = 0; i < args.length; i++){

parameterTypes[i]=args[i].getClass();

System.out.println(parameterTypes[i]);

}

Method method=obj.getClass().getDeclaredMethod(methodName, parameterTypes);//如果使用getDeclaredMethod，就不能获取父类方法，如果使用getMethod，就不能获取私有方法

//

//2. 执行 Method 方法//3. 返回方法的返回值

returnmethod.invoke(obj, args);

}

调用：

@Testpublic void testInvoke() throwsException{

Object obj= newPerson();

invoke(obj,"test", "wang", 1);

}

这样就通过对象名，方法名，方法参数执行了该方法

2.把全类名和方法名作为参数，执行方法

/***@paramclassName: 某个类的全类名

*@parammethodName: 类的一个方法的方法名. 该方法也可能是私有方法.

*@paramargs: 调用该方法需要传入的参数

*@return: 调用方法后的返回值*/

publicObject invoke(String className, String methodName, Object ... args){

Object obj= null;try{

obj=Class.forName(className).newInstance();//调用上一个方法

returninvoke(obj, methodName, args);

}catch(Exception e) {

e.printStackTrace();

}return null;

}

调用

@Testpublic void testInvoke() throwsException{invoke("com.atguigu.java.fanshe.Person","test", "zhagn", 12);

}

使用系统方法(前提是此类有一个无参的构造器(查看API))

@Testpublic void testInvoke() throwsException{

Object result=invoke("java.text.SimpleDateFormat", "format", newDate());

System.out.println(result);

}

这种反射实现的主要功能是可配置和低耦合。只需要类名和方法名，而不需要一个类对象就可以执行一个方法。如果我们把全类名和方法名放在一个配置文件中，就可以根据调用配置文件来执行方法

如何获取父类定义的(私有)方法

前面说一般使用getDeclaredMethod获取方法(因为此方法可以获取类的私有方法，但是不能获取父类方法)

如何获取父类方法呢，上一个例子format方法其实就是父类的方法(获取的时候用到的是getMethod)

首先我们要知道，如何获取类的父亲：

比如有一个类，继承自Person

使用

public classReflectionTest {

@Testpublic void testGetSuperClass() throwsException{

String className= "com.atguigu.java.fanshe.Student";

Class clazz=Class.forName(className);

Class superClazz=clazz.getSuperclass();

System.out.println(superClazz);

}

}//结果是 “ class com.atguigu.java.fanshe.Person ”

此时如果Student中有一个方法是私有方法method1(int age); Person中有一个私有方法method2();

怎么调用

定义一个方法，不但能访问当前类的私有方法，还要能父类的私有方法

/***

*@paramobj: 某个类的一个对象

*@parammethodName: 类的一个方法的方法名.

* 该方法也可能是私有方法, 还可能是该方法在父类中定义的(私有)方法

*@paramargs: 调用该方法需要传入的参数

*@return: 调用方法后的返回值*/

publicObject invoke2(Object obj, String methodName,

Object ... args){//1. 获取 Method 对象

Class [] parameterTypes = newClass[args.length];for(int i = 0; i < args.length; i++){

parameterTypes[i]=args[i].getClass();

}try{

Method method=getMethod(obj.getClass(), methodName, parameterTypes);

method.setAccessible(true);//2. 执行 Method 方法//3. 返回方法的返回值

returnmethod.invoke(obj, args);

}catch(Exception e) {

e.printStackTrace();

}return null;

}/*** 获取 clazz 的 methodName 方法. 该方法可能是私有方法, 还可能在父类中(私有方法)

* 如果在该类中找不到此方法，就向他的父类找，一直到Object类为止

* 这个方法的另一个作用是根据一个类名，一个方法名，追踪到并获得此方法

*@paramclazz

*@parammethodName

*@paramparameterTypes

*@return

*/

publicMethod getMethod(Class clazz, String methodName,

Class ... parameterTypes){for(;clazz != Object.class; clazz =clazz.getSuperclass()){try{

Method method=clazz.getDeclaredMethod(methodName, parameterTypes);returnmethod;

}catch(Exception e) {}

}return null;

}

3.2 如何描述字段-Field

@Testpublic void testField() throwsException{

String className= "com.atguigu.java.fanshe.Person";

Class clazz=Class.forName(className);//1.获取字段//1.1 获取所有字段 -- 字段数组//可以获取公用和私有的所有字段，但不能获取父类字段

Field[] fields =clazz.getDeclaredFields();for(Field field: fields){

System.out.print(" "+field.getName());

}

System.out.println();//1.2获取指定字段

Field field = clazz.getDeclaredField("name");

System.out.println(field.getName());

Person person= new Person("ABC",12);//2.使用字段//2.1获取指定对象的指定字段的值

Object val =field.get(person);

System.out.println(val);//2.2设置指定对象的指定对象Field值

field.set(person, "DEF");

System.out.println(person.getName());//2.3如果字段是私有的，不管是读值还是写值，都必须先调用setAccessible(true)方法//比如Person类中，字段name字段是公用的，age是私有的

field = clazz.getDeclaredField("age");

field.setAccessible(true);

System.out.println(field.get(person));

}

但是如果需要访问父类中的(私有)字段：

/*** //创建 className 对应类的对象, 并为其 fieldName 赋值为 val* //Student继承自Person,age是Person类的私有字段/ public void testClassField() throwsException{

String className= "com.atguigu.java.fanshe.Student";

String fieldName= "age"; //可能为私有, 可能在其父类中.

Object val = 20;

Object obj= null;//1.创建className 对应类的对象

Class clazz =Class.forName(className);//2.创建fieldName 对象字段的对象

Field field =getField(clazz, fieldName);//3.为此对象赋值

obj =clazz.newInstance();

setFieldValue(obj, field, val);//4.获取此对象的值

Object value =getFieldValue(obj,field);

}public Object getFieldValue(Object obj, Field field) throwsException{

field.setAccessible(true);returnfield.get(obj);

}public void setFieldValue(Object obj, Field field, Object val) throwsException {

field.setAccessible(true);

field.set(obj, val);

}public Field getField(Class clazz, String fieldName) throwsException {

Field field= null;for(Class clazz2 = clazz; clazz2 != Object.class;clazz2 =clazz2.getSuperclass()){

field=clazz2.getDeclaredField(fieldName);

}returnfield;

}

3.3如何描述构造器-Constructor

@Testpublic void testConstructor() throwsException{

String className= "com.atguigu.java.fanshe.Person";

Class clazz = (Class) Class.forName(className);//1. 获取 Constructor 对象//1.1 获取全部

Constructor [] constructors =(Constructor[]) Class.forName(className).getConstructors();for(Constructorconstructor: constructors){

System.out.println(constructor);

}//1.2获取某一个，需要参数列表

Constructor constructor = clazz.getConstructor(String.class, int.class);

System.out.println(constructor);//2. 调用构造器的 newInstance() 方法创建对象

Object obj = constructor.newInstance("zhagn", 1);

}

3.4 如何描述注解 -- Annotation

定义一个Annotation

importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotation.RetentionPolicy;importjava.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(value={ElementType.METHOD})public @interfaceAgeValidator {public intmin();public intmax();

}

此注解只能用在方法上

@AgeValidator(min=18,max=35)public void setAge(intage) {this.age =age;

}

那么我们在给Person类对象的age赋值时，是感觉不到注解的存在的

@Testpublic void testAnnotation() throwsException{

Person person= newPerson();

person.setAge(10);

}

必须通过反射的方式为属性赋值，才能获取到注解

/**Annotation 和 反射:

* 1. 获取 Annotation

*

* getAnnotation(Class annotationClass)

* getDeclaredAnnotations()

**/@Testpublic void testAnnotation() throwsException{

String className= "com.atguigu.java.fanshe.Person";

Class clazz=Class.forName(className);

Object obj=clazz.newInstance();

Method method= clazz.getDeclaredMethod("setAge", int.class);int val = 6;//获取指定名称的注解

Annotation annotation = method.getAnnotation(AgeValidator.class);if(annotation != null){if(annotation instanceofAgeValidator){

AgeValidator ageValidator=(AgeValidator) annotation;if(val < ageValidator.min() || val >ageValidator.max()){throw new RuntimeException("年龄非法");

}

}

}

method.invoke(obj,20);

System.out.println(obj);

}

如果在程序中要获取注解，然后获取注解的值进而判断我们赋值是否合法，那么类对象的创建和方法的创建必须是通过反射而来的

4.反射与泛型

定义一个泛型类

public class DAO{//根据id获取一个对象

T get(Integer id){return null;

}//保存一个对象

voidsave(T entity){

}

}

再定义一个子类，继承这个泛型类：

public class PersonDAO extends DAO{

}

父类中的泛型T，就相当于一个参数，当子类继承这个类时，就要给这个参数赋值，这里是把Person类型传给了父类

或者还有一种做法

public class PersonDAO extends DAO{

}

然后进行测试

@Testpublic void testAnnotation() throwsException{

PersonDAO personDAO= newPersonDAO();

Person entity= newPerson();//调用父类的save方法，同时也把Person这个“实参”传给了父类的T

personDAO.save(entity);//这句的本意是要返回一个Person类型的对象

Person result = personDAO.get(1);

System.out.print(result);

}

问题出来了。这里的get方法是父类的get方法，对于父类而言，方法返回值是一个T类型，当T的值为Person时，本该返回一个Person类型，但是必须用反射来创建这个对象(泛型方法返回一个对象)，方法无非就是clazz.newInstance(); 所以关键点就是根据T得到其对于的Class对象。

那么首先，在父类中定义一个字段，表示T所对应的Class，然后想办法得到这个clazz的值

public class DAO{private Classclazz;

T get(Integer id){return null;

}

}

如何获得这个clazz呢？

@Testpublic void test() throwsException{

PersonDAO personDAO= newPersonDAO();

Person result= personDAO.get(1);

System.out.print(result);

}

publicDAO(){//1.

System.out.println("DAO's Constrctor...");

System.out.println(this); //结果是：com.atguigu.java.fanshe.PersonDAO@66588ec0//this：父类构造方法中的this指的是子类对象，因为此时是PersonDAO对象在调用

System.out.println(this.getClass()); //结果是：class com.atguigu.java.fanshe.PersonDAO//2.//获取DAO子类的父类

Class class1 = this.getClass().getSuperclass();

System.out.println(class1);//结果是：class com.atguigu.java.fanshe.DAO//此时只能获的父类的类型名称，却不可以获得父类的泛型参数//3.//获取DAO子类带泛型参数的子类

Type type=this.getClass().getGenericSuperclass();

System.out.println(type);//结果是：com.atguigu.java.fanshe.DAO//此时获得了泛型参数，然后就是把它提取出来//4.//获取具体的泛型参数 DAO//注意Type是一个空的接口，这里使用它的子类ParameterizedType，表示带参数的类类型(即泛型)

if(type instanceofParameterizedType){

ParameterizedType parameterizedType=(ParameterizedType) type;

Type [] arges=parameterizedType.getActualTypeArguments();

System.out.println(Arrays.asList(arges));//结果是：[class com.atguigu.java.fanshe.Person]//得到的是一个数组，因为可能父类是多个泛型参数public class DAO{}

if(arges != null && arges.length >0){

Type arg= arges[0];

System.out.println(arg);//结果是：class com.atguigu.java.fanshe.Person//获得第一个参数

if(arg instanceofClass){

clazz= (Class) arg;//把值赋给clazz字段

}

}

}

}

所以就定义一个方法，获得 Class 定义中声明的父类的泛型参数类型

public classReflectionTest {/*** 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型

* 如: public EmployeeDao extends BaseDao

*@paramclazz: 子类对应的 Class 对象

*@paramindex: 子类继承父类时传入的泛型的索引. 从 0 开始

*@return

*/@SuppressWarnings("unchecked")public Class getSuperClassGenricType(Class clazz, intindex){

Type type=clazz.getGenericSuperclass();if(!(type instanceofParameterizedType)){return null;

}

ParameterizedType parameterizedType=(ParameterizedType) type;

Type [] args=parameterizedType.getActualTypeArguments();if(args == null){return null;

}if(index < 0 || index > args.length - 1){return null;

}

Type arg=args[index];if(arg instanceofClass){return(Class) arg;

}return null;

}

@SuppressWarnings("unchecked")publicClass getSuperGenericType(Class clazz){return getSuperClassGenricType(clazz, 0);

}

@Testpublic voidtestGetSuperClassGenricType(){

Class clazz= PersonDAO.class;//PersonDAO.class

Class argClazz = getSuperClassGenricType(clazz, 0);

System.out.println(argClazz);//结果是class com.atguigu.java.fanshe.Person

}

}

反射小结

1. Class: 是一个类; 一个描述类的类.

封装了描述方法的 Method,

描述字段的 Filed,

描述构造器的 Constructor 等属性.

2. 如何得到 Class 对象:

2.1 Person.class

2.2 person.getClass()

2.3 Class.forName("com.atguigu.javase.Person")

3. 关于 Method:

3.1 如何获取 Method:

1). getDeclaredMethods: 得到 Method 的数组.

2). getDeclaredMethod(String methondName, Class ... parameterTypes)

3.2 如何调用 Method

1). 如果方法时 private 修饰的, 需要先调用 Method 的　setAccessible(true), 使其变为可访问

2). method.invoke(obj, Object ... args);

4. 关于 Field:

4.1 如何获取 Field: getField(String fieldName)

4.2 如何获取 Field 的值:

1). setAccessible(true)

2). field.get(Object obj)

4.3 如何设置 Field 的值:

field.set(Obejct obj, Object val)

5. 了解 Constructor 和 Annotation

6. 反射和泛型.

6.1 getGenericSuperClass: 获取带泛型参数的父类, 返回值为: BaseDao

6.2 Type 的子接口: ParameterizedType

6.3 可以调用 ParameterizedType 的 Type[] getActualTypeArguments() 获取泛型参数的数组.

packagecom.atguigu.javase.lesson12;importjava.lang.reflect.Field;importjava.lang.reflect.InvocationTargetException;importjava.lang.reflect.Method;importjava.lang.reflect.Modifier;importjava.lang.reflect.ParameterizedType;importjava.lang.reflect.Type;/*** 反射的 Utils 函数集合

* 提供访问私有变量, 获取泛型类型 Class, 提取集合中元素属性等 Utils 函数

*@authorAdministrator

**/

public classReflectionUtils {/*** 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型

* 如: public EmployeeDao extends BaseDao

*@paramclazz

*@paramindex

*@return

*/@SuppressWarnings("unchecked")public static Class getSuperClassGenricType(Class clazz, intindex){

Type genType=clazz.getGenericSuperclass();if(!(genType instanceofParameterizedType)){return Object.class;

}

Type [] params=((ParameterizedType)genType).getActualTypeArguments();if(index >= params.length || index < 0){return Object.class;

}if(!(params[index] instanceofClass)){return Object.class;

}return(Class) params[index];

}/*** 通过反射, 获得 Class 定义中声明的父类的泛型参数类型

* 如: public EmployeeDao extends BaseDao

*@param

*@paramclazz

*@return

*/@SuppressWarnings("unchecked")public static ClassgetSuperGenericType(Class clazz){return getSuperClassGenricType(clazz, 0);

}/*** 循环向上转型, 获取对象的 DeclaredMethod

*@paramobject

*@parammethodName

*@paramparameterTypes

*@return

*/

public static Method getDeclaredMethod(Object object, String methodName, Class>[] parameterTypes){for(Class> superClass = object.getClass(); superClass != Object.class; superClass =superClass.getSuperclass()){try{//superClass.getMethod(methodName, parameterTypes);

returnsuperClass.getDeclaredMethod(methodName, parameterTypes);

}catch(NoSuchMethodException e) {//Method 不在当前类定义, 继续向上转型

}//..

}return null;

}/*** 使 filed 变为可访问

*@paramfield*/

public static voidmakeAccessible(Field field){if(!Modifier.isPublic(field.getModifiers())){

field.setAccessible(true);

}

}/*** 循环向上转型, 获取对象的 DeclaredField

*@paramobject

*@paramfiledName

*@return

*/

public staticField getDeclaredField(Object object, String filedName){for(Class> superClass = object.getClass(); superClass != Object.class; superClass =superClass.getSuperclass()){try{returnsuperClass.getDeclaredField(filedName);

}catch(NoSuchFieldException e) {//Field 不在当前类定义, 继续向上转型

}

}return null;

}/*** 直接调用对象方法, 而忽略修饰符(private, protected)

*@paramobject

*@parammethodName

*@paramparameterTypes

*@paramparameters

*@return*@throwsInvocationTargetException

*@throwsIllegalArgumentException*/

public static Object invokeMethod(Object object, String methodName, Class>[] parameterTypes,

Object [] parameters)throwsInvocationTargetException{

Method method=getDeclaredMethod(object, methodName, parameterTypes);if(method == null){throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");

}

method.setAccessible(true);try{returnmethod.invoke(object, parameters);

}catch(IllegalAccessException e) {

System.out.println("不可能抛出的异常");

}return null;

}/*** 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter

*@paramobject

*@paramfieldName

*@paramvalue*/

public static voidsetFieldValue(Object object, String fieldName, Object value){

Field field=getDeclaredField(object, fieldName);if (field == null)throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

makeAccessible(field);try{

field.set(object, value);

}catch(IllegalAccessException e) {

System.out.println("不可能抛出的异常");

}

}/*** 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter

*@paramobject

*@paramfieldName

*@return

*/

public staticObject getFieldValue(Object object, String fieldName){

Field field=getDeclaredField(object, fieldName);if (field == null)throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

makeAccessible(field);

Object result= null;try{

result=field.get(object);

}catch(IllegalAccessException e) {

System.out.println("不可能抛出的异常");

}returnresult;

}

}

反射的 Utils 函数集合