反射

反射概述

  • 反射是指对于任何一个Class类，在"运行的时候"都可以直接得到这个类全部成分。
  • 在运行时，可以直接得到这个类的构造器对象：Constructor
  • 在运行时，可以直接得到这个类的成员变量对象：Field
  • 在运行时，可以直接得到这个类的成员方法对象：Method
  • 这种运行时动态获取类信息以及动态调用类中成分的能力称为Java语言的反射机制。

反射的关键和作用：

反射的第一步都是先得到编译后的Class类对象，然后就可以得到Class的全部成分。

HelloWorld.java -> javac -> HelloWorld.class
Class c = HelloWorld.class;

反射是在运行时获取类的字节码文件对象，然后可以解析类中的全部成分。

反射的核心思想和关键就是得到编译以后的class文件对象。

反射获取类对象

反射的第一步，获取Class类的对象

获取Class对象的方式

1.Class.forName("类全名");
    将字节码加载进内存，返回Class对象。多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class;
    通过类名的属性class获取。多用于参数的传递
3. 对象.getClass();
    getClass()方法在Object类中定义。多用于对象的获取字节码的方式

代码实例

// 1、Class类中的一个静态方法：forName(全限名：包名 + 类名)
Class c = Class.forName("com.alexsel.reflect_class.Student");
System.out.println(c); // Student.class

// 2、类名.class
Class c1 = Student.class;
System.out.println(c1);

// 3、对象.getClass() 获取对象对应类的Class对象。
Student s = new Student();
Class c2 = s.getClass();
System.out.println(c2);

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

反射获取构造器对象

获取构造器的方法

public Constructor<T> getConstructor(Class<?>... parameterTypes);
//返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。

public Constructor<?>[] getConstructors();
//返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes);
//返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。可以获取所有类型的构造器，包括私有的

public Constructor<?>[] getDeclaredConstructors();
//返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。

小结：
获取类的全部构造器对象：
Constructor[] getDeclaredConstructors()
-- 获取所有申明的构造器，只要你写我就能拿到，无所谓权限。建议使用！！

获取类的某个构造器对象：
Constructor getDeclaredConstructor(Class... parameterTypes)
-- 根据参数匹配获取某个构造器，只要申明就可以定位，不关心权限修饰符，建议使用！

测试代码

Student

public class Student {
    private String name;
    private int age;
    public static String schoolName;
    public static final String  COUNTTRY = "中国";
    
    private Student(){
        System.out.println("无参数构造器执行");
    }
    public Student(String name, int age) {
        System.out.println("有参数构造器执行");
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

TestStudent1

public class TestStudent1 {
    // 1. getConstructors:
    // 获取全部的构造器：只能获取public修饰的构造器。
    // Constructor[] getConstructors()
    @Test        //单元测试的方式运行
    public void getConstructors(){
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.提取类中的全部的构造器对象(这里只能拿public修饰)
        Constructor[] constructors = c.getConstructors();
        // c.遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());//获取构造器参数个数
        }
    }


    // 2.getDeclaredConstructors():
    // 获取全部的构造器：只要你敢写，这里就能拿到，无所谓权限是否可及。
    @Test
    public void getDeclaredConstructors(){
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.提取类中的全部的构造器对象
        Constructor[] constructors = c.getDeclaredConstructors();
        // c.遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    // 3.getConstructor(Class... parameterTypes)
    // 获取某个构造器：只能拿public修饰的某个构造器
    @Test
    public void getConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器 只能拿public修饰的某个构造器)
        Constructor cons = c.getConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());
    }


    // 4.getConstructor(Class... parameterTypes)
    // 获取某个构造器：只要你敢写，这里就能拿到，无所谓权限是否可及。
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器)
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());

        // c.定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());

    }

}

Constructor类中用于创建对象的方法

反射获取Class中的构造器对象Constructor作用：初始化并得到类的一个对象返回。

T newInstance(Object... initargs)
根据指定的构造器创建对象

public void setAccessible(boolean flag)
设置为true,表示取消访问检查，进行暴力反射

小结：

可以通过定位类的构造器对象。

如果构造器对象没有访问权限可以通过：void setAccessible(true)打开权限

