java 反射 this_JAVA中的反射机制详解

我就是我 2022-11-03 11:48 257阅读 0赞

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

public class ReflectionTest \{

@Test

public void testMethod() throws Exception\{

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);

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

主要用到的两个方法

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

/\*\*

\* @param name the name of the method

\* @param parameterTypes the list of parameters

\* @return the \{@code Method\} object that matches the specified

\*/

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

/\*\*

\* @param obj the object the underlying method is invoked from

\* @param args the arguments used for the method call

\* @return the result of dispatching the method represented by

\*/

public Object invoke(Object obj, Object... args)\{

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

自定义工具方法

自定义一个方法

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

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

比如Person里有一个方法

public void test(String name,Integer age)\{

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

那么我们自定义一个方法

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

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

/\*\*

\* @param obj: 方法执行的那个对象.

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

\* @param args: 调用该方法需要传入的参数

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

\*/

public Object invoke(Object obj, String methodName, Object ... args) throws Exception\{

//1. 获取 Method 对象

//因为getMethod的参数为Class列表类型，所以要把参数args转化为对应的Class类型。

Class \[\] parameterTypes = new Class\[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. 返回方法的返回值

return method.invoke(obj, args);

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

调用：

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

@Test

public void testInvoke() throws Exception\{

Object obj = new Person();

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

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

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

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

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

/\*\*

\* @param className: 某个类的全类名

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

\* @param args: 调用该方法需要传入的参数

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

\*/

public Object invoke(String className, String methodName, Object ... args)\{

Object obj = null;

try \{

obj = Class.forName(className).newInstance();

//调用上一个方法

return invoke(obj, methodName, args);

\}catch(Exception e) \{

e.printStackTrace();

return null;

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

调用

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

@Test

public void testInvoke() throws Exception\{

invoke("com.atguigu.java.fanshe.Person",

"test", "zhagn", 12);

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

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

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

@Test

public void testInvoke() throws Exception\{

Object result =

invoke("java.text.SimpleDateFormat", "format", new Date());

System.out.println(result);

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

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

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

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

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

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

比如有一个类，继承自Person

使用

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

public class ReflectionTest \{

@Test

public void testGetSuperClass() throws Exception\{

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 ”

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

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

怎么调用

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

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

/\*\*

\* @param obj: 某个类的一个对象

\* @param methodName: 类的一个方法的方法名.

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

\* @param args: 调用该方法需要传入的参数

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

\*/

public Object invoke2(Object obj, String methodName,

Object ... args)\{

//1. 获取 Method 对象

Class \[\] parameterTypes = new Class\[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. 返回方法的返回值

return method.invoke(obj, args);

\} catch (Exception e) \{

e.printStackTrace();

return null;

/\*\*

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

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

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

\* @param clazz

\* @param methodName

\* @param parameterTypes

\* @return

\*/

public Method getMethod(Class clazz, String methodName,

Class ... parameterTypes)\{

for(;clazz != Object.class; clazz = clazz.getSuperclass())\{

try \{

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

return method;

\} catch (Exception e) \{\}

return null;

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

3.2 如何描述字段-Field

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

@Test

public void testField() throws Exception\{

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));

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

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

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

/\*\*

\* //创建 className 对应类的对象, 并为其 fieldName 赋值为 val

\* //Student继承自Person,age是Person类的私有字段/

public void testClassField() throws Exception\{

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) throws Exception\{

field.setAccessible(true);

return field.get(obj);

public void setFieldValue(Object obj, Field field, Object val) throws Exception \{

field.setAccessible(true);

field.set(obj, val);

public Field getField(Class clazz, String fieldName) throws Exception \{

Field field = null;

for(Class clazz2 = clazz; clazz2 != Object.class;clazz2 = clazz2.getSuperclass())\{

field = clazz2.getDeclaredField(fieldName);

return field;

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

3.3如何描述构造器-Constructor

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

@Test

public void testConstructor() throws Exception\{

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(Constructor constructor: 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);

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

3.4 如何描述注解 -- Annotation

定义一个Annotation

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(value=\{ElementType.METHOD\})

public @interface AgeValidator \{

public int min();

public int max();

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

此注解只能用在方法上

@AgeValidator(min=18,max=35)

public void setAge(int age) \{

this.age = age;

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

@Test

public void testAnnotation() throws Exception\{

Person person = new Person();

person.setAge(10);

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

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

/\*\* Annotation 和 反射:

\* 1. 获取 Annotation

\* getAnnotation(Class annotationClass)

\* getDeclaredAnnotations()

\*/

@Test

public void testAnnotation() throws Exception\{

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 instanceof AgeValidator)\{

AgeValidator ageValidator = (AgeValidator) annotation;

if(val < ageValidator.min() || val > ageValidator.max())\{

throw new RuntimeException("年龄非法");

method.invoke(obj, 20);

System.out.println(obj);

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

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

4.反射与泛型

定义一个泛型类

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

public class DAO \{

//根据id获取一个对象

T get(Integer id)\{

return null;

//保存一个对象

void save(T entity)\{

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

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

public class PersonDAO extends DAO \{

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

或者还有一种做法

public class PersonDAO extends DAO \{

然后进行测试

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

@Test

public void testAnnotation() throws Exception\{

PersonDAO personDAO = new PersonDAO();

Person entity = new Person();

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

personDAO.save(entity);

//这句的本意是要返回一个Person类型的对象

Person result = personDAO.get(1);

System.out.print(result);

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

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

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

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

public class DAO \{

private Class clazz;

T get(Integer id)\{

return null;

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

如何获得这个clazz呢？

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

@Test

public void test() throws Exception\{

PersonDAO personDAO = new PersonDAO();

Person result = personDAO.get(1);

System.out.print(result);

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

public DAO()\{

//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 instanceof ParameterizedType)\{

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 instanceof Class)\{

clazz = (Class) arg;

//把值赋给clazz字段

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

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

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

public class ReflectionTest \{

/\*\*

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

\* 如: public EmployeeDao extends BaseDao

\* @param clazz: 子类对应的 Class 对象

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

\* @return

\*/

@SuppressWarnings("unchecked")

public Class getSuperClassGenricType(Class clazz, int index)\{

Type type = clazz.getGenericSuperclass();

if(!(type instanceof ParameterizedType))\{

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 instanceof Class)\{

return (Class) arg;

return null;

@SuppressWarnings("unchecked")

public Class getSuperGenericType(Class clazz)\{

return getSuperClassGenricType(clazz, 0);

@Test

public void testGetSuperClassGenricType()\{

Class clazz = PersonDAO.class;

//PersonDAO.class

Class argClazz = getSuperClassGenricType(clazz, 0);

System.out.println(argClazz);

//结果是class com.atguigu.java.fanshe.Person

![48304ba5e6f9fe08f3fa1abda7d326ab.png][]

反射小结

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() 获取泛型参数的数组.

[48304ba5e6f9fe08f3fa1abda7d326ab.png]: /images/20221024/fad70b57f7934a2a9d8fb4d18666d44e.png

java 反射 this_JAVA中的反射机制详解

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关详解Java中的反射机制

相关 Java中的反射机制详解

相关详解Java中的反射机制

相关 Java中的反射机制详解

相关 java 反射 this_JAVA中的反射机制详解

相关 java中的反射机制详解

相关 Java反射机制详解

相关 Java反射机制详解

相关 Java反射机制详解

相关 Java中反射机制详解