Java反射

最新推荐文章于 2023-07-30 20:47:29 发布

星夜孤帆

最新推荐文章于 2023-07-30 20:47:29 发布

阅读量188

点赞数

分类专栏： Java JDK源码

本文链接：https://blog.csdn.net/qq_38826019/article/details/118209508

版权

Java 同时被 2 个专栏收录

107 篇文章 4 订阅

订阅专栏

JDK源码

19 篇文章 2 订阅

订阅专栏

一、反射概念

反射:框架设计的灵魂

框架:半成品软件。可以在框架的基础上进行软件开发，简化编码

反射:将类的各个组成部分封装为其他对象，这就是反射机制

好处∶

1.可以在程序运行过程中，操作这些对象。

2.可以解耦，提高程序的可扩展行。

Java代码在计算机中经历的阶段：三个阶段

二、反射获取Class对象的三种方式

获取class对象的方式：

1.Class.forName("全类名")：将字节码文件加载进内存，返回class对象。

* 多用于配置文件，将类名定义在配置文件中。读取文件，加载类。

2.类名.class：通过类名的属性class获取

* 多用于参数的传递

3.对象.getClass()：getClass()方法在Object类中定义着。

* 多用于对象的获取字节码的方式

结论：

同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

@Data
public class Person {

    private String name;

    private int age;

    public String a;

    protected String b;

    String c;

    private String d;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {

    }

    public void eat() {
        System.out.println("eat...");
    }

    public void eat(String food) {
        System.out.println("eat..." + food);
    }
}

public class Student {

    public void sleep() {
        System.out.println("sleep...");
    }
}

public class ReflectDemo1 {

    /**
     * 获取class对象的方式：
     *
     * 1.Class.forName("全类名")：将字节码文件加载进内存，返回class对象。
     *
     * 2.类名.class：通过类名的属性class获取
     *
     * 3.对象.getClass()：getClass()方法在Object类中定义着。
     *
     * 结论：
     *
     * 同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
     *
     */
    public static void main(String[] args) throws ClassNotFoundException {
        // 1.Class.forName("全类名")
        Class clazz1 = Class.forName("com.best.domain.Person");
        System.out.println(clazz1);
        // 2.类名.class
        Class clazz2 = Person.class;
        System.out.println(clazz2);
        //3. 对象.getClass()
        Person person = new Person();
        Class clazz3 = person.getClass();
        System.out.println(clazz3);

        // == 比较三个对象
        System.out.println(clazz1 == clazz2);
        System.out.println(clazz1 == clazz3);

        Class studentClass = Student.class;
        System.out.println(studentClass == clazz1);

    }
}

三、Class对象功能

获取功能：

1．获取成员变量们

*Field[ ] getFields()：获取所有public修饰的成员变量
*Field getField(string name)：获取指定名称的public修饰的成员变量
*Field[ ] getDeclaredFields ()：获取所有的成员变量，不考虑修饰符
*Field getDeclaredField(string name)

2．获取构造方法们

*Constructor<?>[] getconstructors()
*Constructor getconstructor(类<?>... parameterTypes)
*ConstructorgetDeclaredconstructor(类<?>... parameterTypes)
*Constructor<?>[getDeclaredconstructors()

3．获取成员方法们∶

*Method[] getMethods()
*Method getMethod(string name，类<?>... parameterTypes)
*Method[] getDeclaredMethods()
* Method getDeclaredMethod(string name，类<?>... parameterTypes)

4. 获取类名

*String getName()

四、获取Field

Field：成员变量

操作：

1.设置值

* void set(Object obj, Object value)

2.获取值

* get(Object obj)

3.忽略访问权限修饰符的安全检查

*setAccessible(true)：暴力反射

public class ReflectDemo2 {

    /**
     * 获取功能：
     *
     * 1．获取成员变量们
     *
     * *Field[] getFields()
     * *Field getField(string name)
     * *Field[] getDeclaredFields ()
     * *Field getDeclaredField(string name)
     *
     */

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        // 0.获取Person的Class对象
        Class personClass = Person.class;
        // 1.Field[] getFields()
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("******************");
        // 2.Field getField(string name)
        Field a = personClass.getField("a");
        // 获取成员变量a的值
        Person person = new Person();
        Object value = a.get(person);
        System.out.println(value);
        // 设置a的值
        a.set(person, "张三");
        System.out.println(person);

        System.out.println("******************");
        // Field[] getDeclaredFields(): 获取所有的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        // Field getDeclaredField(string name)
        Field d = personClass.getDeclaredField("d");
        // 忽略访问权限修饰符的安全检查
        d.setAccessible(true); // 暴力反射
        Object value2 = d.get(person);
        System.out.println(value2);
    }
}

