Java反射（原理剖析与使用）

一、反射机制是什么

1、Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。
2、Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

二、反射的作用

我先讲两个案例来说明反射的重要性

大家可以通过案例过个眼熟，只需看懂有什么用即可，关于反射的知识，我会再后面一一讲解

案例1、通过配置文件的全类名，调用该类方法

在众多都框架中使用到了反射，能动态的生成一个对象，并操作该对象的属性与方法，最经典的就是各种注解和Spring框架的AOP等等

没有用到反射机制的时候，我们只能通过硬编码的方法更改代码中的逻辑，虽然这样的确是可行的

但是对于一个超大的项目来说，这样的维护非常耗成本，并且框架就得不到通过配置动态的更新，框架就会变得累赘，Java 根本也就流行不起来

（1）、配置一个properties文件，也可以用xml来配置

class=com.zhao.reflectdemo.pojo.Cat
name=小白

（2）、写两个实体类

Cat类

// @Data是LomBok的注解，如果不熟悉的小伙伴，可以认为他可以自动生成get、set方法等等
@Data
public class Cat {
    private String name;
    private Integer age;
    private Date brith;
    private String character;
    // 以下随便取的字段
    private String a;
    private String b;
    private String c;
    private String d;

    public void call(String name){
        this.name = name;
        System.out.println("猫儿：" + this.name + "在叫");
    }
}

Dog类

@Data
public class Dog {
    private String name;
    private Integer age;
    private Date brith;
    private String character;
    // 以下随便取的字段
    private String a;
    private String b;
    private String c;
    private String d;

    public void call(String name){
        this.name = name;
        System.out.println("狗儿：" + this.name + "在叫");
    }
}

（3）、测试：

    // 尝试用正常方法从配置文件中通过获取权类名，然后调用该类的call()方法
	// @Test为junit的注解，一般用于单元测试，因为一个类只有一个main方法，这个注解就是让该方法可以达到main方法的作用
    @Test
    public void test() throws Exception{
        // 从 properties 取出数据
        Properties properties = new Properties();
        properties.load(new InputStreamReader(
                Files.newInputStream(Paths.get("src\\main\\resources\\application.properties")),
                StandardCharsets.UTF_8)); // 不要在意我写的文件方法路径
        String className = properties.getProperty("class"); //目前值为：com.zhao.reflectdemo.pojo.Cat
        String name = properties.getProperty("name"); //目前值为：小白
        properties.clone(); // 关闭流
        // 正常方法中我们可以通过全类名，new一个对象，调用该类的方法
        Cat cat = new com.zhao.reflectdemo.pojo.Cat();
        cat.call(name); // 输出：猫儿：小白在叫

        // 那不通过反射我们可以，可以得到对象，并输出call()方法吗
//        Cat cat2 = new className(); // 当然是不可以的 className 指向的是一个字符串，并非一个类，使用这里肯定是会报错的
//        cat2.call(dogName);

        // 所以我们的主角 Class类 反射登场了
        common(className,name);

        // 更改 className 为 Dog类 全类名，当然可以在properties文件中更改，我这里就简化一下，免得本文冗长
        className = "com.zhao.reflectdemo.pojo.Dog";
        common(className,name);
    }
    // 通用方法，我们就可以知道，调用同样的方法，通过反射机制，就可以等到不同结果
    // 最大的不同就是，我们只通过两个字符串就实现了两个对象的方法
    private void common(String className,String name) throws Exception{
        Class<?> animalClass = Class.forName(className); // 通过全类名 得到Class 对象
        Object o = animalClass.newInstance(); // 生成该Cat类的对象
        Method call = animalClass.getMethod("call",String.class); // 得到 Method 对象，这个里面就是存储的该类的方法，因为我写的带参，所以这里也带String类的参数
        call.invoke(o,name);
    }

（4）、结果：

案例2、通过反射更改现有对象的属性

目前我们想用案例1中的Cat类，在初始化时，他的所有属性皆不是基本类型，所有默认初始值为null

我们想获取该存在的类并改变它的名字（name属性）为：大白，其他字符从null，改为""

如果不使用反射的话，我们就是一个个的通过set方法，改变该对象的属性，这样是可行的，但代码是不是会比较的冗长呢

进阶：如果说该类的熟悉为private，且没有任何方法能改变属性呢。

下面就一个通过案例解决上述问题