构造器可以通过T newInstance(Object... initargs)调用自己，传入参数！

实例代码

TestStudent2

public class TestStudent2 {
    // 1.调用构造器得到一个类的对象返回。
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器)，
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());
        // 如果遇到了私有的构造器，可以暴力反射
        cons.setAccessible(true); // 权限被打开
        //无参构造器会把对象初始化为默认内容
        Student s = (Student) cons.newInstance();
        
        System.out.println(s);
        System.out.println("-------------------");
        // c.定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());
        Student s1 = (Student) cons1.newInstance("alexsel", 123);
        System.out.println(s1);
    }
}

反射获取成员变量对象

获取成员变量对象的方法

1、Field getField(String name);
    根据成员变量名获得对应Field对象，只能获得public修饰
    
2.Field getDeclaredField(String name);
    根据成员变量名获得对应Field对象，只要声明了就可以得到
    
3.Field[] getFields();
    获得所有的成员变量对应的Field对象，只能获得public的
    
4.Field[] getDeclaredFields();
    获得所有的成员变量对应的Field对象，只要声明了就可以得到

小结：

获取全部成员变量：getDeclaredFields

获取某个成员变量：getDeclaredField

代码实例

FieldDemo1

public class FieldDemo1 {
    /**
     * 1.获取全部的成员变量。
     * Field[] getDeclaredFields();
     *  获得所有的成员变量对应的Field对象，只要声明了就可以得到
     */
    @Test
    public void getDeclaredFields(){
        // a.定位Class对象
        Class c = Student.class;
        // b.定位全部成员变量
        Field[] fields = c.getDeclaredFields();
        // c.遍历一下
        for (Field field : fields) {
            System.out.println(field.getName() + "==>" + field.getType());
            //输出字段名和字段类型
        }
    }

    /**
     2.获取某个成员变量对象 Field getDeclaredField(String name);
     */
    @Test
    public void getDeclaredField() throws Exception {
        // a.定位Class对象
        Class c = Student.class;
        // b.根据名称定位某个成员变量
        Field f = c.getDeclaredField("age");
        System.out.println(f.getName() +"===>" + f.getType());
    }
}

Field类中用于取值、赋值的方法

得到成员变量对象之后我们可以进行取值赋值操作

取值赋值的方法

void set(Object obj, Object value);    给对象的某个成员变量注入数据
Object get(Object obj);                获取对象的成员变量的值。
void setAccessible(true);            暴力反射，设置为可以直接访问私有类型的属性。
Class getType();                     获取属性的类型，返回Class对象。
String getName();                     获取属性的名称。

代码实例

public class FieldDemo02 {
    @Test
    public void setField() throws Exception {
        // a.反射第一步，获取类对象
        Class c = Student.class;
        // b.提取某个成员变量
        Field ageF = c.getDeclaredField("age");
        ageF.setAccessible(true); // 暴力打开权限

        // c.赋值
        //要给成员变量赋值需要有对象，因为成员变量是不能孤立存在的
        Student s = new Student();
        ageF.set(s , 18);  // s.setAge(18);
        System.out.println(s);

        // d、取值
        int age = (int) ageF.get(s);
        System.out.println(age);
    }
}

反射获取方法对象

反射获取对象的方法

1、Method getMethod(String name,Class...args);
根据方法名和参数类型获得对应的方法对象，只能获得public的

2、Method getDeclaredMethod(String name,Class...args);
根据方法名和参数类型获得对应的方法对象，包括private的

3、Method[] getMethods();
获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的

4、Method[] getDeclaredMethods();
获得类中的所有成员方法对象，返回数组,只获得本类声明的方法。

执行获取的方法

Object invoke(Object obj, Object... args)
参数一：触发的是哪个对象的方法执行。
参数二：args 调用方法时传递的实际参数

代码实例

Dog

public class Dog {
    private String name ;
    public Dog(){
    }

