• Java基础 | 反射机制详解

    Java基础 | 反射机制

    文章目录

    什么是反射？

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

    加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息，通过这个对象得到类的结构，就称之为反射。

    正常创建对象的方式就是new，每创建一个对象就要new一次

    public class Main {

    public static void main(String[] args) {
        I a = create("A");
        a.test();
        I b = create("B");
        b.test();
    }

    public static I create(String name){
        if (name.equals("A")) {
            return new A();
        } else if(name.equals("B")){
            return new B();
        }
        return null;
    }
}
interface I {
    public void test();
}

class A implements I {
    @Override
    public void test() {
        System.out.println("A");
    }
}

class B implements I {
    @Override
    public void test() {
        System.out.println("B");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    使用反射来创建对象

        // 使用反射机制
    public static I create2(String name) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class<?> aClass = Class.forName(name);
        I i = (I) aClass.newInstance();
        return i;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
     I a1 = create2("A");

    • 1

    只需要将类名传入到creat2方法中就可以动态加载该类，并且实例化该对象

    反射的作用

    • 在运行时（动态编译）获知任意一个对象所属的类。
    • 在运行时构造任意一个类的对象。
    • 在运行时获知任意一个类所具有的成员变量和方法。
    • 在运行时调用任意一个对象的方法和属性。
    • 生成动态代理

    反射主要的类

    1. java.lang.Class:代表一个类，Class对象表示某个类加载后在堆中的对象

    2. java.lang.reflect.Method:代表类的方法，Method对象表示某个类的方法

    3. java.lang.reflect.Field:代表类的成员变量，Field对象表示某个类的成员变量

    4. java.lang.reflect.Constructor:代表类的构造方法，Constructor对象表示构造器

    类加载机制

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8bilDR0y-1666164795200)(Java基础 反射机制.assets/image-20221019143036788.png)]

    当程序经过编译之后会生成一个.class文件，然后被类加载器（Class Loader）加载进 JVM 的内存中，同时会创建一个 A 类的 Class 对象存到堆中（注意这个不是 new 出来的对象，而是类的类型对象）。JVM 在创建 A 对象前，会先检查其类是否加载，寻找类对应的 Class 对象，若加载好，则为其分配内存，然后再进行初始化.

    每一个类只会拥有一个class对象，继续执行new语句也只会指向一个class对象

    当一个类加载完毕之后，就会在堆内存中产生一个class对象，这个对象包含了类的完整信息，我们可以之后通过对象来看见类的完整信息，也就是反射

    获取class类对象的四种方式

    第一种：已知一个类的全类名

    可通过Class类的静态方法forName(获取，可能抛出ClassNotFoundException

    Class a = Class.forName("com.xxx.a");

    • 1

    应用场景：多用于配置文件，读取类全路径，加载类.

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C6ZTgLob-1666164795201)(Java基础 反射机制.assets/image-20221019144536489.png)]

    boolean 参数表示类是否需要初始化，默认是需要初始化。一旦初始化，就会触发目标对象的 static 块代码执行，static 参数也会被再次初始化。

    第二种：知道具体类的情况下可以使用：

    通过类的class获取，该方式最为安全可靠，程序性能最高

    Class a = A.class;

    • 1

    应用场景：多用于参数传递，比如通过反射得到对应构造器对象.

    第三种：已知某个实例对象

    调用该实例的getClass()方法获取Classj对象

    Class a = a.getClass();

    • 1

    应用场景：通过创建好的对象，获取Class对象

    第四种:通过类加载器 xxxClassLoader.loadClass() 传入类路径获取

    class a = ClassLoader.LoadClass("com.xxx.A");

    • 1

    通过类加载器获取 Class 对象不会进行初始化，意味着不进行包括初始化等一些列步骤，静态块和静态对象不会得到执行。和forName方法有所不同

    通过反射构造一个类的实例

    第一种：使用 Class.newInstance

            A a = new A();
        Class<? extends A> aClass = a.getClass();
        A a2 = aClass.newInstance();//这里a 和 a2 是具有相同类型的实例

    • 1
    • 2
    • 3

    第二种： 通过反射先获取构造方法再调用

    由于不是所有的类都有无参构造函数又或者类构造器是 private 的，在这样的情况下，如果我们还想通过反射来实例化对象，Class.newInstance 是无法满足的。

    此时，我们可以使用 Constructor 的 newInstance 方法来实现，先获取构造函数，再执行构造函数。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8nn1Xauo-1666164795201)(Java基础 反射机制.assets/image-20221019145746903.png)]

    在这里插入图片描述

    第三种：使用开源库 Objenesis

    Objenesis 是一个开源库，和上述第二种方法一样，可以调用任意的构造函数

    反射机制的优缺点

    优点： 比较灵活，能够在运行时动态获取类的实例。

    缺点：

    1）性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的 Java 代码要慢很多。

    2）安全问题：反射机制破坏了封装性，因为通过反射可以获取并调用类的私有方法和字段

    通过反射获得类的结构信息

    java.lang.Class类包含的

    1. getName:获取全类名

    2. getSimpleName:获取简单类名

    3. getFields:获取所有public修饰的属性，包含本类以及父类的

    4. getDeclaredFields:获取本类中所有属性

    5. getMethods:获取所有oublicf修饰的方法，包含本类以及父类的

    6. getDeclaredMethods:获取本类中所有方法

    7. getConstructors:获取本类所有public修饰的构造器

    8. getDeclaredConstructors:获取本类中所有构造器

    9. getPackage:以Package形式返回包信息

    10. getSuperClass:以Class形式返回父类信息

    11. getInterfaces:以Class[]形式返回接口信息

    12. getAnnotations:以Annotation]形式返回注解信息

    java.lang.reflect.Constructor 类包含的

    1. getModifiers:以int形式返回修饰符

    2. getName:返回构造器名（全类名）

    3. getParameterTypes:以Class[]返回参数类型数组

    public class ReflectionUtils {
    public static void main(String[] args) {

    }

    @Test
    public void api_02() throws ClassNotFoundException, NoSuchMethodException {
        //得到Class对象
        Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
        //getDeclaredFields:获取本类中所有属性
        //规定 说明: 默认修饰符 是0 ， public  是1 ，private 是 2 ，protected 是 4 , static 是 8 ，final 是 16
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有属性=" + declaredField.getName()
                    + " 该属性的修饰符值=" + declaredField.getModifiers()
                    + " 该属性的类型=" + declaredField.getType());
        }

        //getDeclaredMethods:获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类中所有方法=" + declaredMethod.getName()
                    + " 该方法的访问修饰符值=" + declaredMethod.getModifiers()
                    + " 该方法返回类型" + declaredMethod.getReturnType());

            //输出当前这个方法的形参数组情况
            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("该方法的形参类型=" + parameterType);
            }
        }

        //getDeclaredConstructors:获取本类中所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("====================");
            System.out.println("本类中所有构造器=" + declaredConstructor.getName());//这里老师只是输出名

            Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("该构造器的形参类型=" + parameterType);
            }

        }

    }

    //第一组方法API
    @Test
    public void api_01() throws ClassNotFoundException, NoSuchMethodException {

        //得到Class对象
        Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
        //getName:获取全类名
        System.out.println(personCls.getName());//com.hspedu.reflection.Person
        //getSimpleName:获取简单类名
        System.out.println(personCls.getSimpleName());//Person
        //getFields:获取所有public修饰的属性，包含本类以及父类的
        Field[] fields = personCls.getFields();
        for (Field field : fields) {//增强for
            System.out.println("本类以及父类的属性=" + field.getName());
        }
        //getDeclaredFields:获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有属性=" + declaredField.getName());
        }
        //getMethods:获取所有public修饰的方法，包含本类以及父类的
        Method[] methods = personCls.getMethods();
        for (Method method : methods) {
            System.out.println("本类以及父类的方法=" + method.getName());
        }
        //getDeclaredMethods:获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类中所有方法=" + declaredMethod.getName());
        }
        //getConstructors: 获取所有public修饰的构造器，包含本类
        Constructor<?>[] constructors = personCls.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("本类的构造器=" + constructor.getName());
        }
        //getDeclaredConstructors:获取本类中所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("本类中所有构造器=" + declaredConstructor.getName());//这里老师只是输出名
        }
        //getPackage:以Package形式返回 包信息
        System.out.println(personCls.getPackage());//com.hspedu.reflection
        //getSuperClass:以Class形式返回父类信息
        Class<?> superclass = personCls.getSuperclass();
        System.out.println("父类的class对象=" + superclass);//
        //getInterfaces:以Class[]形式返回接口信息
        Class<?>[] interfaces = personCls.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("接口信息=" + anInterface);
        }
        //getAnnotations:以Annotation[] 形式返回注解信息
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("注解信息=" + annotation);//注解
        }


    }
}