（1）、使用Cat类，去掉@Data注解和任何方法

public class Cat {
    private String name;
    private Integer age;
    private Date brith;
    private String character;
    // 以下随便取的字段
    private String a;
    private String b;
    private String c;
    private String d;
}

（2）、测试类：

    public void Test2() throws Exception {
        Cat cat = new Cat();
        common2(cat);
        System.out.println(cat);
    }
    private <T> void common2(T t) throws Exception{
        // 我这里直接塞的是对象了，对象也可以通过getClass方法，获取该对象的Class类
        Class<?> tClass = t.getClass(); // 通过泛型得到该类的Class对象
        Field[] fields = tClass.getDeclaredFields(); // 得到该类所有的属性（包括private）
        for (Field field : fields) {
            field.setAccessible(true); // 关闭验证，我们就可以操作私有属性（private）
            if (field.getType() == String.class) { // 如果获取到属性的类型是String
                String name = field.getName(); // 获取该 Class 类的属性名
                Object o = field.get(t); // 获取该类的该方法的值
                if (Objects.isNull(o)){ // 如果值是空的话
                    if (name.equals("name")) { // 如果获取到属性的名字是name
                        field.set(t,"大白"); // 设置name值为大白
                    }else {
                        field.set(t,""); // 设置属性值为 ""
                    }
                }
            }
        }
    }

（3）、结果：debug看一下，的确可以实现改熟悉的值

三、反射原理

要搞懂Java反射的原理，我们要从写好一个java文件，到编译成class文件，在通过类加载器加载到JVM的堆，加载类时由Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造，形成每个对象对应的全局唯一的一个Class方法

我就从Java程序计算机的三个阶段讲起：编译、类加载、运行

1、编译

一个我们编写的java文件，这个文件时面向与程序员的，可以通过javaSE很直观明了的代码的逻辑，但是计算机是看不懂的，计算机只能识别强弱电信号，就是以二进制形式存在的二进制文件，所以我们需要通过编译得到class字节码文件，再由jvm转换为计算机可识别的二进制数据

第一步，很简单就是通过javac命令，让java文件编译成class文件

图解

Java文件与Class文件对比

2、类加载

通过ClassLoader的defineClass 方法自动构造的，全局唯一的Class对象

把他的所有的成员变量、构造方法、成员方法封装为Class类中的Field数组、Constructor数组、Method数组，这个数组里面存放的就是类中的成员变量、构造方法、成员方法等信息

图解

DeBug看一下

查看Class对象是否是唯一的

3、运行

通过主方法运行 Cat cat = new Cat() 代码时，会先找对应的Class对象信息，把信息加载到堆中，生成一个cat对象

Class对象，可以想象成一个镜子，镜子里面有类的各种信息，反射就是指，通过这面镜子拿到自己想要的信息

四、使用反射

反射类集中在java.lang.reflect包下面

反射机制相关的重要的类

一、获取class对象的三种方法

如果使用的类形同，那么获取的是同一个Class对象

class对象一般要配合Method、Constructor、Field对象来使用

Cat cat = new Cat();
Class<? extends Cat> class1 = cat.getClass();
Class<Cat> class2 = Cat.class;
Class<?> class3 = Class.forName("com.zhao.reflectdemo.pojo.Cat");
System.out.println(class1 == class2); //true
System.out.println(class1 == class3); //true
System.out.println(class2 == class3); //true

二、Class类

其实这个类取的名字是带有误解性的，因为他是的的确确存在与java.lang包下的一个类，与我上述讲解的class对象，不是一个东西，但又有千丝万缕的关系

Class 类没有公共构造方法。Class 对象是在加载类时由Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的，因此不能显式地声明一个Class对象。

Class类常用的方法

特别强调一下newInstance()方法，可以反射实例化对象

三、反射获取方法（Method）

Method类

案例：

1、有个Cat类：

public class Cat {
    public void call(String name){
        System.out.println("cat的有参方法，参数：" + name);
    }
    public String call(){
        System.out.println("cat的无参方法");
        return "无参方法";
    }
    private String privatization(){
        System.out.println("cat的私有方法");
        return "私有方法";
    }
}

