反射机制说明

反射机制（Java Reflection）允许程序在执行期间借助于Reflection API取得任何类的内部信息（比如成员变量，构造器，成员方法等等），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到。

获取Class对象的方式

1. Class.forName(“类路径”);
2. 类名.class
3. 对象.getClass();

上反射代码

一、测试类

/**
 * 测试类
 *
 * @author _running
 * @since 2022-07-10
 */
public class TestOne {

    /**
     * 名称字段
     */
    public String name = "DevRunning";

  
    /**
     * 无参构造
     */
    public TestOne() {
        System.out.println("这里是无参构造！");
    }

    /**
     * 有参构造
     *
     * @param name 名称
     */
    public TestOne(String name) {
        this.name = name;
        System.out.println("这里是有参构造！");
    }

  
    /**
     * easyOne 方法
     */
    public void easyOne() {
        System.out.println("hi! this is easyOne！");
    }

    /**
     * easyTwo 方法
     *
     * @param hello hello
     */
    public void easyTwo(String hello) {
        System.out.println(hello + "! easyTwo！");
    }
    
}

二、调用类

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/**
 * 调用类
 *
 * @author _running
 * @since 2022-07-10
 */
public class TestMain {

    public static void main(String[] args) throws Exception {
        // 根据类路径获取类
        Class<?> aClass = Class.forName("cn.running.demo.test.TestOne");
        // 实例化对象（无参）
        Object obj = aClass.newInstance();
        // 获取字段
        Field name = aClass.getField("name");
        // 获取字段值
        System.out.println(name.get(obj));
        // 设置字段值
        name.set(obj, "_running");

        // 获取无参方法并调用方法
        aClass.getMethod("easyOne").invoke(obj);
        // 获取有参方法并调用方法
        aClass.getMethod("easyTwo", String.class).invoke(obj, "hello");

        // 获取有参构造器
        Constructor<?> constructor = aClass.getConstructor(String.class);
        // 实例化对象（有参）
        Object obj2 = constructor.newInstance("DevRunning");
        
    }
}

使用反射爆破（直接操作私有的）

setAccessible(true);

一、测试类（属性私有、构造器私有、方法私有）

/**
 * 测试类
 *
 * @author _running
 * @since 2022-07-12
 */
public class TestTwo {

    /**
     * 名称字段
     */
    private String name = "DevRunning";


    /**
     * 无参构造
     */
    private TestTwo() {
        System.out.println("这里是无参构造！");
    }

    /**
     * 有参构造
     *
     * @param name 名称
     */
    private TestTwo(String name) {
        this.name = name;
        System.out.println("这里是有参构造！");
    }


    /**
     * easyOne 方法
     */
    private void easyOne() {
        System.out.println("hi! this is easyOne！");
    }

    /**
     * easyTwo 方法
     *
     * @param hello hello
     */
    private void easyTwo(String hello) {
        System.out.println(hello + "! easyTwo！");
    }

}

二、调用类

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 调用类
 *
 * @author _running
 * @since 2022-07-10
 */
public class TestMain {

    public static void main(String[] args) throws Exception {
        // 根据类路径获取类
        Class<?> aClass = Class.forName("cn.running.demo.test.TestTwo");
        // 获取无参构造器
        Constructor<?> noConstructor = aClass.getDeclaredConstructor();
        // 设置无障碍
        noConstructor.setAccessible(true);
        // 实例化对象（无参）
        Object obj = noConstructor.newInstance();

        // 获取字段
        Field name = aClass.getDeclaredField("name");
        // 设置无障碍
        name.setAccessible(true);
        // 获取字段值
        System.out.println(name.get(obj));
        // 设置字段值
        name.set(obj, "_running");

        // 获取无参方法
        Method easyOne = aClass.getDeclaredMethod("easyOne");
        // 设置无障碍
        easyOne.setAccessible(true);
        // 调用无参方法
        easyOne.invoke(obj);

        // 获取有参方法
        Method easyTwo = aClass.getDeclaredMethod("easyTwo", String.class);
        // 设置无障碍
        easyTwo.setAccessible(true);
        // 调用有参方法
        easyTwo.invoke(obj, "hello");
        
        // 获取有参构造器
        Constructor<?> yesConstructor = aClass.getDeclaredConstructor(String.class);
        // 设置无障碍
        yesConstructor.setAccessible(true);
        // 实例化对象（有参）
        yesConstructor.newInstance("DevRunning");

    }
}