Java中的反射(看这篇就够了)

Rsun04551

已于 2024-10-13 22:32:41 修改

阅读量576

点赞数 1

分类专栏： JavaSE 文章标签： java jvm 开发语言

于 2021-04-10 13:52:49 首次发布

本文链接：https://blog.youkuaiyun.com/yang_guang3/article/details/115573227

版权

JavaSE 专栏收录该内容

35 篇文章

订阅专栏

前言

在运行状态中，对于任意一个对象，都能够知道这个对象的所有属性和方法；这种动态获取信息以及动态调用对象的方法的功能称为java语言的反射机制
首先创建一个person对象如下：

package com.ruoyi.gateway.test;

public class Person {
    //成员变量
    public String name;
    public int age;
    private String address;

    //构造方法
    public Person() {
        System.out.println("空参数构造方法");
    }

    public Person(String name) {
        this.name = name;
        System.out.println("带有String的构造方法");
    }
    //私有的构造方法
    private Person(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("带有String，int的构造方法");
    }

    public Person(String name, int age, String address){
        this.name = name;
        this.age = age;
        this.address = address;
        System.out.println("带有String, int, String的构造方法");
    }

    //成员方法
    //没有返回值没有参数的方法
    public void method1(){
        System.out.println("没有返回值没有参数的方法");
    }
    //没有返回值，有参数的方法
    public void method2(String name){
        System.out.println("没有返回值，有参数的方法 name= "+ name);
    }
    //有返回值，没有参数
    public int method3(){
        System.out.println("有返回值，没有参数的方法");
        return 123;
    }
    //有返回值，有参数的方法
    public String method4(String name){
        System.out.println("有返回值，有参数的方法");
        return "哈哈" + name;
    }
    //私有方法
    private void method5(){
        System.out.println("私有方法");
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";
    }
}

Class对象的四种方式

//forName获得
Class<?> person1 = Class.forName("com.ruoyi.gateway.test.Person");
//通过对象获得
Class<? extends Person> person2 = new Person().getClass();
//类名.class获得
Class<Person> person3 = Person.class;
//基本内置类型的包装类都有一个TYPE类型
Class type = Integer.TYPE;
System.out.println(person1);

输出：

class com.ruoyi.gateway.test.Person

注意：第一种和后三种的区别

后三种你必须明确Person类型，后面是指定这种类型的字符串就行，这种扩展更强，我不需要知道你的类，我只提供字符串，按照配置文件加载就可以了，常用第一种方式

构造方法

//获取所有public的构造方法
Constructor[] cons1 = person1.getConstructors();
//获取所有的构造方法，经常用Declared的构造方法
Constructor[] cons2 = person1.getDeclaredConstructors();
for (Constructor con : cons2) {
}
//获取无参构造方法：public Person()
Constructor con1 = person1.getDeclaredConstructor(null);
System.out.println(con1);
//获取有参构造方法：public Person(String name, int age, String address)
Constructor con2 = person1.getDeclaredConstructor(String.class, int.class, String.class);
System.out.println(con2);

输出：

public com.ruoyi.gateway.test.Person()
public com.ruoyi.gateway.test.Person(java.lang.String,int,java.lang.String)

获取对象

//通过构造方法类中Constructor的方法，创建实例化对象
Person instance1 = (Person) con1.newInstance(null);
Person instance2 = (Person) con2.newInstance("小明", 22, "哈尔滨");
System.out.println(instance1.name);
System.out.println(instance2.name);
//private修饰的构造方法，创建实例需要用到暴力反射，不然会报无法访问异常
Constructor con3 = person1.getDeclaredConstructor(String.class, int.class);
con3.setAccessible(true);
Person instance3 = (Person) con3.newInstance("小李", 20);
System.out.println(instance3.name);

输出：

null
小明
小李

成员变量

//获取pubic修饰的所有成员变量
Field[] fields1 = person1.getFields();
//获取所有的成员变量
Field[] fields2 = person1.getDeclaredFields();
for (Field field : fields2) {
    System.out.println(field);
}
//获取某个成员变量
Field ageField = person1.getField("age");
System.out.println(ageField);
//获取私有化private的成员变量address
Field addressField = person1.getDeclaredField("address");
System.out.println(addressField);

输出：

public int com.ruoyi.gateway.test.Person.age
private java.lang.String com.ruoyi.gateway.test.Person.address

给对象中字段赋值

//给对象中某个字段赋值
Constructor<?> constructor = person1.getConstructor(String.class);
Object obj = constructor.newInstance("小明");
Field address = person1.getDeclaredField("address");
address.setAccessible(true);
address.set(obj,"上海");
System.out.println("address="+address.get(obj));

输出：

address=上海

成员方法