interface IA {
}

interface IB {

}

@Deprecated
class Person extends A implements IA, IB {
    //属性
    public String name;
    protected static int age; // 4 + 8 = 12
    String job;
    private double sal;

    //构造器
    public Person() {
    }

    public Person(String name) {
    }

    //私有的
    private Person(String name, int age) {

    }

    //方法
    public void m1(String name, int age, double sal) {

    }

    protected String m2() {
        return null;
    }

    void m3() {

    }

    private void m4() {

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151

    通过反射调用成员方法

    public class ReflecAccessMethod {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

        //1. 得到Boss类对应的Class对象
        Class<?> bossCls = Class.forName("com.hspedu.reflection.Boss");
        //2. 创建对象
        Object o = bossCls.newInstance();
        //3. 调用public的hi方法
        Method hi = bossCls.getMethod("hi", String.class);//OK
        //3.1 得到hi方法对象
        Method hi2 = bossCls.getDeclaredMethod("hi", String.class);//OK
        //3.2 调用
        hi.invoke(o, "韩顺平教育~");
        hi2.invoke(o,"123");

        //4. 调用private static 方法
        //4.1 得到 say 方法对象
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
        //4.2 因为say方法是private, 所以需要暴破，原理和前面讲的构造器和属性一样
        say.setAccessible(true);
        System.out.println(say.invoke(o, 100, "张三", '男'));
        //4.3 因为say方法是static的，还可以这样调用 ，可以传入null
        System.out.println(say.invoke(null, 200, "李四", '女'));

        //5. 在反射中，如果方法有返回值，统一返回Object , 但是他运行类型和方法定义的返回类型一致
        Object reVal = say.invoke(null, 300, "王五", '男');
        System.out.println("reVal 的运行类型=" + reVal.getClass());//String


        //在演示一个返回的案例
        Method m1 = bossCls.getDeclaredMethod("m1");
        Object reVal2 = m1.invoke(o);
        System.out.println("reVal2的运行类型=" + reVal2.getClass());//Monster


    }
}

class Monster {}
class Boss {//类
    public int age;
    private static String name;