    public Dog(String name) {
        this.name = name;
    }
    public void run(){
        System.out.println("狗刨");
    }
    private void eat(){
        System.out.println("狗吃");
    }
    private String eat(String name){
        System.out.println("狗吃" + name);
        return "很开心";
    }
    public static void inAddr(){
        System.out.println("Earth");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

MethodDemo1

public class MethodDemo1 {
    /**
     * 1.获得类中的所有成员方法对象
     */
    @Test
    public void getDeclaredMethods(){
        // a.获取类对象
        Class c = Dog.class;
        // b.提取全部方法；包括私有的
        Method[] methods = c.getDeclaredMethods();
        // c.遍历全部方法
        for (Method method : methods) {
            System.out.println(method.getName() +" 返回值类型：" + method.getReturnType() + " 参数个数：" + method.getParameterCount());
        }
    }

    /**
     * 2. 获取某个方法对象
     */
    @Test
    public void getDeclardMethod() throws Exception {
        // a.获取类对象
        Class c = Dog.class;
        // b.提取单个方法对象
        Method m = c.getDeclaredMethod("eat");
        Method m2 = c.getDeclaredMethod("eat", String.class);

        // 暴力打开权限了
        m.setAccessible(true);
        m2.setAccessible(true);

        // c.触发方法的执行
        Dog d = new Dog();
        // 注意：方法如果是没有结果回来的，那么返回的是null.
        Object result = m.invoke(d);
        System.out.println(result);

        Object result2 = m2.invoke(d, "骨头");
        System.out.println(result2);
    }
}

获取类名

Class c = Class.forName("com.alexsel.reflect_class.Student");
String name = c.getName();
System.out.println(name);

反射的作用-绕过编译阶段为集合添加数据

反射是作用在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素

ArrayList<Integer> list = new ArrayList<>();
list.add(100);
// list.add(“alexsel"); // 报错
list.add(99);

泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真实类型都是ArrayList了，泛型相当于被擦除了。

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 需求：反射实现泛型擦除后，加入其他类型的元素
        ArrayList<String> lists1 = new ArrayList<>();
        ArrayList<Integer> lists2 = new ArrayList<>();

        System.out.println(lists1.getClass());
        System.out.println(lists2.getClass());
        System.out.println(lists1.getClass() ==  lists2.getClass());  // ArrayList.class
        //这里他们都是ArrayList所以这里返回true

        System.out.println("---------------------------");
        ArrayList<Integer> lists3 = new ArrayList<>();
        lists3.add(23);
        lists3.add(22);
        // lists3.add("alexsel");

        Class c = lists3.getClass(); // ArrayList.class  ===> public boolean add(E e)
        // 定位c类中的add方法
        Method add = c.getDeclaredMethod("add", Object.class);
        boolean rs = (boolean) add.invoke(lists3, "alexsel");
        System.out.println(rs);

        System.out.println(lists3);

        //突破泛型限制
        ArrayList list4 = lists3;
        list4.add("ALEXSEL");
        list4.add(false);
        System.out.println(lists3);
    }
}

输出结果

class java.util.ArrayList
class java.util.ArrayList
true
---------------------------
true
[23, 22, alexsel]
[23, 22, alexsel, ALEXSEL, false]

反射的作用-通用框架的底层原理

反射做通用框架

我们可以完成这样一个功能，给你任意一个对象，在不清楚对象字段的情况可以，可以把对象的字段名称和对应值存储到文件中去。

分析
1.定义一个方法，可以接收任意类的对象。
2.每次收到一个对象后，需要解析这个对象的全部成员变量名称。
3.这个对象可能是任意的，那么怎么样才可以知道这个对象的全部成员变量名称呢？
4.使用反射获取对象的Class类对象，然后获取全部成员变量信息。
5.遍历成员变量信息，然后提取本成员变量在对象中的具体值
6.存入成员变量名称和值到文件中去即可。

反射的具体应用案例

我们之前做的都是反射的一些基本使用，后面来看一个小案例来了解反射的具体应用。

1.首先我们需要创建一个配置文件，然后定义需要创建的兑现和需要执行的方法定义在配置文件里面。

2.在程序中读取配置文件

3.使用反射机制加载类文件进内存

4.创建对象

5.执行方法

一般java里面的配置文件都是以.properites结尾，那么就定义一个pro.properites文件。

pro.properites文件内容