//获取多个所有方法
Method[] methods1 = person1.getMethods();
//获取多个private方法
Method[] methods2 = person1.getDeclaredMethods();
for (Method method : methods1) {
}
//获取单个方法method1
Method method = person1.getMethod("method1", null);
System.out.println(method);
//获取私有方法method5
method = person1.getDeclaredMethod("method5", null);
System.out.println(method);

调用方法

//获取构造方法：Person(String name, int age, String address)
Constructor con = person1.getConstructor(String.class, int.class, String.class);
//通过构造方法，创建对象
Object obj = con.newInstance("小明", 23, "哈尔滨");
//获取方法：method4(String name)
Method m4 = person1.getMethod("method4", String.class);
Object result = m4.invoke(obj, "itcast");
System.out.println("result = " + result);

调用private方法

//获取构造方法：Person(String name, int age, String address)
Constructor con = person1.getConstructor(String.class, int.class, String.class);
//通过构造方法，创建对象
Object obj = con.newInstance("小明", 23, "哈尔滨");
//获取指定的方法：method5
Method m5 = person1.getDeclaredMethod("method5", null);
//开启暴力访问
m5.setAccessible(true);
//执行找到的方法
m5.invoke(obj, null);

泛型擦除

思考，将已存在的ArrayList集合中添加一个字符串数据，如何实现呢？
我来告诉大家，其实程序编译后产生的.class文件中是没有泛型约束的，这种现象我们称为泛型的擦除。那么，我们可以通过反射技术，来完成向有泛型约束的集合中，添加任意类型的元素

ArrayList<Integer> list = new ArrayList<Integer>();
//添加元素到集合
list.add(new Integer(30));
list.add(new Integer("12345"));
list.add(123);
//list.add("哈哈");//因为有泛型类型的约束
System.out.println(list);
//通过反射技术，实现添加任意类型的元素
//1, 获取字节码文件对象
Class c = Class.forName("java.util.ArrayList");
//2, 找到add()方法
// public boolean add(E e)
Method addMethod = c.getMethod("add", Object.class);
//3，  执行add()方法
addMethod.invoke(list, "哈哈");// list.add("哈哈");
System.out.println(list);

输出：

[30, 12345, 123]
[30, 12345, 123, 哈哈]

配置文件

通过反射配置文件，运行配置文件中指定类的对应方法
读取Peoperties.txt文件中的数据，通过反射技术，来完成Person对象的创建
Peoperties.txt文件内容如下：

className=cn.itcast_01_Reflect.Person
methodName=method5

代码：

// 通过Properties集合从文件中读取数据
Properties prop = new Properties();
// 读取文件中的数据到集合中
prop.load(new FileInputStream("resources/properties.txt"));
// 获取键所对应的值
String className = prop.getProperty("className");
System.out.println(className);
// 1，获取Person.class 字节码文件对象
Class c = Class.forName(className);
// 2，获取构造方法
// public Person(String name, int age, String address)
Constructor con = c.getConstructor(String.class, int.class, String.class);
// 3,创建对象
Object obj = con.newInstance("小明", 20, "中国");
System.out.println(obj);
// 4，获取指定的方法
// private void method5(){}
String methodName = prop.getProperty("methodName");
Method m5 = c.getDeclaredMethod(methodName, null);
// 5,开启暴力访问
m5.setAccessible(true);
// 6，执行找到的方法
m5.invoke(obj, null);

异常处理

java.lang.NoSuchMethodException：缺少Declared
java.lang.IllegalAccessException：缺少暴力反射

单例和反射的共存：
如果一个类是单例类，一般不会通过反射获取私有化构造方法，这违背了单例的原则

反射练习

将如下代码利用反射抽公共方法

BigDecimal osMoney = futureStockMarginDto.getOsMoney();
if (!Objects.isNull(osMoney)) {
    int scale = osMoney.scale();
    if (scale < 2) {
        futureStockMarginDto.setOsMoney(osMoney.setScale(2, BigDecimal.ROUND_HALF_UP));
    } else {
        futureStockMarginDto.setOsMoney(osMoney.setScale(4, BigDecimal.ROUND_HALF_UP));
    }
}

实现结果：

    public static <T> T setScale(T t, String name, BigDecimal price) {
        if (!Objects.isNull(price)) {
            int scale = price.scale();
            if (scale < 2) {
                price = price.setScale(2, BigDecimal.ROUND_HALF_UP);
            } else {
                price = price.setScale(4, BigDecimal.ROUND_HALF_UP);
            }
        }
        Method[] methods = t.getClass().getMethods();
        for (Method method : methods) {
            if (("set" + name).equalsIgnoreCase(method.getName())) {
                try {
                    method.invoke(t, price);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return t;
    }