五、获取Constructor

Constructor：构造方法

* 创建对象

* T newInstance(Object... initargs)

* 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

public class ReflectDemo2 {

    /**
     * 获取功能：
     *
     * 1．获取成员变量们
     *
     * *Field[] getFields()
     * *Field getField(string name)
     * *Field[] getDeclaredFields ()
     * *Field getDeclaredField(string name)
     *
     */

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        // 0.获取Person的Class对象
        Class personClass = Person.class;
        // 1.Field[] getFields()
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("******************");
        // 2.Field getField(string name)
        Field a = personClass.getField("a");
        // 获取成员变量a的值
        Person person = new Person();
        Object value = a.get(person);
        System.out.println(value);
        // 设置a的值
        a.set(person, "张三");
        System.out.println(person);

        System.out.println("******************");
        // Field[] getDeclaredFields(): 获取所有的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        // Field getDeclaredField(string name)
        Field d = personClass.getDeclaredField("d");
        // 忽略访问权限修饰符的安全检查
        d.setAccessible(true); // 暴力反射
        Object value2 = d.get(person);
        System.out.println(value2);
    }
}

六、获取Method

Method：方法对象

* 执行方法：

* Object invoke(Object obj, Object... args)

* 获取方法名称：

* String getName：获取方法名

public class ReflectDemo4 {

    /**
     * 获取功能：
     *
     * 3．获取成员方法们∶
     *
     * *Method[] getMethods()
     * *Method getMethod(string name，类<?>... parameterTypes)
     * *Method[] getDeclaredMethods()
     * *Method getDeclaredMethod(string name，类<?>... parameterTypes)
     *
     */

    public static void main(String[] args) throws Exception {
        // 0.获取Person的Class对象
        Class personClass = Person.class;
        // 获取指定名称的方法
        Method eat_method = personClass.getMethod("eat");
        Person person = new Person();
        person.eat();

        // 执行方法
        eat_method.invoke(person);

        Method eat_method2 = personClass.getMethod("eat", String.class);
        // 执行方法
        eat_method2.invoke(person, "饭");

        System.out.println("***********************************");
        // 获取所有public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            // method.setAccessible(ture); 暴力反射
        }
        System.out.println(methods[0].getName());

        // 获取类名
        String className = personClass.getName();
        System.out.println(className); // com.best.domain.Person

    }
}

七、案例

需求：写一个框架，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

/**
 * 框架类
 */
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // 可以创建任意类的对象，可以执行任意方法

        // 前提: 不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
//        Person person = new Person();
//        person.eat();
//
//        Student student = new Student();
//        student.sleep();

        // 1.加载配置文件
        // 1.1 创建Properties对象
        Properties properties = new Properties();

        // 1.2 加载配置文件，转换为一个集合
        // 1.2.1 获取class目录下的配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream inputStream = classLoader.getResourceAsStream("pro.properties");
        properties.load(inputStream);

        // 2.获取配置文件中定义的数据
        String className = properties.getProperty("className");
        String methodName = properties.getProperty("methodName");

        // 3.加载该类进内存
        Class clazz = Class.forName(className);

        // 4.创建对象
        Object obj = clazz.newInstance();

        // 5.获取方法对象
        Method method = clazz.getMethod(methodName);

        // 6.执行方法
        method.invoke(obj);

    }
}