Java篇之Java反射

2021-11-06

字数统计: 2.9k | 阅读时长≈ 12 分钟

Java反射

最近ctf比赛打得太多了，现在看到ctf题就脑壳痛哈哈哈，就想着找点别的来学吧，换换脑筋；于是准备学学Java安全，后面去研究研究Java反序列化啥的，在学Java反序列化之前肯定得先学Java反射，虽然说学校老师讲过了但讲的太快而且难度也不太够，所以说自己重新学了学顺便来总结总结

Java反射是啥

Java反射就是说，对于任意的一个类，我们都可以通过反射获取这个类中所有的属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制

通过Class类对象来获取Student和Teacher类中的成员变量和成员方法，而不是直接通过创建Student和Teacher类对象，这就叫反射

Student类代码如下，接下来的所有测试操作都基于这段代码，这段代码是从黑马程序员那偷的：

public class Student {
    private String name;
    int age;
    public String address;
    public Student(){

    }
    private Student(String name){
        this.name=name;
    }
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public Student(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }
    private void function(){
        System.out.println("function");
    }
    public void method1(){
        System.out.println("method");
    }
    public void method2(String s){
        System.out.println("method:"+s);
    }
    public String method3(String s,int i){
        return s + "," + i;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

获取Class类对象

既然我们想通过反射去使用一个类，那我们首先就得获取该那个类的字节码文件对象，也就是类型为Class的对象，一般来讲我们有三种方法来获取，具体如下：

1.第一种是直接使用该类的class属性来获取该类对应的Class对象，就像Student.class返回Student类所对应的Class对象，但这种方法不太实用，因为如果不在一个包下，使用之前就需要先导入类的包，依赖性太强

import com.testforclass.Student;
public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu1 = Student.class;
        System.out.println(stu1);
    }
}

2.第二种是先创建一个该类的对象，再调用该对象中的getClass()方法，就可以返回该对象所属类中的Class对象；这种方法我觉得就更离谱了，既然我们都已经创建该类的对象了，那直接用这个对象就好了啊，反射还有啥意义呢哈哈哈

public class test {
    public static void main(String[] args) throws Exception{
        Student student = new Student();
        Class<?> stu2 = student.getClass();
        System.out.println(stu2);
    }
}

3.第三种方法是直接使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整包名的路径；这种方法是最实用的，灵活性也最高，所以说我们一般就用这种方法就行

public class test {
    public static void main(String[] args) throws Exception{
       Class<?> stu3 = Class.forName("com.testforclass.Student");
       System.out.println(stu3);
    }
}

看看运行结果，肯定都是一样的：

获取构造方法

当我们已经获取到一个Class对象之后，我们肯定得想办法获取到它的构造方法，毕竟创建一个对象是需要构造方法的嘛

在Class类中，提供了四种方法来获取构造方法，分别如下：

1.返回所有公共构造方法对象的数组：getConstructors()，这个它只能返回public的构造方法，它的返回值是一个数组，我们可以用一个加强for循环来遍历它：

import java.lang.reflect.Constructor;

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Constructor<?> [] cons = stu.getConstructors();
        for(Constructor con : cons){
            System.out.println(con);
        }
    }
}

就返回了无参和带参两个构造方法，这俩都是public的

2.返回所有构造方法对象的数组：getDeclaredConstructors()，这个它就会返回所有的构造方法

import java.lang.reflect.Constructor;

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Constructor<?> [] cons = stu.getDeclaredConstructors();
        for(Constructor con : cons){
            System.out.println(con);
        }
    }
}

就返回了四个构造方法，其中两个公有，一个私有还有一个默认

3.前面两种方法它都是返回的数组，都需要遍历，就很不方便，有没有方法它返回的是单个的呢？毫无疑问是有的，比如说返回单个公共构造方法对象的：getConstructor()，这里面是有参数的，通过这个参数来判断是哪个构造方法，如果不填参数的话就是无参构造方法

import java.lang.reflect.Constructor;

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Constructor<?> con1 = stu.getConstructor();
        Constructor<?> con2 = stu.getConstructor(String.class,int.class,String.class);
        System.out.println(con1);
        System.out.println(con2);
    }
}

4.返回单个构造方法对象的：getDeclaredConstructor()，这个用法和上面的是一样的，只不过私有构造方法对象和默认构造方法对象它都能返回罢了，所以说一般来说我们就用这个就行，记得在里面加上参数哈

利用构造方法创建对象

既然我们有了构造方法，我们肯定就想着用构造方法来创建对象了，而在Constructor类中正好有拿来创建对象的方法：newInstance；创建方法如下：

import java.lang.reflect.Constructor;

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Constructor<?> con2 = stu.getDeclaredConstructor(String.class,int.class,String.class);
        System.out.println(con2);
        Object obj = con2.newInstance("Arsene.Tang",18,"中国");
        System.out.println(obj);
    }
}