    public Boss() {//构造器
    }

    public Monster m1() {
        return new Monster();
    }

    private static String say(int n, String s, char c) {//静态方法
        return n + " " + s + " " + c;
    }

    public void hi(String s) {//普通public方法
        System.out.println("hi " + s);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59

    通过反射操作成员属性

    public class ReflecAccessProperty {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {

        //1. 得到Student类对应的 Class对象
        Class<?> stuClass = Class.forName("com.hspedu.reflection.Student");
        //2. 创建对象
        Object o = stuClass.newInstance();//o 的运行类型就是Student
        System.out.println(o.getClass());//Student
        //3. 使用反射得到age 属性对象
        Field age = stuClass.getField("age");
        age.set(o, 88);//通过反射来操作属性
        System.out.println(o);//
        System.out.println(age.get(o));//返回age属性的值

        //4. 使用反射操作name 属性
        Field name = stuClass.getDeclaredField("name");
        //对name 进行暴破, 可以操作private 属性
        name.setAccessible(true);
        //name.set(o, "老韩");
        name.set(null, "老韩~");//因为name是static属性，因此 o 也可以写出null
        System.out.println(o);
        System.out.println(name.get(o)); //获取属性值
        System.out.println(name.get(null));//获取属性值, 要求name是static

    }
}

class Student {//类
    public int age;
    private static String name;

    public Student() {//构造器
    }

    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    反射的应用

    • 动态代理机制
    • 使用 JDBC 连接数据库
    • Spring

    连接数据库

    在 JDBC 的操作中，如果要想进行数据库的连接，则必须按照以下几步完成：

    • 通过 Class.forName() 加载数据库的驱动程序 （通过反射加载）
    • 通过 DriverManager 类连接数据库，参数包含数据库的连接地址、用户名、密码
    • 通过 Connection 接口接收连接
    • 关闭连接
    public static void main(String[] args) throws Exception {  
        Connection con = null; // 数据库的连接对象  
        // 1. 通过反射加载驱动程序
        Class.forName("com.mysql.jdbc.Driver"); 
        // 2. 连接数据库  
        con = DriverManager.getConnection(
            "jdbc:mysql://localhost:3306/test","root","root"); 
        // 3. 关闭数据库连接
        con.close(); 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    Spring

    通过xml文件来转载Bean对象，IOC过程：

    • 加载配置文件，获取 Spring 容器
    • 使用反射机制，根据传入的字符串获得某个类的 Class 实例
    // 获取 Spring 的 IoC 容器，并根据 id 获取对象
public static void main(String[] args) {
    // 1.使用 ApplicationContext 接口加载配置文件，获取 spring 容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
    // 2. 使用反射机制，根据这个字符串获得某个类的 Class 实例
    AService aService = (IAccountService) ac.getBean("AServiceImpl");
    System.out.println(aService);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    代码部分来自于：韩顺平老师的反射课程
    https://www.bilibili.com/video/BV1g84y1F7df/?p=20&spm_id_from=333.880.my_history.page.click

  • 相关阅读:
    pyspark使用xgboost做模型训练
    查杀Linux服务器病毒进程并对Linux中的文件描述符FD进行简单探索
    ClickHouse引擎之-MaterializeMYSQL
    C语言：字符串函数（2）
    力扣每日一题-第63天-867. 转置矩阵
    如何实现MongoDB数据的快速迁移？
    实现动态表单的一种思路 | 京东云技术团队
    MySQL的驱动表与被驱动表
    Flink SQL: JAR Statements
    XML的解析
  • 原文地址：https://blog.csdn.net/qq_43167873/article/details/127409179