Java中反射的应用
更新时间：2023年10月17日 11:14:50 作者：yuhuofei2021
这篇文章主要介绍了Java中反射的应用,通过反射,我们可以在运行时检查类的属性、方法和构造函数,并且可以在不知道类名的情况下创建对象、调用方法和访问属性,需要的朋友可以参考下
反射的应用
1. 获取运行时类的完整结构
通过反射获取运行时类的完整结构，包括一下所列都是可以获取的，下面来试试
- Interface：实现的全部接口
- Superclass：所继承的父类
- Constructor：全部的构造器
- Method：全部的方法
- Field：全部的属性
- Annotation：注解
新建一个 Person.java 类
package com.javabasic.reflection;
/**
* @Description
* @ClassName Person
* @Author yuhuofei
* @Date 2022/9/25 16:44
* @Version 1.0
*/
public class Person {
private String name;
private Integer age;
private String getName() {
return name;
}
private void setName(String name) {
this.name = name;
}
private Integer getAge() {
return age;
}
private void setAge(Integer age) {
this.age = age;
}
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
新建 TestReflection.java 类，测试一下通过反射获取上面这个类的信息
package com.javabasic.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* @Description 反射的应用
* @ClassName TestReflection
* @Author yuhuofei
* @Date 2022/10/2 15:57
* @Version 1.0
*/
public class TestReflection {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class<?> aClass = Class.forName("com.javabasic.reflection.Person");
System.out.println("==================获取类名=====================");
//获取类的名字
System.out.println("类名：" + aClass.getSimpleName());
//获取包名+类名
System.out.println("包名及类名：" + aClass.getName());
System.out.println("==================获取类的属性=====================");
//获取类的public类型属性
Field[] fields1 = aClass.getFields();
for (Field field : fields1) {
System.out.println("类的public类型属性：" + field);
}
//获取类的所有属性
Field[] fields = aClass.getDeclaredFields();
for (Field field : fields) {
System.out.println("类的所有属性：" + field);
}
//获取指定的属性
Field name = aClass.getDeclaredField("name");
System.out.println("类的指定属性：" + name);
System.out.println("==================获取类的方法=====================");
//获取本类及父类的所有public类型方法
Method[] methods = aClass.getMethods();
for (Method method : methods) {
System.out.println("本类及父类的所有public类型方法：" + method);
}
//获取本类及父类的所有方法
Method[] declaredMethods = aClass.getDeclaredMethods();
for (Method method : declaredMethods) {
System.out.println("本类父类的所有方法：" + method);
}
//获取指定方法
Method getName = aClass.getDeclaredMethod("getName", null);
Method setName = aClass.getDeclaredMethod("setName", String.class);
System.out.println("获取指定的getName方法：" + getName);
System.out.println("获取指定的setName方法：" + setName);
System.out.println("==================获取类的构造器=====================");
//获取所有public类型构造器
Constructor<?>[] constructors = aClass.getConstructors();
for (Constructor constructor : constructors) {
System.out.println("获取所有public类型构造器：" + constructor);
}
//获取所有构造器
Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
for (Constructor constructor : declaredConstructors) {
System.out.println("获取所有构造器：" + constructor);
}
//获取指定的构造器
Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class, Integer.class);
System.out.println("获取指定的构造器：" + declaredConstructor);
}
}
结果如下
2. 动态创建对象动态操作方法及属性
2.1 动态创建对象
通过调用 Class 对象的 newInstance() 方法，可以创建类的对象
有了类的对象，就可以通过对象.方法名的形式使用方法了，这和平常的使用方式一样，但需要注意设置的访问权限问题
使用 Class 对象创建类的对象是需要条件的，不同情况下，条件不同
使用无参构造器时的条件
- 无参构造器存在
- 无参构造器的访问权限要足够
//获取Class对象
Class<?> aClass = Class.forName("com.javabasic.reflection.Person");
//通过一个无参构造器创建一个Person的对象
Person person01 = (Person) aClass.newInstance();
System.out.println(person01);
使用有参构造器时的条件
- 通过 Class 类的 getDeclaredConstructor(Class<?>… parameterTypes) 获取当前类的指定有参构造器
- 向构造器的形参中传递一个对象数组进去，里面要包含构造器中所需的各个参数
- 通过 Constructor 实例化对象
//获取Class对象
Class<?> aClass = Class.forName("com.javabasic.reflection.Person");
//通过有参构造器创建对象
Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class, Integer.class);
Person person02 = (Person) declaredConstructor.newInstance("张三", 20);
System.out.println(person02);
2.2 动态操作方法及属性
这里延用上面的 Person.java 类，然后新建一个测试类来测试
package com.javabasic.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @Description
* @ClassName Test01
* @Author yuhuofei
* @Date 2022/10/2 17:08
* @Version 1.0
*/
public class Test01 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
//获取Class对象
Class<?> aClass = Class.forName("com.javabasic.reflection.Person");
//通过一个无参构造器创建一个Person的对象
Person person01 = (Person) aClass.newInstance();
System.out.println(person01);
//通过有参构造器创建对象
Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class, Integer.class);
Person person02 = (Person) declaredConstructor.newInstance("张三", 20);
System.out.println(person02);
//通过反射调用普通方法
Method method = aClass.getDeclaredMethod("setName", String.class);
method.setAccessible(true); //关闭安全检测，允许访问private方法
Person person03 = (Person) aClass.newInstance();
method.invoke(person03, "李四"); //向person03对象中的setName方法传参
System.out.println(person03);
//通过反射调用属性
Field field01 = aClass.getDeclaredField("name");
Field field02 = aClass.getDeclaredField("age");
field01.setAccessible(true); //关闭安全检测，允许访问private属性
field02.setAccessible(true);
Person person04 = (Person) aClass.newInstance();
field01.set(person04, "王五"); //设置名字
field02.set(person04, 19); //设置年龄
System.out.println(person04);
}
}
值得注意的是，如果方法或者属性的访问权限是 private，那么需要配置 .setAccessible(true);，不然无法访问
3. 反射操作泛型
java 采用泛型擦除的机制来引入泛型，但却只是给编译器 javac 使用的，用于确保数据的安全性和免去强制类型转换的问题，而一旦编译完成，所有与泛型相关的类型会全部擦除
为了通过反射能操作这些类型，java 新增了 ParameterizedType、GenericArrayType、TypeVariable、WildcardType 这几种类型来代表不能被归一到 Class 类中的类型但又和原始类型齐名的类型
- ParameterizedType：表示一种参数化类型，比如 Collection< String >
- GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
- TypeVariable：各种类型变量的公共父接口
- WildcardType ：代表一种通配符类型表达式
下面写一个类来实践一下，这里还是延用前面的 Person 类
package com.javabasic.reflection;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
/**
* @Description 测试反射获取泛型
* @ClassName Test02
* @Author yuhuofei
* @Date 2022/10/2 20:06
* @Version 1.0
*/
public class Test02 {
public void getData(Map<String, Person> map, List<Person> list) {
System.out.println("getData()");
}
public Map<String, Person> getMap() {
System.out.println("getMap()");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
//获取入参泛型
Method method = Test02.class.getMethod("getData", Map.class, List.class);
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
System.out.println("泛型：" + genericParameterType);
//判断拿到的是不是参数化类型，即是不是前面定义的Map或者List
if (genericParameterType instanceof ParameterizedType) {
//获取真实参数
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
System.out.println("============分割线===========");
//获取返回值泛型
method = Test02.class.getMethod("getMap", null);
Type genericReturnType = method.getGenericReturnType();
System.out.println("返回值类型：" + genericReturnType);
if (genericReturnType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type at : actualTypeArguments) {
System.out.println(at);
}
}
}
}
得到的结果如下：
4. 反射操作注解
定义一个注解，如下：
package com.javabasic.annotation;
import java.lang.annotation.*;
/**
* @Description 自定义注解
* @InterfaceName MyAnnotation
* @Author yuhuofei
* @Date 2022/9/18 11:26
* @Version 1.0
*/
@Target({ElementType.TYPE, ElementType.METHOD})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
/**
* 描述信息
*/
String value() default "";
}
定义一个使用上面的注解的类，如下：
package com.javabasic.annotation;
/**
* @Description 测试自定义注解的使用
* @ClassName TestAnnotation
* @Author yuhuofei
* @Date 2022/9/18 11:32
* @Version 1.0
*/
@MyAnnotation(value = "打印出两个整数之和，这是标记在类上的注解")
public class TestAnnotation {
@MyAnnotation(value = "打印出两个整数之和，这是标记在方法上的注解")
public static void printResult() {
int a = 39;
int b = 54;
int result = a + b;
System.out.println(result);
}
public static void main(String[] args) {
printResult();
}
}
定义一个测试类，测试通过反射操作注解，如下：
package com.javabasic.annotation;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
/**
* @Description 测试反射获得注解
* @ClassName Test03
* @Author yuhuofei
* @Date 2022/10/2 20:36
* @Version 1.0
*/
public class Test03 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
Class c = Class.forName("com.javabasic.annotation.TestAnnotation");
//通过反射获得注解
Annotation[] annotations = c.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获得注解的value
MyAnnotation annotation = (MyAnnotation) c.getAnnotation(MyAnnotation.class);
String value = annotation.value();
System.out.println(value);
//获得类中方法或者属性上指定的注解
System.out.println("============分割线===========");
Method method = c.getMethod("printResult", null);
MyAnnotation an = method.getAnnotation(MyAnnotation.class);
System.out.println(an);
System.out.println(an.value());
}
}
运行结果：
到此这篇关于Java中反射的应用的文章就介绍到这了,更多相关Java反射内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
Java class文件格式之属性详解_动力节点java学院整理
这篇文章主要介绍了Java class文件格式之属性详解,需要的朋友可以参考下2017-06-06
这篇文章主要介绍了Java 内省(Introspector)深入理解的相关资料,需要的朋友可以参考下2017-03-03
这篇文章主要介绍了Java原子操作CAS原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2019-10-10
这篇文章主要介绍了SpringBoot为啥不用配置启动类的实现,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2020-04-04
Spring4下validation数据校验无效(maven)的解决
这篇文章主要介绍了Spring4下validation数据校验无效(maven)的解决，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2021-06-06
这篇文章主要为大家详细介绍了Java如何调用opencv实现图片矫正功能,文中的示例代码简洁易懂,感兴趣的小伙伴可以跟随小编一起学习一下2023-09-09
在Web应用开发中,我们经常需要对URL进行格式验证,今天我们结合 Java 的 Pattern 和 Matcher 类,深入理解正则表达式在实际应用中的强大功能,并剖析一段实际的 Java 示例源码,感兴趣的朋友一起看看吧2025-04-04
本篇文章分享的就是spring boot中的一个轮子，spring cache注解的方式实现接口数据缓存。默认的配置想非常简单，但是有一个弊端是缓存数据为永久缓存，本次将介绍如何设置接口缓存数据的过期时间2022-07-07
这篇文章主要介绍了Java中数组与集合的相互转换实现解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2019-08-08
Java中JSONObject与JSONArray的使用区别详解
这篇文章主要介绍了Java中JSONObject与JSONArray的使用区别详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2017-11-11
最新评论