如果是公有的构造方法，那么直接用这种方法就行，构造方法对象.newInstance()里面直接加上需要的参数就行

如果是私有的构造方法，那么直接这样创建就不行了，会报错，因为私有的方法肯定不能直接用嘛，但我们可以使用暴力反射嘛，就是在前面先把构造方法的Accessible设置为true，让它不检测就行，具体如下：

import java.lang.reflect.Constructor;

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Constructor<?> con2 = stu.getDeclaredConstructor(String.class);
        System.out.println(con2);
        con2.setAccessible(true);
        Object obj = con2.newInstance("Arsene.Tang");
        System.out.println(obj);
    }
}

这样子就行啦，就可以愉快的创建对象了

获取成员变量

那接下来我们看看能不能获取类中的成员变量呢，那肯定也是可以的，又去Class类中找方法

同样的，Class类中获取成员变量的方法也是四种；同样也是两个返回数组两个返回单个的；同样也是两个返回公共成员变量对象两个返回所有成员变量对象

1.返回所有公共成员变量对象的数组：getFields()，同样的，返回的是数组，那么我们还是用一个加强for循环来遍历

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

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Field []fields = stu.getFields();
        for(Field field : fields){
            System.out.println(field);
        }
    }
}

就返回了唯一一个公有的成员变量：address

2.返回所有成员变量对象的数组：getDeclaredFields()，用法和上面完全一样：

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

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Field []fields = stu.getDeclaredFields();
        for(Field field : fields){
            System.out.println(field);
        }
    }
}

就把三个成员变量都返回了

3.返回单个公共成员变量对象：getField(String name)：里面的参数为变量名

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

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Field field = stu.getField("address");
        System.out.println(field);
    }
}

4.返回单个成员变量对象：getDeclaredField(String name)：里面的参数同样为变量名

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

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Field field = stu.getDeclaredField("name");
        System.out.println(field);
    }
}

获取了成员变量之后，我们怎么给它赋值呢，这里就用到Field类中的set方法来给成员变量赋值，用法为：

void set(Object obj,Object value)：给obj对象的成员变量赋值为value：

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


public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Constructor<?> con2 = stu.getConstructor(String.class,int.class,String.class);
        Object obj = con2.newInstance("aaa",18,"中国");
        System.out.println(obj);
        Field field = stu.getDeclaredField("name");
        field.setAccessible(true);
        field.set(obj,"Arsene.Tang");
        System.out.println(obj);
    }
}

获取成员方法

获取成员方法和获取成员变量方法基本上一模一样，也是四种方法

1.返回所有公共成员方法对象的数组，包括继承的方法：getMethods()

import java.lang.reflect.Method;

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Method []methods = stu.getMethods();
        for(Method method:methods){
            System.out.println(method);
        }
    }
}

2.返回所有成员方法对象的数组，不包括继承的：getDeclaredMethods()

import java.lang.reflect.Method;

public class test {
    public static void main(String[] args) throws Exception{
        Class<?> stu = Class.forName("com.testforclass.Student");
        Method []methods = stu.getDeclaredMethods();
        for(Method method:methods){
            System.out.println(method);
        }
    }
}

3.返回单个公共成员方法对象：getMethod(String name,Class<?>...parameterTypes)，name参数填写方法名，后面那个参数填该方法的参数类型，如String.class等，如果是无参则不填，这样就可以返回单个公共成员方法了

import java.lang.reflect.Method;

public class test {
    public static void main(String[] args) throws Exception {
        Class<?> stu = Class.forName("com.testforclass.Student");
        Method method = stu.getMethod("method1");
        System.out.println(method);
    }
}

4.返回单个所有成员方法对象：getDeclaredMethod(String name,Class<?>...parameterTypes)，name参数填写方法名，后面的填方法中的参数类型，如果是无参就不填

import java.lang.reflect.Method;

public class test {
    public static void main(String[] args) throws Exception {
        Class<?> stu = Class.forName("com.testforclass.Student");
        Method method = stu.getDeclaredMethod("function");
        System.out.println(method);
    }
}

好，方法有了，最后一个问题就是调用这些方法了，在Method类中有一个invoke()方法，可以调用方法，返回一个对象，其实这里和Field类中的set方法很像，用法为：invoke(Object obj,Object...args)，后面的参数就填方法中想传的参数：

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

public class test {
    public static void main(String[] args) throws Exception {
        Class<?> stu = Class.forName("com.testforclass.Student");
        Constructor<?> con2 = stu.getConstructor(String.class, int.class, String.class);
        Object obj = con2.newInstance("Arsene.Tang", 18, "中国");
        Method method = stu.getDeclaredMethod("method2",String.class);
        method.setAccessible(true);
        obj = method.invoke(obj,"method2222");
    }
}

这样就成功调用了带参数的method2方法，至此Java反射差不多就到这儿了，最后给上几张黑马程序员中的图来做个总结：

版权声明： 本博客所有文章除特别声明外，著作权归作者所有。转载请注明出处！