className=com.alexsel.reflect_method.Dog    //写入需要加载的类
methodName=eat                                 //写入需要加载的方法

反射作用总结

  • 可以在运行时得到一个类的全部成分然后操作。
  • 可以破坏封装性。（很突出）
  • 也可以破坏泛型的约束性。（很突出）
  • 更重要的用途是适合：做Java高级框架
  • 基本上主流框架都会基于反射设计一些通用技术功能。

反射案例

加载配置文件中的类以及方法

1.首先我们需要创建一个配置文件，然后定义需要创建的兑现和需要执行的方法定义在配置文件里面。

2.在程序中读取配置文件

3.使用反射机制加载类文件进内存

4.创建对象

5.执行方法

DemoTest

package com.alexsel.d10_sec_demo;

public class DemoTest {

    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();               //创建properties对象
        ClassLoader classLoader = Dog.class.getClassLoader();   //获取加载
        //classLoader,就是负责把磁盘上的.class文件加载到JVM内存中
        InputStream resourceAsStream = classLoader.getResourceAsStream("com/alexsel/d10_sec_demo/pro.properites"); //获取路径文件流
        //项目中经常会使用 properties 文件定义一些配置变量，相应的就需要写一个类来加载此配置。
        //常用的方式是使用 class 或者 classLoader 对象的getResourceAsStream 来加载properties文件。
        properties.load(resourceAsStream); //加载文件
        //获取配置文件定义的数据
        String className = properties.getProperty("className"); //获取类名
        String methodName = properties.getProperty("methodName");//获取方法名

        Class cls = Class.forName(className);  //将类加载进内存
        Object o = cls.newInstance(); //创建无参构造对象

        Method method = cls.getDeclaredMethod(methodName);   //创建方法，因为eat是私有方法所以这里我们需要获取所有声明过的方法
        method.setAccessible(true);//设置可以获取私有方法
        method.invoke(o);      //调用方法
        
    }
}

pro.properites配置文件中的内容

className=com.alexsel.d5_reflect_method.Dog          //写入需要加载的类
methodName=eat                                         //写入需要加载的方法

1665858325140

反射调用Runtime

Runtime这个函数有exec方法可以本地执行命令，大部分关于jsp命令执行的payload可能都是调用Runtime进行Runtime的exec方法进行命令执行的。

一般方式调用Runtime
package com.alexsel.d10_sec_demo;
import org.apache.commons.io.IOUtils;

import java.io.IOException;
import java.io.InputStream;

public class DemoTest2 {
    public static void main(String[] args) throws IOException {
        InputStream ipconfig = Runtime.getRuntime().exec("ipconfig").getInputStream();
        String s = IOUtils.toString(ipconfig,"gbk");
        //使用IOUtils.toString静态方法将字节输入流转换为字符
        System.out.println(s);
    }
}
使用反射的方式调用Runtime
public class DemoTest {

    public static void main(String[] args) throws Exception{
        String command = "ipconfig";
        Class cls = Class.forName("java.lang.Runtime");//加载类进入内存
        Constructor declaredConstructor = cls.getDeclaredConstructor();//获取构造方法
        declaredConstructor.setAccessible(true);
        Object o = declaredConstructor.newInstance();
        //在这个过程中，是先取了这个类的不带参数的构造方法，然后调用构造方法的newInstance来创建对象

        Method exec = cls.getMethod("exec",String.class);
        //获取exec方法并设置参数见类型

        Process process = (Process)exec.invoke(o,command);
        //执行exec方法

        InputStream inputStream = process.getInputStream();//获取输出的数据
        String ipconfig = IOUtils.toString(inputStream,"gbk");
        System.out.println(ipconfig);

    }
}

1665862670527

method.invoke的第一个参数必须是类实例对象，如果调用的是static方法那么第一个参数值可以传null，因为在java中调用静态方法是不需要有类实例的，因为可以直接类名.方法名(参数)的方式调用。

method.invoke的第二个参数不是必须的，如果当前调用的方法没有参数，那么第二个参数可以不传，如果有参数那么就必须严格的依次传入对应的参数类型。

最后修改：2022 年 11 月 11 日
© 允许规范转载
如果觉得我的文章对你有用，请随意赞赏