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 函数集合