2、测试案例：

    @Test
    public void Test2() throws Exception {
        Class<Cat> catClass = Cat.class; // 获取Cat的class对象
        Cat cat = catClass.newInstance(); // 得到一个Cat对象，与 new Cat() 类似

        System.out.println("============获取单个非私有方法==================");
        Method method = catClass.getMethod("call"); // 获取单个非私有方法
        Object o = method.invoke(cat);
        System.out.println("method的返回值是" + o);
        Method method2 = catClass.getMethod("call",String.class); // 获取单个非私有方法，带参
        method2.invoke(cat, "随便");
//        Method method3 = catClass.getMethod("privatization"); // 获取单个私有方法 //会报错
//        method3.invoke(cat);

        // 由于数据里面的方法，包括Object类太多了，就不打印出来了，可以自己解开试一试
//        System.out.println("============获取多个非私有方法==================");
//        Method[] methods = catClass.getMethods(); // 获取多个非私有方法
//        for (Method method1 : methods) {
//            System.out.println("================for循环=============================");
//            // 获取修饰符列表
//            System.out.print("获取修饰符列表：");
//            System.out.println(method1.getModifiers());
//            // 获取方法的返回值类型
//            System.out.print("获取方法的返回值类型：");
//            System.out.println(method1.getReturnType().getSimpleName());
//            // 获取方法名
//            System.out.print("获取方法名：");
//            System.out.println(method1.getName());
//        }

        Method[] declaredMethods = catClass.getDeclaredMethods(); // 获取全部方法，包括私有
        System.out.println("============获取单个方法==================");
        Method declaredMethod = catClass.getDeclaredMethod("privatization"); //获取单个私有方法
        declaredMethod.setAccessible(true); // 关闭检查，这样才可以调用私有方法
        declaredMethod.invoke(cat);

    }

3、结果

四、反射获取字段（Field）

Field类

案例：

1、有个Cat类：

@Data
public class Cat {
        //相信以大家的聪明才智肯定能举一反三，使用我就直接全部私有化属性了
    private String name;
    private Integer age;
    private Date brith;
    private String character;
    // 以下随便取的字段
    private String a;
    private String b;
    private String c;
    private String d;
}

2、测试案例：

借用一下案例二的例子

目前我们想用案例1中的Cat类，在初始化时，他的所有属性皆不是基本类型，所有默认初始值为null

我们想获取该存在的类并改变它的名字（name属性）为：大白，其他字符从null，改为""

    @Test
    public void Test3() throws Exception{
        //相信以大家的聪明才智肯定能举一反三，使用我就直接全部私有化属性了
        Cat cat = new Cat();
        cat.setA("随便，随便拉");
        Class<?> tClass = cat.getClass(); // 通过泛型得到该类的Class对象
        Field[] fields = tClass.getDeclaredFields(); // 得到该类所有的属性（包括private）
        for (Field field : fields) {
            field.setAccessible(true); // 关闭验证，我们就可以操作私有属性（private）
            if (field.getType() == String.class) { // 如果获取到属性的类型是String
                String name = field.getName(); // 获取该 Class 类的属性名
                Object o = field.get(cat); // 获取该类的该方法的值
                if (Objects.isNull(o)){ // 如果值是空的话
                    if (name.equals("name")) { // 如果获取到属性的名字是name
                        field.set(cat,"大白"); // 设置name值为大白
                    }else {
                        field.set(cat,""); // 设置属性值为 ""
                    }
                }
            }
        }
        System.out.println(cat);
    }

3、Debug

五、反射获取构造函数（Constructor）

Constructor类

案例：

1、有个Cat类：

public class Cat {
    public String name;

    private Cat(){

    }
    public Cat(String name){ this.name = name;}
}

2、测试案例：

    @Test
    public void Test4() throws Exception{
        Class<Cat> catClass = Cat.class;
        Constructor<Cat> constructor = catClass.getConstructor(String.class); // 获取非私有的构造函数
        Cat cat1 = constructor.newInstance("名字是个啥");
        System.out.println(cat1.name);
        Constructor<Cat> declaredConstructor = catClass.getDeclaredConstructor(); // 获取构造函数
        declaredConstructor.setAccessible(true); // 私有的要关闭检验
        Cat cat2 = declaredConstructor.newInstance(); // 通过私有的构造函数，得到Cat对象
        System.out.println(cat2.name);
    }

3、结果

文章来源地址https://www.toymoban.com/news/detail-434178.html

到了这里，关于Java反射（原理剖析与使用）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！